Trace your agents

1. Store the key (in your own terminal, never in a chat)

sh -c '{ set +x; } 2>/dev/null; umask 077; trap "stty echo 2>/dev/null" EXIT; trap "exit 1" HUP INT TERM; printf "Paste the tracing key, then Enter: "; stty -echo 2>/dev/null; IFS= read -r k; stty echo 2>/dev/null; echo; case "$k" in lp_*) ;; *) echo "LastPing: that is not a tracing key (it starts with lp_). Nothing was changed." >&2; exit 1 ;; esac; if printf "%s" "$k" | LC_ALL=C grep -q "[^A-Za-z0-9_-]" || [ "${#k}" -lt 27 ] || [ "${#k}" -gt 200 ]; then echo "LastPing: that is not a tracing key. Nothing was changed." >&2; exit 1; fi; f="$HOME/.claude/lastping-tracing-key"; mkdir -p "$HOME/.claude" && touch "$f" && chmod 600 "$f" && printf "%s\n" "$k" > "$f" && echo saved'

It asks for the key at a hidden prompt, so the key lands in neither a chat nor your shell's history, and prints saved. It runs in bash or zsh on macOS or Linux. In fish or PowerShell, do not paste it: put the key in with an editor instead.

2. Run the reviewed set-up script

The agent writes ~/.lastping/setup-claude-code.sh (mode 700), a script that holds no key. Read it, then run it with Claude Code's ! prefix, ! sh ~/.lastping/setup-claude-code.sh, or in a terminal. It merges the settings below into ~/.claude/settings.json and writes the helper script. It backs up what it changes, and a second run changes nothing. The agent never opens ~/.claude/settings.json, which can hold other tools' keys: the script checks it.

• If settings.json already sends telemetry somewhere else, the script changes nothing and exits 5. Settings that only change how the export is sent, such as OTEL_EXPORTER_OTLP_TIMEOUT or OTEL_EXPORTER_OTLP_COMPRESSION, are not a conflict and stay as they are.
• If it already sends Claude Code's telemetry to another LastPing monitor, the script names that monitor, changes nothing and exits 6. To move tracing to this monitor, run ! LASTPING_REPLACE=1 sh ~/.lastping/setup-claude-code.sh. To keep tracing on the other monitor, do not store this monitor's tracing key: there is one key file, so a key stored for this monitor stops the other monitor's traces until you store that monitor's own key again with its key line.
• When python3 works and the LastPing hook reports to the same monitor, it also removes the LastPing reporting block from ~/.claude/CLAUDE.md, and from ./CLAUDE.md when that file is outside a git work tree. Otherwise it leaves the block where it is and tells you what to remove.

The files below are what it writes, for doing it by hand.

~/.claude/settings.json (merge)

{
  "env": {
    "CLAUDE_CODE_ENABLE_TELEMETRY": "1",
    "CLAUDE_CODE_ENHANCED_TELEMETRY_BETA": "1",
    "OTEL_TRACES_EXPORTER": "otlp",
    "OTEL_METRICS_EXPORTER": "otlp",
    "OTEL_LOGS_EXPORTER": "otlp",
    "OTEL_EXPORTER_OTLP_PROTOCOL": "http/protobuf",
    "OTEL_EXPORTER_OTLP_ENDPOINT": "https://ping.lastping.dev",
    "OTEL_RESOURCE_ATTRIBUTES": "lastping.monitor_id=<monitor id>",
    "OTEL_TRACES_EXPORT_INTERVAL": "15000",
    "OTEL_LOGS_EXPORT_INTERVAL": "15000"
  },
  "otelHeadersHelper": "~/.claude/lastping-otel-headers.sh"
}

~/.claude/lastping-otel-headers.sh (whole file, mode 700)

#!/bin/sh
# Prints the LastPing tracing key as an OTLP header for Claude Code, which
# runs this at start-up and about every 29 minutes. The key stays in its own
# file, so a new key takes effect without editing settings.json.
key=$(tr -d ' \r\n' < "$HOME/.claude/lastping-tracing-key" 2>/dev/null)
[ -n "$key" ] || exit 1
printf '{"Authorization":"Bearer %s"}\n' "$key"

~/.claude/lastping-tracing-key (whole file, mode 600)

<your tracing key>

Or paste these by hand (the same settings as variables)

