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.

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.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.

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:

{
  "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": []
      }
    },
    "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

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.

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 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, 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.

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. ctx does not advance the checkpoint past malformed pending records; retrying after repair may re-export already delivered events, so downstream collectors should deduplicate by event_id.

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 export drains the pending spool before advancing the checkpoint, not just the event or metric that triggered the write. If all pending well-formed records export successfully and no malformed pending records remain, the checkpoint advances to the last exported id. If malformed pending records or a checkpoint anomaly are present, ctx records status: degraded and leaves the checkpoint in place so an operator can repair or intentionally replay.

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]
    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"]
        }
      }
    }
  }
}

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]
    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
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 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.