docs/telemetry.md

Enterprise Telemetry

ctx records privacy-first operational telemetry for API, MCP, CLI, core-tool, and runtime lifecycle boundaries. The default mode is local and redacted: events are written to ~/.ctx/telemetry/events.jsonl, metric points are written separately to ~/.ctx/telemetry/metrics.jsonl, raw prompts and queries are hashed or removed, and network export is disabled unless an operator explicitly enables it or runs an export.

Event Shape

Events use the ctx.telemetry.v1 envelope and OpenTelemetry-style naming:

• ctx.api.recommend_bundle
• ctx.api.recommend_related
• ctx.mcp.request
• ctx.mcp.external_tool_call
• ctx.core.recommend_bundle
• ctx.core.recommend_related
• ctx.runtime_lifecycle.record
• ctx.cli.run
• ctx.cli.resume

Outcome and dimensions live in attributes such as otel.status_code, ctx.operation, ctx.tool.name, ctx.result.count, ctx.selection.selected.count, ctx.selection.rejected.count, ctx.selection.source, ctx.selection.selected, ctx.usage.attribution, and failure/correlation attributes such as ctx.run.failure_stage, ctx.session.previous_trace_id, ctx.traceparent.received, and hashed identifiers like ctx.query.hash, ctx.slug.hash, or ctx.session.hash.

Every recorded event gets a generated OpenTelemetry-compatible trace_id and span_id when the caller does not provide one. The local envelope also keeps parent_span_id when a span was parented to another ctx span or to inbound MCP traceparent metadata. OTLP export maps trace and span ids to the log record traceId and spanId fields and also includes ctx release provenance as ctx.version. In installed wheels this comes from package metadata; in source checkouts it falls back to ctx.__version__.

The ctx run session log stores the initial CLI trace id so ctx resume can emit ctx.session.previous_trace_id without exposing raw prompts. When the generic MCP router calls an external MCP server, it records ctx.mcp.external_tool_call, injects W3C traceparent plus a hashed session correlator into JSON-RPC _meta, and the ctx MCP server parents request spans to valid inbound trace metadata.

Trace Shape

export_traces() projects the redacted event spool into a real OTLP/HTTP traces signal at /v1/traces. The payload uses resourceSpans[].scopeSpans[].spans[] with hexadecimal traceId, spanId, and optional parentSpanId, nanosecond start/end timestamps, span status, resource attributes, and sanitized span attributes.

Events that share one trace_id and span_id are emitted as one OTLP span. Trace export preserves those original ids, including parent_span_id, so trace spans correlate exactly with OTLP log records and retain their parent topology. The first event names the span and every grouped record appears under its events array. Start time is derived from each record's timestamp and duration_ms; end time is the latest grouped event timestamp. ctx never invents trace context during export: records with missing or invalid trace/span ids fail both preview and export without advancing the checkpoint.

Because the local event envelope has no explicit span-close marker, trace export uses a deterministic maturity high-water mark. A span is eligible only after its latest event is at least five seconds old. The delay is configured as traces.export.span_maturity_seconds, is capped at 300 seconds, and can be set to zero only when an operator explicitly accepts immediate maturity. Export advances across a complete prefix of mature span groups; younger or crossing groups remain in the tail with status: pending and a retained_events count. The high-water mark is evaluated on each preview or export invocation; ctx does not start a background timer.

If an event later reuses a span id already before the checkpoint, ctx does not emit that span a second time: it retains the event, reports status: degraded, and increments late_span_events.

Trace export reads the same retained event spool but has independent delivery state:

• ~/.ctx/telemetry/events.jsonl.trace-export-checkpoint.json
• ~/.ctx/telemetry/events.jsonl.trace-export-status.json

Log, trace, and metric retries therefore cannot advance one another's checkpoints.

Metric Shape

Metrics use the ctx.telemetry.metrics.v1 envelope and the same local redaction rules as events. record_counter() writes monotonic counter points and record_histogram() writes histogram observations. OTLP export maps counters to delta sum metrics and observations to delta histogram metrics under resourceMetrics.

Metrics use a separate spool, checkpoint, and status file:

• ~/.ctx/telemetry/metrics.jsonl
• ~/.ctx/telemetry/metrics.jsonl.export-checkpoint.json
• ~/.ctx/telemetry/metrics.jsonl.export-status.json

Metric checkpointing is independent from event/log checkpointing, so replaying or repairing one signal does not advance the other.

Runtime lifecycle token usage emits OTel-style metric names when a host records ctx__mark_entity_used.token_usage:

