109 KiB
Semantic conventions for OpenTelemetry SDK metrics
Status: Development
This document describes metrics emitted by the OpenTelemetry SDK components themselves about their internal state.
Span metrics
Metric: otel.sdk.span.live
This metric is recommended.
| Name | Instrument Type | Unit (UCUM) | Description | Stability | Entity Associations |
|---|---|---|---|---|---|
otel.sdk.span.live |
UpDownCounter | {span} |
The number of created spans with recording=true for which the end operation has not been called yet. |
 |
| Attribute | Type | Description | Examples | Requirement Level | Stability |
|---|---|---|---|---|---|
otel.span.sampling_result |
string | The result value of the sampler for this span | DROP; RECORD_ONLY; RECORD_AND_SAMPLE |
Recommended |
|
otel.span.sampling_result has the following list of well-known values. If one of them applies, then the respective value MUST be used; otherwise, a custom value MAY be used.
| Value | Description | Stability |
|---|---|---|
DROP |
The span is not sampled and not recording | |
RECORD_AND_SAMPLE |
The span is sampled and recording | |
RECORD_ONLY |
The span is not sampled, but recording | |
Metric: otel.sdk.span.started
This metric is recommended.
| Name | Instrument Type | Unit (UCUM) | Description | Stability | Entity Associations |
|---|---|---|---|---|---|
otel.sdk.span.started |
Counter | {span} |
The number of created spans. [1] | |
[1]: Implementations MUST record this metric for all spans, even for non-recording ones.
| Attribute | Type | Description | Examples | Requirement Level | Stability |
|---|---|---|---|---|---|
otel.span.parent.origin |
string | Determines whether the span has a parent span, and if so, whether it is a remote parent | none; local; remote |
Recommended |
|
otel.span.sampling_result |
string | The result value of the sampler for this span | DROP; RECORD_ONLY; RECORD_AND_SAMPLE |
Recommended |
|
otel.span.parent.origin has the following list of well-known values. If one of them applies, then the respective value MUST be used; otherwise, a custom value MAY be used.
| Value | Description | Stability |
|---|---|---|
local |
The span has a parent and the parent's span context isRemote() is false | |
none |
The span does not have a parent, it is a root span | |
remote |
The span has a parent and the parent's span context isRemote() is true | |
otel.span.sampling_result has the following list of well-known values. If one of them applies, then the respective value MUST be used; otherwise, a custom value MAY be used.
| Value | Description | Stability |
|---|---|---|
DROP |
The span is not sampled and not recording | |
RECORD_AND_SAMPLE |
The span is sampled and recording | |
RECORD_ONLY |
The span is not sampled, but recording | |
Metric: otel.sdk.processor.span.queue.size
This metric is recommended.
| Name | Instrument Type | Unit (UCUM) | Description | Stability | Entity Associations |
|---|---|---|---|---|---|
otel.sdk.processor.span.queue.size |
UpDownCounter | {span} |
The number of spans in the queue of a given instance of an SDK span processor. [1] | |
[1]: Only applies to span processors which use a queue, e.g. the SDK Batching Span Processor.
| Attribute | Type | Description | Examples | Requirement Level | Stability |
|---|---|---|---|---|---|
otel.component.name |
string | A name uniquely identifying the instance of the OpenTelemetry component within its containing SDK instance. [1] | otlp_grpc_span_exporter/0; custom-name |
Recommended |
|
otel.component.type |
string | A name identifying the type of the OpenTelemetry component. [2] | batching_span_processor; com.example.MySpanExporter |
Recommended |
|
[1] otel.component.name: Implementations SHOULD ensure a low cardinality for this attribute, even across application or SDK restarts.
E.g. implementations MUST NOT use UUIDs as values for this attribute.
Implementations MAY achieve these goals by following a <otel.component.type>/<instance-counter> pattern, e.g. batching_span_processor/0.
Hereby otel.component.type refers to the corresponding attribute value of the component.
The value of instance-counter MAY be automatically assigned by the component and uniqueness within the enclosing SDK instance MUST be guaranteed.
For example, <instance-counter> MAY be implemented by using a monotonically increasing counter (starting with 0), which is incremented every time an
instance of the given component type is started.
With this implementation, for example the first Batching Span Processor would have batching_span_processor/0
as otel.component.name, the second one batching_span_processor/1 and so on.
These values will therefore be reused in the case of an application restart.
[2] otel.component.type: If none of the standardized values apply, implementations SHOULD use the language-defined name of the type.
E.g. for Java the fully qualified classname SHOULD be used in this case.
otel.component.type has the following list of well-known values. If one of them applies, then the respective value MUST be used; otherwise, a custom value MAY be used.
| Value | Description | Stability |
|---|---|---|
batching_log_processor |
The builtin SDK batching log record processor | |
batching_span_processor |
The builtin SDK batching span processor | |
otlp_grpc_log_exporter |
OTLP log record exporter over gRPC with protobuf serialization | |
otlp_grpc_metric_exporter |
OTLP metric exporter over gRPC with protobuf serialization | |
otlp_grpc_span_exporter |
OTLP span exporter over gRPC with protobuf serialization | |
otlp_http_json_log_exporter |
OTLP log record exporter over HTTP with JSON serialization | |
otlp_http_json_metric_exporter |
OTLP metric exporter over HTTP with JSON serialization | |
otlp_http_json_span_exporter |
OTLP span exporter over HTTP with JSON serialization | |
otlp_http_log_exporter |
OTLP log record exporter over HTTP with protobuf serialization | |
otlp_http_metric_exporter |
OTLP metric exporter over HTTP with protobuf serialization | |
otlp_http_span_exporter |
OTLP span exporter over HTTP with protobuf serialization | |
periodic_metric_reader |
The builtin SDK periodically exporting metric reader | |
prometheus_http_text_metric_exporter |
Prometheus metric exporter over HTTP with the default text-based format | |
simple_log_processor |
The builtin SDK simple log record processor | |
simple_span_processor |
The builtin SDK simple span processor | |
zipkin_http_span_exporter |
Zipkin span exporter over HTTP | |
Metric: otel.sdk.processor.span.queue.capacity
This metric is recommended.
| Name | Instrument Type | Unit (UCUM) | Description | Stability | Entity Associations |
|---|---|---|---|---|---|
otel.sdk.processor.span.queue.capacity |
UpDownCounter | {span} |
The maximum number of spans the queue of a given instance of an SDK span processor can hold. [1] | |
[1]: Only applies to span processors which use a queue, e.g. the SDK Batching Span Processor.
| Attribute | Type | Description | Examples | Requirement Level | Stability |
|---|---|---|---|---|---|
otel.component.name |
string | A name uniquely identifying the instance of the OpenTelemetry component within its containing SDK instance. [1] | otlp_grpc_span_exporter/0; custom-name |
Recommended |
|
otel.component.type |
string | A name identifying the type of the OpenTelemetry component. [2] | batching_span_processor; com.example.MySpanExporter |
Recommended |
|
[1] otel.component.name: Implementations SHOULD ensure a low cardinality for this attribute, even across application or SDK restarts.
E.g. implementations MUST NOT use UUIDs as values for this attribute.
Implementations MAY achieve these goals by following a <otel.component.type>/<instance-counter> pattern, e.g. batching_span_processor/0.
Hereby otel.component.type refers to the corresponding attribute value of the component.
The value of instance-counter MAY be automatically assigned by the component and uniqueness within the enclosing SDK instance MUST be guaranteed.
For example, <instance-counter> MAY be implemented by using a monotonically increasing counter (starting with 0), which is incremented every time an
instance of the given component type is started.
With this implementation, for example the first Batching Span Processor would have batching_span_processor/0
as otel.component.name, the second one batching_span_processor/1 and so on.
These values will therefore be reused in the case of an application restart.
[2] otel.component.type: If none of the standardized values apply, implementations SHOULD use the language-defined name of the type.
E.g. for Java the fully qualified classname SHOULD be used in this case.
otel.component.type has the following list of well-known values. If one of them applies, then the respective value MUST be used; otherwise, a custom value MAY be used.
| Value | Description | Stability |
|---|---|---|
batching_log_processor |
The builtin SDK batching log record processor | |
batching_span_processor |
The builtin SDK batching span processor | |
otlp_grpc_log_exporter |
OTLP log record exporter over gRPC with protobuf serialization | |
otlp_grpc_metric_exporter |
OTLP metric exporter over gRPC with protobuf serialization | |
otlp_grpc_span_exporter |
OTLP span exporter over gRPC with protobuf serialization | |
otlp_http_json_log_exporter |
OTLP log record exporter over HTTP with JSON serialization | |
otlp_http_json_metric_exporter |
OTLP metric exporter over HTTP with JSON serialization | |
otlp_http_json_span_exporter |
OTLP span exporter over HTTP with JSON serialization | |
otlp_http_log_exporter |
OTLP log record exporter over HTTP with protobuf serialization | |
otlp_http_metric_exporter |
OTLP metric exporter over HTTP with protobuf serialization | |
otlp_http_span_exporter |
OTLP span exporter over HTTP with protobuf serialization | |
periodic_metric_reader |
The builtin SDK periodically exporting metric reader | |
prometheus_http_text_metric_exporter |
Prometheus metric exporter over HTTP with the default text-based format | |
simple_log_processor |
The builtin SDK simple log record processor | |
simple_span_processor |
The builtin SDK simple span processor | |
zipkin_http_span_exporter |
Zipkin span exporter over HTTP | |
Metric: otel.sdk.processor.span.processed
This metric is recommended.
| Name | Instrument Type | Unit (UCUM) | Description | Stability | Entity Associations |
|---|---|---|---|---|---|
otel.sdk.processor.span.processed |
Counter | {span} |
The number of spans for which the processing has finished, either successful or failed. [1] | |
[1]: For successful processing, error.type MUST NOT be set. For failed processing, error.type MUST contain the failure cause.
For the SDK Simple and Batching Span Processor a span is considered to be processed already when it has been submitted to the exporter, not when the corresponding export call has finished.
| Attribute | Type | Description | Examples | Requirement Level | Stability |
|---|---|---|---|---|---|
error.type |
string | A low-cardinality description of the failure reason. SDK Batching Span Processors MUST use queue_full for spans dropped due to a full queue. [1] |
queue_full |
Recommended |
 |
