Top Related Projects
OpenTelemetry Collector
CNCF Jaeger, a Distributed Tracing Platform
Zipkin is a distributed tracing system
The Prometheus monitoring system and time series database.
Quick Overview
The OpenTelemetry Specification repository contains the official specifications for OpenTelemetry, an observability framework for cloud-native software. It defines standards for generating, collecting, and exporting telemetry data (metrics, logs, and traces) to help developers monitor, debug, and optimize their applications.
Pros
- Provides a vendor-neutral, open-source standard for observability
- Supports multiple programming languages and environments
- Offers a unified approach to metrics, logs, and traces
- Enables easy integration with various backend systems and tools
Cons
- Can be complex to implement fully, especially for large systems
- Ongoing development may lead to occasional breaking changes
- Adoption may require significant changes to existing monitoring setups
- Some advanced features are still in experimental stages
Getting Started
To get started with OpenTelemetry, follow these steps:
- Choose the appropriate OpenTelemetry SDK for your programming language.
- Install the SDK and any necessary dependencies.
- Configure the SDK in your application:
# Example configuration (pseudo-code)
1. Import OpenTelemetry SDK
2. Set up a tracer provider
3. Configure exporters (e.g., OTLP, Jaeger)
4. Initialize and register instrumentation
# Implement tracing in your code
5. Create spans for important operations
6. Add attributes and events to spans
7. Propagate context across service boundaries
# Configure metrics collection
8. Set up a meter provider
9. Define and record metrics in your code
# Set up logging (if supported in your SDK)
10. Configure a log provider
11. Use OpenTelemetry logging API in your code
For detailed, language-specific instructions, refer to the OpenTelemetry documentation for your chosen programming language.
Competitor Comparisons
OpenTelemetry Collector
Pros of opentelemetry-collector
- Provides a ready-to-use implementation for collecting, processing, and exporting telemetry data
- Offers a wide range of built-in components for various data sources and destinations
- Supports dynamic configuration and hot-reloading for easier management and updates
Cons of opentelemetry-collector
- More complex to set up and maintain compared to the specification
- May introduce additional overhead in terms of resource usage and performance
- Requires regular updates to keep up with evolving standards and best practices
Code Comparison
opentelemetry-collector (Go):
func NewFactory() component.ReceiverFactory {
return receiverhelper.NewFactory(
"otlp",
createDefaultConfig,
receiverhelper.WithTraces(createTracesReceiver),
receiverhelper.WithMetrics(createMetricsReceiver),
receiverhelper.WithLogs(createLogsReceiver),
)
}
opentelemetry-specification (Markdown):
# Span
A span represents a single operation within a trace. Spans can be nested to form a trace tree. Each trace contains a root span, which typically describes the end-to-end latency and, optionally, one or more sub-spans for its sub-operations.
The code snippets illustrate the difference in focus between the two repositories. The collector provides concrete implementations, while the specification defines concepts and standards.
CNCF Jaeger, a Distributed Tracing Platform
Pros of Jaeger
- Mature and battle-tested distributed tracing system with a large user base
- Provides a complete end-to-end tracing solution out of the box
- Offers a rich UI for trace visualization and analysis
Cons of Jaeger
- Less flexible and extensible compared to OpenTelemetry's modular approach
- Limited to tracing, while OpenTelemetry covers metrics and logs as well
- Potentially more complex to set up and maintain for large-scale deployments
Code Comparison
Jaeger (Go):
tracer, closer := jaeger.NewTracer(
"service-name",
jaeger.NewConstSampler(true),
jaeger.NewInMemoryReporter(),
)
defer closer.Close()
OpenTelemetry (Go):
tp := sdktrace.NewTracerProvider(
sdktrace.WithSampler(sdktrace.AlwaysSample()),
sdktrace.WithBatcher(exporter),
)
defer tp.Shutdown(context.Background())
otel.SetTracerProvider(tp)
While Jaeger provides a more straightforward setup for its specific tracing solution, OpenTelemetry offers a more flexible and standardized approach to instrumentation across various observability signals. OpenTelemetry's specification aims to create a unified standard for telemetry data collection and transmission, potentially simplifying the observability landscape in the long run.
Zipkin is a distributed tracing system
Pros of Zipkin
- Mature and battle-tested system with a long history of production use
- Simpler architecture, easier to set up and maintain for smaller projects
- Provides a built-in UI for trace visualization out of the box
Cons of Zipkin
- Limited language support compared to OpenTelemetry's wide range of SDKs
- Less flexible data model, which may not capture all types of telemetry data
- Smaller ecosystem and community compared to OpenTelemetry's growing adoption
Code Comparison
Zipkin instrumentation example:
Span span = tracer.newTrace().name("encode").start();
try {
doSomethingExpensive();
} finally {
span.finish();
}
OpenTelemetry instrumentation example:
Span span = tracer.spanBuilder("encode").startSpan();
try (Scope scope = span.makeCurrent()) {
doSomethingExpensive();
} finally {
span.end();
}
Both examples show similar concepts for creating and managing spans, but OpenTelemetry introduces the concept of a "current" span through the use of a Scope.
Pros of apm-server
- Tightly integrated with Elasticsearch and Kibana for seamless data visualization
- Provides out-of-the-box instrumentation for popular frameworks and languages
- Offers built-in error tracking and exception handling capabilities
Cons of apm-server
- Less flexible for custom instrumentation compared to OpenTelemetry
- Limited support for non-Elastic observability backends
- Smaller community and ecosystem compared to OpenTelemetry
Code Comparison
apm-server:
func (p *Processor) ProcessTransformable(t transform.Transformable) []beat.Event {
events := t.Transform()
for i := range events {
p.enhanceEventWithMetadata(&events[i])
}
return events
}
opentelemetry-specification:
func (e *spanExporter) ExportSpans(ctx context.Context, spans []*trace.SpanData) error {
for _, span := range spans {
e.processSpan(span)
}
return e.client.Upload(ctx, e.buffer)
}
The code snippets show different approaches to processing and exporting telemetry data. apm-server focuses on transforming events and enhancing them with metadata, while OpenTelemetry's example demonstrates exporting spans and uploading them to a client.
The Prometheus monitoring system and time series database.
Pros of Prometheus
- Mature and battle-tested monitoring system with a large ecosystem
- Built-in alerting and visualization capabilities
- Simple setup and configuration for basic monitoring needs
Cons of Prometheus
- Limited to pull-based metrics collection
- Lacks native support for distributed tracing and logs
- Less flexible data model compared to OpenTelemetry's unified approach
Code Comparison
Prometheus configuration (prometheus.yml):
scrape_configs:
- job_name: 'my_app'
static_configs:
- targets: ['localhost:8080']
OpenTelemetry configuration (otel-collector-config.yaml):
receivers:
otlp:
protocols:
grpc:
exporters:
prometheus:
endpoint: "0.0.0.0:8889"
service:
pipelines:
metrics:
receivers: [otlp]
exporters: [prometheus]
While Prometheus focuses on metrics and a pull-based model, OpenTelemetry provides a more comprehensive observability solution with support for metrics, traces, and logs. OpenTelemetry's specification aims to standardize telemetry data collection across various languages and platforms, offering greater flexibility and interoperability. However, Prometheus remains a popular choice for its simplicity and robust ecosystem, especially for metrics-focused monitoring scenarios.
Convert 
designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual CopilotREADME
OpenTelemetry Specification
The OpenTelemetry specification describes the cross-language requirements and expectations for all OpenTelemetry implementations.
- The latest release is hosted at opentelemetry.io/docs/specs/otel
- Markdown sources are under specification
Change / contribution process
For details, see CONTRIBUTING.md, in particular read Proposing a change before submitting a PR.
Questions
Questions that need additional attention can be brought to the regular specifications meeting. EU and US timezone friendly meeting is held every Tuesday at 8 AM Pacific time. Meeting notes are held in the Google doc. APAC timezone friendly meetings are held on request. See OpenTelemetry calendar.
Escalations to technical committee may be made over the e-mail. Technical committee holds regular meetings, notes are held here.
Specification compliance matrix by language
See Compliance of Implementations with Specification.
Project Timeline
The current project status as well as information on notable past releases is found at the OpenTelemetry project page.
Information about current work and future development plans is found at the specification development milestones.
Versioning the Specification
Changes to the specification are versioned according to Semantic Versioning 2.0 and described in CHANGELOG.md. Layout changes are not versioned. Specific implementations of the specification should specify which version they implement.
Changes to the change process itself are not currently versioned but may be independently versioned in the future.
License
By contributing to OpenTelemetry Specification repository, you agree that your contributions will be licensed under its Apache 2.0 License.
Top Related Projects
OpenTelemetry Collector
CNCF Jaeger, a Distributed Tracing Platform
Zipkin is a distributed tracing system
The Prometheus monitoring system and time series database.
Convert designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual Copilot