export CLAUDE_CODE_ENABLE_TELEMETRY="1"
export CLAUDE_CODE_ENHANCED_TELEMETRY_BETA="1"
export OTEL_TRACES_EXPORTER="otlp"
export OTEL_METRICS_EXPORTER="otlp"
export OTEL_LOGS_EXPORTER="otlp"
export OTEL_EXPORTER_OTLP_PROTOCOL="http/protobuf"
export OTEL_EXPORTER_OTLP_ENDPOINT="https://ping.lastping.dev"
export OTEL_RESOURCE_ATTRIBUTES="lastping.monitor_id=<monitor id>"
export OTEL_TRACES_EXPORT_INTERVAL="15000"
export OTEL_LOGS_EXPORT_INTERVAL="15000"
export OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer $(tr -d ' \r\n' < "$HOME/.claude/lastping-tracing-key")"

The key header is for the one terminal the tool is started from, for that session only. Never put it in a shell profile, where every program that reads OTEL_EXPORTER_OTLP_HEADERS would send your key to its own endpoint.

Test span (must print 202)

now=$(date +%s)
tid=$(od -An -N16 -tx1 /dev/urandom | tr -d ' \n')
sid=$(od -An -N8 -tx1 /dev/urandom | tr -d ' \n')
{ printf 'Authorization: Bearer '; tr -d ' \r\n' < "$HOME/.claude/lastping-tracing-key"; printf '\n'; } |
curl -fsS -m 10 -o /dev/null -w '%{http_code}\n' -X POST "https://ping.lastping.dev/v1/traces" \
  -H "Content-Type: application/json" \
  -H @- \
  -d '{"resourceSpans":[{"resource":{"attributes":[{"key":"lastping.monitor_id","value":{"stringValue":"<monitor id>"}}]},"scopeSpans":[{"scope":{"name":"lastping-setup"},"spans":[{"traceId":"'"$tid"'","spanId":"'"$sid"'","name":"lastping test span","kind":1,"startTimeUnixNano":"'"$now"'000000000","endTimeUnixNano":"'"$now"'100000000","attributes":[{"key":"lastping.test","value":{"boolValue":true}}]}]}]}]}'

Then restart Claude Code once, because it reads these settings only when a session starts, and send it one message: that turn arrives as a run with its model calls and tool calls.

The key goes into ~/.codex/config.toml, readable only by you (mode 600), and into ~/.codex/lastping-tracing-key (mode 600), where the set-up script reads it. Nothing is added to your shell's start-up files.

1. Store the key (in your own terminal, never in a chat)

sh -c '{ set +x; } 2>/dev/null; umask 077; trap "stty echo 2>/dev/null" EXIT; trap "exit 1" HUP INT TERM; printf "Paste the tracing key, then Enter: "; stty -echo 2>/dev/null; IFS= read -r k; stty echo 2>/dev/null; echo; case "$k" in lp_*) ;; *) echo "LastPing: that is not a tracing key (it starts with lp_). Nothing was changed." >&2; exit 1 ;; esac; if printf "%s" "$k" | LC_ALL=C grep -q "[^A-Za-z0-9_-]" || [ "${#k}" -lt 27 ] || [ "${#k}" -gt 200 ]; then echo "LastPing: that is not a tracing key. Nothing was changed." >&2; exit 1; fi; f="$HOME/.codex/lastping-tracing-key"; mkdir -p "$HOME/.codex" && touch "$f" && chmod 600 "$f" && printf "%s\n" "$k" > "$f" && echo saved'

It asks for the key at a hidden prompt, so the key lands in neither a chat nor your shell's history, and prints saved. It runs in bash or zsh on macOS or Linux. In fish or PowerShell, do not paste it: put the key in with an editor instead.

2. Run the reviewed set-up script

The agent writes ~/.lastping/setup-codex.sh (mode 700), a script that holds no key; Codex asks for your approval, because its default sandbox lets a task write only inside its workspace and temporary folders. Read the script, then run it with Codex's ! prefix, ! sh ~/.lastping/setup-codex.sh, or, if that is refused, in a terminal. It writes the [otel] block below into ~/.codex/config.toml with the key you stored, which it reads with the shell's own read and never prints. It backs the file up to ~/.lastping/backups first, keeps every other line as it was, and leaves the file at mode 600. If the file already sends telemetry somewhere else, it changes nothing and says so; a second run changes nothing and says "already set".

~/.codex/config.toml (merge, mode 600)

