The OpenTelemetry project uses terminology you may or may not be familiar with. In addition, the project may define the terminology in a different way than others. This page captures terminology used in the project and what it means.

Generic Terminology

  • Aggregation: The process of combining multiple measurements into exact or estimated statistics about the measurements that took place during an interval of time, during program execution. Used by the Metric Data Source.
  • API: Application Programming Interface. In the OpenTelemetry project, used to define how telemetry data is generated per Data Source.
  • Application: One or more Services designed for end users or other applications.
  • APM: Application Performance Monitoring. Typically a back-end of the Tracing Data Source.
  • Attribute: A key-value pair. Used by the Tracing Data Source to attach data to a Span.
  • Baggage: A mechanism for propagating name/value pairs to help establish a causal relationship between events and services.
  • Client Library: See Instrumented Library.
  • Client-side App: A component of an Application that is not running inside a private infrastructure and is typically used directly by end-users. Examples of client-side apps are browser apps, mobile apps, and apps running on IoT devices.
  • Collector: A vendor-agnostic implementation on how to receive, process, and export telemetry data. A single binary that can be deployed as an agent or gateway.
  • Contrib: Several Instrumentation Libraries and the Collector offer a set of core capabilities as well as a dedicated contrib repository for non-core capabilities including vendor Exporters.
  • Context Propagation: Allows all Data Sources to share an underlying context mechanism for storing state and accessing data across the lifespan of a Transaction.
  • DAG: Directed Acyclic Graph.
  • Data Source: One of Traces, Metrics or Logs.
  • Dimension: See Label.
  • Distributed Tracing: Tracks the progression of a single Request, called a Trace, as it is handled by Services that make up an Application. A Distributed Trace transverses process, network and security boundaries.
  • Event: Something that happened where representation depends on the Data Source. For example, Spans.
  • Exporter: Provides functionality to emit telemetry to consumers. Used by Instrumentation Libraries and the Collector. Exporters can be push or pull based.
  • Field: name/value pairs added to Log Records (similar to Attributes for Spans and Labels for Metrics).
  • gRPC: A high-performance, open source universal RPC framework.
  • HTTP: Hypertext Transfer Protocol.
  • Instrumented Library: Denotes the Library for which the telemetry signals (Traces, Metrics, Logs) are gathered.
  • Instrumentation Library: Denotes the Library that provides the instrumentation for a given Instrumented Library. Instrumented Library and Instrumentation Library may be the same Library if it has built-in OpenTelemetry instrumentation.
  • JSON: JavaScript Object Notation.
  • Label: see Attribute.
  • Language: Programming Language.
  • Library: A language-specific collection of behavior invoked by an interface.
  • Log: Sometimes used to refer to a collection of Log Records. May be ambiguous, since people also sometimes use Log to refer to a single Log Record, thus this term should be used carefully and in the context where ambiguity is possible additional qualifiers should be used (e.g. Log Record).
  • Log Record: A recording of an Event. Typically the record includes a timestamp indicating when the Event happened as well as other data that describes what happened, where it happened, etc.
  • Metadata: name/value pair added to telemetry data. OpenTelemetry calls this Attributes on Spans, Labels on Metrics and Fields on Logs.
  • Metric: Records a data point, either raw measurements or predefined aggregation, as timeseries with Metadata.
  • OC: OpenCensus.
  • OpenCensus: a set of libraries for various languages that allow you to collect application metrics and distributed traces, then transfer the data to a backend of your choice in real time. Precursor to OpenTelemetry.
  • OpenTracing: Vendor-neutral APIs and instrumentation for distributed tracing. Precursor to OpenTelemetry.
  • OT: OpenTracing.
  • OTel: OpenTelemetry.
  • OtelCol: OpenTelemetry Collector.
  • OTLP: OpenTelemetry Protocol.
  • Processor: Operation performed on data between being received and being exported. For example, batching. Used by Instrumentation Libraries and the Collector.
  • Propagators: Used to serialize and deserialize specific parts of telemetry data such as span context and Baggage in Spans.
  • Proto: Language independent interface types.
  • Receiver: Term used by the Collector to define how telemetry data is received. Receivers can be push or pull based.
  • Request: See Distributed Tracing.
  • Resource: Captures information about the entity for which telemetry is recorded. For example, a process producing telemetry that is running in a container on Kubernetes has a pod name, it is in a namespace and possibly is part of a deployment which also has a name. All three of these attributes can be included in the Resource and applied to any data source.
  • REST: Representation State Transfer.
  • RPC: Remote Procedure Call.
  • Sampling: A mechanism to control the amount of data exported. Most commonly used with the Tracing Data Source.
  • SDK: Software Development Kit. Refers to a telemetry SDK that denotes a Library that implement the OpenTelemetry API.
  • Semantic Conventions: Defines standard names and values of Metadata in order to provide vendor-agnostic telemetry data.
  • Service: A component of an Application. Multiple instances of a Service are typically deployed for high availability and scalability. A Service may be deployed in multiple locations.
  • Span: Represents a single operation within a Trace.
  • Span Link: A span link is a link between causally-related spans. For details see Links between spans and Specifying Links.
  • Specification: Describes the cross-language requirements and expectations for all implementations.
  • Status: The result of the operation. Typically used to indicate whether an error occurred.
  • Tag: see Metadata.
  • Trace: A DAG of Spans, where the edges between Spans are defined as parent/child relationship.
  • Tracer: Responsible for creating Spans.
  • Transaction: See Distributed Tracing.
  • zPages: An in-process alternative to external exporters. When included, they collect and aggregate tracing and metrics information in the background; this data is served on web pages when requested.

Additional Terminology




Semantic Conventions

Last modified December 23, 2021: Refresh go docs again (#1012) (c9102ad)