# tempo.yaml
server:
  http_listen_port: 3200

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

storage:
  trace:
    backend: local
    local:
      path: /var/tempo/traces

docker run --rm --name tempo \
  -p 3200:3200 \
  -p 4317:4317 \
  -p 4318:4318 \
  -v "$PWD/tempo.yaml:/etc/tempo.yaml" \
  grafana/tempo:latest \
  -target=all -config.file=/etc/tempo.yaml

services:
  tempo:
    image: grafana/tempo:latest
    command: ["-target=all", "-config.file=/etc/tempo.yaml"]
    ports:
      - "3200:3200"
      - "4317:4317"
      - "4318:4318"
    volumes:
      - ./tempo.yaml:/etc/tempo.yaml

until curl -sf http://localhost:3200/ready; do sleep 1; done

from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter

provider = TracerProvider()
provider.add_span_processor(
    BatchSpanProcessor(
        OTLPSpanExporter(endpoint="http://localhost:4317", insecure=True)
    )
)
trace.set_tracer_provider(provider)

{ span.http.status_code >= 400 && span.http.status_code < 500 }
{ resource.service.name = "checkout" && span:status = error }
{ span.http.method =~ "GET|POST" }
{ span.any_attribute != nil }
{ trace:duration > 2s }

{ span.http.url = "/checkout" } >> { span.db.system = "postgresql" }

{ span:status = error } | count() > 1
{ span:status = error } | by(resource.service.name) | count() > 1
{ resource.service.name = "api" } | avg(span:duration) > 500ms
{ span:status = error } | select(span.http.status_code, span.http.url)

{
  "traces": [
    {
      "traceID": "abc123",
      "rootServiceName": "checkout",
      "rootTraceName": "POST /order",
      "durationMs": 342,
      "spanSets": [
        {
          "spans": [
            {
              "spanID": "def456",
              "durationNanos": "45000000",
              "attributes": [
                { "key": "http.status_code", "value": { "intValue": "200" } }
              ]
            }
          ],
          "matched": 1
        }
      ]
    }
  ]
}

import time, requests
from urllib.parse import quote

def test_checkout_span_reaches_tempo():
    with tracer.start_as_current_span("POST /order"):
        place_order(items=["widget"])

    trace.get_tracer_provider().force_flush(timeout_millis=5000)
    time.sleep(0.5)  # Tempo ingest pipeline

    query = '{ resource.service.name = "checkout" && span.http.url = "/order" }'
    resp = requests.get(
        "http://localhost:3200/api/search",
        params={"q": query, "limit": 1},
    )
    resp.raise_for_status()
    traces = resp.json()["traces"]
    assert len(traces) == 1, f"Expected 1 trace, got {len(traces)}"
    assert traces[0]["rootServiceName"] == "checkout"

def test_db_span_is_child_of_checkout():
    with tracer.start_as_current_span("POST /order") as root:
        with tracer.start_as_current_span("db.query"):
            run_query("INSERT INTO orders ...")
        trace_id = format(root.get_span_context().trace_id, "032x")

    trace.get_tracer_provider().force_flush(timeout_millis=5000)
    time.sleep(0.5)

    resp = requests.get(f"http://localhost:3200/api/traces/{trace_id}")
    resp.raise_for_status()
    data = resp.json()

    resource_spans = data["resourceSpans"]
    all_spans = [
        s
        for rs in resource_spans
        for ss in rs["scopeSpans"]
        for s in ss["spans"]
    ]

    root_span = next(s for s in all_spans if s["name"] == "POST /order")
    db_span   = next(s for s in all_spans if s["name"] == "db.query")

    assert db_span["parentSpanId"] == root_span["spanId"]

def attr(span, key):
    for a in span.get("attributes", []):
        if a["key"] == key:
            v = a["value"]
            return next(iter(v.values()))
    return None

assert attr(db_span, "db.system") == "postgresql"
assert int(attr(root_span, "http.status_code")) == 200

import uuid
service = f"checkout-test-{uuid.uuid4()}"
# ... configure TracerProvider with service.name = service ...
query = f'{{ resource.service.name = "{service}" }}'