Demo OTel Col Metrics

This guide demonstrates how to configure the OpenTelemetry Collector to receive metrics using two common approaches:

Push-based (OTLP) — your application pushes metrics to the Collector.
Pull-based (Prometheus-style) — the Collector scrapes your application for metrics.

Below are compact, corrected Collector configuration and application examples used in the demo, followed by representative Collector console output showing metrics ingestion. Use these snippets to validate both ingestion models and to troubleshoot common issues.

This article shows two common ways to get metrics into the Collector: OTLP push and Prometheus scrape. You can enable both simultaneously by configuring both receivers and adding them to your metrics pipeline.

Collector: common pieces

The Collector configuration below contains attribute enrichment, an OTLP receiver, a Prometheus receiver (for scraping), processors, and exporters. The critical parts for metrics are the receivers and the service.pipelines.metrics section that wires receivers into the metrics pipeline.

# collectors-config.yaml
extensions:
  health_check: {}

receivers:
  otlp:
    protocols:
      grpc:
        endpoint: 0.0.0.0:4317
      http:
        endpoint: 0.0.0.0:4318
  prometheus:
    config:
      scrape_configs:
        - job_name: "python-app"
          scrape_interval: 15s
          static_configs:
            - targets: ["python-app:8000"]

processors:
  batch:
    timeout: 15s
    send_batch_size: 512
  attributes/add_env:
    actions:
      - key: deployment.environment
        value: production
        action: insert
      - key: service.region
        value: us-west-2
        action: upsert

exporters:
  debug:
    verbosity: detailed
  otlp/jaeger:
    endpoint: http://jaeger:4317
    tls:
      insecure: true

service:
  pipelines:
    traces:
      receivers: [otlp]
      processors: [attributes/add_env, batch]
      exporters: [debug, otlp/jaeger]
    metrics:
      receivers: [prometheus, otlp]
      processors: [attributes/add_env, batch]
      exporters: [debug]
    logs:
      receivers: [otlp]
      exporters: [debug]

Key points:

The prometheus receiver uses Prometheus-style scrape_configs so the Collector behaves like Prometheus and pulls metrics from python-app:8000.
The otlp receiver accepts OTLP over both gRPC and HTTP (useful for client push exporters).
For metrics ingestion, make sure the receiver(s) are listed under service.pipelines.metrics.receivers.

Quick comparison: Push vs Pull

Aspect	Push (OTLP)	Pull (Prometheus scrape)
How metrics arrive	Application pushes to Collector via OTLP	Collector scrapes `/metrics` endpoint
Typical endpoint	`http://collector:4318/v1/metrics`	`http://your-app:8000/metrics`
Use case	Instrumented apps pushing telemetry (e.g., SDK exporters)	Existing Prometheus exporters or instrumented apps exposing `/metrics`
Collector role	OTLP receiver (HTTP/gRPC)	Prometheus receiver (scraper)
Good for	Short-lived batches, centralized pushing	Long-lived services with Prometheus exposition

Push-based metrics (OTLP)

For push-based metrics, configure an OTLP metrics exporter in your application to send metrics to the Collector. When using the HTTP OTLP exporter, provide the full URL including /v1/metrics. Example Python configuration using OTLP HTTP metrics exporter and a periodic metric reader:

# metrics_push.py
from opentelemetry import metrics
from opentelemetry.sdk.metrics import MeterProvider
from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
from opentelemetry.exporter.otlp.proto.http.metric_exporter import OTLPMetricExporter
from opentelemetry.sdk.resources import Resource

def configure_meter_push() -> metrics.Meter:
    export_url = "http://localhost:4318/v1/metrics"  # Collector OTLP HTTP endpoint
    otlp_exporter = OTLPMetricExporter(endpoint=export_url)

    # Export every 5 seconds
    reader = PeriodicExportingMetricReader(otlp_exporter, export_interval_millis=5000)

    provider = MeterProvider(resource=Resource.create({}), metric_readers=[reader])
    metrics.set_meter_provider(provider)

    return metrics.get_meter(name="cooling-heating", version="0.1.2")

Create observable gauges in the app (example):

# inside your application startup
import random
from opentelemetry.metrics import Observation

