Observability & Streaming Dictionary

55 entries

• RPS (Requests Per Second)

  Metrics

  The rate of inbound requests a service handles each second. A primary throughput signal used to size capacity and detect traffic spikes during live OTT events.

• Throughput

  Metrics

  The volume of work completed per unit time (requests/sec, bytes/sec, or segments/sec). In streaming it captures how much media data the pipeline moves end to end.

• SLO (Service Level Objective)

  Metrics

  A target reliability threshold for a service level indicator over a rolling window, e.g. 99.9% of playback starts succeed. Drives error budgets and alerting.

• SLI (Service Level Indicator)

  Metrics

  A quantitative measure of a service's behavior, such as request success ratio or latency percentile, that an SLO sets a target against.

• Error Budget

  Metrics

  The allowable amount of unreliability implied by an SLO (100% minus the objective). When exhausted, teams freeze risky changes and prioritize reliability work.

• Burn Rate

  Metrics

  How fast an incident consumes the error budget relative to the SLO window. A burn rate of 1 exhausts the budget exactly at the window's end; higher values trigger faster alerts.

• Cardinality

  Metrics

  The number of unique time series produced by a metric and its label combinations. High cardinality (e.g. per-user labels) inflates storage cost and can destabilize a TSDB.

• PromQL

  Metrics

  Prometheus Query Language, used to select and aggregate time series. Supports selectors, functions, and operators for building dashboards and alert expressions.

• rate()

  Metrics

  A PromQL function computing the per-second average rate of increase of a counter over a range window, handling counter resets automatically. Ideal for smooth request/error rates.

• increase()

  Metrics

  A PromQL function returning the total increase of a counter across a range window. Equivalent to rate() multiplied by the window length; used for counts over an interval.

• Histogram

  Metrics

  A metric type that buckets observations (e.g. request durations) so quantiles like p95/p99 latency can be estimated with histogram_quantile in PromQL.

• Counter

  Metrics

  A monotonically increasing cumulative metric (e.g. total requests) that only resets on restart. Queried with rate() or increase() rather than read directly.

• Gauge

  Metrics

  A metric that can go up or down, representing a point-in-time value such as memory usage, queue depth, or concurrent connections.

• Structured Logs

  Metrics

  Log records emitted as machine-parseable key/value data (typically JSON) so fields can be indexed, filtered, and correlated with traces and metrics.

• Unstructured Logs

  Metrics

  Free-form plain-text log lines without a consistent schema. Human-readable but expensive to parse, query, and correlate at scale compared to structured logs.

• Distributed Trace

  Traces

  A tree of spans capturing a single request's journey across services, revealing latency contribution and dependencies end to end.

• Span

  Traces

  A single named, timed operation within a trace (e.g. an HTTP handler or DB call), carrying start/end timestamps, attributes, and a link to its parent span.

• Critical Path

  Traces

  The chain of spans that determines a trace's total duration. Optimizing spans off the critical path yields no end-to-end latency improvement.

• Head Sampling

  Traces

  A sampling decision made at the start of a trace, before its outcome is known. Cheap and simple, but can miss rare errors or slow requests.

• Tail Sampling

  Traces

  A sampling decision made after a trace completes, using the full trace (errors, latency) to keep interesting traces. More accurate but requires buffering and more resources.

• W3C Trace Context

  Traces

  A W3C standard defining the traceparent and tracestate HTTP headers so trace and span identity propagate consistently across service and vendor boundaries.

• OTLP (OpenTelemetry Protocol)

  Traces

  The vendor-neutral wire protocol for exporting traces, metrics, and logs from instrumentation to the OpenTelemetry Collector and downstream backends.

• OpenTelemetry Collector

  Traces

  A configurable agent/gateway with receivers, processors, and exporters that ingests, transforms, and forwards telemetry without changing application code.

• memory_limiter

  Traces

  An OpenTelemetry Collector processor that caps memory usage and back-pressures or drops data before the process is OOM-killed, protecting collector stability under load.

• batch (processor)

  Traces

  An OpenTelemetry Collector processor that groups telemetry into batches to reduce export calls and improve throughput. Usually placed after memory_limiter in the pipeline.

• Jaeger

  Traces

  An open-source distributed tracing backend for storing, querying, and visualizing traces, commonly fed via the OpenTelemetry Collector.

• Tempo

  Traces

  Grafana's high-scale, object-storage-backed distributed tracing backend that indexes only trace IDs, keeping cost low for large trace volumes.

• Loki

  Traces

  Grafana's horizontally scalable log aggregation system that indexes labels rather than full log content, pairing efficiently with Prometheus and Tempo.