[otel]
environment = "dev"
log_user_prompt = false
exporter = { otlp-http = { endpoint = "https://ping.lastping.dev/v1/logs", protocol = "binary", headers = { "Authorization" = "Bearer <your tracing key>" } } }
metrics_exporter = { otlp-http = { endpoint = "https://ping.lastping.dev/v1/metrics", protocol = "binary", headers = { "Authorization" = "Bearer <your tracing key>" } } }
trace_exporter = { otlp-http = { endpoint = "https://ping.lastping.dev/v1/traces", protocol = "binary", headers = { "Authorization" = "Bearer <your tracing key>" } } }

~/.codex/lastping-tracing-key (whole file, mode 600)

<your tracing key>

By hand, merge the block into ~/.codex/config.toml with your key in place of the placeholder, then run chmod 600 ~/.codex/config.toml.

Check the file (prints 3, and nothing of the file)

grep -c 'https://ping.lastping.dev/v1/' ~/.codex/config.toml

Test span (must print 202)

now=$(date +%s)
tid=$(od -An -N16 -tx1 /dev/urandom | tr -d ' \n')
sid=$(od -An -N8 -tx1 /dev/urandom | tr -d ' \n')
{ printf 'Authorization: Bearer '; tr -d ' \r\n' < "$HOME/.codex/lastping-tracing-key"; printf '\n'; } |
curl -fsS -m 10 -o /dev/null -w '%{http_code}\n' -X POST "https://ping.lastping.dev/v1/traces" \
  -H "Content-Type: application/json" \
  -H @- \
  -d '{"resourceSpans":[{"resource":{"attributes":[{"key":"lastping.monitor_id","value":{"stringValue":"<monitor id>"}}]},"scopeSpans":[{"scope":{"name":"lastping-setup"},"spans":[{"traceId":"'"$tid"'","spanId":"'"$sid"'","name":"lastping test span","kind":1,"startTimeUnixNano":"'"$now"'000000000","endTimeUnixNano":"'"$now"'100000000","attributes":[{"key":"lastping.test","value":{"boolValue":true}}]}]}]}]}'

Then start a new Codex session and run one task: its token usage appears on this monitor. If an earlier LastPing set-up added a line that exports LASTPING_TRACING_KEY to your shell's start-up file (~/.zshrc, ~/.bashrc or similar), remove that line yourself: Codex no longer needs it, the script does not edit those files, and it hands the key to every program your shell starts. If you keep ~/.codex/config.toml in a dotfiles repository, keep that file out of git.

~/.gemini/settings.json (merge, mode 600)

{
  "telemetry": {
    "enabled": true,
    "target": "local",
    "traces": true,
    "otlpProtocol": "http",
    "otlpEndpoint": "https://ping.lastping.dev/<monitor id>",
    "logPrompts": false
  }
}

Or paste these by hand (the same settings as variables)

export GEMINI_TELEMETRY_ENABLED="true"
export GEMINI_TELEMETRY_TARGET="local"
export GEMINI_TELEMETRY_TRACES_ENABLED="true"
export GEMINI_TELEMETRY_OTLP_PROTOCOL="http"
export GEMINI_TELEMETRY_OTLP_ENDPOINT="https://ping.lastping.dev/<monitor id>"
export GEMINI_TELEMETRY_LOG_PROMPTS="false"

Test span (must print 202)

now=$(date +%s)
tid=$(od -An -N16 -tx1 /dev/urandom | tr -d ' \n')
sid=$(od -An -N8 -tx1 /dev/urandom | tr -d ' \n')
curl -fsS -m 10 -o /dev/null -w '%{http_code}\n' -X POST "https://ping.lastping.dev/<monitor id>/v1/traces" \
  -H "Content-Type: application/json" \
  -d '{"resourceSpans":[{"resource":{"attributes":[{"key":"lastping.monitor_id","value":{"stringValue":"<monitor id>"}}]},"scopeSpans":[{"scope":{"name":"lastping-setup"},"spans":[{"traceId":"'"$tid"'","spanId":"'"$sid"'","name":"lastping test span","kind":1,"startTimeUnixNano":"'"$now"'000000000","endTimeUnixNano":"'"$now"'100000000","attributes":[{"key":"lastping.test","value":{"boolValue":true}}]}]}]}]}'

Then start a new Gemini CLI session and send it one prompt: the turn arrives as a run with its model and tool calls.