• ctx.tool_usage.records counts usage records by entity type and attribution.
• ctx.tool_usage.input_tokens and ctx.tool_usage.output_tokens count reported provider input and output tokens.
• ctx.tool_usage.cached_input_tokens and ctx.tool_usage.uncached_input_tokens split reported input usage when the provider exposes cache-read counts.
• ctx.tool_usage.tokens counts total tokens when the record has a non-negative total_tokens value.
• ctx.tool_usage.tokens_per_record observes the same total as a histogram.

Those metric points are recorded inside the same telemetry span as the ctx.runtime_lifecycle.record event that describes the usage, so trace/span correlation stays aligned across event and metric signals. The low-cardinality ctx.usage.tokens_reported attribute distinguishes explicit zero usage from an unavailable provider report.

Attribution is always explicit through ctx.usage.attribution: exact, estimated, or unavailable. The built-in ctx run provider totals are session-scoped and are labeled as unavailable for per-tool attribution; ctx does not split session totals across selected tools. Exact per-tool rows require the host or runner to provide usage for that specific entity.

Privacy Defaults

The shipped config keeps telemetry local. The optional trace block shown here also defaults to export disabled:

{
  "telemetry": {
    "enabled": true,
    "mode": "local_redacted",
    "path": "~/.ctx/telemetry/events.jsonl",
    "export": {
      "enabled": false,
      "sink": "otlp_http",
      "otlp": {
        "endpoint": "http://localhost:4318/v1/logs",
        "allowed_hosts": []
      }
    },
    "traces": {
      "enabled": true,
      "export": {
        "enabled": false,
        "span_maturity_seconds": 5,
        "sink": "otlp_http",
        "otlp": {
          "endpoint": "http://localhost:4318/v1/traces",
          "allowed_hosts": []
        }
      }
    },
    "metrics": {
      "enabled": true,
      "path": "~/.ctx/telemetry/metrics.jsonl",
      "export": {
        "enabled": false,
        "sink": "otlp_http",
        "path": "~/.ctx/telemetry/exported-metrics.jsonl",
        "otlp": {
          "endpoint": "http://localhost:4318/v1/metrics",
          "allowed_hosts": []
        }
      }
    },
    "privacy": {
      "store_raw_inputs": false,
      "hash_identifiers": true,
      "hash_salt_env": "CTX_TELEMETRY_HASH_SALT",
      "hash_salt_path": "~/.ctx/telemetry/hash-salt"
    },
    "retention": {
      "enabled": true,
      "status_path": "~/.ctx/telemetry/retention-status.json",
      "min_keep_records": 1000,
      "drop_malformed": false,
      "events": {
        "max_age_days": 90,
        "max_records": 100000
      },
      "metrics": {
        "max_age_days": 30,
        "max_records": 200000
      }
    }
  }
}

local_redacted removes or hashes raw input fields such as query, prompt, tool_input, stdout, stderr, repo names, secrets, paths, dotted or hyphenated path keys such as ctx.repo.path and repo-path, and keys that normalize to _path or _paths suffixes. It also scans arbitrary string payload values for local host paths such as /Users/..., /home/..., ~/..., and Windows drive paths, replacing each match with [path_hash:sha256:...]. The only accepted modes are local_redacted, disabled, off, and none; unknown modes fail closed instead of emitting raw fields.

Runtime lifecycle records apply the same local-redacted posture to their evidence-bearing strings. Top-level reason, evidence, command, summary, trigger, and status values, plus nested security-scan text, are stored only after secret and local path redaction.

Local JSONL records retain the top-level session_id field for compatibility with existing local-only workflows, but they also include a salted session_hash. Remote OTLP export sends ctx.session.hash and never sends the raw session id, including when exporting legacy local records that predate session_hash. Manual local_jsonl export preserves the same local envelope, so treat exported JSONL as local-sensitive if session ids are present.

Identifier hashes are salted by default. ctx first checks the CTX_TELEMETRY_HASH_SALT environment variable, then any configured privacy.hash_salt, then an owner-only local salt file at ~/.ctx/telemetry/hash-salt. Set CTX_TELEMETRY_HASH_SALT per tenant or deployment when multiple hosts need to correlate the same redacted identifiers. Do not commit a literal privacy.hash_salt into shared source control.

Manual Export

Use ctx-telemetry-export to export an existing local spool without changing the default privacy posture.

Export to another JSONL file:

ctx-telemetry-export \
  --sink local_jsonl \
  --output /var/log/ctx/exported-events.jsonl

Export to an OpenTelemetry Collector logs endpoint:

ctx-telemetry-export \
  --sink otlp_http \
  --otlp-endpoint https://collector.example:4318/v1/logs \
  --otlp-allowed-host collector.example