meter = configure_meter_push()

def temperature_callback(options):
    return [Observation(random.uniform(60.0, 90.0))]

def humidity_callback(options):
    return [Observation(random.uniform(0.0, 1.0))]

meter.create_observable_gauge(
    "current_temperature_fahrenheit",
    description="Current Temperature",
    unit="degF",
    callbacks=[temperature_callback],
)

meter.create_observable_gauge(
    "current_humidity_percentage",
    description="Current Humidity",
    unit="1",  # fraction 0.0 - 1.0
    callbacks=[humidity_callback],
)

Run the application:

python scripts/metrics-push.py

Collector debug output when receiving pushed metrics (cleaned and truncated for clarity):

otel-collector | 2025-09-30T00:12:22.523Z info service@v0.135.0/service.go:211 Starting otelcol-contrib...
otel-collector | 2025-09-30T00:12:22.523Z info extensions/extensions.go:41 Starting extensions..
otel-collector | 2025-09-30T00:12:22.523Z info otlpreceiver@v0.135.0/otlpreceiver.go:121 Starting GRPC server {"endpoint":"[::]:4317"}
otel-collector | 2025-09-30T00:12:22.524Z info otlpreceiver@v0.135.0/otlpreceiver.go:179 Starting HTTP server {"endpoint":"[::]:4318"}
otel-collector | 2025-09-30T00:12:22.534Z info service@v0.135.0/service.go:234 Everything is ready. server

When the Collector’s debug exporter prints pushed metrics it may show:

ResourceMetrics #0
Resource attributes:
  telemetry.sdk.language: Str(python)
  telemetry.sdk.name: Str(opentelemetry)
  telemetry.sdk.version: Str(1.0.0)
ScopeMetrics #0
InstrumentationScope cooling-heating 0.1.2
Metric #0
Descriptor:
  - Name: current_temperature_fahrenheit
  - Description: Current Temperature
  - Unit: degF
  - DataType: Gauge
NumberDataPoints #0
Timestamp: 2025-09-30T00:14:45.251669000 UTC
Value: 78.554979
Metric #1
Descriptor:
  - Name: current_humidity_percentage
  - Description: Current Humidity
  - Unit: 1
  - DataType: Gauge
NumberDataPoints #0
Timestamp: 2025-09-30T00:14:45.251669000 UTC
Value: 0.407680

This verifies successful push-based ingestion: the app exported metrics to http://localhost:4318/v1/metrics, the Collector received them via its OTLP HTTP receiver, and the debug exporter printed them.

Pull-based metrics (Prometheus scraping)

For Prometheus-style scraping, your application exposes an HTTP endpoint that returns Prometheus-formatted metrics (commonly using the prometheus_client library). The Collector scrapes that endpoint using the Prometheus receiver. Example Python configuration using PrometheusMetricReader:

# metrics_pull.py
from prometheus_client import start_http_server
from opentelemetry import metrics
from opentelemetry.sdk.metrics import MeterProvider
from opentelemetry.sdk.resources import Resource
from opentelemetry.exporter.prometheus import PrometheusMetricReader

def configure_meter_pull():
    # Expose metrics at http://localhost:8000/metrics for Prometheus scraping
    start_http_server(port=8000, addr="localhost")

    reader = PrometheusMetricReader()
    provider = MeterProvider(resource=Resource.create({}), metric_readers=[reader])
    metrics.set_meter_provider(provider)
    return metrics.get_meter(name="cooling-heating", version="0.1.2")

Observable gauges and Flask integration example:

# inside your application startup
import random
from opentelemetry.metrics import Observation
from flask import Flask

meter = configure_meter_pull()

def temperature_callback(options):
    return [Observation(random.uniform(60.0, 90.0))]

def humidity_callback(options):
    return [Observation(random.uniform(0.0, 1.0))]

meter.create_observable_gauge(
    "current_temperature_fahrenheit",
    description="Current Temperature",
    unit="degF",
    callbacks=[temperature_callback],
)

meter.create_observable_gauge(
    "current_humidity_percentage",
    description="Current Humidity",
    unit="1",
    callbacks=[humidity_callback],
)

app = Flask(__name__)