Antigravity CLI (agy) exports no telemetry itself. LastPing's hook script reports the runs and sends the spans. The tracing key goes in ~/.lastping/agy/lastping-tracing-key (mode 600), where the script reads it.

1. Install the hook (reports runs without any key)

An AI assistant connected to LastPing calls get_ping_instructions with the tool antigravity and carries out hook_install (over REST, GET /api/v1/checks/{id}/ping-instructions?hook_tool=antigravity), or use the monitor's Connect page: "What runs your agent?", then Antigravity CLI. It writes ~/.lastping/agy-report.sh and adds a hook group named lastping to ~/.gemini/config/hooks.json (PostToolUse, PostInvocation, Stop). Each agy turn becomes a run: started, a step per tool call, then success, or fail when agy's Stop reports an error.

2. Store the key (in your own terminal, never in a chat)

sh -c '{ set +x; } 2>/dev/null; umask 077; trap "stty echo 2>/dev/null" EXIT; trap "exit 1" HUP INT TERM; printf "Paste the tracing key, then Enter: "; stty -echo 2>/dev/null; IFS= read -r k; stty echo 2>/dev/null; echo; case "$k" in lp_*) ;; *) echo "LastPing: that is not a tracing key (it starts with lp_). Nothing was changed." >&2; exit 1 ;; esac; if printf "%s" "$k" | LC_ALL=C grep -q "[^A-Za-z0-9_-]" || [ "${#k}" -lt 27 ] || [ "${#k}" -gt 200 ]; then echo "LastPing: that is not a tracing key. Nothing was changed." >&2; exit 1; fi; f="$HOME/.lastping/agy/lastping-tracing-key"; mkdir -p "$HOME/.lastping/agy" && touch "$f" && chmod 600 "$f" && printf "%s\n" "$k" > "$f" && echo saved'

