HTTP Telemetry Fields for CometAPI Reliability Reviews

Last reviewed: 2026-06-12

When something goes wrong with a CometAPI call, the first question is usually: what did the HTTP exchange actually look like? Without a consistent set of telemetry fields attached to each request, incident reviews become guesswork. This guide describes which HTTP-level fields to capture, how they map to the OpenTelemetry semantic conventions for HTTP, and how to verify the exact field shapes against the CometAPI documentation before you rely on them in alerts or dashboards.

Direct answer

The HTTP telemetry fields that matter most for CometAPI reliability reviews fall into three groups:

Request identity fields pin the call to a specific endpoint and method:

• http.request.method — should be POST for both the chat completions and responses endpoints; verify the exact allowed methods in the CometAPI docs.
• http.route — the matched route template (e.g., a path under /api/text/); verify the exact path strings against the docs before hardcoding them into dashboards.
• server.address — the CometAPI host; confirm in the docs which base URL is current for your region or account tier.
• network.protocol.version — typically 1.1 or 2; useful when debugging connection-level differences.

Response outcome fields let you classify every call without reading response bodies:

• http.response.status_code — the single most useful field for reliability dashboards. 2xx signals success; 4xx signals a client-side problem (auth, malformed request); 5xx signals a server-side problem. Check the help center for any CometAPI-specific status codes that fall outside this general pattern.
• error.type — populated by your tracing library on non-2xx responses; allows grouping errors by category rather than individual codes.

Duration fields feed latency percentiles and timeout-budget tracking:

• http.request.duration (histogram) or http.client.request.duration — the elapsed time from sending the first byte to receiving the last byte of the response. Verify the exact attribute name your OTel SDK emits; naming conventions differ across SDK versions.

All attribute names above follow the OpenTelemetry HTTP semantic conventions. The CometAPI docs at /api/text/chat and /api/text/responses define the endpoint paths and request/response shapes that these fields describe. Always verify the current attribute names in both sources before wiring them into alert rules.

Smoke-test workflow

Setup assumptions

• You have a valid CometAPI API key in an environment variable (do not hard-code it).
• Your tracing SDK is configured to export spans locally (e.g., to stdout or a local collector) for this test only.
• Base URL and endpoint path are taken from the current CometAPI docs — verify /api/text/chat is still the correct path before running.

Happy-path request plan

1. Send a POST request to the chat completions endpoint with a minimal valid payload (a single short user message).
2. Assert the response status is 200.
3. Confirm the exported span contains http.request.method, http.route, http.response.status_code, and a duration attribute.
4. Record the fields in your log template (see below).

Error-path check

1. Send the same request with an invalid or absent Authorization header.
2. Assert the response status is 4xx (the exact code to expect — 401 or 403 — should be verified in the CometAPI help center).
3. Confirm error.type is populated in the span.
4. Record http.response.status_code and error.type in your log.

Minimum assertions

• http.response.status_code is present on every span.
• http.route matches the documented endpoint path exactly.
• Duration attribute is a positive number.

Pass / fail logging fields Record http.response.status_code, error.type (if present), http.route, and duration_ms for every run. A pass is any run where the happy-path returns 200 with all three span attributes present. A fail is any run where a required field is absent or where the happy-path returns a non-2xx code.

What the smoke test must not assert

• Specific latency SLA values or percentile targets (these require production traffic volume to be meaningful).
• Model availability or which model IDs are currently active.
• Pricing, billing fields, or usage quota values.
• Uptime guarantees of any kind.

Sanitized log record template

Record one row per smoke-test run. Replace placeholders with real values; do not record real credentials, full request bodies, or raw response payloads.

ts: <ISO-8601 timestamp, e.g. 2026-06-12T03:00:00Z> trace_id: <hex trace ID from span context, e.g. 00000000000000000000000000000001> span_id: <hex span ID, e.g. 0000000000000001> http.request.method: POST http.route: <verify exact path in docs, e.g. /api/text/chat> http.response.status_code: <200 | 4xx | 5xx> duration_ms: <integer, measured by SDK> error.type: <omit if 2xx; otherwise error class string> server.address: test_scenario: happy_path | missing_auth pass: true | false notes: <free text, e.g. “missing http.route on SDK version X”>

