Beyond auto-instrumentation, you can emit custom metrics from your application using the OpenTelemetry Metrics API. Rocketlog ingests them via OTLP and you can use them in dashboards, alerts, and SLOs. The OpenTelemetry metrics API supports Counter, UpDownCounter, Histogram, and Gauge (observable). Below are copy-paste examples for Python and Node.js. For full details, see the OpenTelemetry Metrics API and language-specific docs.

​
Python

Install the SDK and OTLP exporter if you haven’t already: 
pip install opentelemetry-api opentelemetry-sdk opentelemetry-exporter-otlp
Configure the MeterProvider and export to your Rocketlog endpoint (same as in Python instrumentation): 
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

resource = Resource.create({"service.name": "my-service"})
exporter = OTLPMetricExporter(endpoint="https://{your-ingress-endpoint}.rocketgraph.app/v1/metrics")
reader = PeriodicExportingMetricReader(exporter, export_interval_millis=10000)
provider = MeterProvider(resource=resource, metric_readers=[reader])
metrics.set_meter_provider(provider)

meter = metrics.get_meter("my-app", "1.0.0")

​
Counter (monotonically increasing)

request_count = meter.create_counter(
    "http_requests_total",
    description="Total HTTP requests",
    unit="1",
)
request_count.add(1, {"method": "GET", "path": "/api/users"})
request_count.add(2, {"method": "POST", "path": "/api/orders"})

​
Histogram (distributions, e.g. duration)

request_duration = meter.create_histogram(
    "http_request_duration_seconds",
    description="HTTP request duration",
    unit="s",
)
request_duration.record(0.25, {"method": "GET", "path": "/api/users"})
request_duration.record(1.3, {"method": "POST", "path": "/api/orders"})

​
Observable Gauge (current value, e.g. queue size)

def get_queue_size(options):
    # Read current queue size from your app
    options.observe(42, {"queue": "tasks"})

meter.create_observable_gauge(
    "queue_size",
    callbacks=[get_queue_size],
    description="Current queue size",
    unit="1",
)

​
Node.js

Install the API, SDK, and OTLP exporter: 
npm install @opentelemetry/api @opentelemetry/sdk-metrics @opentelemetry/exporter-metrics-otlp-http
Configure the MeterProvider (endpoint same as in Node.js instrumentation): 
const { metrics } = require('@opentelemetry/api');
const { MeterProvider, PeriodicExportingMetricReader } = require('@opentelemetry/sdk-metrics');
const { OTLPMetricExporter } = require('@opentelemetry/exporter-metrics-otlp-http');
const { Resource } = require('@opentelemetry/resources');

const resource = new Resource({ 'service.name': 'my-service' });
const exporter = new OTLPMetricExporter({
  url: 'https://{your-ingress-endpoint}.rocketgraph.app/v1/metrics',
});
const reader = new PeriodicExportingMetricReader({ exporter, exportIntervalMillis: 10000 });
const provider = new MeterProvider({ resource, readers: [reader] });
metrics.setGlobalMeterProvider(provider);

const meter = metrics.getMeter('my-app', '1.0.0');

​
Counter

const requestCount = meter.createCounter(
  'http_requests_total',
  { description: 'Total HTTP requests', unit: '1' }
);
requestCount.add(1, { method: 'GET', path: '/api/users' });
requestCount.add(2, { method: 'POST', path: '/api/orders' });

​
Histogram

const requestDuration = meter.createHistogram(
  'http_request_duration_seconds',
  { description: 'HTTP request duration', unit: 's' }
);
requestDuration.record(0.25, { method: 'GET', path: '/api/users' });
requestDuration.record(1.3, { method: 'POST', path: '/api/orders' });

​
Observable Gauge

const queueSize = meter.createObservableGauge(
  'queue_size',
  { description: 'Current queue size', unit: '1' }
);
queueSize.addCallback((result) => {
  const size = getQueueSizeFromApp(); // your logic
  result.observe(size, { queue: 'tasks' });
});

​
Sending to Rocketlog

Use the same OTLP endpoint as for traces and logs: https://{your-ingress-endpoint}.rocketgraph.app. The metrics exporter uses the /v1/metrics path when using the HTTP exporter. Ensure your app or collector is configured with the same endpoint and that Rocketlog is set as the OTLP destination for metrics. Once custom metrics are flowing, you can use them in the Rocketlog UI for dashboards, alerts, and SLOs. For more instrument types and semantics, see the official OpenTelemetry metrics documentation.