OpenRouter Broadcast tracing with Future AGI

Save this as otelcol.yaml. Everything it reads from the environment is listed in the next step.

extensions:
  # The endpoint has to be reachable from OpenRouter's cloud, so it must not be open: anyone who finds it
  # could write into your project. The Headers field of the destination carries the token.
  bearertokenauth/broadcast:
    scheme: Bearer
    token: ${env:BROADCAST_TOKEN}

receivers:
  otlp:
    protocols:
      http:
        endpoint: 0.0.0.0:4318
        auth:
          authenticator: bearertokenauth/broadcast
        # Put TLS in front of this (a load balancer or reverse proxy), or set `tls:` here with
        # cert_file and key_file.

processors:
  resource/future_agi:
    attributes:
      - key: project_name
        value: ${env:FI_PROJECT_NAME}
        action: upsert
      - key: project_type
        value: observe
        action: insert

  transform/openrouter:
    error_mode: ignore
    trace_statements:
      - context: span
        statements:
          # Future AGI reads gen_ai.usage.input_tokens and output_tokens. OpenRouter's Webhook page shows
          # prompt_tokens and completion_tokens instead; copy them across when only those arrive.
          - set(attributes["gen_ai.usage.input_tokens"], attributes["gen_ai.usage.prompt_tokens"]) where attributes["gen_ai.usage.input_tokens"] == nil and attributes["gen_ai.usage.prompt_tokens"] != nil
          - set(attributes["gen_ai.usage.output_tokens"], attributes["gen_ai.usage.completion_tokens"]) where attributes["gen_ai.usage.output_tokens"] == nil and attributes["gen_ai.usage.completion_tokens"] != nil
          # OpenRouter's cost for the request (US dollars). Observe reads gen_ai.cost.total; OpenRouter writes
          # gen_ai.usage.total_cost when Cost metadata is enabled.
          - set(attributes["gen_ai.cost.total"], attributes["gen_ai.usage.total_cost"]) where attributes["gen_ai.usage.total_cost"] != nil
          - set(attributes["gen_ai.cost.input"], attributes["gen_ai.usage.input_cost"]) where attributes["gen_ai.usage.input_cost"] != nil
          - set(attributes["gen_ai.cost.output"], attributes["gen_ai.usage.output_cost"]) where attributes["gen_ai.usage.output_cost"] != nil
          # Span types in Observe: the generation is an LLM span, everything else a chain.
          - set(attributes["fi.span.kind"], "LLM") where attributes["gen_ai.request.model"] != nil
          - set(attributes["fi.span.kind"], "CHAIN") where attributes["gen_ai.request.model"] == nil
          # Content ON: fill the Input and Output panes from OpenRouter's span.input / span.output.
          - set(attributes["input.value"], attributes["span.input"]) where attributes["span.input"] != nil and "${env:FI_CAPTURE_CONTENT:-false}" == "true"
          - set(attributes["output.value"], attributes["span.output"]) where attributes["span.output"] != nil and "${env:FI_CAPTURE_CONTENT:-false}" == "true"
          - delete_key(attributes, "span.input") where "${env:FI_CAPTURE_CONTENT:-false}" == "true"
          - delete_key(attributes, "span.output") where "${env:FI_CAPTURE_CONTENT:-false}" == "true"
          # Content OFF (the default): prompts and completions in every spelling OpenRouter or the
          # OpenTelemetry GenAI conventions use, including `<key>.truncated` markers and indexed keys.
          - delete_matching_keys(attributes, "^(span|trace)\\.(input|output|status_message)(\\..*)?$") where "${env:FI_CAPTURE_CONTENT:-false}" != "true"
          - delete_matching_keys(attributes, "^gen_ai\\.(prompt|completion|input\\.messages|output\\.messages)(\\..*)?$") where "${env:FI_CAPTURE_CONTENT:-false}" != "true"
          # Raw provider usage can hold any field the provider adds. OpenRouter nulls it in Privacy Mode.
          - delete_matching_keys(attributes, "^(span|trace)\\.metadata\\.openrouter_generation\\.upstream_raw_response_usage$") where "${env:FI_CAPTURE_CONTENT:-false}" != "true"
          # Error text can echo the request. Keep the fact of the error, not the words.
          - set(status.message, "error") where status.message != "" and "${env:FI_CAPTURE_CONTENT:-false}" != "true"
      - context: spanevent
        statements:
          - delete_key(attributes, "exception.message") where "${env:FI_CAPTURE_CONTENT:-false}" != "true"
          - delete_key(attributes, "exception.stacktrace") where "${env:FI_CAPTURE_CONTENT:-false}" != "true"

  # OpenRouter shortens any attribute over 10,000,000 characters. Future AGI reads at most 16 MiB per
  # request, so batching keeps requests small. A single generation can still exceed it.
  batch:
    send_batch_size: 256
    send_batch_max_size: 512
    timeout: 2s

exporters:
  otlp_http/future_agi:
    traces_endpoint: ${env:FI_TRACES_URL}
    encoding: proto
    compression: none          # optional: Future AGI also accepts gzip bodies
    headers:
      X-Api-Key: ${env:FI_API_KEY}
      X-Secret-Key: ${env:FI_SECRET_KEY}

service:
  extensions: [bearertokenauth/broadcast]
  telemetry:
    metrics:
      level: none              # no self-metrics endpoint; Broadcast sends traces only
    logs:
      level: warn
  pipelines:
    traces:
      receivers: [otlp]
      processors: [resource/future_agi, transform/openrouter, batch]
      exporters: [otlp_http/future_agi]

FI_CAPTURE_CONTENT is read as the exact string true. Any other value, or none, removes the fields listed in Privacy. Custom metadata and model parameters are retained; do not put sensitive text in them.

export BROADCAST_TOKEN=$(openssl rand -hex 24)   # the secret OpenRouter will send
export FI_API_KEY=YOUR_API_KEY FI_SECRET_KEY=YOUR_SECRET_KEY

docker run -d --name openrouter-broadcast-otelcol --memory 512m \
  -p 4318:4318 \
  -v "$PWD/otelcol.yaml:/etc/otelcol/config.yaml:ro" \
  -e BROADCAST_TOKEN -e FI_API_KEY -e FI_SECRET_KEY \
  -e FI_CAPTURE_CONTENT="${FI_CAPTURE_CONTENT:-false}" \
  -e FI_PROJECT_NAME=my-openrouter \
  -e FI_TRACES_URL=https://api.futureagi.com/tracer/v1/traces \
  otel/opentelemetry-collector-contrib:0.162.0 --config /etc/otelcol/config.yaml

OpenRouter’s page says the collector must be on a publicly accessible endpoint. The collector listens on plain HTTP on port 4318. Put TLS in front of it with a load balancer or a reverse proxy, or add tls: with cert_file and key_file under the receiver’s http: block. Every request must carry the bearer token; without it the collector answers 401.

An organization admin opens Settings, Observability, switches Enable Broadcast on, and edits OpenTelemetry Collector.

Click Test Connection. OpenRouter saves the destination only if the test passes. Test Connection checks OpenRouter to collector only. It passes even if your Future AGI keys are wrong, because the collector answers OpenRouter before it exports anything. Send a real request and check Observe.

Any client works. user, session_id and trace are optional and are what link traces to users and sessions in Observe:

{
  "model": "openai/gpt-4o-mini",
  "messages": [{ "role": "user", "content": "What is the capital of France?" }],
  "user": "user_12345",
  "session_id": "session_abc",
  "trace": { "environment": "staging" }
}

Open Observe, select your project, and open the trace.