Remote OTLP endpoints must use https:// and their host must be listed in telemetry.export.otlp.allowed_hosts, or provided for a one-off command with --otlp-allowed-host. Plain http:// is accepted only for loopback collectors (localhost, 127.0.0.1, or [::1]). Literal metadata/link-local, multicast, unspecified, and reserved IP endpoints are rejected even when a command-line or OTEL_EXPORTER_OTLP_* endpoint override is used. Redirects are refused instead of revalidating a second network target.

Preview the event count without exporting:

ctx-telemetry-export --dry-run --json

Export metrics with the same CLI:

ctx-telemetry-export \
  --signal metrics \
  --sink otlp_http \
  --otlp-endpoint https://collector.example:4318/v1/metrics \
  --otlp-allowed-host collector.example

Preview or export traces with the same CLI:

ctx-telemetry-export \
  --signal traces \
  --dry-run \
  --sink otlp_http \
  --otlp-endpoint https://collector.example:4318/v1/traces \
  --otlp-allowed-host collector.example \
  --json

ctx-telemetry-export \
  --signal traces \
  --sink otlp_http \
  --otlp-endpoint https://collector.example:4318/v1/traces \
  --otlp-allowed-host collector.example

The equivalent Python API is:

from pathlib import Path

from ctx.telemetry import export_traces, preview_traces_export

config = {
    "traces": {
        "enabled": True,
        "export": {
            "enabled": True,
            "sink": "otlp_http",
            "otlp": {
                "endpoint": "https://collector.example:4318/v1/traces",
                "allowed_hosts": ["collector.example"],
            },
        },
    },
}

preview = preview_traces_export(
    Path("~/.ctx/telemetry/events.jsonl"),
    config=config,
)
result = export_traces(
    Path("~/.ctx/telemetry/events.jsonl"),
    config=config,
)

Both trace export surfaces build and validate the real OTLP payload. They re-sanitize every outbound string and attribute at the network boundary, hash raw legacy session ids, and apply the same HTTPS, host allow-list, header, timeout, and no-redirect policy as logs and metrics. Content-Type: application/json and Content-Encoding: identity are mandatory and cannot be overridden through configured headers. Trace export is disabled when traces.export.enabled is absent or false for direct API calls. An explicit ctx-telemetry-export --signal traces invocation enables the trace exporter for that run, matching the existing event and metric CLI behavior.

Trace attempted, exported, and failed counts are mature OTLP spans, not source events. ctx.trace.event_count records how many source events are inside each span. A populated 200 OTLP partialSuccess.rejectedSpans response is non-retryable: ctx records exported = attempted - rejectedSpans, failed = rejectedSpans, status: partial_success, a sanitized collector message when present, and advances the checkpoint for the acknowledged request only when no malformed pending local records exist. With malformed pending records, ctx preserves the prior checkpoint so those records remain visible and repairable; accepted spans may be resent after repair.

The direct OTLP client retries 429, 502, 503, 504, URLError, timeout, and connection-disconnect failures up to two times by default. It honors Retry-After; otherwise it uses bounded exponential backoff with jitter. Each delay is capped at five seconds. Override these limits with max_retries, retry_backoff_seconds, retry_jitter_ratio, and max_retry_delay_seconds inside the signal's export.otlp block. Collector response bodies are read through a 64 KiB limit and oversized responses fail closed.

Export metrics from Python:

from pathlib import Path

from ctx.telemetry import export_metrics, record_counter, record_histogram

record_counter("ctx.api.requests", attributes={"ctx.source": "api"})
record_histogram("ctx.api.duration", value=42.0, unit="ms")

result = export_metrics(
    Path("~/.ctx/telemetry/metrics.jsonl"),
    config={
        "metrics": {
            "enabled": True,
            "export": {
                "enabled": True,
                "sink": "otlp_http",
                "otlp": {
                    "endpoint": "https://collector.example:4318/v1/metrics",
                    "allowed_hosts": ["collector.example"],
                },
            },
        }
    },
)

Metrics export uses its own checkpoint and status files next to metrics.jsonl, and the OTEL_EXPORTER_OTLP_METRICS_ENDPOINT environment variable overrides the configured metrics endpoint. OTEL_EXPORTER_OTLP_ENDPOINT is also supported and automatically appends /v1/metrics for metric exports.

OTEL_EXPORTER_OTLP_TRACES_ENDPOINT overrides the configured traces endpoint. OTEL_EXPORTER_OTLP_ENDPOINT appends /v1/traces for trace exports.