Run this in a separate terminal window (Terminal, iTerm or your editor's terminal), not in Antigravity's chat and not as a ! command. It asks for the key at a hidden prompt, so the key never appears in the chat or your shell history. It prints saved. It runs in bash or zsh on macOS or Linux. In fish or PowerShell, do not paste it: put the key in with an editor instead.

What is written

• ~/.lastping/agy/lastping-tracing-key, the whole file is the key (mode 600).
• ~/.lastping/agy-report.sh, the hook script, and the lastping group in ~/.gemini/config/hooks.json.

There is one span per model call (chat <model>), one per tool call (execute_tool <tool>) and a root span per turn. No prompt or command text is sent.

Test span (must print 202)

now=$(date +%s)
tid=$(od -An -N16 -tx1 /dev/urandom | tr -d ' \n')
sid=$(od -An -N8 -tx1 /dev/urandom | tr -d ' \n')
{ printf 'Authorization: Bearer '; tr -d ' \r\n' < "$HOME/.lastping/agy/lastping-tracing-key"; printf '\n'; } |
curl -fsS -m 10 -o /dev/null -w '%{http_code}\n' -X POST "https://ping.lastping.dev/v1/traces" \
  -H "Content-Type: application/json" \
  -H @- \
  -d '{"resourceSpans":[{"resource":{"attributes":[{"key":"lastping.monitor_id","value":{"stringValue":"<monitor id>"}}]},"scopeSpans":[{"scope":{"name":"lastping-setup"},"spans":[{"traceId":"'"$tid"'","spanId":"'"$sid"'","name":"lastping test span","kind":1,"startTimeUnixNano":"'"$now"'000000000","endTimeUnixNano":"'"$now"'100000000","attributes":[{"key":"lastping.test","value":{"boolValue":true}}]}]}]}]}'

Spans start with the next Antigravity CLI turn after the key is stored, and nothing needs to be started again: the turn arrives as a run with its model and tool calls.

Limits: no token counts or cost, because Antigravity does not expose them. Span timing is approximate, because hooks fire after the fact, at one-second resolution. A run is never marked blocked, because there is no hook for waiting on a person. One Antigravity monitor per machine, because the key file is per user. The hook script needs a POSIX shell (macOS, Linux or WSL). Existing Gemini CLI installs keep using the Gemini CLI steps above.

Run, in order

pipx install opentelemetry-hooks==0.14.0

otel-hook setup --agent cursor

~/.local/share/opentelemetry-hooks/otel_config.json (merge, mode 600)

{
  "OTEL_EXPORTER_OTLP_ENDPOINT": "https://ping.lastping.dev/v1/traces",
  "OTEL_EXPORTER_OTLP_PROTOCOL": "http/protobuf",
  "OTEL_EXPORTER_OTLP_HEADERS": "Authorization=Bearer <your tracing key>",
  "OTEL_RESOURCE_ATTRIBUTES": "lastping.monitor_id=<monitor id>",
  "OTEL_SERVICE_NAME": "cursor",
  "IDE_OTEL_CAPTURE_CONVERSATION_CONTENT": "false"
}

Or paste these by hand (the same settings as variables)

export OTEL_EXPORTER_OTLP_ENDPOINT="https://ping.lastping.dev/v1/traces"
export OTEL_EXPORTER_OTLP_PROTOCOL="http/protobuf"
export OTEL_RESOURCE_ATTRIBUTES="lastping.monitor_id=<monitor id>"
export OTEL_SERVICE_NAME="cursor"

Then paste this line on its own, after the lines above, and paste the key when it asks

lp_key=$(trap 'stty echo 2>/dev/null' EXIT; trap 'exit 130' INT TERM; printf 'Paste the tracing key, then Enter: ' >&2; stty -echo 2>/dev/null; IFS= read -r k || exit 1; printf '%s' "$k") && echo >&2 && export OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer $lp_key"; unset lp_key

The key header is for the one terminal the tool is started from, for that session only. Never put it in a shell profile, where every program that reads OTEL_EXPORTER_OTLP_HEADERS would send your key to its own endpoint.

Test span (must print 202)

key=$(sed -n 's/.*"Authorization=Bearer \([^"]*\)".*/\1/p' "$HOME/.local/share/opentelemetry-hooks/otel_config.json")
now=$(date +%s)
tid=$(od -An -N16 -tx1 /dev/urandom | tr -d ' \n')
sid=$(od -An -N8 -tx1 /dev/urandom | tr -d ' \n')
printf 'Authorization: %s\n' "Bearer $key" |
curl -fsS -m 10 -o /dev/null -w '%{http_code}\n' -X POST "https://ping.lastping.dev/v1/traces" \
  -H "Content-Type: application/json" \
  -H @- \
  -d '{"resourceSpans":[{"resource":{"attributes":[{"key":"lastping.monitor_id","value":{"stringValue":"<monitor id>"}}]},"scopeSpans":[{"scope":{"name":"lastping-setup"},"spans":[{"traceId":"'"$tid"'","spanId":"'"$sid"'","name":"lastping test span","kind":1,"startTimeUnixNano":"'"$now"'000000000","endTimeUnixNano":"'"$now"'100000000","attributes":[{"key":"lastping.test","value":{"boolValue":true}}]}]}]}]}'

Then restart Cursor and run one agent turn: it arrives as a run with its token counts and tool sequence.

Before writing the key, check that .env is git ignored (git check-ignore .env prints .env); if it is not, add it to .gitignore first.

Run, in order

pip install opentelemetry-distro opentelemetry-exporter-otlp-proto-http opentelemetry-instrumentation-openai opentelemetry-instrumentation-anthropic opentelemetry-instrumentation-httpx opentelemetry-instrumentation-requests

(cr=$(printf '\r'); while IFS= read -r l || [ -n "$l" ]; do l=${l%"$cr"}; case "$l" in OTEL_EXPORTER_OTLP_ENDPOINT=*|OTEL_EXPORTER_OTLP_PROTOCOL=*|OTEL_EXPORTER_OTLP_HEADERS=*|OTEL_RESOURCE_ATTRIBUTES=*|OTEL_SERVICE_NAME=*|OTEL_TRACES_EXPORTER=*|OTEL_METRICS_EXPORTER=*|OTEL_LOGS_EXPORTER=*|TRACELOOP_TRACE_CONTENT=*) v=${l#*=}; v=${v#\"}; v=${v%\"}; export "${l%%=*}=$v";; esac; done < .env; exec opentelemetry-instrument python agent.py)

.env (merge, mode 600)

OTEL_EXPORTER_OTLP_ENDPOINT="https://ping.lastping.dev"
OTEL_EXPORTER_OTLP_PROTOCOL="http/protobuf"
OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer <your tracing key>"
OTEL_RESOURCE_ATTRIBUTES="lastping.monitor_id=<monitor id>"
OTEL_SERVICE_NAME="your-agent"
OTEL_TRACES_EXPORTER="otlp"
OTEL_METRICS_EXPORTER="none"
OTEL_LOGS_EXPORTER="none"
TRACELOOP_TRACE_CONTENT="false"

Or paste these by hand (the same settings as variables)

export OTEL_EXPORTER_OTLP_ENDPOINT="https://ping.lastping.dev"
export OTEL_EXPORTER_OTLP_PROTOCOL="http/protobuf"
export OTEL_RESOURCE_ATTRIBUTES="lastping.monitor_id=<monitor id>"
export OTEL_SERVICE_NAME="your-agent"
export OTEL_TRACES_EXPORTER="otlp"
export OTEL_METRICS_EXPORTER="none"
export OTEL_LOGS_EXPORTER="none"
export TRACELOOP_TRACE_CONTENT="false"

Then paste this line on its own, after the lines above, and paste the key when it asks

lp_key=$(trap 'stty echo 2>/dev/null' EXIT; trap 'exit 130' INT TERM; printf 'Paste the tracing key, then Enter: ' >&2; stty -echo 2>/dev/null; IFS= read -r k || exit 1; printf '%s' "$k") && echo >&2 && export OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer $lp_key"; unset lp_key

The key header is for the one terminal the tool is started from, for that session only. Never put it in a shell profile, where every program that reads OTEL_EXPORTER_OTLP_HEADERS would send your key to its own endpoint.

Test span (must print 202)

auth=$(sed -n 's/^OTEL_EXPORTER_OTLP_HEADERS="*\([^"]*\).*/\1/p' .env | tr -d '\r' | tail -n 1)
now=$(date +%s)
tid=$(od -An -N16 -tx1 /dev/urandom | tr -d ' \n')
sid=$(od -An -N8 -tx1 /dev/urandom | tr -d ' \n')
printf 'Authorization: %s\n' "${auth#Authorization=}" |
curl -fsS -m 10 -o /dev/null -w '%{http_code}\n' -X POST "https://ping.lastping.dev/v1/traces" \
  -H "Content-Type: application/json" \
  -H @- \
  -d '{"resourceSpans":[{"resource":{"attributes":[{"key":"lastping.monitor_id","value":{"stringValue":"<monitor id>"}}]},"scopeSpans":[{"scope":{"name":"lastping-setup"},"spans":[{"traceId":"'"$tid"'","spanId":"'"$sid"'","name":"lastping test span","kind":1,"startTimeUnixNano":"'"$now"'000000000","endTimeUnixNano":"'"$now"'100000000","attributes":[{"key":"lastping.test","value":{"boolValue":true}}]}]}]}]}'

Then start the agent with the new command and let it make one model call: that call arrives as a span with its model and token counts.

Before writing the key, check that .env is git ignored (git check-ignore .env prints .env); if it is not, add it to .gitignore first.

Run, in order

npm install @opentelemetry/api @opentelemetry/instrumentation @opentelemetry/auto-instrumentations-node

# Either: a CommonJS project
node --env-file=.env --require @opentelemetry/auto-instrumentations-node/register agent.js

# Or, instead of the step above: an ES module project
node --env-file=.env --experimental-loader=@opentelemetry/instrumentation/hook.mjs --import @opentelemetry/auto-instrumentations-node/register agent.mjs

.env (merge, mode 600)

OTEL_EXPORTER_OTLP_ENDPOINT="https://ping.lastping.dev"
OTEL_EXPORTER_OTLP_PROTOCOL="http/protobuf"
OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer <your tracing key>"
OTEL_RESOURCE_ATTRIBUTES="lastping.monitor_id=<monitor id>"
OTEL_SERVICE_NAME="your-agent"
OTEL_TRACES_EXPORTER="otlp"
OTEL_METRICS_EXPORTER="none"
OTEL_LOGS_EXPORTER="none"
OTEL_NODE_RESOURCE_DETECTORS="env,host,os"

Or paste these by hand (the same settings as variables)

export OTEL_EXPORTER_OTLP_ENDPOINT="https://ping.lastping.dev"
export OTEL_EXPORTER_OTLP_PROTOCOL="http/protobuf"
export OTEL_RESOURCE_ATTRIBUTES="lastping.monitor_id=<monitor id>"
export OTEL_SERVICE_NAME="your-agent"
export OTEL_TRACES_EXPORTER="otlp"
export OTEL_METRICS_EXPORTER="none"
export OTEL_LOGS_EXPORTER="none"
export OTEL_NODE_RESOURCE_DETECTORS="env,host,os"

Then paste this line on its own, after the lines above, and paste the key when it asks

lp_key=$(trap 'stty echo 2>/dev/null' EXIT; trap 'exit 130' INT TERM; printf 'Paste the tracing key, then Enter: ' >&2; stty -echo 2>/dev/null; IFS= read -r k || exit 1; printf '%s' "$k") && echo >&2 && export OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer $lp_key"; unset lp_key

The key header is for the one terminal the tool is started from, for that session only. Never put it in a shell profile, where every program that reads OTEL_EXPORTER_OTLP_HEADERS would send your key to its own endpoint.

Test span (must print 202)

auth=$(sed -n 's/^OTEL_EXPORTER_OTLP_HEADERS="*\([^"]*\).*/\1/p' .env | tr -d '\r' | tail -n 1)
now=$(date +%s)
tid=$(od -An -N16 -tx1 /dev/urandom | tr -d ' \n')
sid=$(od -An -N8 -tx1 /dev/urandom | tr -d ' \n')
printf 'Authorization: %s\n' "${auth#Authorization=}" |
curl -fsS -m 10 -o /dev/null -w '%{http_code}\n' -X POST "https://ping.lastping.dev/v1/traces" \
  -H "Content-Type: application/json" \
  -H @- \
  -d '{"resourceSpans":[{"resource":{"attributes":[{"key":"lastping.monitor_id","value":{"stringValue":"<monitor id>"}}]},"scopeSpans":[{"scope":{"name":"lastping-setup"},"spans":[{"traceId":"'"$tid"'","spanId":"'"$sid"'","name":"lastping test span","kind":1,"startTimeUnixNano":"'"$now"'000000000","endTimeUnixNano":"'"$now"'100000000","attributes":[{"key":"lastping.test","value":{"boolValue":true}}]}]}]}]}'

Then start the agent with the line for its module type and let it make one model call: that call arrives as a span with its model and token counts.

Before writing the key, check that .env is git ignored (git check-ignore .env prints .env); if it is not, add it to .gitignore first.

.env (merge, mode 600)

OTEL_EXPORTER_OTLP_ENDPOINT="https://ping.lastping.dev"
OTEL_EXPORTER_OTLP_PROTOCOL="http/protobuf"
OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer <your tracing key>"
OTEL_RESOURCE_ATTRIBUTES="lastping.monitor_id=<monitor id>"

Or paste these by hand (the same settings as variables)

export OTEL_EXPORTER_OTLP_ENDPOINT="https://ping.lastping.dev"
export OTEL_EXPORTER_OTLP_PROTOCOL="http/protobuf"
export OTEL_RESOURCE_ATTRIBUTES="lastping.monitor_id=<monitor id>"

Then paste this line on its own, after the lines above, and paste the key when it asks

lp_key=$(trap 'stty echo 2>/dev/null' EXIT; trap 'exit 130' INT TERM; printf 'Paste the tracing key, then Enter: ' >&2; stty -echo 2>/dev/null; IFS= read -r k || exit 1; printf '%s' "$k") && echo >&2 && export OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer $lp_key"; unset lp_key

The key header is for the one terminal the tool is started from, for that session only. Never put it in a shell profile, where every program that reads OTEL_EXPORTER_OTLP_HEADERS would send your key to its own endpoint.

Test span (must print 202)

auth=$(sed -n 's/^OTEL_EXPORTER_OTLP_HEADERS="*\([^"]*\).*/\1/p' .env | tr -d '\r' | tail -n 1)
now=$(date +%s)
tid=$(od -An -N16 -tx1 /dev/urandom | tr -d ' \n')
sid=$(od -An -N8 -tx1 /dev/urandom | tr -d ' \n')
printf 'Authorization: %s\n' "${auth#Authorization=}" |
curl -fsS -m 10 -o /dev/null -w '%{http_code}\n' -X POST "https://ping.lastping.dev/v1/traces" \
  -H "Content-Type: application/json" \
  -H @- \
  -d '{"resourceSpans":[{"resource":{"attributes":[{"key":"lastping.monitor_id","value":{"stringValue":"<monitor id>"}}]},"scopeSpans":[{"scope":{"name":"lastping-setup"},"spans":[{"traceId":"'"$tid"'","spanId":"'"$sid"'","name":"lastping test span","kind":1,"startTimeUnixNano":"'"$now"'000000000","endTimeUnixNano":"'"$now"'100000000","attributes":[{"key":"lastping.test","value":{"boolValue":true}}]}]}]}]}'

Then start your program with these variables in its environment, through your framework's own .env loading or, in a shell, with this line, which reads only these variables from .env and runs nothing in it:

(cr=$(printf '\r'); while IFS= read -r l || [ -n "$l" ]; do l=${l%"$cr"}; case "$l" in OTEL_EXPORTER_OTLP_ENDPOINT=*|OTEL_EXPORTER_OTLP_PROTOCOL=*|OTEL_EXPORTER_OTLP_HEADERS=*|OTEL_RESOURCE_ATTRIBUTES=*) v=${l#*=}; v=${v#\"}; v=${v%\"}; export "${l%%=*}=$v";; esac; done < .env; exec your-start-command)

Its spans arrive on this monitor.

Before writing the key, check that .env is git ignored (git check-ignore .env prints .env); if it is not, add it to .gitignore first.

Run, in order

# Either: the collector installed on this machine
LASTPING_TRACING_KEY="$(sed -n 's/^LASTPING_TRACING_KEY="*\([^"]*\).*/\1/p' .env | tr -d '\r' | tail -n 1)" otelcol --config otelcol-config.yaml

# Or, instead of the step above: the collector in docker
LASTPING_TRACING_KEY="$(sed -n 's/^LASTPING_TRACING_KEY="*\([^"]*\).*/\1/p' .env | tr -d '\r' | tail -n 1)" docker run --rm -p 4317:4317 -p 4318:4318 -e LASTPING_TRACING_KEY -v "$PWD/otelcol-config.yaml:/etc/otelcol/config.yaml:ro" otel/opentelemetry-collector --config /etc/otelcol/config.yaml

otelcol-config.yaml (merge)

exporters:
  otlphttp/lastping:
    endpoint: https://ping.lastping.dev
    headers:
      Authorization: "Bearer ${env:LASTPING_TRACING_KEY}"

# Add otlphttp/lastping to the exporters of the pipelines that carry
# this agent's telemetry, for example:
service:
  pipelines:
    traces:
      receivers: [otlp]
      exporters: [otlphttp/lastping]

.env (merge, mode 600)

LASTPING_TRACING_KEY="<your tracing key>"

Or paste this by hand (it asks for the key at a hidden prompt)

lp_key=$(trap 'stty echo 2>/dev/null' EXIT; trap 'exit 130' INT TERM; printf 'Paste the tracing key, then Enter: ' >&2; stty -echo 2>/dev/null; IFS= read -r k || exit 1; printf '%s' "$k") && echo >&2 && export LASTPING_TRACING_KEY="$lp_key"; unset lp_key

Test span (must print 202)

key=$(sed -n 's/^LASTPING_TRACING_KEY="*\([^"]*\).*/\1/p' .env | tr -d '\r' | tail -n 1)
now=$(date +%s)
tid=$(od -An -N16 -tx1 /dev/urandom | tr -d ' \n')
sid=$(od -An -N8 -tx1 /dev/urandom | tr -d ' \n')
printf 'Authorization: %s\n' "Bearer $key" |
curl -fsS -m 10 -o /dev/null -w '%{http_code}\n' -X POST "https://ping.lastping.dev/v1/traces" \
  -H "Content-Type: application/json" \
  -H @- \
  -d '{"resourceSpans":[{"resource":{"attributes":[{"key":"lastping.monitor_id","value":{"stringValue":"<monitor id>"}}]},"scopeSpans":[{"scope":{"name":"lastping-setup"},"spans":[{"traceId":"'"$tid"'","spanId":"'"$sid"'","name":"lastping test span","kind":1,"startTimeUnixNano":"'"$now"'000000000","endTimeUnixNano":"'"$now"'100000000","attributes":[{"key":"lastping.test","value":{"boolValue":true}}]}]}]}]}'

Then restart the collector with the key from .env in its environment, as the start line above does: what it forwards arrives on this monitor.

USD per million tokens. "Input rate" means the row has no separate price and that column is charged at the input rate. A row with a later "from" date takes over on that day. Each row's source is its provider's own pricing page: Anthropic, OpenAI and Google.