otel.component.name |
string | A name uniquely identifying the instance of the OpenTelemetry component within its containing SDK instance. [2] | otlp_grpc_span_exporter/0; custom-name |
Recommended |
|
otel.component.type |
string | A name identifying the type of the OpenTelemetry component. [3] | batching_span_processor; com.example.MySpanExporter |
Recommended |
|
[1] error.type: The error.type SHOULD be predictable, and SHOULD have low cardinality.
When error.type is set to a type (e.g., an exception type), its
canonical class name identifying the type within the artifact SHOULD be used.
Instrumentations SHOULD document the list of errors they report.
The cardinality of error.type within one instrumentation library SHOULD be low.
Telemetry consumers that aggregate data from multiple instrumentation libraries and applications
should be prepared for error.type to have high cardinality at query time when no
additional filters are applied.
If the operation has completed successfully, instrumentations SHOULD NOT set error.type.
If a specific domain defines its own set of error identifiers (such as HTTP or gRPC status codes), it's RECOMMENDED to:
- Use a domain-specific attribute
- Set
error.typeto capture all errors, regardless of whether they are defined within the domain-specific set or not.
[2] otel.component.name: Implementations SHOULD ensure a low cardinality for this attribute, even across application or SDK restarts.
E.g. implementations MUST NOT use UUIDs as values for this attribute.
Implementations MAY achieve these goals by following a <otel.component.type>/<instance-counter> pattern, e.g. batching_span_processor/0.
Hereby otel.component.type refers to the corresponding attribute value of the component.
The value of instance-counter MAY be automatically assigned by the component and uniqueness within the enclosing SDK instance MUST be guaranteed.
For example, <instance-counter> MAY be implemented by using a monotonically increasing counter (starting with 0), which is incremented every time an
instance of the given component type is started.
With this implementation, for example the first Batching Span Processor would have batching_span_processor/0
as otel.component.name, the second one batching_span_processor/1 and so on.
These values will therefore be reused in the case of an application restart.
[3] otel.component.type: If none of the standardized values apply, implementations SHOULD use the language-defined name of the type.
E.g. for Java the fully qualified classname SHOULD be used in this case.
error.type has the following list of well-known values. If one of them applies, then the respective value MUST be used; otherwise, a custom value MAY be used.
| Value | Description | Stability |
|---|---|---|
_OTHER |
A fallback error value to be used when the instrumentation doesn't define a custom value. | |
otel.component.type has the following list of well-known values. If one of them applies, then the respective value MUST be used; otherwise, a custom value MAY be used.
| Value | Description | Stability |
|---|---|---|
batching_log_processor |
The builtin SDK batching log record processor | |
batching_span_processor |
The builtin SDK batching span processor | |
otlp_grpc_log_exporter |
OTLP log record exporter over gRPC with protobuf serialization | |
otlp_grpc_metric_exporter |
OTLP metric exporter over gRPC with protobuf serialization | |
otlp_grpc_span_exporter |
OTLP span exporter over gRPC with protobuf serialization | |
otlp_http_json_log_exporter |
OTLP log record exporter over HTTP with JSON serialization | |
otlp_http_json_metric_exporter |
OTLP metric exporter over HTTP with JSON serialization | |
otlp_http_json_span_exporter |
OTLP span exporter over HTTP with JSON serialization | |
otlp_http_log_exporter |
OTLP log record exporter over HTTP with protobuf serialization | |
otlp_http_metric_exporter |
OTLP metric exporter over HTTP with protobuf serialization | |
otlp_http_span_exporter |
OTLP span exporter over HTTP with protobuf serialization | |
periodic_metric_reader |
The builtin SDK periodically exporting metric reader | |
prometheus_http_text_metric_exporter |
Prometheus metric exporter over HTTP with the default text-based format | |
simple_log_processor |
The builtin SDK simple log record processor | |
simple_span_processor |
The builtin SDK simple span processor | |
zipkin_http_span_exporter |
Zipkin span exporter over HTTP | |
Metric: otel.sdk.exporter.span.inflight
This metric is recommended.
| Name | Instrument Type | Unit (UCUM) | Description | Stability | Entity Associations |
|---|---|---|---|---|---|
otel.sdk.exporter.span.inflight |
UpDownCounter | {span} |
The number of spans which were passed to the exporter, but that have not been exported yet (neither successful, nor failed). [1] | |
[1]: For successful exports, error.type MUST NOT be set. For failed exports, error.type MUST contain the failure cause.
| Attribute | Type | Description | Examples | Requirement Level | Stability |
|---|---|---|---|---|---|
otel.component.name |
string | A name uniquely identifying the instance of the OpenTelemetry component within its containing SDK instance. [1] | otlp_grpc_span_exporter/0; custom-name |
Recommended |
|
otel.component.type |
string | A name identifying the type of the OpenTelemetry component. [2] | batching_span_processor; com.example.MySpanExporter |
Recommended |
|
server.address |
string | Server domain name if available without reverse DNS lookup; otherwise, IP address or Unix domain socket name. [3] | example.com; 10.1.2.80; /tmp/my.sock |
Recommended when applicable |
|
server.port |
int | Server port number. [4] | 80; 8080; 443 |
Recommended when applicable |
|
[1] otel.component.name: Implementations SHOULD ensure a low cardinality for this attribute, even across application or SDK restarts.
E.g. implementations MUST NOT use UUIDs as values for this attribute.
Implementations MAY achieve these goals by following a <otel.component.type>/<instance-counter> pattern, e.g. batching_span_processor/0.
Hereby otel.component.type refers to the corresponding attribute value of the component.
The value of instance-counter MAY be automatically assigned by the component and uniqueness within the enclosing SDK instance MUST be guaranteed.
For example, <instance-counter> MAY be implemented by using a monotonically increasing counter (starting with 0), which is incremented every time an
instance of the given component type is started.
With this implementation, for example the first Batching Span Processor would have batching_span_processor/0
as otel.component.name, the second one batching_span_processor/1 and so on.
These values will therefore be reused in the case of an application restart.
[2] otel.component.type: If none of the standardized values apply, implementations SHOULD use the language-defined name of the type.
E.g. for Java the fully qualified classname SHOULD be used in this case.
[3] server.address: When observed from the client side, and when communicating through an intermediary, server.address SHOULD represent the server address behind any intermediaries, for example proxies, if it's available.
[4] server.port: When observed from the client side, and when communicating through an intermediary, server.port SHOULD represent the server port behind any intermediaries, for example proxies, if it's available.
otel.component.type has the following list of well-known values. If one of them applies, then the respective value MUST be used; otherwise, a custom value MAY be used.
| Value | Description | Stability |
|---|---|---|
batching_log_processor |
The builtin SDK batching log record processor | |
batching_span_processor |
The builtin SDK batching span processor | |
otlp_grpc_log_exporter |
OTLP log record exporter over gRPC with protobuf serialization | |
otlp_grpc_metric_exporter |
OTLP metric exporter over gRPC with protobuf serialization | |
otlp_grpc_span_exporter |
OTLP span exporter over gRPC with protobuf serialization | |
otlp_http_json_log_exporter |
OTLP log record exporter over HTTP with JSON serialization | |
otlp_http_json_metric_exporter |
OTLP metric exporter over HTTP with JSON serialization | |
otlp_http_json_span_exporter |
OTLP span exporter over HTTP with JSON serialization | |
otlp_http_log_exporter |
OTLP log record exporter over HTTP with protobuf serialization | |
otlp_http_metric_exporter |
OTLP metric exporter over HTTP with protobuf serialization | |
otlp_http_span_exporter |
OTLP span exporter over HTTP with protobuf serialization | |
periodic_metric_reader |
The builtin SDK periodically exporting metric reader | |
prometheus_http_text_metric_exporter |
Prometheus metric exporter over HTTP with the default text-based format | |
simple_log_processor |
The builtin SDK simple log record processor | |
simple_span_processor |
The builtin SDK simple span processor | |
zipkin_http_span_exporter |
Zipkin span exporter over HTTP | |
Metric: otel.sdk.exporter.span.exported
This metric is recommended.
| Name | Instrument Type | Unit (UCUM) | Description | Stability | Entity Associations |
|---|---|---|---|---|---|
otel.sdk.exporter.span.exported |
Counter | {span} |
The number of spans for which the export has finished, either successful or failed. [1] | |
[1]: For successful exports, error.type MUST NOT be set. For failed exports, error.type MUST contain the failure cause.
For exporters with partial success semantics (e.g. OTLP with rejected_spans), rejected spans MUST count as failed and only non-rejected spans count as success.
If no rejection reason is available, rejected SHOULD be used as value for error.type.
| Attribute | Type | Description | Examples | Requirement Level | Stability |
|---|---|---|---|---|---|
error.type |
string | Describes a class of error the operation ended with. [1] | rejected; timeout; 500; java.net.UnknownHostException |
Recommended |
|
otel.component.name |
string | A name uniquely identifying the instance of the OpenTelemetry component within its containing SDK instance. [2] | otlp_grpc_span_exporter/0; custom-name |
Recommended |
|
otel.component.type |
string | A name identifying the type of the OpenTelemetry component. [3] | batching_span_processor; com.example.MySpanExporter |
Recommended |
|
server.address |
string | Server domain name if available without reverse DNS lookup; otherwise, IP address or Unix domain socket name. [4] | example.com; 10.1.2.80; /tmp/my.sock |
Recommended when applicable |
|
server.port |
int | Server port number. [5] | 80; 8080; 443 |
Recommended when applicable |
|
[1] error.type: The error.type SHOULD be predictable, and SHOULD have low cardinality.
When error.type is set to a type (e.g., an exception type), its
canonical class name identifying the type within the artifact SHOULD be used.
Instrumentations SHOULD document the list of errors they report.
The cardinality of error.type within one instrumentation library SHOULD be low.
Telemetry consumers that aggregate data from multiple instrumentation libraries and applications
should be prepared for error.type to have high cardinality at query time when no
additional filters are applied.
If the operation has completed successfully, instrumentations SHOULD NOT set error.type.
If a specific domain defines its own set of error identifiers (such as HTTP or gRPC status codes), it's RECOMMENDED to:
- Use a domain-specific attribute
- Set
error.typeto capture all errors, regardless of whether they are defined within the domain-specific set or not.
[2] otel.component.name: Implementations SHOULD ensure a low cardinality for this attribute, even across application or SDK restarts.
E.g. implementations MUST NOT use UUIDs as values for this attribute.
Implementations MAY achieve these goals by following a <otel.component.type>/<instance-counter> pattern, e.g. batching_span_processor/0.
Hereby otel.component.type refers to the corresponding attribute value of the component.
The value of instance-counter MAY be automatically assigned by the component and uniqueness within the enclosing SDK instance MUST be guaranteed.
For example, <instance-counter> MAY be implemented by using a monotonically increasing counter (starting with 0), which is incremented every time an
instance of the given component type is started.
With this implementation, for example the first Batching Span Processor would have batching_span_processor/0
as otel.component.name, the second one batching_span_processor/1 and so on.
These values will therefore be reused in the case of an application restart.
[3] otel.component.type: If none of the standardized values apply, implementations SHOULD use the language-defined name of the type.
E.g. for Java the fully qualified classname SHOULD be used in this case.
[4] server.address: When observed from the client side, and when communicating through an intermediary, server.address SHOULD represent the server address behind any intermediaries, for example proxies, if it's available.
[5] server.port: When observed from the client side, and when communicating through an intermediary, server.port SHOULD represent the server port behind any intermediaries, for example proxies, if it's available.
error.type has the following list of well-known values. If one of them applies, then the respective value MUST be used; otherwise, a custom value MAY be used.
| Value | Description | Stability |
|---|---|---|
_OTHER |
A fallback error value to be used when the instrumentation doesn't define a custom value. | |
otel.component.type has the following list of well-known values. If one of them applies, then the respective value MUST be used; otherwise, a custom value MAY be used.
| Value | Description | Stability |
|---|---|---|
batching_log_processor |
The builtin SDK batching log record processor | |
batching_span_processor |
The builtin SDK batching span processor | |
otlp_grpc_log_exporter |
OTLP log record exporter over gRPC with protobuf serialization | |
otlp_grpc_metric_exporter |
OTLP metric exporter over gRPC with protobuf serialization | |
otlp_grpc_span_exporter |
OTLP span exporter over gRPC with protobuf serialization | |
otlp_http_json_log_exporter |
OTLP log record exporter over HTTP with JSON serialization | |
otlp_http_json_metric_exporter |
OTLP metric exporter over HTTP with JSON serialization | |
otlp_http_json_span_exporter |
OTLP span exporter over HTTP with JSON serialization | |
otlp_http_log_exporter |
OTLP log record exporter over HTTP with protobuf serialization | |
otlp_http_metric_exporter |
OTLP metric exporter over HTTP with protobuf serialization | |
otlp_http_span_exporter |
OTLP span exporter over HTTP with protobuf serialization | |
periodic_metric_reader |
The builtin SDK periodically exporting metric reader | |
prometheus_http_text_metric_exporter |
Prometheus metric exporter over HTTP with the default text-based format | |
simple_log_processor |
The builtin SDK simple log record processor | |
simple_span_processor |
The builtin SDK simple span processor | |
zipkin_http_span_exporter |
Zipkin span exporter over HTTP | |
Log metrics
Metric: otel.sdk.log.created
This metric is recommended.
| Name | Instrument Type | Unit (UCUM) | Description | Stability | Entity Associations |
|---|---|---|---|---|---|
otel.sdk.log.created |
Counter | {log_record} |
The number of logs submitted to enabled SDK Loggers. | |
Metric: otel.sdk.processor.log.queue.size
This metric is recommended.
| Name | Instrument Type | Unit (UCUM) | Description | Stability | Entity Associations |
|---|---|---|---|---|---|
otel.sdk.processor.log.queue.size |
UpDownCounter | {log_record} |
The number of log records in the queue of a given instance of an SDK log processor. [1] | |
[1]: Only applies to log record processors which use a queue, e.g. the SDK Batching Log Record Processor.
| Attribute | Type | Description | Examples | Requirement Level | Stability |
|---|---|---|---|---|---|
otel.component.name |
string | A name uniquely identifying the instance of the OpenTelemetry component within its containing SDK instance. [1] | otlp_grpc_span_exporter/0; custom-name |
Recommended |
|
otel.component.type |
string | A name identifying the type of the OpenTelemetry component. [2] | batching_span_processor; com.example.MySpanExporter |
Recommended |
|
[1] otel.component.name: Implementations SHOULD ensure a low cardinality for this attribute, even across application or SDK restarts.
E.g. implementations MUST NOT use UUIDs as values for this attribute.
Implementations MAY achieve these goals by following a <otel.component.type>/<instance-counter> pattern, e.g. batching_span_processor/0.
Hereby otel.component.type refers to the corresponding attribute value of the component.
The value of instance-counter MAY be automatically assigned by the component and uniqueness within the enclosing SDK instance MUST be guaranteed.
For example, <instance-counter> MAY be implemented by using a monotonically increasing counter (starting with 0), which is incremented every time an
instance of the given component type is started.
With this implementation, for example the first Batching Span Processor would have batching_span_processor/0
as otel.component.name, the second one batching_span_processor/1 and so on.
These values will therefore be reused in the case of an application restart.
[2] otel.component.type: If none of the standardized values apply, implementations SHOULD use the language-defined name of the type.
E.g. for Java the fully qualified classname SHOULD be used in this case.
otel.component.type has the following list of well-known values. If one of them applies, then the respective value MUST be used; otherwise, a custom value MAY be used.
| Value | Description | Stability |
|---|---|---|
batching_log_processor |
The builtin SDK batching log record processor | |
batching_span_processor |
The builtin SDK batching span processor | |
otlp_grpc_log_exporter |
OTLP log record exporter over gRPC with protobuf serialization | |
otlp_grpc_metric_exporter |
OTLP metric exporter over gRPC with protobuf serialization | |
otlp_grpc_span_exporter |
OTLP span exporter over gRPC with protobuf serialization | |
otlp_http_json_log_exporter |
OTLP log record exporter over HTTP with JSON serialization | |
otlp_http_json_metric_exporter |
OTLP metric exporter over HTTP with JSON serialization | |
otlp_http_json_span_exporter |
OTLP span exporter over HTTP with JSON serialization | |
otlp_http_log_exporter |
OTLP log record exporter over HTTP with protobuf serialization | |
otlp_http_metric_exporter |
OTLP metric exporter over HTTP with protobuf serialization | |
otlp_http_span_exporter |
OTLP span exporter over HTTP with protobuf serialization | |
periodic_metric_reader |
The builtin SDK periodically exporting metric reader | |
prometheus_http_text_metric_exporter |
Prometheus metric exporter over HTTP with the default text-based format | |
simple_log_processor |
The builtin SDK simple log record processor | |
simple_span_processor |
The builtin SDK simple span processor | |
zipkin_http_span_exporter |
Zipkin span exporter over HTTP | |
Metric: otel.sdk.processor.log.queue.capacity
This metric is recommended.
| Name | Instrument Type | Unit (UCUM) | Description | Stability | Entity Associations |
|---|---|---|---|---|---|
otel.sdk.processor.log.queue.capacity |
UpDownCounter | {log_record} |
The maximum number of log records the queue of a given instance of an SDK Log Record processor can hold. [1] | |
[1]: Only applies to Log Record processors which use a queue, e.g. the SDK Batching Log Record Processor.
| Attribute | Type | Description | Examples | Requirement Level | Stability |
|---|---|---|---|---|---|
otel.component.name |
string | A name uniquely identifying the instance of the OpenTelemetry component within its containing SDK instance. [1] | otlp_grpc_span_exporter/0; custom-name |
Recommended |
|
otel.component.type |
string | A name identifying the type of the OpenTelemetry component. [2] | batching_span_processor; com.example.MySpanExporter |
Recommended |
|
[1] otel.component.name: Implementations SHOULD ensure a low cardinality for this attribute, even across application or SDK restarts.
E.g. implementations MUST NOT use UUIDs as values for this attribute.
Implementations MAY achieve these goals by following a <otel.component.type>/<instance-counter> pattern, e.g. batching_span_processor/0.
Hereby otel.component.type refers to the corresponding attribute value of the component.
The value of instance-counter MAY be automatically assigned by the component and uniqueness within the enclosing SDK instance MUST be guaranteed.
For example, <instance-counter> MAY be implemented by using a monotonically increasing counter (starting with 0), which is incremented every time an
instance of the given component type is started.
With this implementation, for example the first Batching Span Processor would have batching_span_processor/0
as otel.component.name, the second one batching_span_processor/1 and so on.
These values will therefore be reused in the case of an application restart.
[2] otel.component.type: If none of the standardized values apply, implementations SHOULD use the language-defined name of the type.
E.g. for Java the fully qualified classname SHOULD be used in this case.
otel.component.type has the following list of well-known values. If one of them applies, then the respective value MUST be used; otherwise, a custom value MAY be used.
| Value | Description | Stability |
|---|---|---|
batching_log_processor |
The builtin SDK batching log record processor | |
batching_span_processor |
The builtin SDK batching span processor | |
otlp_grpc_log_exporter |
OTLP log record exporter over gRPC with protobuf serialization | |
otlp_grpc_metric_exporter |
OTLP metric exporter over gRPC with protobuf serialization | |
otlp_grpc_span_exporter |
OTLP span exporter over gRPC with protobuf serialization | |
otlp_http_json_log_exporter |
OTLP log record exporter over HTTP with JSON serialization | |
otlp_http_json_metric_exporter |
OTLP metric exporter over HTTP with JSON serialization | |
otlp_http_json_span_exporter |
OTLP span exporter over HTTP with JSON serialization | |
otlp_http_log_exporter |
OTLP log record exporter over HTTP with protobuf serialization | |
otlp_http_metric_exporter |
OTLP metric exporter over HTTP with protobuf serialization | |
otlp_http_span_exporter |
OTLP span exporter over HTTP with protobuf serialization | |
periodic_metric_reader |
The builtin SDK periodically exporting metric reader | |
prometheus_http_text_metric_exporter |
Prometheus metric exporter over HTTP with the default text-based format | |
simple_log_processor |
The builtin SDK simple log record processor | |
simple_span_processor |
The builtin SDK simple span processor | |
zipkin_http_span_exporter |
Zipkin span exporter over HTTP | |
Metric: otel.sdk.processor.log.processed
This metric is recommended.
| Name | Instrument Type | Unit (UCUM) | Description | Stability | Entity Associations |
|---|---|---|---|---|---|
otel.sdk.processor.log.processed |
Counter | {log_record} |
The number of log records for which the processing has finished, either successful or failed. [1] | |
[1]: For successful processing, error.type MUST NOT be set. For failed processing, error.type MUST contain the failure cause.
For the SDK Simple and Batching Log Record Processor a log record is considered to be processed already when it has been submitted to the exporter,
not when the corresponding export call has finished.
| Attribute | Type | Description | Examples | Requirement Level | Stability |
|---|---|---|---|---|---|
error.type |
string | A low-cardinality description of the failure reason. SDK Batching Log Record Processors MUST use queue_full for log records dropped due to a full queue. [1] |
queue_full |
Recommended |
|
otel.component.name |
string | A name uniquely identifying the instance of the OpenTelemetry component within its containing SDK instance. [2] | otlp_grpc_span_exporter/0; custom-name |
Recommended |
|
otel.component.type |
string | A name identifying the type of the OpenTelemetry component. [3] | batching_span_processor; com.example.MySpanExporter |
Recommended |
|
[1] error.type: The error.type SHOULD be predictable, and SHOULD have low cardinality.
When error.type is set to a type (e.g., an exception type), its
canonical class name identifying the type within the artifact SHOULD be used.
Instrumentations SHOULD document the list of errors they report.
The cardinality of error.type within one instrumentation library SHOULD be low.
Telemetry consumers that aggregate data from multiple instrumentation libraries and applications
should be prepared for error.type to have high cardinality at query time when no
additional filters are applied.
If the operation has completed successfully, instrumentations SHOULD NOT set error.type.
If a specific domain defines its own set of error identifiers (such as HTTP or gRPC status codes), it's RECOMMENDED to:
- Use a domain-specific attribute
- Set
error.typeto capture all errors, regardless of whether they are defined within the domain-specific set or not.
[2] otel.component.name: Implementations SHOULD ensure a low cardinality for this attribute, even across application or SDK restarts.
E.g. implementations MUST NOT use UUIDs as values for this attribute.
Implementations MAY achieve these goals by following a <otel.component.type>/<instance-counter> pattern, e.g. batching_span_processor/0.
Hereby otel.component.type refers to the corresponding attribute value of the component.
The value of instance-counter MAY be automatically assigned by the component and uniqueness within the enclosing SDK instance MUST be guaranteed.
For example, <instance-counter> MAY be implemented by using a monotonically increasing counter (starting with 0), which is incremented every time an
instance of the given component type is started.
With this implementation, for example the first Batching Span Processor would have batching_span_processor/0
as otel.component.name, the second one batching_span_processor/1 and so on.
These values will therefore be reused in the case of an application restart.
[3] otel.component.type: If none of the standardized values apply, implementations SHOULD use the language-defined name of the type.
E.g. for Java the fully qualified classname SHOULD be used in this case.
error.type has the following list of well-known values. If one of them applies, then the respective value MUST be used; otherwise, a custom value MAY be used.
| Value | Description | Stability |
|---|---|---|
_OTHER |
A fallback error value to be used when the instrumentation doesn't define a custom value. | |
otel.component.type has the following list of well-known values. If one of them applies, then the respective value MUST be used; otherwise, a custom value MAY be used.
| Value | Description | Stability |
|---|---|---|
batching_log_processor |
The builtin SDK batching log record processor | |
batching_span_processor |
The builtin SDK batching span processor | |
otlp_grpc_log_exporter |
OTLP log record exporter over gRPC with protobuf serialization | |
otlp_grpc_metric_exporter |
OTLP metric exporter over gRPC with protobuf serialization | |
otlp_grpc_span_exporter |
OTLP span exporter over gRPC with protobuf serialization | |
otlp_http_json_log_exporter |
OTLP log record exporter over HTTP with JSON serialization | |
otlp_http_json_metric_exporter |
OTLP metric exporter over HTTP with JSON serialization | |
otlp_http_json_span_exporter |
OTLP span exporter over HTTP with JSON serialization | |
otlp_http_log_exporter |
OTLP log record exporter over HTTP with protobuf serialization | |
otlp_http_metric_exporter |
OTLP metric exporter over HTTP with protobuf serialization | |
otlp_http_span_exporter |
OTLP span exporter over HTTP with protobuf serialization | |
periodic_metric_reader |
The builtin SDK periodically exporting metric reader | |
prometheus_http_text_metric_exporter |
Prometheus metric exporter over HTTP with the default text-based format | |
simple_log_processor |
The builtin SDK simple log record processor | |
simple_span_processor |
The builtin SDK simple span processor | |
zipkin_http_span_exporter |
Zipkin span exporter over HTTP | |
Metric: otel.sdk.exporter.log.inflight
This metric is recommended.
| Name | Instrument Type | Unit (UCUM) | Description | Stability | Entity Associations |
|---|---|---|---|---|---|
otel.sdk.exporter.log.inflight |
UpDownCounter | {log_record} |
The number of log records which were passed to the exporter, but that have not been exported yet (neither successful, nor failed). [1] | |
[1]: For successful exports, error.type MUST NOT be set. For failed exports, error.type MUST contain the failure cause.
| Attribute | Type | Description | Examples | Requirement Level | Stability |
|---|---|---|---|---|---|
otel.component.name |
string | A name uniquely identifying the instance of the OpenTelemetry component within its containing SDK instance. [1] | otlp_grpc_span_exporter/0; custom-name |
Recommended |
|
otel.component.type |
string | A name identifying the type of the OpenTelemetry component. [2] | batching_span_processor; com.example.MySpanExporter |
Recommended |
|
server.address |
string | Server domain name if available without reverse DNS lookup; otherwise, IP address or Unix domain socket name. [3] | example.com; 10.1.2.80; /tmp/my.sock |
Recommended when applicable |
|
server.port |
int | Server port number. [4] | 80; 8080; 443 |
Recommended when applicable |
|
[1] otel.component.name: Implementations SHOULD ensure a low cardinality for this attribute, even across application or SDK restarts.
E.g. implementations MUST NOT use UUIDs as values for this attribute.
Implementations MAY achieve these goals by following a <otel.component.type>/<instance-counter> pattern, e.g. batching_span_processor/0.
Hereby otel.component.type refers to the corresponding attribute value of the component.
The value of instance-counter MAY be automatically assigned by the component and uniqueness within the enclosing SDK instance MUST be guaranteed.
For example, <instance-counter> MAY be implemented by using a monotonically increasing counter (starting with 0), which is incremented every time an
instance of the given component type is started.
With this implementation, for example the first Batching Span Processor would have batching_span_processor/0
as otel.component.name, the second one batching_span_processor/1 and so on.
These values will therefore be reused in the case of an application restart.
[2] otel.component.type: If none of the standardized values apply, implementations SHOULD use the language-defined name of the type.
E.g. for Java the fully qualified classname SHOULD be used in this case.
[3] server.address: When observed from the client side, and when communicating through an intermediary, server.address SHOULD represent the server address behind any intermediaries, for example proxies, if it's available.
[4] server.port: When observed from the client side, and when communicating through an intermediary, server.port SHOULD represent the server port behind any intermediaries, for example proxies, if it's available.
otel.component.type has the following list of well-known values. If one of them applies, then the respective value MUST be used; otherwise, a custom value MAY be used.
| Value | Description | Stability |
|---|---|---|
batching_log_processor |
The builtin SDK batching log record processor | |
batching_span_processor |
The builtin SDK batching span processor | |
otlp_grpc_log_exporter |
OTLP log record exporter over gRPC with protobuf serialization | |
otlp_grpc_metric_exporter |
OTLP metric exporter over gRPC with protobuf serialization | |
otlp_grpc_span_exporter |
OTLP span exporter over gRPC with protobuf serialization | |
otlp_http_json_log_exporter |
OTLP log record exporter over HTTP with JSON serialization | |
otlp_http_json_metric_exporter |
OTLP metric exporter over HTTP with JSON serialization | |
otlp_http_json_span_exporter |
OTLP span exporter over HTTP with JSON serialization | |
otlp_http_log_exporter |
OTLP log record exporter over HTTP with protobuf serialization | |
otlp_http_metric_exporter |
OTLP metric exporter over HTTP with protobuf serialization | |
otlp_http_span_exporter |
OTLP span exporter over HTTP with protobuf serialization | |
periodic_metric_reader |
The builtin SDK periodically exporting metric reader | |
prometheus_http_text_metric_exporter |
Prometheus metric exporter over HTTP with the default text-based format | |
simple_log_processor |
The builtin SDK simple log record processor | |
simple_span_processor |
The builtin SDK simple span processor | |
zipkin_http_span_exporter |
Zipkin span exporter over HTTP | |
Metric: otel.sdk.exporter.log.exported
This metric is recommended.
| Name | Instrument Type | Unit (UCUM) | Description | Stability | Entity Associations |
|---|---|---|---|---|---|
otel.sdk.exporter.log.exported |
Counter | {log_record} |
The number of log records for which the export has finished, either successful or failed. [1] | |
[1]: For successful exports, error.type MUST NOT be set. For failed exports, error.type MUST contain the failure cause.
For exporters with partial success semantics (e.g. OTLP with rejected_log_records), rejected log records MUST count as failed and only non-rejected log records count as success.
If no rejection reason is available, rejected SHOULD be used as value for error.type.
| Attribute | Type | Description | Examples | Requirement Level | Stability |
|---|---|---|---|---|---|
error.type |
string | Describes a class of error the operation ended with. [1] | rejected; timeout; 500; java.net.UnknownHostException |
Recommended |
|
otel.component.name |
string | A name uniquely identifying the instance of the OpenTelemetry component within its containing SDK instance. [2] | otlp_grpc_span_exporter/0; custom-name |
Recommended |
|
otel.component.type |
string | A name identifying the type of the OpenTelemetry component. [3] | batching_span_processor; com.example.MySpanExporter |
Recommended |
|
server.address |
string | Server domain name if available without reverse DNS lookup; otherwise, IP address or Unix domain socket name. [4] | example.com; 10.1.2.80; /tmp/my.sock |
Recommended when applicable |
|
server.port |
int | Server port number. [5] | 80; 8080; 443 |
Recommended when applicable |
|
[1] error.type: The error.type SHOULD be predictable, and SHOULD have low cardinality.
When error.type is set to a type (e.g., an exception type), its
canonical class name identifying the type within the artifact SHOULD be used.
Instrumentations SHOULD document the list of errors they report.
The cardinality of error.type within one instrumentation library SHOULD be low.
Telemetry consumers that aggregate data from multiple instrumentation libraries and applications
should be prepared for error.type to have high cardinality at query time when no
additional filters are applied.
If the operation has completed successfully, instrumentations SHOULD NOT set error.type.
If a specific domain defines its own set of error identifiers (such as HTTP or gRPC status codes), it's RECOMMENDED to:
- Use a domain-specific attribute
- Set
error.typeto capture all errors, regardless of whether they are defined within the domain-specific set or not.
[2] otel.component.name: Implementations SHOULD ensure a low cardinality for this attribute, even across application or SDK restarts.
E.g. implementations MUST NOT use UUIDs as values for this attribute.
Implementations MAY achieve these goals by following a <otel.component.type>/<instance-counter> pattern, e.g. batching_span_processor/0.
Hereby otel.component.type refers to the corresponding attribute value of the component.
The value of instance-counter MAY be automatically assigned by the component and uniqueness within the enclosing SDK instance MUST be guaranteed.
For example, <instance-counter> MAY be implemented by using a monotonically increasing counter (starting with 0), which is incremented every time an
instance of the given component type is started.
With this implementation, for example the first Batching Span Processor would have batching_span_processor/0
as otel.component.name, the second one batching_span_processor/1 and so on.
These values will therefore be reused in the case of an application restart.
[3] otel.component.type: If none of the standardized values apply, implementations SHOULD use the language-defined name of the type.
E.g. for Java the fully qualified classname SHOULD be used in this case.
[4] server.address: When observed from the client side, and when communicating through an intermediary, server.address SHOULD represent the server address behind any intermediaries, for example proxies, if it's available.
[5] server.port: When observed from the client side, and when communicating through an intermediary, server.port SHOULD represent the server port behind any intermediaries, for example proxies, if it's available.
error.type has the following list of well-known values. If one of them applies, then the respective value MUST be used; otherwise, a custom value MAY be used.
| Value | Description | Stability |
|---|---|---|
_OTHER |
A fallback error value to be used when the instrumentation doesn't define a custom value. | |
otel.component.type has the following list of well-known values. If one of them applies, then the respective value MUST be used; otherwise, a custom value MAY be used.
| Value | Description | Stability |
|---|---|---|
batching_log_processor |
The builtin SDK batching log record processor | |
batching_span_processor |
The builtin SDK batching span processor | |
otlp_grpc_log_exporter |
OTLP log record exporter over gRPC with protobuf serialization | |
otlp_grpc_metric_exporter |
OTLP metric exporter over gRPC with protobuf serialization | |
otlp_grpc_span_exporter |
OTLP span exporter over gRPC with protobuf serialization | |
otlp_http_json_log_exporter |
OTLP log record exporter over HTTP with JSON serialization | |
otlp_http_json_metric_exporter |
OTLP metric exporter over HTTP with JSON serialization | |
otlp_http_json_span_exporter |
OTLP span exporter over HTTP with JSON serialization | |
otlp_http_log_exporter |
OTLP log record exporter over HTTP with protobuf serialization | |
otlp_http_metric_exporter |
OTLP metric exporter over HTTP with protobuf serialization | |
otlp_http_span_exporter |
OTLP span exporter over HTTP with protobuf serialization | |
periodic_metric_reader |
The builtin SDK periodically exporting metric reader | |
prometheus_http_text_metric_exporter |
Prometheus metric exporter over HTTP with the default text-based format | |
simple_log_processor |
The builtin SDK simple log record processor | |
simple_span_processor |
The builtin SDK simple span processor | |
zipkin_http_span_exporter |
Zipkin span exporter over HTTP | |
Metric metrics
Metric: otel.sdk.exporter.metric_data_point.inflight
This metric is recommended.
| Name | Instrument Type | Unit (UCUM) | Description | Stability | Entity Associations |
|---|---|---|---|---|---|
otel.sdk.exporter.metric_data_point.inflight |
UpDownCounter | {data_point} |
The number of metric data points which were passed to the exporter, but that have not been exported yet (neither successful, nor failed). [1] | |
[1]: For successful exports, error.type MUST NOT be set. For failed exports, error.type MUST contain the failure cause.
| Attribute | Type | Description | Examples | Requirement Level | Stability |
|---|---|---|---|---|---|
otel.component.name |
string | A name uniquely identifying the instance of the OpenTelemetry component within its containing SDK instance. [1] | otlp_grpc_span_exporter/0; custom-name |
Recommended |
|
otel.component.type |
string | A name identifying the type of the OpenTelemetry component. [2] | batching_span_processor; com.example.MySpanExporter |
Recommended |
|
server.address |
string | Server domain name if available without reverse DNS lookup; otherwise, IP address or Unix domain socket name. [3] | example.com; 10.1.2.80; /tmp/my.sock |
Recommended when applicable |
|
server.port |
int | Server port number. [4] | 80; 8080; 443 |
Recommended when applicable |
|
[1] otel.component.name: Implementations SHOULD ensure a low cardinality for this attribute, even across application or SDK restarts.
E.g. implementations MUST NOT use UUIDs as values for this attribute.
Implementations MAY achieve these goals by following a <otel.component.type>/<instance-counter> pattern, e.g. batching_span_processor/0.
Hereby otel.component.type refers to the corresponding attribute value of the component.
The value of instance-counter MAY be automatically assigned by the component and uniqueness within the enclosing SDK instance MUST be guaranteed.
For example, <instance-counter> MAY be implemented by using a monotonically increasing counter (starting with 0), which is incremented every time an
instance of the given component type is started.
With this implementation, for example the first Batching Span Processor would have batching_span_processor/0
as otel.component.name, the second one batching_span_processor/1 and so on.
These values will therefore be reused in the case of an application restart.
[2] otel.component.type: If none of the standardized values apply, implementations SHOULD use the language-defined name of the type.
E.g. for Java the fully qualified classname SHOULD be used in this case.
[3] server.address: When observed from the client side, and when communicating through an intermediary, server.address SHOULD represent the server address behind any intermediaries, for example proxies, if it's available.
[4] server.port: When observed from the client side, and when communicating through an intermediary, server.port SHOULD represent the server port behind any intermediaries, for example proxies, if it's available.
otel.component.type has the following list of well-known values. If one of them applies, then the respective value MUST be used; otherwise, a custom value MAY be used.
| Value | Description | Stability |
|---|---|---|
batching_log_processor |
The builtin SDK batching log record processor | |
batching_span_processor |
The builtin SDK batching span processor | |
otlp_grpc_log_exporter |
OTLP log record exporter over gRPC with protobuf serialization | |
otlp_grpc_metric_exporter |
OTLP metric exporter over gRPC with protobuf serialization | |
otlp_grpc_span_exporter |
OTLP span exporter over gRPC with protobuf serialization | |
otlp_http_json_log_exporter |
OTLP log record exporter over HTTP with JSON serialization | |
otlp_http_json_metric_exporter |
OTLP metric exporter over HTTP with JSON serialization | |
otlp_http_json_span_exporter |
OTLP span exporter over HTTP with JSON serialization | |
otlp_http_log_exporter |
OTLP log record exporter over HTTP with protobuf serialization | |
otlp_http_metric_exporter |
OTLP metric exporter over HTTP with protobuf serialization | |
otlp_http_span_exporter |
OTLP span exporter over HTTP with protobuf serialization | |
periodic_metric_reader |
The builtin SDK periodically exporting metric reader | |
prometheus_http_text_metric_exporter |
Prometheus metric exporter over HTTP with the default text-based format | |
simple_log_processor |
The builtin SDK simple log record processor | |
simple_span_processor |
The builtin SDK simple span processor | |
zipkin_http_span_exporter |
Zipkin span exporter over HTTP | |
Metric: otel.sdk.exporter.metric_data_point.exported
This metric is recommended.
| Name | Instrument Type | Unit (UCUM) | Description | Stability | Entity Associations |
|---|---|---|---|---|---|
otel.sdk.exporter.metric_data_point.exported |
Counter | {data_point} |
The number of metric data points for which the export has finished, either successful or failed. [1] | |
[1]: For successful exports, error.type MUST NOT be set. For failed exports, error.type MUST contain the failure cause.
For exporters with partial success semantics (e.g. OTLP with rejected_data_points), rejected data points MUST count as failed and only non-rejected data points count as success.
If no rejection reason is available, rejected SHOULD be used as value for error.type.
| Attribute | Type | Description | Examples | Requirement Level | Stability |
|---|---|---|---|---|---|
error.type |
string | Describes a class of error the operation ended with. [1] | rejected; timeout; 500; java.net.UnknownHostException |
Recommended |
|
otel.component.name |
string | A name uniquely identifying the instance of the OpenTelemetry component within its containing SDK instance. [2] | otlp_grpc_span_exporter/0; custom-name |
Recommended |
|
otel.component.type |
string | A name identifying the type of the OpenTelemetry component. [3] | batching_span_processor; com.example.MySpanExporter |
Recommended |
|
server.address |
string | Server domain name if available without reverse DNS lookup; otherwise, IP address or Unix domain socket name. [4] | example.com; 10.1.2.80; /tmp/my.sock |
Recommended when applicable |
|
server.port |
int | Server port number. [5] | 80; 8080; 443 |
Recommended when applicable |
|
[1] error.type: The error.type SHOULD be predictable, and SHOULD have low cardinality.
When error.type is set to a type (e.g., an exception type), its
canonical class name identifying the type within the artifact SHOULD be used.
Instrumentations SHOULD document the list of errors they report.
The cardinality of error.type within one instrumentation library SHOULD be low.
Telemetry consumers that aggregate data from multiple instrumentation libraries and applications
should be prepared for error.type to have high cardinality at query time when no
additional filters are applied.
If the operation has completed successfully, instrumentations SHOULD NOT set error.type.
If a specific domain defines its own set of error identifiers (such as HTTP or gRPC status codes), it's RECOMMENDED to:
- Use a domain-specific attribute
- Set
error.typeto capture all errors, regardless of whether they are defined within the domain-specific set or not.
[2] otel.component.name: Implementations SHOULD ensure a low cardinality for this attribute, even across application or SDK restarts.
E.g. implementations MUST NOT use UUIDs as values for this attribute.
Implementations MAY achieve these goals by following a <otel.component.type>/<instance-counter> pattern, e.g. batching_span_processor/0.
Hereby otel.component.type refers to the corresponding attribute value of the component.
The value of instance-counter MAY be automatically assigned by the component and uniqueness within the enclosing SDK instance MUST be guaranteed.
For example, <instance-counter> MAY be implemented by using a monotonically increasing counter (starting with 0), which is incremented every time an
instance of the given component type is started.
With this implementation, for example the first Batching Span Processor would have batching_span_processor/0
as otel.component.name, the second one batching_span_processor/1 and so on.
These values will therefore be reused in the case of an application restart.
[3] otel.component.type: If none of the standardized values apply, implementations SHOULD use the language-defined name of the type.
E.g. for Java the fully qualified classname SHOULD be used in this case.
[4] server.address: When observed from the client side, and when communicating through an intermediary, server.address SHOULD represent the server address behind any intermediaries, for example proxies, if it's available.
[5] server.port: When observed from the client side, and when communicating through an intermediary, server.port SHOULD represent the server port behind any intermediaries, for example proxies, if it's available.
error.type has the following list of well-known values. If one of them applies, then the respective value MUST be used; otherwise, a custom value MAY be used.
| Value | Description | Stability |
|---|---|---|
_OTHER |
A fallback error value to be used when the instrumentation doesn't define a custom value. | |
otel.component.type has the following list of well-known values. If one of them applies, then the respective value MUST be used; otherwise, a custom value MAY be used.
| Value | Description | Stability |
|---|---|---|
batching_log_processor |
The builtin SDK batching log record processor | |
batching_span_processor |
The builtin SDK batching span processor | |
otlp_grpc_log_exporter |
OTLP log record exporter over gRPC with protobuf serialization | |
otlp_grpc_metric_exporter |
OTLP metric exporter over gRPC with protobuf serialization | |
otlp_grpc_span_exporter |
OTLP span exporter over gRPC with protobuf serialization | |
otlp_http_json_log_exporter |
OTLP log record exporter over HTTP with JSON serialization | |
otlp_http_json_metric_exporter |
OTLP metric exporter over HTTP with JSON serialization | |
otlp_http_json_span_exporter |
OTLP span exporter over HTTP with JSON serialization | |
otlp_http_log_exporter |
OTLP log record exporter over HTTP with protobuf serialization | |
otlp_http_metric_exporter |
OTLP metric exporter over HTTP with protobuf serialization | |
otlp_http_span_exporter |
OTLP span exporter over HTTP with protobuf serialization | |
periodic_metric_reader |
The builtin SDK periodically exporting metric reader | |
prometheus_http_text_metric_exporter |
Prometheus metric exporter over HTTP with the default text-based format | |
simple_log_processor |
The builtin SDK simple log record processor | |
simple_span_processor |
The builtin SDK simple span processor | |
zipkin_http_span_exporter |
Zipkin span exporter over HTTP | |
Operation Metrics
Metric: otel.sdk.metric_reader.collection.duration
This metric is recommended.
This metric SHOULD be specified with
ExplicitBucketBoundaries
with a single bucket with no boundaries.
| Name | Instrument Type | Unit (UCUM) | Description | Stability | Entity Associations |
|---|---|---|---|---|---|
otel.sdk.metric_reader.collection.duration |
Histogram | s |
The duration of the collect operation of the metric reader. [1] | |
[1]: For successful collections, error.type MUST NOT be set. For failed collections, error.type SHOULD contain the failure cause.
It can happen that metrics collection is successful for some MetricProducers, while others fail. In that case error.type SHOULD be set to any of the failure causes.
| Attribute | Type | Description | Examples | Requirement Level | Stability |
|---|---|---|---|---|---|
error.type |
string | Describes a class of error the operation ended with. [1] | timeout; java.net.UnknownHostException; server_certificate_invalid; 500 |
Recommended |
|
otel.component.name |
string | A name uniquely identifying the instance of the OpenTelemetry component within its containing SDK instance. [2] | otlp_grpc_span_exporter/0; custom-name |
Recommended |
|
otel.component.type |
string | A name identifying the type of the OpenTelemetry component. [3] | batching_span_processor; com.example.MySpanExporter |
Recommended |
|
[1] error.type: The error.type SHOULD be predictable, and SHOULD have low cardinality.
When error.type is set to a type (e.g., an exception type), its
canonical class name identifying the type within the artifact SHOULD be used.
Instrumentations SHOULD document the list of errors they report.
The cardinality of error.type within one instrumentation library SHOULD be low.
Telemetry consumers that aggregate data from multiple instrumentation libraries and applications
should be prepared for error.type to have high cardinality at query time when no
additional filters are applied.
If the operation has completed successfully, instrumentations SHOULD NOT set error.type.
If a specific domain defines its own set of error identifiers (such as HTTP or gRPC status codes), it's RECOMMENDED to:
- Use a domain-specific attribute
- Set
error.typeto capture all errors, regardless of whether they are defined within the domain-specific set or not.
[2] otel.component.name: Implementations SHOULD ensure a low cardinality for this attribute, even across application or SDK restarts.
E.g. implementations MUST NOT use UUIDs as values for this attribute.
Implementations MAY achieve these goals by following a <otel.component.type>/<instance-counter> pattern, e.g. batching_span_processor/0.
Hereby otel.component.type refers to the corresponding attribute value of the component.
The value of instance-counter MAY be automatically assigned by the component and uniqueness within the enclosing SDK instance MUST be guaranteed.
For example, <instance-counter> MAY be implemented by using a monotonically increasing counter (starting with 0), which is incremented every time an
instance of the given component type is started.
With this implementation, for example the first Batching Span Processor would have batching_span_processor/0
as otel.component.name, the second one batching_span_processor/1 and so on.
These values will therefore be reused in the case of an application restart.
[3] otel.component.type: If none of the standardized values apply, implementations SHOULD use the language-defined name of the type.
E.g. for Java the fully qualified classname SHOULD be used in this case.
error.type has the following list of well-known values. If one of them applies, then the respective value MUST be used; otherwise, a custom value MAY be used.
| Value | Description | Stability |
|---|---|---|
_OTHER |
A fallback error value to be used when the instrumentation doesn't define a custom value. | |
otel.component.type has the following list of well-known values. If one of them applies, then the respective value MUST be used; otherwise, a custom value MAY be used.
| Value | Description | Stability |
|---|---|---|
batching_log_processor |
The builtin SDK batching log record processor | |
batching_span_processor |
The builtin SDK batching span processor | |
otlp_grpc_log_exporter |
OTLP log record exporter over gRPC with protobuf serialization | |
otlp_grpc_metric_exporter |
OTLP metric exporter over gRPC with protobuf serialization | |
otlp_grpc_span_exporter |
OTLP span exporter over gRPC with protobuf serialization | |
otlp_http_json_log_exporter |
OTLP log record exporter over HTTP with JSON serialization | |
otlp_http_json_metric_exporter |
OTLP metric exporter over HTTP with JSON serialization | |
otlp_http_json_span_exporter |
OTLP span exporter over HTTP with JSON serialization | |
otlp_http_log_exporter |
OTLP log record exporter over HTTP with protobuf serialization | |
otlp_http_metric_exporter |
OTLP metric exporter over HTTP with protobuf serialization | |
otlp_http_span_exporter |
OTLP span exporter over HTTP with protobuf serialization | |
periodic_metric_reader |
The builtin SDK periodically exporting metric reader | |
prometheus_http_text_metric_exporter |
Prometheus metric exporter over HTTP with the default text-based format | |
simple_log_processor |
The builtin SDK simple log record processor | |
simple_span_processor |
The builtin SDK simple span processor | |
zipkin_http_span_exporter |
Zipkin span exporter over HTTP | |
Metric: otel.sdk.exporter.operation.duration
This metric is recommended.
This metric SHOULD be specified with
ExplicitBucketBoundaries
with a single bucket with no boundaries.
| Name | Instrument Type | Unit (UCUM) | Description | Stability | Entity Associations |
|---|---|---|---|---|---|
otel.sdk.exporter.operation.duration |
Histogram | s |
The duration of exporting a batch of telemetry records. [1] | |
[1]: This metric defines successful operations using the full success definitions for http
and grpc. Anything else is defined as an unsuccessful operation. For successful
operations, error.type MUST NOT be set. For unsuccessful export operations, error.type MUST contain a relevant failure cause.
| Attribute | Type | Description | Examples | Requirement Level | Stability |
|---|---|---|---|---|---|
error.type |
string | Describes a class of error the operation ended with. [1] | rejected; timeout; 500; java.net.UnknownHostException |
Conditionally Required If operation has ended with an error |
|
http.response.status_code |
int | The HTTP status code of the last HTTP request performed in scope of this export call. | 200 |
Recommended when applicable |
|
otel.component.name |
string | A name uniquely identifying the instance of the OpenTelemetry component within its containing SDK instance. [2] | otlp_grpc_span_exporter/0; custom-name |
Recommended |
|
otel.component.type |
string | A name identifying the type of the OpenTelemetry component. [3] | otlp_grpc_span_exporter; com.example.MySpanExporter |
Recommended |
|
rpc.grpc.status_code |
int | The gRPC status code of the last gRPC requests performed in scope of this export call. | 0; 1; 2 |
Recommended when applicable |
|
server.address |
string | Server domain name if available without reverse DNS lookup; otherwise, IP address or Unix domain socket name. [4] | example.com; 10.1.2.80; /tmp/my.sock |
Recommended when applicable |
|
server.port |
int | Server port number. [5] | 80; 8080; 443 |
Recommended when applicable |
|
[1] error.type: The error.type SHOULD be predictable, and SHOULD have low cardinality.
When error.type is set to a type (e.g., an exception type), its
canonical class name identifying the type within the artifact SHOULD be used.
Instrumentations SHOULD document the list of errors they report.
The cardinality of error.type within one instrumentation library SHOULD be low.
Telemetry consumers that aggregate data from multiple instrumentation libraries and applications
should be prepared for error.type to have high cardinality at query time when no
additional filters are applied.
If the operation has completed successfully, instrumentations SHOULD NOT set error.type.
If a specific domain defines its own set of error identifiers (such as HTTP or gRPC status codes), it's RECOMMENDED to:
- Use a domain-specific attribute
- Set
error.typeto capture all errors, regardless of whether they are defined within the domain-specific set or not.
[2] otel.component.name: Implementations SHOULD ensure a low cardinality for this attribute, even across application or SDK restarts.
E.g. implementations MUST NOT use UUIDs as values for this attribute.
Implementations MAY achieve these goals by following a <otel.component.type>/<instance-counter> pattern, e.g. batching_span_processor/0.
Hereby otel.component.type refers to the corresponding attribute value of the component.
The value of instance-counter MAY be automatically assigned by the component and uniqueness within the enclosing SDK instance MUST be guaranteed.
For example, <instance-counter> MAY be implemented by using a monotonically increasing counter (starting with 0), which is incremented every time an
instance of the given component type is started.
With this implementation, for example the first Batching Span Processor would have batching_span_processor/0
as otel.component.name, the second one batching_span_processor/1 and so on.
These values will therefore be reused in the case of an application restart.
[3] otel.component.type: If none of the standardized values apply, implementations SHOULD use the language-defined name of the type.
E.g. for Java the fully qualified classname SHOULD be used in this case.
[4] server.address: When observed from the client side, and when communicating through an intermediary, server.address SHOULD represent the server address behind any intermediaries, for example proxies, if it's available.
[5] server.port: When observed from the client side, and when communicating through an intermediary, server.port SHOULD represent the server port behind any intermediaries, for example proxies, if it's available.
error.type has the following list of well-known values. If one of them applies, then the respective value MUST be used; otherwise, a custom value MAY be used.
| Value | Description | Stability |
|---|---|---|
_OTHER |
A fallback error value to be used when the instrumentation doesn't define a custom value. | |
otel.component.type has the following list of well-known values. If one of them applies, then the respective value MUST be used; otherwise, a custom value MAY be used.
| Value | Description | Stability |
|---|---|---|
batching_log_processor |
The builtin SDK batching log record processor | |
batching_span_processor |
The builtin SDK batching span processor | |
otlp_grpc_log_exporter |
OTLP log record exporter over gRPC with protobuf serialization | |
otlp_grpc_metric_exporter |
OTLP metric exporter over gRPC with protobuf serialization | |
otlp_grpc_span_exporter |
OTLP span exporter over gRPC with protobuf serialization | |
otlp_http_json_log_exporter |
OTLP log record exporter over HTTP with JSON serialization | |
otlp_http_json_metric_exporter |
OTLP metric exporter over HTTP with JSON serialization | |
otlp_http_json_span_exporter |
OTLP span exporter over HTTP with JSON serialization | |
otlp_http_log_exporter |
OTLP log record exporter over HTTP with protobuf serialization | |
otlp_http_metric_exporter |
OTLP metric exporter over HTTP with protobuf serialization | |
otlp_http_span_exporter |
OTLP span exporter over HTTP with protobuf serialization | |
periodic_metric_reader |
The builtin SDK periodically exporting metric reader | |
prometheus_http_text_metric_exporter |
Prometheus metric exporter over HTTP with the default text-based format | |
simple_log_processor |
The builtin SDK simple log record processor | |
simple_span_processor |
The builtin SDK simple span processor | |
zipkin_http_span_exporter |
Zipkin span exporter over HTTP | |
rpc.grpc.status_code has the following list of well-known values. If one of them applies, then the respective value MUST be used; otherwise, a custom value MAY be used.
| Value | Description | Stability |
|---|---|---|
0 |
OK | |
1 |
CANCELLED | |
2 |
UNKNOWN | |
3 |
INVALID_ARGUMENT | |
4 |
DEADLINE_EXCEEDED | |
5 |
NOT_FOUND | |
6 |
ALREADY_EXISTS | |
7 |
PERMISSION_DENIED | |
8 |
RESOURCE_EXHAUSTED | |
9 |
FAILED_PRECONDITION | |
10 |
ABORTED | |
11 |
OUT_OF_RANGE | |
12 |
UNIMPLEMENTED | |
13 |
INTERNAL | |
14 |
UNAVAILABLE | |
15 |
DATA_LOSS | |
16 |
UNAUTHENTICATED | |