Successful exports advance an owner-only checkpoint file. By default it lives next to the spool as events.jsonl.export-checkpoint.json, so later runs export only new events. Use --checkpoint /path/to/checkpoint.json to choose another checkpoint file, or --all when you intentionally want to replay the full spool.

The command exits non-zero if the selected exporter or trace preview validation fails. Use --fail-on-degraded when running from cron or CI and you also want malformed pending records or checkpoint anomalies to fail the command. Real export attempts also write an owner-only status file next to the spool as events.jsonl.export-status.json. It records an explicit status of ok, noop, pending, partial_success, failed, or degraded, plus the sink, destination hash, attempted/exported/failed counts, checkpoint-before/checkpoint-after ids, whether the checkpoint advanced, malformed pending record counts, and the last exporter error kind. Trace status also records retained_events, late_span_events, and only a sanitized collector error_message.

degraded means the exporter delivered the well-formed events it could, but ctx detected a condition an operator should inspect, such as malformed pending local records or a checkpoint id that no longer appears in the spool. A fully accepted trace request does not advance past malformed pending records; retrying after repair may re-export already delivered spans, so downstream collectors should deduplicate by ctx.event_id. The same checkpoint barrier applies to partial_success: accepted spans may be resent, but malformed local evidence cannot be stranded behind an advanced checkpoint.

Manual and continuous exporters re-sanitize legacy local records at the export boundary before writing local_jsonl or sending OTLP, so older spool entries that predate current redaction rules do not leak raw query, path, repo, stdout, stderr, token, or secret payload values.

Retention

Retention is explicit operator action, never a background deletion. Plan first:

ctx-telemetry-retention plan --signal all --json

Then enforce:

ctx-telemetry-retention enforce --signal all --json

Malformed JSONL records are preserved by default so an operator can inspect and repair them. Use --drop-malformed only when the malformed lines have already been preserved elsewhere. Every enforcement run writes an owner-only status file at ~/.ctx/telemetry/retention-status.json.

Continuous Export

To export every new event as it is recorded, enable the exporter in config. User overrides live at ~/.claude/skill-system-config.json.

{
  "telemetry": {
    "export": {
      "enabled": true,
      "sink": "otlp_http",
      "otlp": {
        "endpoint": "https://collector.example:4318/v1/logs",
        "allowed_hosts": ["collector.example"],
        "service_name": "ctx",
        "service_namespace": "ctx",
        "deployment_environment": "prod"
      }
    }
  }
}

OTEL_EXPORTER_OTLP_LOGS_ENDPOINT overrides the configured logs endpoint. OTEL_EXPORTER_OTLP_ENDPOINT is also supported and automatically appends /v1/logs.

Continuous log and metric export drains the pending spool before advancing the checkpoint, not just the record that triggered the write. Trace export advances only through the mature high-water prefix. A fully or partially accepted request advances to that prefix's final event only when no malformed pending records exist. Younger trace events stay pending. With malformed pending records, ctx keeps its prior checkpoint; a fully accepted request reports status: degraded and a populated partial-success response reports status: partial_success. A checkpoint anomaly is reported as degraded while a successful mature prefix can establish a replacement checkpoint. Reopened closed-span events remain in the tail for operator inspection.

Collector Examples

Use an OpenTelemetry Collector between ctx and the observability backend. That keeps ctx vendor-neutral and gives enterprise operators one place to add batching, retry, TLS, auth, routing, and backend-specific exporters.

Local loopback smoke config:

receivers:
  otlp:
    protocols:
      http:
        endpoint: 127.0.0.1:4318

processors:
  batch:

exporters:
  debug:
    verbosity: detailed

service:
  pipelines:
    logs:
      receivers: [otlp]
      processors: [batch]
      exporters: [debug]
    traces:
      receivers: [otlp]
      processors: [batch]
      exporters: [debug]
    metrics:
      receivers: [otlp]
      processors: [batch]
      exporters: [debug]

Run it, then point ctx at the local Collector:

otelcol --config=file:ctx-otel-local.yaml

ctx-telemetry-export \
  --sink otlp_http \
  --otlp-endpoint http://127.0.0.1:4318/v1/logs \
  --otlp-allowed-host 127.0.0.1

For production, keep ctx pointed at a tenant-approved HTTPS Collector and allow-list only that host:

{
  "telemetry": {
    "export": {
      "enabled": true,
      "sink": "otlp_http",
      "otlp": {
        "endpoint": "https://otel-gateway.example.com:4318/v1/logs",
        "allowed_hosts": ["otel-gateway.example.com"],
        "service_name": "ctx",
        "service_namespace": "ctx",
        "deployment_environment": "prod"
      }
    },
    "metrics": {
      "export": {
        "enabled": true,
        "sink": "otlp_http",
        "otlp": {
          "endpoint": "https://otel-gateway.example.com:4318/v1/metrics",
          "allowed_hosts": ["otel-gateway.example.com"]
        }
      }
    },
    "traces": {
      "export": {
        "enabled": true,
        "sink": "otlp_http",
        "otlp": {
          "endpoint": "https://otel-gateway.example.com:4318/v1/traces",
          "allowed_hosts": ["otel-gateway.example.com"]
        }
      }
    }
  }
}

Production Collector sketch:

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

processors:
  memory_limiter:
    check_interval: 5s
    limit_mib: 512
  batch:

exporters:
  otlphttp/vendor:
    endpoint: https://observability-vendor.example.com/otlp
    headers:
      Authorization: ${env:OTEL_VENDOR_AUTH_HEADER}

service:
  pipelines:
    logs:
      receivers: [otlp]
      processors: [memory_limiter, batch]
      exporters: [otlphttp/vendor]
    traces:
      receivers: [otlp]
      processors: [memory_limiter, batch]
      exporters: [otlphttp/vendor]
    metrics:
      receivers: [otlp]
      processors: [memory_limiter, batch]
      exporters: [otlphttp/vendor]

Keep the Collector's public listener and upstream exporter TLS/auth policy under the enterprise network owner. ctx still rejects non-loopback plaintext OTLP endpoints before it sends data.

Dashboards And Alerts

Build the first production dashboard from the stable ctx attributes instead of raw message text:

Panel	Query dimensions
Request volume	count logs grouped by event.name, ctx.source, ctx.operation
Error rate	count logs where otel.status_code = ERROR, grouped by ctx.source
Exception fingerprints	count logs grouped by ctx.exception.fingerprint, ctx.exception.type
Request traces	trace spans grouped by service.name, span name, status, and ctx.source
API latency	histogram metric ctx.api.duration by ctx.operation
CLI/runtime usage	count logs for ctx.cli.run, ctx.cli.resume, ctx.runtime_lifecycle.record, ctx.mcp.external_tool_call
Exporter health	status JSON fields status, attempted, exported, failed, malformed_pending_records, error_kind
Spool growth	event_count, malformed_records, and checkpoint age from /api/status.json

Recommended enterprise alerts:

Alert	Condition
CtxTelemetryExporterFailed	latest export status is failed for 2 consecutive runs
CtxTelemetryExporterDegraded	latest export status is degraded or malformed_pending_records > 0
CtxTelemetrySilent	telemetry is enabled but no new event appears during an expected active window
CtxTelemetrySpoolGrowing	local spool count grows while checkpoint id stays unchanged
CtxTelemetryUnhandledExceptions	new ctx.exception.fingerprint appears in prod

For local dashboard checks, use:

ctx-monitor serve
curl -fsS http://127.0.0.1:8765/api/status.json

The monitor surfaces telemetry health, spool counts, malformed counts, checkpoint presence, exporter attempted/exported/failed counts, and exporter error_kind without rendering event payloads.

Operator Runbook

1. Confirm config posture: ctx-telemetry-export --dry-run --json.
2. Inspect dashboard health: curl -fsS http://127.0.0.1:8765/api/status.json.
3. Inspect exporter status: cat ~/.ctx/telemetry/events.jsonl.export-status.json, cat ~/.ctx/telemetry/events.jsonl.trace-export-status.json, and cat ~/.ctx/telemetry/metrics.jsonl.export-status.json.
4. Repair malformed local records by preserving the original file, removing only invalid JSON lines, and rerunning export with --fail-on-degraded.
5. Replay intentionally with --all only after confirming the downstream backend deduplicates by event_id.
6. Rotate tenant salts only during a planned privacy reset; rotation breaks cross-run correlation for hashed identifiers and exception fingerprints.

Verification

For a local smoke test, run:

ctx-telemetry-export --dry-run --json
ctx-telemetry-export --sink local_jsonl --output /tmp/ctx-telemetry-export.jsonl --json
ctx-telemetry-export --all --sink local_jsonl --output /tmp/ctx-telemetry-replay.jsonl --json

The exported JSONL should contain the same event ids as the local spool and no raw prompt, query, path, repo, stdout, stderr, token, or secret values.

Inspect the durable exporter status after a real run:

cat ~/.ctx/telemetry/events.jsonl.export-status.json

The ctx monitor also surfaces the same local health summary on /status and /api/status.json: capture enabled/mode, spool event and malformed counts, the latest event name/outcome, checkpoint presence, exporter attempted/exported/failed counts, and exporter error_kind. The monitor does not render telemetry payloads.