Skip to content

Troubleshooting guide ​

Use this page to identify which telemetry can help explain a problem. See Telemetry reference for event and field definitions and Integration coverage for collection behavior. Open Events in your project or connect your AI agent to inspect it.

Field availability depends on the SDK, integration, runtime, and provider. The fields below describe supported signals, not a guarantee that every event contains them. A missing value means unknown, not zero.

Start with the symptom ​

ProblemInspect
Calls fail or time outFailures
Responses are slowLatency
Token use or cost increasesUsage and cost
Only some devices struggleDevice performance
Results change after a releaseModel behavior
A multi-step run failsRuns and traces
You need the original exampleCaptured content

Failures ​

Applies to: OpenAI and Anthropic SDK integrations, LiteLLM, OpenRouter, and Bifrost.

Start with the failed inference or error event. Compare the error code, model, and elapsed time before opening the surrounding run.

SignalUse it to check
success, error_codeWhich calls failed and how failures are classified
http_status, provider_error_codeWhether a remote provider rejected the request
duration_msWhether failure was immediate or followed a long wait
error_message, stack_trace_hashError details and repeated failures, when supplied
related_event_idThe event linked to an SDK error

SDK integrations can report inference failures and separate error events. Gateways report the failures they export. For example, OpenRouter does not export requests rejected before routing. See gateway limitations.

Error text can contain content from your code or a provider. Review what your integration sends before treating error messages as content-free telemetry.

Latency ​

Applies to: llama.cpp, MLX, Transformers, remote model APIs, and gateway calls.

Separate total call duration from the delay before output starts. For local models, inspect load time and hardware state as well.

SignalUse it to check
duration_msTotal inference duration
time_to_first_token_msDelay before generation starts
tokens_out, tokens_per_secondOutput size and generation throughput
model_load durationModel startup overhead
Span durationsTime spent in tools, retrieval, or other application work

SDK integrations supply timing supported by the runtime or provider. Gateways supply exported call timing. OpenRouter reports time to first token for streamed and non-streamed calls.

Compare calls with similar models, input sizes, and output sizes. Longer output can increase total duration without indicating slower generation.

Usage and cost ​

Applies to: LiteLLM, OpenRouter, and Bifrost for reported cost. SDK integrations can supply token usage.

Compare usage by requested model and the model that served the call. Check missing prices before interpreting totals.

SignalUse it to check
tokens_in, tokens_outInput and output token use
cached_input_tokens, reasoning_tokens_outCached input and reasoning usage, when reported
requested_model_id, model_name, model_providerGateway routing and model selection
reported_cost_amount, reported_cost_currencyGateway-reported cost
reported_cost_is_estimatedWhether that cost is an estimate
request_idRelated gateway attempts, where supported

The cost fields above come from gateway exports. LiteLLM and Bifrost report estimated prices. OpenRouter reports the amount charged. Missing cost does not mean a free call. Gateway fields and query examples cover these differences.

If the gateway exports a cloud call, disable SDK tracking for that call to avoid counting it twice. SDK tracking for on-device models and gateway tracking for cloud models do not overlap. See app and gateway setup.

Device performance ​

Applies to: Core ML, TensorFlow Lite, ONNX Runtime, and other SDK-tracked local runtimes.

Compare device models first. Accelerator values identify execution targets such as CPU or GPU. They do not necessarily identify a chipset or prove that its NPU was used.

Filter by device, app version, and model version. Compare affected devices with devices running the same model successfully.

SignalUse it to check
Device model, OS version, app versionWhether the issue is limited to a device class or release
Thermal state and CPU frequencyWhether heat or throttling coincides with slower calls
Available memoryWhether memory pressure coincides with failures
accelerator_actualWhich accelerator ran the inference
Model load and unload eventsStartup overhead and model eviction
Requested and actual acceleratorDifferences between configuration and reported execution

These signals require SDK instrumentation and platform support. Gateway exports do not describe the calling device's hardware. A missing accelerator value does not prove the requested accelerator was used.

Model behavior ​

Applies to: ONNX Runtime, Transformers, Core ML, and other integrations that supply model and prediction metadata.

Compare the same task across model versions, app releases, runtimes, and device classes. Use feedback and captured examples to assess whether a change improved results.

SignalUse it to check
Model name, version, format, quantizationWhich model configuration changed
resolved_model_id, system_fingerprint, service_tierProvider metadata returned for an SDK-tracked API call
Classification labels, confidence, bounding boxesChanges in predictions, where supplied
Image brightness, audio quality, text length and languageChanges in input measurements, where supplied
Generation settings and stop reasonChanges in generation configuration or completion behavior
Feedback linked to an inferenceUser acceptance, rejection, or edits

SDK support varies by integration. Some values require manual tracking. Gateway exports provide call metadata and usage, not the same prediction, input-quality, or feedback signals as SDK instrumentation.

Confidence and input statistics help locate changes. They do not establish whether a prediction was correct. Inspect feedback or examples before drawing that conclusion.

Runs and traces ​

Start with one failed or slow event, then follow its run or trace to inspect preceding steps.

SignalUse it to check
trace_id, span_id, parent_span_idParent and child relationships
run_id, agent_idEvents associated with an agent run
Span name, kind, duration, statusWhich application step failed or took time
conversation_id, step_indexConversation or execution position, when supplied

SDK correlation depends on the instrumentation and context passed between steps. SDK and gateway events are not automatically linked into one trace.

Investigate events and traces provides prompts for a first investigation.

Captured content ​

Measurements can identify a problem without showing the original input or output. To inspect an example, check whether content was explicitly supplied or capture was enabled for that integration.

ContentHow it reaches WildEdge
Input or output filesAttachments uploaded separately and referenced by an inference event
Span input and output previewsOptional input_summary and output_summary
Custom contextValues supplied in attributes
Error detailsError messages supplied by your code or integration

Input and output capture is opt-in. Follow your SDK guide to configure capture or supply attachments. Support and upload limits depend on the integration and project configuration.

WildEdge keeps prompt and response text from gateway traces as event summaries, when the gateway exports it. LiteLLM leaves it out by default, Bifrost with disable_content_logging, and OpenRouter in Privacy Mode.

Review summaries, attributes, error messages, and attachments for sensitive content. Disabling attachments does not remove content supplied in other fields.

Missing events or fields ​

  1. Confirm that events are going to the intended project.
  2. Check that your SDK integration or gateway exports the signal you need.
  3. Run one inference and find its event before expanding the time range.
  4. Check exporter or SDK logs if the event does not arrive.

Follow app setup or gateway troubleshooting for connection checks. Use the API reference for endpoint schemas.

Next ​