For broader release checks, see CometAPI chat reliability contract review.

Who this is for

This guide is for backend engineers and SREs who run services that call CometAPI and want to build reliable observability around those calls. It assumes you are already using an OpenTelemetry-compatible tracing or metrics library and want to know which HTTP-level attributes to prioritize when setting up dashboards, alerts, or incident-review checklists.

It is also useful for anyone conducting a post-incident review of a CometAPI outage or degradation who needs a common vocabulary for describing what the HTTP exchange looked like at each layer.

For a deeper look at how fallback decisions are recorded alongside these telemetry fields, see Fallback Decision Logs for CometAPI Gateway Calls.

Key takeaways

• http.response.status_code and http.route are the two highest-value fields for CometAPI reliability reviews; instrument these before anything else.
• Use the OpenTelemetry HTTP semantic conventions as your naming standard so span attributes are consistent across services and tools.
• Verify the exact CometAPI endpoint paths and response shapes in the current docs before wiring telemetry field names into alert rules or dashboards — these are the areas most likely to drift over time.
• Duration fields feed timeout-budget analysis; consult the CometAPI help center for any documented timeout guidance before setting alert thresholds.
• A smoke-test that checks only http.response.status_code, http.route, and duration presence is enough to confirm your instrumentation is working before you rely on it in production.
• Start with CometAPI if you are evaluating the API for a new project.

Failure modes

• Evidence gap: the agent cannot inspect the failing log, source page, pull request, or local command output. The safe action is to stop and record the missing evidence instead of guessing.
• Scope drift: the agent edits files that are not connected to the observed failure. Keep the repair tied to the failing signal and leave unrelated cleanup for a separate task.
• Environment mismatch: the local check uses different versions, credentials, feature flags, or runtime settings than the hosted path. Record the mismatch before treating the result as proof.
• Unreviewed fallback: the agent changes models, endpoints, permissions, or retry behavior to make a run pass without preserving the review boundary. Treat access and provider failures as operational blockers, not topic failures.
• Weak handoff: the final note says the issue is fixed but omits the command, result, changed files, and remaining uncertainty. That makes the next operator repeat the investigation.

Sources checked

• CometAPI documentation - accessed 2026-06-12; purpose: verify current CometAPI documentation navigation.
• CometAPI chat completions reference - accessed 2026-06-12; purpose: verify chat completion contract areas.
• CometAPI responses reference - accessed 2026-06-12; purpose: verify responses endpoint contract areas.
• OpenTelemetry HTTP semantic conventions - accessed 2026-06-12; purpose: verify HTTP telemetry field context.

Contract details to verify

Reader next step

Compare the workflow against Start with CometAPI.

Use CometAPI chat reliability contract review as the next comparison point. Keep Timeout-budget fallback checks for chat completions nearby for setup and permission checks.

FAQ

Which OTel attribute tells me whether a CometAPI call succeeded? http.response.status_code is the most direct field. A value in the 2xx range indicates success at the HTTP transport layer. Note that a 200 response does not guarantee the model output met your application-level quality bar — that requires inspecting the response body, which is a separate concern from HTTP telemetry.

Should I capture url.full or http.route? For reliability dashboards, prefer http.route (the matched route template) over url.full because it has lower cardinality — all calls to the same endpoint share the same route string regardless of query parameters. Use url.full only in debug-level traces where you need the exact request URL. Check the current OTel HTTP semantic conventions for the precise definitions.

How do I distinguish a CometAPI server error from a network error in my spans? error.type is populated differently for HTTP errors versus connection errors. An HTTP 5xx response typically sets error.type to the HTTP status code string; a connection timeout or DNS failure sets it to the exception class name. Verify how your specific OTel SDK handles each case.

Do I need to capture request headers in my spans? Capturing request headers (via http.request.header.*) increases span size and may expose sensitive data including auth tokens. For reliability reviews, http.response.status_code, http.route, and duration are sufficient. Only capture specific headers if your runbook explicitly requires them and you have scrubbed auth header values.

How often should I review these telemetry fields against the CometAPI docs? Verify endpoint paths and response shapes whenever you update your CometAPI integration, after any CometAPI release note mentions endpoint or contract changes, and at least quarterly for long-running services. The CometAPI documentation home is the starting point for checking what has changed.