• EFK Stack

  Traces

  Elasticsearch, Fluentd (or Fluent Bit), and Kibana — a common logging pipeline that collects, stores, and visualizes logs, an alternative to the ELK stack.

• eBPF (kprobes/uprobes/socket filters)

  Traces

  A Linux kernel technology running sandboxed programs on hooks like kprobes (kernel functions), uprobes (user functions), and socket filters to capture telemetry with no code changes.

• Ingress

  Networking

  Traffic entering a system or network boundary — inbound requests, uploads, or segment pushes arriving at edge or origin services.

• Egress

  Networking

  Traffic leaving a system or network boundary — outbound responses and media bytes delivered to clients or downstream services. A major cost driver in streaming.

• Connection Pool Starvation

  Networking

  A failure mode where all pooled connections (DB, HTTP, Redis) are held by slow or leaked operations, so new requests queue and time out despite a healthy backend.

• Socket Timeout

  Networking

  The maximum time a client waits for a socket operation (connect, read, write) before aborting. Misconfigured timeouts cause cascading stalls or premature failures.

• CDN (Content Delivery Network)

  Networking

  A geographically distributed cache of edge servers that serves media segments close to viewers, reducing origin load, egress cost, and playback latency.

• DRM (Digital Rights Management)

  Networking

  License and encryption technology (e.g. Widevine, FairPlay, PlayReady) that controls access to protected streaming content and enforces playback entitlements.

• Kafka

  Networking

  A distributed, partitioned commit log used as a durable, high-throughput event streaming backbone for telemetry, playback events, and service-to-service messaging.

• Kinesis

  Networking

  AWS's managed streaming data service for real-time ingestion and processing of large event streams, an alternative to self-managed Kafka.

• TTL (Time To Live) in Live Streaming

  Networking

  How long a cached media segment or manifest stays valid at the edge. Short TTLs keep live streams fresh; overly long TTLs serve stale segments.

• Backpressure

  Networking

  A flow-control mechanism where a downstream consumer signals it cannot keep up, causing upstream producers to slow, buffer, or shed load to avoid overload.

• Redis

  Redis/Caching

  An in-memory key/value data store used for caching, session state, rate limiting, and pub/sub, prized for sub-millisecond reads in latency-sensitive paths.

• Redis COBL (Cache Operations Blocking Latency)

  Redis/Caching

  Latency introduced when long-running or blocking Redis operations stall the single-threaded command loop, delaying all other clients and starving connection pools.

• LRU (Least Recently Used) Eviction

  Redis/Caching

  A cache eviction policy that discards the entries untouched for the longest time when memory is full, keeping hot data resident.

• OOM-Kill Protection

  Redis/Caching

  Safeguards (memory limits, maxmemory policies, cgroups) that prevent the Linux OOM killer from terminating a process by bounding memory before the kernel intervenes.

• Memory Limiter

  Redis/Caching

  A guardrail that caps a process's memory consumption and rejects or sheds load as it nears the limit, avoiding hard OOM kills — as in Redis maxmemory or the collector's memory_limiter.

• Cache Hit Ratio

  Redis/Caching

  The fraction of lookups served from cache versus total lookups. Higher ratios cut backend load and latency; a falling ratio often precedes an origin overload incident.

• Cache Stampede

  Redis/Caching

  A surge where many clients simultaneously miss an expired cache key and hammer the origin at once. Mitigated with request coalescing, jittered TTLs, or locks.

• TTL (Cache Expiry)

  Redis/Caching

  The lifetime assigned to a cached key after which it expires and is refetched. Balances freshness against origin load and stampede risk.

• QoE (Quality of Experience)

  QoE

  The viewer-perceived quality of a streaming session, captured by metrics like startup time, rebuffering, and bitrate rather than raw server health alone.

• Rebuffering Ratio

  QoE

  The share of playback time spent stalled waiting for the buffer to refill. A key QoE signal; even small increases sharply raise viewer abandonment.

• Startup Time (Join Time)

  QoE

  The delay from a viewer pressing play to the first frame rendering. Lower startup time strongly correlates with higher engagement and retention.

• Video Start Failure (VSF)

  QoE

  A QoE metric counting sessions where playback never begins after a play attempt, due to manifest, DRM, CDN, or player errors.

• Bitrate (Average Playback Bitrate)

  QoE

  The mean encoded quality delivered during a session. Higher bitrate signals better visual quality but must be balanced against rebuffering under constrained bandwidth.

• Adaptive Bitrate (ABR)

  QoE

  A streaming technique that switches between quality renditions in real time based on bandwidth and buffer state to minimize rebuffering while maximizing quality.

• Concurrent Plays (Concurrency)

  QoE

  The number of viewers streaming simultaneously. Peak concurrency during live OTT events drives capacity planning and is a leading indicator of infrastructure stress.