@app.route("/")
def index():
    return "Hello, metrics!"

Start the app:

python3 scripts/metrics-pull.py

Collector logs when starting and scraping (important parts):

otel-collector | 2025-09-30T10:09:45Z info otlpreceiver@v0.135.0/otlpreceiver.go:121 Starting gRPC server {"endpoint":"[::]:4317"}
otel-collector | 2025-09-30T10:09:45Z info otlpreceiver@v0.135.0/otlpreceiver.go:179 Starting HTTP server {"endpoint":"[::]:4318"}
otel-collector | 2025-09-30T10:09:45Z info service@v0.135.0/service.go:234 Everything is ready. Begin running and processing data

After scraping (every 15s as configured), the debug exporter prints scraped metrics. Example (truncated):

2025-09-30T00:24:49.424Z info Metrics {"otelcol.component.kind":"exporter","otelcol.signal":"metrics"}
ResourceMetrics #0
Resource attributes:
  -> service.name: Str(python-app)
  -> service.address: Str(python-app)
  -> service.instance.id: Str(python-app:8000)
  -> server.port: Str(8000)
  -> url.scheme: Str(http)
ScopeMetrics #0
InstrumentationScope github.com/open-telemetry/opentelemetry-collector-contrib/receiver/prometheus 0.135.0
Metric #0
Descriptor:
  -> Name: python_gc_objects_collected_total
  -> Description: Objects collected during gc
  -> DataType: Sum
  -> IsMonotonic: true
  -> AggregationTemporality: Cumulative
NumberDataPoints #0
  Value: 415.000000
...
Metric #4
Descriptor:
  -> Name: current_humidity_percentage
  -> Description: Current Humidity
  -> DataType: Gauge
NumberDataPoints #0
  Timestamp: 2025-09-30T00:24:49.412Z
  Value: 0.157135

This confirms successful scraping: the Prometheus receiver pulled the /metrics endpoint from python-app:8000 and the debug exporter displayed the metrics.

Common pitfalls and fixes

Symptom	Likely cause	Fix / Tip
No metrics in pipeline	Receiver defined but not added to `service.pipelines.metrics`	Add the receiver name to `service.pipelines.metrics.receivers`
OTLP HTTP exporter fails to send	Incorrect endpoint path	Use full path: `http://host:4318/v1/metrics`
Prometheus static target not found	Missing port or wrong address	Ensure `static_configs.targets` includes port, e.g., `python-app:8000`
Scraped metrics missing labels	Prometheus exposition missing metadata	Confirm exporter/library sets desired labels (e.g., `service.name`)

Tips:

You can enable both OTLP push and Prometheus scraping simultaneously by listing both otlp and prometheus in the metrics pipeline.
When troubleshooting, the debug exporter is very helpful to observe exactly what the Collector receives.

Summary

Push-based (OTLP): App pushes metrics to the Collector using an OTLP exporter (often HTTP to /v1/metrics). See the OTLP protocol docs: https://opentelemetry.io/docs/reference/specification/protocol/otlp/
Pull-based (Prometheus): App exposes a /metrics endpoint and the Collector scrapes it via the Prometheus receiver. See Prometheus: https://prometheus.io/
The Collector can accept both approaches simultaneously—configure both receivers and add them to service.pipelines.metrics.receivers.

With the configuration and code snippets above you can validate both ingestion models and observe metrics via the Collector’s debug exporter.

Links and References

OpenTelemetry Collector: https://opentelemetry.io/docs/collector/
OTLP protocol: https://opentelemetry.io/docs/reference/specification/protocol/otlp/
Prometheus docs: https://prometheus.io/
Python prometheus_client: https://github.com/prometheus/client_python
OpenTelemetry Python metrics: https://opentelemetry.io/docs/instrumentation/python/metrics/

​Collector: common pieces

​Quick comparison: Push vs Pull

​Push-based metrics (OTLP)

​Pull-based metrics (Prometheus scraping)

​Common pitfalls and fixes

​Summary

​Links and References

Watch Video

Collector: common pieces

Quick comparison: Push vs Pull

Push-based metrics (OTLP)

Pull-based metrics (Prometheus scraping)

Common pitfalls and fixes

Summary

Links and References