Logs OpenTelemetry Integration

This guide explains how to send additional logs to Metoro using OpenTelemetry. Metoro supports the OpenTelemetry Protocol (OTLP) for log ingestion, allowing you to send logs from any application or service that can export OpenTelemetry logs.

Prerequisites

A Metoro account
An application configured with OpenTelemetry

Pricing

Custom logs are billed at $0.30 per GB.

High Level Overview

The Metoro exporter running in each cluster accepts logs over OTLP/HTTP using protobuf or JSON payloads. The standard environment-variable configuration below uses the http/protobuf protocol.

Endpoint Configuration

Use the following OTLP base URL when your SDK or collector automatically appends the signal-specific path:

http://metoro-exporter.metoro.svc.cluster.local/api/v1/custom/otel

Alternatively, use the full logs endpoint when configuring a signal-specific URL:

http://metoro-exporter.metoro.svc.cluster.local/api/v1/custom/otel/v1/logs

These endpoints use OTLP over HTTP and are available within the Kubernetes cluster where the Metoro exporter is installed. The older /api/v1/send/logs/otel endpoint remains available for compatibility, but new configurations should use the OTLP-compatible endpoints above. The Metoro exporter does not expose an OTLP/gRPC endpoint.

Authentication

No additional authentication is required when sending logs from within the cluster to the Metoro exporter.

OpenTelemetry Collector Configuration

If you’re using the OpenTelemetry Collector to forward logs to Metoro, here’s an example configuration:

receivers:
  otlp:
    protocols:
      http:
        endpoint: 0.0.0.0:4318
      grpc:
        endpoint: 0.0.0.0:4317

processors:
  batch:
    timeout: 10s
    send_batch_size: 1000

exporters:
  otlphttp/metoro:
    endpoint: http://metoro-exporter.metoro.svc.cluster.local/api/v1/custom/otel

service:
  pipelines:
    logs:
      receivers: [otlp]
      processors: [batch]
      exporters: [otlphttp/metoro]

This configuration:

Receives logs via OTLP over both HTTP (4318) and gRPC (4317)
Batches logs for efficient transmission
Forwards logs to the Metoro exporter via OTLP/HTTP

Ports 4317 and 4318 belong to the collector configured in this example. The collector forwards telemetry to the Metoro exporter through its in-cluster HTTP service.

Language-Specific Examples

Go

package main

import (
    "context"
    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploghttp"
    "go.opentelemetry.io/otel/sdk/resource"
    sdklog "go.opentelemetry.io/otel/sdk/log"
    semconv "go.opentelemetry.io/otel/semconv/v1.24.0"
)

func initLogger() (*sdklog.LoggerProvider, error) {
    ctx := context.Background()

    exporter, err := otlploghttp.New(ctx,
        otlploghttp.WithEndpoint("metoro-exporter.metoro.svc.cluster.local"),
        otlploghttp.WithURLPath("/api/v1/custom/otel/v1/logs"),
        otlploghttp.WithInsecure(), // Since we're in-cluster
    )
    if err != nil {
        return nil, err
    }

    resource := resource.NewWithAttributes(
        semconv.SchemaURL,
        semconv.ServiceName("your-service-name"),
    )

    loggerProvider := sdklog.NewLoggerProvider(
        sdklog.WithBatcher(exporter),
        sdklog.WithResource(resource),
    )

    return loggerProvider, nil
}

Python

from opentelemetry._logs import set_logger_provider
from opentelemetry.exporter.otlp.proto.http._log_exporter import OTLPLogExporter
from opentelemetry.sdk.resources import Resource
from opentelemetry.sdk._logs import LoggerProvider
from opentelemetry.sdk._logs.export import BatchLogRecordProcessor

def init_logger():
    resource = Resource.create({
        "service.name": "your-service-name"
    })

    provider = LoggerProvider(resource=resource)
    exporter = OTLPLogExporter(
        endpoint="http://metoro-exporter.metoro.svc.cluster.local/api/v1/custom/otel/v1/logs"
    )
    provider.add_log_record_processor(BatchLogRecordProcessor(exporter))
    set_logger_provider(provider)

    return provider

Node.js

const {
  LoggerProvider,
  BatchLogRecordProcessor,
} = require('@opentelemetry/sdk-logs');
const { OTLPLogExporter } = require('@opentelemetry/exporter-logs-otlp-http');
const { Resource } = require('@opentelemetry/resources');
const { SemanticResourceAttributes } = require('@opentelemetry/semantic-conventions');

const resource = new Resource({
  [SemanticResourceAttributes.SERVICE_NAME]: 'your-service-name',
});

const logExporter = new OTLPLogExporter({
  url: 'http://metoro-exporter.metoro.svc.cluster.local/api/v1/custom/otel/v1/logs',
  headers: {},
});

const loggerProvider = new LoggerProvider({
  resource: resource,
});

loggerProvider.addLogRecordProcessor(new BatchLogRecordProcessor(logExporter));

Via environment variables

Most OpenTelemetry SDKs support the generic OTLP environment variables. The SDK appends /v1/logs to the base URL:

export OTEL_EXPORTER_OTLP_ENDPOINT="http://metoro-exporter.metoro.svc.cluster.local/api/v1/custom/otel"
export OTEL_EXPORTER_OTLP_PROTOCOL="http/protobuf"

Attributes and Context

When sending logs via OpenTelemetry, you can include additional attributes that will be indexed and searchable in Metoro:

Use resource attributes to define static information about the service
Use log attributes to include dynamic information with each log entry
Link logs with traces using trace context propagation

Troubleshooting

If you encounter issues with OpenTelemetry log ingestion:

Verify your endpoint URL and API key are correct
Check your network connectivity to the Metoro OTLP endpoint
Enable debug logging in your OpenTelemetry SDK
Verify your logs appear in the Metoro logs view
Contact support if issues persist

Get Started

AI SRE

Concepts

Ingestion Settings

Traces

Logs

Metrics

Profiling

Kubernetes Resources

Dashboards

Infrastructure

Advisor

Alerts & Monitoring

Integrations

Uptime Monitoring

User Management

On-Premises

Administration

Prerequisites

Pricing

High Level Overview

Endpoint Configuration

Authentication

OpenTelemetry Collector Configuration

Language-Specific Examples

Go

Python

Node.js

Via environment variables

Attributes and Context

Troubleshooting

Additional Resources

​Prerequisites

​Pricing

​High Level Overview

​Endpoint Configuration

​Authentication

​OpenTelemetry Collector Configuration

​Language-Specific Examples

​Go

​Python

​Node.js

​Via environment variables

​Attributes and Context

​Troubleshooting

​Additional Resources

Prerequisites

Pricing

High Level Overview

Endpoint Configuration

Authentication

OpenTelemetry Collector Configuration

Language-Specific Examples

Go

Python

Node.js

Via environment variables

Attributes and Context

Troubleshooting

Additional Resources