Location>code7788 >text

Converting OpenTelemetry Traces to Metrics with SpanMetrics Connector

Popularity：315 ℃/2024-08-26 13:48:35

original text：/blog/convert-opentelemetry-traces-to-metrics-using-spanconnector/

What if you have implemented tracking but lack robust metrics capabilities? SpanConnector is a tool that bridges this gap by converting tracking data into actionable metrics. This article details how SpanConnector works, providing guidance on its configuration and implementation.

A common problem with OpenTelemetry is that the language supports trace detection (Trace burying), but the metrics side is in progress or not yet available. In this case, you can use SpanConnector to convert trace-generated spans (Span) into metrics.

What is Connector?

SpanConnector is a component in OpenTelemetry Collector that allows you to get metrics from span (span) data. This is especially useful when you have powerful tracking capabilities but your language or framework lacks native metrics support.

Converting traces into metrics can provide valuable insights into system performance and operational conditions without the need for separate staked burial points. This unified approach creates a more comprehensive view of observability and reduces the overhead of managing two different staking systems.

SpanMetrics 连接器的工作原理

SpanMetrics Related Configurations

Aggregate Requests, Errors, and Duration in Span data () OpenTelemetry metrics.

connectors:
  spanmetrics:
    histogram:
      explicit:
        buckets: [100us, 1ms, 2ms, 6ms, 10ms, 100ms, 250ms]
    dimensions:
      - name: 
        default: GET
      - name: http.status_code
      - name: 
    exemplars:
      enabled: true
    dimensions_cache_size: 1000
    aggregation_temporality: "AGGREGATION_TEMPORALITY_CUMULATIVE"
    metrics_flush_interval: 15s
    metrics_expiration: 5m
    events:
      enabled: true
      dimensions:
        - name: 
        - name: 
    resource_metrics_key_attributes:
      - 
      - 
      -

Understanding SpanMetrics Configuration

Let's break down the key parts of this configuration:

  • Histogram Buckets： field defines the latency bucket for the metric. This allows you to view the distribution of request durations.
  • Dimensions: these are the properties in Span that will be used to create labels for the metrics. In this example, we use the、http.status_code cap (a poem)。
  • Exemplars: when enabled, you can link metrics back to specific tracking examples to provide more context for your metrics.
  • Dimensions Cache: Sets the maximum number of Dimension Combinations to be stored. It helps to manage memory usage.
  • Aggregation Temporality: this determines how the metrics are aggregated over time. "CUMULATIVE" means that the metrics are accumulated from the beginning of the process.
  • Metrics Flush Interval: how often metrics are generated from the connector.
  • Metrics Expiration: this defines how long the metrics will remain in memory before being discarded when not updated.
  • Events: when enabled, you can create metrics from spanning events such as exceptions.
  • Resource Metrics Key Attributes: these attributes in the resource associated with the span will be added as tags to all generated metrics.

Benefits of Using SpanMetrics Connectors

  • Uniform Observability: Converting traces to metrics gives you a more comprehensive view of your system's performance without the need for separate metrics testing.
  • Consistency: Make sure your metrics are perfectly aligned with tracking from the same source.
  • Reduced overhead: Eliminates the need for dual detection (trace and metrics) in the application code.
  • Flexibility: You can generate customized metrics based on your needs and span attributes.

Guidelines for Implementing SpanMetrics

1. Setting up OpenTelemetry tracking: First, make sure your application is properly detected for tracking.

Here's a simple example using Python:

from opentelemetry import trace
from  import TracerProvider
from  import (
    ConsoleSpanExporter,
    BatchSpanProcessor,
)
from .trace_exporter import OTLPSpanExporter

# Set up the tracer provider
trace.set_tracer_provider(TracerProvider())

# Create an OTLP exporter
otlp_exporter = OTLPSpanExporter(endpoint="http://localhost:4317", insecure=True)

# Create a BatchSpanProcessor and add the exporter to it
span_processor = BatchSpanProcessor(otlp_exporter)

# Add the span processor to the tracer provider
trace.get_tracer_provider().add_span_processor(span_processor)

# Get a tracer
tracer = trace.get_tracer(__name__)

# Use the tracer to create spans in your code
with tracer.start_as_current_span("main"):
    # Your application code here
    pass

2. Installation and configuration of OpenTelemetry Collector

a. Download the OpenTelemetry collector:

curl -OL /open-telemetry/opentelemetry-collector-releases/releases/download/v0.81.0/otelcol-contrib_0.81.0_linux_amd64.
tar xzf otelcol-contrib_0.81.0_linux_amd64.

b. Create a configuration file named

receivers:
  otlp:
    protocols:
      grpc:
      http:

processors:
  batch:

connectors:
  spanmetrics:
    histogram:
      explicit:
        buckets: [100us, 1ms, 2ms, 6ms, 10ms, 100ms, 250ms]
    dimensions:
      - name: 
        default: GET
      - name: http.status_code
      - name: 
    exemplars:
      enabled: true
    dimensions_cache_size: 1000
    aggregation_temporality: "AGGREGATION_TEMPORALITY_CUMULATIVE"
    metrics_flush_interval: 15s
    metrics_expiration: 5m
    events:
      enabled: true
      dimensions:
        - name: 
        - name: 
    resource_metrics_key_attributes:
      - 
      - 
      - 

exporters:
  prometheus:
    endpoint: "0.0.0.0:8889"
  logging:
    verbosity: detailed

service:
  pipelines:
    traces:
      receivers: [otlp]
      processors: [batch]
      exporters: [logging, spanmetrics]
    metrics:
      receivers: [spanmetrics]
      exporters: [logging, prometheus]

3. Starting the OpenTelemetry collector

Run the collector with your configuration:

./otelcol-contrib --config

4. Send the trace to the collector

Modify your application to send traces to the collector. If you are using the Python example in step 1, you are set up to send traces to thehttp://localhost:4317。

5. Viewing the generated indicators

The Otel Collector will be in thehttp://localhost:8889/metrics Public metrics, you can view the raw metrics via curl:

curl http://localhost:8889/metrics

For a more user-friendly view, you can set up Prometheus to grab these metrics and create files:

global:
  scrape_interval: 15s

scrape_configs:
  - job_name: 'otel-collector'
    static_configs:
      - targets: ['localhost:8889']

Start Prometheus (assuming you have downloaded it):

./prometheus --=

You can do this now withhttp://localhost:9090 Access the Prometheus UI to query and visualize your metrics.

wrap-up

SpanConnector is a powerful tool in the OpenTelemetry ecosystem that bridges the gap between traces and metrics. by generating meaningful metrics with existing trace data, you can enhance your observability strategy without the additional overhead of burying metrics. This approach is particularly valuable for transitioning to OpenTelemetry, and for languages where metrics are less well buried.

<Previous Next>