Skip to content
Start here

Run a query

workers.observability.telemetry.query(TelemetryQueryParams**kwargs) -> TelemetryQueryResponse
POST/accounts/{account_id}/workers/observability/telemetry/query

Run a temporary or saved query.

Security
API Email + API Key

The previous authorization scheme for interacting with the Cloudflare API, used in conjunction with a Global API key.

Example:X-Auth-Email: user@example.com

The previous authorization scheme for interacting with the Cloudflare API. When possible, use API tokens instead of Global API keys.

Example:X-Auth-Key: 144c9defac04969c7bfad8efaa8ea194
API Token

The preferred authorization scheme for interacting with the Cloudflare API. Create a token.

Example:Authorization: Bearer Sn3lZJTBX6kkg7OdcBUAxOO963GEIyGQqnFTOFYY
User Service Key

Used when interacting with the Origin CA certificates API. View/change your key.

Example:X-Auth-User-Service-Key: v1.0-144c9defac04969c7bfad8ef-631a41d003a32d25fe878081ef365c49503f7fada600da935e2851a1c7326084b85cbf6429c4b859de8475731dc92a9c329631e6d59e6c73da7b198497172b4cefe071d90d0f5d2719
Accepted Permissions (at least one required)
Workers Observability Write
ParametersExpand Collapse
account_id: str
query_id: str

Identifier for the query. When parameters are omitted, this ID is used to load a previously saved query’s parameters. When providing parameters inline, pass any identifier (e.g. an ad-hoc ID).

timeframe: Timeframe

Timeframe for the query using Unix timestamps in milliseconds. ‘from’ must be earlier than ‘to’. Narrower timeframes produce faster responses and more specific results.

from_: int

Start timestamp for the query timeframe. Unix timestamp in milliseconds

maximum253402300799999
minimum0
to: int

End timestamp for the query timeframe. Unix timestamp in milliseconds

maximum253402300799999
minimum0
chart: Optional[bool]

When true, includes time-series data in the response.

chart_type: Optional[Literal["timeseries_and_aggregate", "timeseries", "aggregate", "distribution"]]

Controls the SQL shape and response payload for the ‘calculations’ view. Omitted or ‘timeseries_and_aggregate’: current behaviour — both the time-series and aggregate queries. ‘timeseries’: time-series only. ‘aggregate’: aggregate only. ‘distribution’: a bucketed 2D histogram (time × value buckets) returned in ‘distribution’ instead of ‘calculations’. ‘distribution’ is not compatible with ‘compare’ — combining them returns a 400.

One of the following:
"timeseries_and_aggregate"
"timeseries"
"aggregate"
"distribution"
compare: Optional[bool]

When true, includes a comparison dataset from the previous time period of equal length.

distribution_scale: Optional[Literal["log", "linear"]]

Value-axis bucketing for chartType ‘distribution’. Omitted or ‘log’: geometric buckets, best for heavy-tailed latency. ‘linear’: fixed-width buckets, clearer for narrow or additive ranges. Ignored for other chartTypes. The response echoes the scheme used in distribution.bucketMode.

One of the following:
"log"
"linear"
dry: Optional[bool]

When true, executes the query without persisting the results. Useful for validation or previewing.

granularity: Optional[float]

Number of time-series buckets. Only used when view is ‘calculations’. Omit to let the system auto-detect an appropriate granularity.

ignore_series: Optional[bool]

When true, omits time-series data from the response and returns only aggregated values. Reduces response size when series are not needed.

limit: Optional[float]

Maximum number of events to return when view is ‘events’. Also controls the number of group-by rows when view is ‘calculations’.

maximum2000
offset: Optional[str]

Cursor for pagination in event, trace, invocation, and agent views. Pass the $metadata.id of the last event, the trace cursor, or AgentRun.id to fetch the next page.

offset_by: Optional[float]

Numeric offset for paginating grouped/pattern results (top-N lists). Use together with limit. Not used by cursor-based pagination.

offset_direction: Optional[str]

Pagination direction: ‘next’ for forward, ‘prev’ for backward.

parameters: Optional[Parameters]

Query parameters defining what data to retrieve — filters, calculations, group-bys, and ordering. In practice this should always be provided for ad-hoc queries. Only omit when executing a previously saved query by queryId. Use the keys and values endpoints to discover available fields before building filters.

calculations: Optional[Iterable[ParametersCalculation]]

Aggregation calculations to compute (e.g. count, avg, p99). Each calculation produces aggregate values and optional time-series data.

One of the following:
class ParametersCalculationUnionMember0: …
operator: Literal["count", "COUNT"]

Aggregation operator to apply. Examples: count, avg, sum, min, max, median, p90, p95, p99, uniq, stddev, variance.

One of the following:
"count"
"COUNT"
alias: Optional[str]

Custom label for this calculation in the results. Useful for distinguishing multiple calculations.

key: Optional[str]

Field name to calculate over. Must exist in the data. Verify with the keys endpoint. Required for every operator except count, which aggregates whole rows and may omit it.

key_type: Optional[Literal["string", "number", "boolean"]]

Data type of the key. Required when key is provided to ensure correct aggregation.

One of the following:
"string"
"number"
"boolean"
class ParametersCalculationUnionMember1: …
key: str

Field name to calculate over. Must exist in the data. Verify with the keys endpoint. Required for every operator except count, which aggregates whole rows and may omit it.

operator: Literal["uniq", "max", "min", 33 more]

Aggregation operator to apply. Examples: count, avg, sum, min, max, median, p90, p95, p99, uniq, stddev, variance.

One of the following:
"uniq"
"max"
"min"
"sum"
"avg"
"median"
"p001"
"p01"
"p05"
"p10"
"p25"
"p75"
"p90"
"p95"
"p99"
"p999"
"stddev"
"variance"
"COUNT_DISTINCT"
"MAX"
"MIN"
"SUM"
"AVG"
"MEDIAN"
"P001"
"P01"
"P05"
"P10"
"P25"
"P75"
"P90"
"P95"
"P99"
"P999"
"STDDEV"
"VARIANCE"
alias: Optional[str]

Custom label for this calculation in the results. Useful for distinguishing multiple calculations.

key_type: Optional[Literal["string", "number", "boolean"]]

Data type of the key. Required when key is provided to ensure correct aggregation.

One of the following:
"string"
"number"
"boolean"
datasets: Optional[Sequence[str]]

Datasets to query. Leave empty to query all available datasets.

filter_combination: Optional[Literal["and", "or", "AND", "OR"]]

Logical operator for combining top-level filters: ‘and’ (all must match) or ‘or’ (any must match). Defaults to ‘and’.

One of the following:
"and"
"or"
"AND"
"OR"
filters: Optional[Iterable[ParametersFilter]]

Filters to narrow query results. Use the keys and values endpoints to discover available fields before building filters. Supports nested groups via kind: ‘group’. Maximum nesting depth is 4.

One of the following:
class ParametersFilterUnionMember0: …
filter_combination: Literal["and", "or", "AND", "OR"]
One of the following:
"and"
"or"
"AND"
"OR"
filters: Iterable[ParametersFilterUnionMember0Filter]
One of the following:
class ParametersFilterUnionMember0FilterUnionMember0: …
filter_combination: Literal["and", "or", "AND", "OR"]
One of the following:
"and"
"or"
"AND"
"OR"
filters: Iterable[object]
kind: Literal["group"]
class ParametersFilterUnionMember0FilterWorkersObservabilityFilterLeaf: …

A filter condition applied to query results. Use the keys and values endpoints to discover available fields and their values before constructing filters.

key: str

Filter field name. Use verified keys from previous query results or the keys endpoint. Common keys include $metadata.service, $metadata.origin, $metadata.trigger, $metadata.message, and $metadata.error.

operation: Literal["includes", "not_includes", "starts_with", 27 more]

Comparison operator. String operators: includes, not_includes, starts_with, ends_with, regex. Existence: exists, is_null. Set membership: in, not_in (comma-separated values). Numeric: eq, neq, gt, gte, lt, lte.

One of the following:
"includes"
"not_includes"
"starts_with"
"ends_with"
"regex"
"exists"
"is_null"
"in"
"not_in"
"eq"
"neq"
"gt"
"gte"
"lt"
"lte"
"="
"!="
">"
">="
"<"
"<="
"INCLUDES"
"DOES_NOT_INCLUDE"
"MATCH_REGEX"
"EXISTS"
"DOES_NOT_EXIST"
"IN"
"NOT_IN"
"STARTS_WITH"
"ENDS_WITH"
type: Literal["string", "number", "boolean"]

Data type of the filter field. Must match the actual type of the key being filtered.

One of the following:
"string"
"number"
"boolean"
kind: Optional[Literal["filter"]]

Discriminator for leaf filter nodes. Always ‘filter’ when present; may be omitted.

value: Optional[Union[str, float, bool]]

Comparison value. Must match actual values in your data — verify with the values endpoint. Ensure the value type (string/number/boolean) matches the field type. String comparisons are case-sensitive. Regex uses RE2 syntax (no lookaheads/lookbehinds).

One of the following:
str
float
bool
kind: Literal["group"]
class ParametersFilterWorkersObservabilityFilterLeaf: …

A filter condition applied to query results. Use the keys and values endpoints to discover available fields and their values before constructing filters.

key: str

Filter field name. Use verified keys from previous query results or the keys endpoint. Common keys include $metadata.service, $metadata.origin, $metadata.trigger, $metadata.message, and $metadata.error.

operation: Literal["includes", "not_includes", "starts_with", 27 more]

Comparison operator. String operators: includes, not_includes, starts_with, ends_with, regex. Existence: exists, is_null. Set membership: in, not_in (comma-separated values). Numeric: eq, neq, gt, gte, lt, lte.

One of the following:
"includes"
"not_includes"
"starts_with"
"ends_with"
"regex"
"exists"
"is_null"
"in"
"not_in"
"eq"
"neq"
"gt"
"gte"
"lt"
"lte"
"="
"!="
">"
">="
"<"
"<="
"INCLUDES"
"DOES_NOT_INCLUDE"
"MATCH_REGEX"
"EXISTS"
"DOES_NOT_EXIST"
"IN"
"NOT_IN"
"STARTS_WITH"
"ENDS_WITH"
type: Literal["string", "number", "boolean"]

Data type of the filter field. Must match the actual type of the key being filtered.

One of the following:
"string"
"number"
"boolean"
kind: Optional[Literal["filter"]]

Discriminator for leaf filter nodes. Always ‘filter’ when present; may be omitted.

value: Optional[Union[str, float, bool]]

Comparison value. Must match actual values in your data — verify with the values endpoint. Ensure the value type (string/number/boolean) matches the field type. String comparisons are case-sensitive. Regex uses RE2 syntax (no lookaheads/lookbehinds).

One of the following:
str
float
bool
group_bys: Optional[Iterable[ParametersGroupBy]]

Fields to group calculation results by. Only applicable when the query view is ‘calculations’. Produces per-group aggregate values.

type: Literal["string", "number", "boolean"]

Data type of the group-by field.

One of the following:
"string"
"number"
"boolean"
value: str

Field name to group results by (e.g. $metadata.service, $metadata.statusCode).

havings: Optional[Iterable[ParametersHaving]]

Post-aggregation filters applied to calculation results. Use to filter groups after aggregation (e.g. only groups where count > 100).

key: str

Calculation alias or operator to filter on after aggregation.

operation: Literal["eq", "neq", "gt", 3 more]

Numeric comparison operator: eq, neq, gt, gte, lt, lte.

One of the following:
"eq"
"neq"
"gt"
"gte"
"lt"
"lte"
value: float

Threshold value to compare the calculation result against.

limit: Optional[int]

Maximum number of group-by rows to return in calculation results. A value of 10 is a sensible default for most use cases.

maximum2000
minimum0
needle: Optional[ParametersNeedle]

Full-text search expression applied across all event fields. Matches events containing the specified text.

value: Union[str, float, bool]

The text or pattern to search for.

maxLength1000
One of the following:
str
float
bool
is_regex: Optional[bool]

When true, treats the value as a regular expression (RE2 syntax).

match_case: Optional[bool]

When true, performs a case-sensitive search. Defaults to case-insensitive.

order_by: Optional[ParametersOrderBy]

Ordering for grouped calculation results. Only effective when a group-by is present.

value: str

Alias of the calculation to order results by. Must match the alias (or operator) of a calculation in the query.

order: Optional[Literal["asc", "desc"]]

Sort direction: ‘asc’ for ascending, ‘desc’ for descending.

One of the following:
"asc"
"desc"
view: Optional[Literal["traces", "events", "calculations", 3 more]]

Controls the shape of the response. ‘events’: individual log lines matching the query. ‘calculations’: aggregated metrics (count, avg, p99, etc.) with optional group-by breakdowns and time-series. ‘invocations’: events grouped by request ID. ‘traces’: distributed trace summaries. ‘agents’: agent-specific trace summaries.

One of the following:
"traces"
"events"
"calculations"
"invocations"
"requests"
"agents"
ReturnsExpand Collapse
class TelemetryQueryResponse: …

Complete results of a query run. The populated fields depend on the requested view type (events, calculations, invocations, traces, or agents).

run: Run

Represents a single execution of a query against Workers Observability data, including the query definition, execution status, and performance statistics.

id: str

Unique identifier for this query run.

account_id: str

Cloudflare account ID that owns this query run.

dry: bool

Whether this was a dry run (results not persisted).

granularity: float

Number of time-series buckets used for the query. Higher values produce more detailed series data.

query: RunQuery

A saved query definition with its parameters, metadata, and ownership information.

id: str
adhoc: bool

If the query wasn’t explcitly saved

created: Union[str, datetime]
formatdate-time
One of the following:
str
datetime
created_by: str
description: Optional[str]
maxLength1000
name: str

Query name

maxLength250
minLength1
parameters: RunQueryParameters
calculations: Optional[List[RunQueryParametersCalculation]]

Create Calculations to compute as part of the query.

One of the following:
class RunQueryParametersCalculationUnionMember0: …
operator: Literal["count", "COUNT"]
One of the following:
"count"
"COUNT"
alias: Optional[str]
key: Optional[str]
key_type: Optional[Literal["string", "number", "boolean"]]
One of the following:
"string"
"number"
"boolean"
class RunQueryParametersCalculationUnionMember1: …
key: str
operator: Literal["uniq", "max", "min", 33 more]
One of the following:
"uniq"
"max"
"min"
"sum"
"avg"
"median"
"p001"
"p01"
"p05"
"p10"
"p25"
"p75"
"p90"
"p95"
"p99"
"p999"
"stddev"
"variance"
"COUNT_DISTINCT"
"MAX"
"MIN"
"SUM"
"AVG"
"MEDIAN"
"P001"
"P01"
"P05"
"P10"
"P25"
"P75"
"P90"
"P95"
"P99"
"P999"
"STDDEV"
"VARIANCE"
alias: Optional[str]
key_type: Optional[Literal["string", "number", "boolean"]]
One of the following:
"string"
"number"
"boolean"
datasets: Optional[List[str]]

Set the Datasets to query. Leave it empty to query all the datasets.

filter_combination: Optional[Literal["and", "or", "AND", "OR"]]

Set a Flag to describe how to combine the filters on the query.

One of the following:
"and"
"or"
"AND"
"OR"
filters: Optional[List[RunQueryParametersFilter]]

Configure the Filters to apply to the query. Supports nested groups via kind: ‘group’.

One of the following:
class RunQueryParametersFilterUnionMember0: …
filter_combination: Literal["and", "or", "AND", "OR"]
One of the following:
"and"
"or"
"AND"
"OR"
filters: List[object]
kind: Literal["group"]
class RunQueryParametersFilterWorkersObservabilityFilterLeaf: …

A filter condition applied to query results. Use the keys and values endpoints to discover available fields and their values before constructing filters.

key: str

Filter field name. Use verified keys from previous query results or the keys endpoint. Common keys include $metadata.service, $metadata.origin, $metadata.trigger, $metadata.message, and $metadata.error.

operation: Literal["includes", "not_includes", "starts_with", 27 more]

Comparison operator. String operators: includes, not_includes, starts_with, ends_with, regex. Existence: exists, is_null. Set membership: in, not_in (comma-separated values). Numeric: eq, neq, gt, gte, lt, lte.

One of the following:
"includes"
"not_includes"
"starts_with"
"ends_with"
"regex"
"exists"
"is_null"
"in"
"not_in"
"eq"
"neq"
"gt"
"gte"
"lt"
"lte"
"="
"!="
">"
">="
"<"
"<="
"INCLUDES"
"DOES_NOT_INCLUDE"
"MATCH_REGEX"
"EXISTS"
"DOES_NOT_EXIST"
"IN"
"NOT_IN"
"STARTS_WITH"
"ENDS_WITH"
type: Literal["string", "number", "boolean"]

Data type of the filter field. Must match the actual type of the key being filtered.

One of the following:
"string"
"number"
"boolean"
kind: Optional[Literal["filter"]]

Discriminator for leaf filter nodes. Always ‘filter’ when present; may be omitted.

value: Optional[Union[str, float, bool, null]]

Comparison value. Must match actual values in your data — verify with the values endpoint. Ensure the value type (string/number/boolean) matches the field type. String comparisons are case-sensitive. Regex uses RE2 syntax (no lookaheads/lookbehinds).

One of the following:
str
float
bool
group_bys: Optional[List[RunQueryParametersGroupBy]]

Define how to group the results of the query.

type: Literal["string", "number", "boolean"]
One of the following:
"string"
"number"
"boolean"
value: str
havings: Optional[List[RunQueryParametersHaving]]

Configure the Having clauses that filter on calculations in the query result.

key: str
operation: Literal["eq", "neq", "gt", 3 more]
One of the following:
"eq"
"neq"
"gt"
"gte"
"lt"
"lte"
value: float
limit: Optional[int]

Set a limit on the number of results / records returned by the query

maximum100
minimum0
needle: Optional[RunQueryParametersNeedle]

Define an expression to search using full-text search.

value: RunQueryParametersNeedleValue
is_regex: Optional[bool]
match_case: Optional[bool]
order_by: Optional[RunQueryParametersOrderBy]

Configure the order of the results returned by the query.

value: str

Configure which Calculation to order the results by.

order: Optional[Literal["asc", "desc"]]

Set the order of the results

One of the following:
"asc"
"desc"
updated: Union[str, datetime]
formatdate-time
One of the following:
str
datetime
updated_by: str
status: Literal["STARTED", "COMPLETED"]

Current execution status of the query run.

One of the following:
"STARTED"
"COMPLETED"
timeframe: RunTimeframe

Time range for the query execution. ‘from’ must be earlier than ‘to’. No fractional milliseconds.

from_: int

Start timestamp for the query timeframe. Unix timestamp in milliseconds

maximum253402300799999
minimum0
to: int

End timestamp for the query timeframe. Unix timestamp in milliseconds

maximum253402300799999
minimum0
user_id: str

ID of the user who initiated the query run.

created: Optional[str]

ISO-8601 timestamp when the query run was created.

statistics: Optional[RunStatistics]

Query performance statistics from the database (does not include network latency).

bytes_read: float

Number of uncompressed bytes read from the table.

elapsed: float

Time in seconds for the query to run.

rows_read: float

Number of rows scanned from the table.

abr_level: Optional[float]

The level of Adaptive Bit Rate (ABR) sampling used for the query. If empty the ABR level is 1

updated: Optional[str]

ISO-8601 timestamp when the query run was last updated.

statistics: Statistics

Query performance statistics from the database. Includes execution time, rows scanned, and bytes read. Does not include network latency.

bytes_read: float

Number of uncompressed bytes read from the table.

elapsed: float

Time in seconds for the query to run.

rows_read: float

Number of rows scanned from the table.

abr_level: Optional[float]

The level of Adaptive Bit Rate (ABR) sampling used for the query. If empty the ABR level is 1

agents: Optional[List[Agent]]

Agent run summaries. Present when the query view is ‘agents’. Each entry represents one trace containing at least one agent invocation.

id: str

Stable pagination cursor for this agent run.

errors: List[str]

Distinct errors reported by spans in the run.

models: List[str]

Distinct models reported by chat spans across the run’s trace.

providers: List[str]

Distinct GenAI providers reported by chat spans in the run.

services: List[str]

Worker services represented in the run’s trace.

spans: float

Number of spans in the run’s trace.

status: Literal["completed", "error"]

Observed run status.

One of the following:
"completed"
"error"
trace_duration_ms: float

Total trace duration in milliseconds.

trace_end_ms: float

End of the run’s trace as a Unix epoch in milliseconds.

trace_id: str

Trace identifier for this agent run.

trace_start_ms: float

Start of the run’s trace as a Unix epoch in milliseconds.

agent_id: Optional[str]

ID from the earliest agent invocation that provides one.

agent_name: Optional[str]

Name from the earliest agent invocation that provides one.

conversation_id: Optional[str]

Conversation ID from the earliest invocation that provides one.

input_tokens: Optional[float]

Input tokens summed across chat spans in the run’s trace; informational, not billing data.

output_tokens: Optional[float]

Output tokens summed across chat spans in the run’s trace; informational, not billing data.

calculations: Optional[List[Calculation]]

Aggregated calculation results. Present when the query view is ‘calculations’. Contains computed metrics (count, avg, p99, etc.) with optional group-by breakdowns and time-series data.

aggregates: List[CalculationAggregate]
count: float

Estimated number of matching events: the sum of the sample intervals of the stored events. It equals the number of stored events when sampleInterval is 1.

Deprecatedinterval: float

Deprecated alias of sampleInterval. Always has the same value; use sampleInterval instead.

sample_interval: float

Average sample interval of the matched events. Each stored event has a sample interval of 1 / (the sampling rate applied when it was ingested): the Worker’s head_sampling_rate multiplied by any platform sampling applied to the account or script. A value of 1 means none of the matched events were sampled. A value above 1 means count and value are estimated from sampled data, not exact. This is independent of statistics.abr_level.

value: float

Result of the calculation. count, sum, avg, median, and percentiles are weighted by each event’s sample interval

groups: Optional[List[CalculationAggregateGroup]]
key: str
value: Union[str, float, bool]
One of the following:
str
float
bool
calculation: str
series: List[CalculationSeries]
data: List[CalculationSeriesData]
count: float

Estimated number of matching events: the sum of the sample intervals of the stored events. It equals the number of stored events when sampleInterval is 1.

Deprecatedinterval: float

Deprecated alias of sampleInterval. Always has the same value; use sampleInterval instead.

sample_interval: float

Average sample interval of the matched events. Each stored event has a sample interval of 1 / (the sampling rate applied when it was ingested): the Worker’s head_sampling_rate multiplied by any platform sampling applied to the account or script. A value of 1 means none of the matched events were sampled. A value above 1 means count and value are estimated from sampled data, not exact. This is independent of statistics.abr_level.

value: float

Result of the calculation. count, sum, avg, median, and percentiles are weighted by each event’s sample interval

first_seen: Optional[str]
groups: Optional[List[CalculationSeriesDataGroup]]
key: str
value: Union[str, float, bool]
One of the following:
str
float
bool
last_seen: Optional[str]
time: str
alias: Optional[str]
compare: Optional[List[Compare]]

Comparison calculation results from the previous time period. Present when the compare option is enabled. Same structure as calculations.

aggregates: List[CompareAggregate]
count: float

Estimated number of matching events: the sum of the sample intervals of the stored events. It equals the number of stored events when sampleInterval is 1.

Deprecatedinterval: float

Deprecated alias of sampleInterval. Always has the same value; use sampleInterval instead.

sample_interval: float

Average sample interval of the matched events. Each stored event has a sample interval of 1 / (the sampling rate applied when it was ingested): the Worker’s head_sampling_rate multiplied by any platform sampling applied to the account or script. A value of 1 means none of the matched events were sampled. A value above 1 means count and value are estimated from sampled data, not exact. This is independent of statistics.abr_level.

value: float

Result of the calculation. count, sum, avg, median, and percentiles are weighted by each event’s sample interval

groups: Optional[List[CompareAggregateGroup]]
key: str
value: Union[str, float, bool]
One of the following:
str
float
bool
calculation: str
series: List[CompareSeries]
data: List[CompareSeriesData]
count: float

Estimated number of matching events: the sum of the sample intervals of the stored events. It equals the number of stored events when sampleInterval is 1.

Deprecatedinterval: float

Deprecated alias of sampleInterval. Always has the same value; use sampleInterval instead.

sample_interval: float

Average sample interval of the matched events. Each stored event has a sample interval of 1 / (the sampling rate applied when it was ingested): the Worker’s head_sampling_rate multiplied by any platform sampling applied to the account or script. A value of 1 means none of the matched events were sampled. A value above 1 means count and value are estimated from sampled data, not exact. This is independent of statistics.abr_level.

value: float

Result of the calculation. count, sum, avg, median, and percentiles are weighted by each event’s sample interval

first_seen: Optional[str]
groups: Optional[List[CompareSeriesDataGroup]]
key: str
value: Union[str, float, bool]
One of the following:
str
float
bool
last_seen: Optional[str]
time: str
alias: Optional[str]
distribution: Optional[Distribution]

Bucketed 2D histogram of a numeric field over time. Present when chartType is ‘distribution’.

bins: List[str]

Time-bucket labels (ISO-8601 strings), one per matrix column.

bucket_boundaries: List[float]

Raw bucket edges in the value’s native unit, length buckets.length + 1. Used for the colour scale and percentile mapping.

bucket_mode: Literal["log", "linear"]

Bucketing scheme used to derive the boundaries. ‘log’ produces geometric edges; ‘linear’ produces fixed-width edges.

One of the following:
"log"
"linear"
buckets: List[str]

Value-range labels, one per matrix row (e.g. ‘50–100ms’).

matrix: List[List[float]]

Sampling-corrected counts. matrix[bucketIdx][binIdx] is the estimated number of events in value-bucket ‘bucketIdx’ during time-bin ‘binIdx’.

events: Optional[Events]

Individual event results. Present when the query view is ‘events’. Contains the matching log lines and their metadata.

count: Optional[float]

Total number of events matching the query (may exceed the number returned due to limits).

events: Optional[List[EventsEvent]]

List of individual telemetry events matching the query.

metadata: EventsEventMetadata

Structured metadata extracted from the event. These fields are indexed and available for filtering and aggregation.

id: str

Unique event ID. Use as the cursor value for offset-based pagination.

account: Optional[str]

Cloudflare account identifier.

cloud_service: Optional[str]

Cloudflare product that generated this event (e.g. workers, pages).

cold_start: Optional[int]
exclusiveMinimum
minimum0
cost: Optional[int]

Estimated cost units for this invocation.

exclusiveMinimum
minimum0
duration: Optional[int]

Span duration in milliseconds.

exclusiveMinimum
minimum0
end_time: Optional[int]

Span end time as a Unix epoch in milliseconds.

minimum0
end_time_ns: Optional[str]

Span end time as a Unix epoch in nanoseconds.

error: Optional[str]

Error message, present when the log represents an error.

error_template: Optional[str]

Templatized version of the error message used for grouping similar errors.

fingerprint: Optional[str]

Content-based fingerprint used to group similar events.

level: Optional[str]

Log level (e.g. log, debug, info, warn, error).

message: Optional[str]

Log message text.

message_template: Optional[str]

Templatized version of the log message used for grouping similar messages.

metric_name: Optional[str]

Metric name when the event represents a metric data point.

origin: Optional[str]

Origin of the event (e.g. fetch, scheduled, queue).

parent_span_id: Optional[str]

Span ID of the parent span in the trace hierarchy.

provider: Optional[str]

Infrastructure provider identifier.

rayid: Optional[str]

Cloudflare Ray ID from the cf-ray header of the request that triggered the invocation.

region: Optional[str]

Cloudflare data center / region that handled the request.

request_id: Optional[str]

Cloudflare request ID that ties all logs from a single invocation together.

service: Optional[str]

Worker script name that produced this event.

span_id: Optional[str]

Span ID for this individual unit of work within a trace.

span_name: Optional[str]

Human-readable name for this span.

stack_id: Optional[str]

Stack / deployment identifier.

start_time: Optional[int]

Span start time as a Unix epoch in milliseconds.

minimum0
start_time_ns: Optional[str]

Span start time as a Unix epoch in nanoseconds.

status_code: Optional[int]

HTTP response status code returned by the Worker.

exclusiveMinimum
minimum0
timestamp_ns: Optional[str]

Event time as a Unix epoch in nanoseconds.

trace_duration: Optional[int]

Total duration of the entire trace in milliseconds.

exclusiveMinimum
minimum0
trace_id: Optional[str]

Distributed trace ID linking spans across services.

transaction_name: Optional[str]

Logical transaction name for this request.

trigger: Optional[str]

What triggered the invocation (e.g. GET /users, POST /orders, queue message).

type: Optional[str]

Event type classifier (e.g. cf-worker-event, cf-worker-log).

url: Optional[str]

Request URL that triggered the Worker invocation.

dataset: str

The dataset this event belongs to (e.g. cloudflare-workers).

source: Union[str, Dict[str, object]]

Raw log payload. May be a string or a structured object depending on how the log was emitted.

One of the following:
str
Dict[str, object]
timestamp: int

Event timestamp as a Unix epoch in milliseconds.

minimum0
containers: Optional[Dict[str, object]]

Cloudflare Containers event information that enriches your logs for identifying and debugging issues.

workers: Optional[EventsEventWorkers]

Cloudflare Workers event information that enriches your logs for identifying and debugging issues.

One of the following:
class EventsEventWorkersUnionMember0: …
event_type: Literal["fetch", "scheduled", "alarm", 9 more]
One of the following:
"fetch"
"scheduled"
"alarm"
"cron"
"queue"
"email"
"tail"
"rpc"
"jsrpc"
"websocket"
"workflow"
"unknown"
script_name: str
durable_object_id: Optional[str]
entrypoint: Optional[str]
event: Optional[Dict[str, object]]
execution_model: Optional[Literal["durableObject", "stateless"]]
One of the following:
"durableObject"
"stateless"
outcome: Optional[str]
preview: Optional[EventsEventWorkersUnionMember0Preview]
id: Optional[str]
name: Optional[str]
slug: Optional[str]
request_id: Optional[str]
script_version: Optional[EventsEventWorkersUnionMember0ScriptVersion]
id: Optional[str]
message: Optional[str]
tag: Optional[str]
span_id: Optional[str]
trace_id: Optional[str]
truncated: Optional[bool]
class EventsEventWorkersUnionMember1: …
cpu_time_ms: float
event_type: Literal["fetch", "scheduled", "alarm", 9 more]
One of the following:
"fetch"
"scheduled"
"alarm"
"cron"
"queue"
"email"
"tail"
"rpc"
"jsrpc"
"websocket"
"workflow"
"unknown"
outcome: str
script_name: str
wall_time_ms: float
diagnostics_channel_events: Optional[List[EventsEventWorkersUnionMember1DiagnosticsChannelEvent]]
channel: str
message: str
timestamp: float
dispatch_namespace: Optional[str]
durable_object_id: Optional[str]
entrypoint: Optional[str]
event: Optional[Dict[str, object]]
execution_model: Optional[Literal["durableObject", "stateless"]]
One of the following:
"durableObject"
"stateless"
preview: Optional[EventsEventWorkersUnionMember1Preview]
id: Optional[str]
name: Optional[str]
slug: Optional[str]
request_id: Optional[str]
script_version: Optional[EventsEventWorkersUnionMember1ScriptVersion]
id: Optional[str]
message: Optional[str]
tag: Optional[str]
span_id: Optional[str]
trace_id: Optional[str]
truncated: Optional[bool]
fields: Optional[List[EventsField]]

List of fields discovered in the matched events. Useful for building dynamic UIs.

key: str

Field name present in the matched events.

type: str

Data type of the field (string, number, or boolean).

series: Optional[List[EventsSeries]]

Time-series data for the matched events, bucketed by the query granularity.

data: List[EventsSeriesData]
aggregates: EventsSeriesDataAggregates
Deprecated_count: int
exclusiveMinimum
minimum0
Deprecated_interval: float
exclusiveMinimum
minimum0
Deprecated_first_seen: Optional[str]
Deprecated_last_seen: Optional[str]
Deprecatedbin: Optional[object]
count: float

Estimated number of matching events: the sum of the sample intervals of the stored events. It equals the number of stored events when sampleInterval is 1.

Deprecatedinterval: float

Deprecated alias of sampleInterval. Always has the same value; use sampleInterval instead.

sample_interval: float

Average sample interval of the matched events. Each stored event has a sample interval of 1 / (the sampling rate applied when it was ingested): the Worker’s head_sampling_rate multiplied by any platform sampling applied to the account or script. A value of 1 means none of the matched events were sampled. A value above 1 means count and value are estimated from sampled data, not exact. This is independent of statistics.abr_level.

errors: Optional[float]
groups: Optional[Dict[str, Union[str, float, bool]]]

Groups in the query results.

One of the following:
str
float
bool
time: str
invocations: Optional[Dict[str, List[Invocation]]]

Events grouped by invocation (request ID). Present when the query view is ‘invocations’. Each key is a request ID mapping to all events from that invocation.

metadata: InvocationMetadata

Structured metadata extracted from the event. These fields are indexed and available for filtering and aggregation.

id: str

Unique event ID. Use as the cursor value for offset-based pagination.

account: Optional[str]

Cloudflare account identifier.

cloud_service: Optional[str]

Cloudflare product that generated this event (e.g. workers, pages).

cold_start: Optional[int]
exclusiveMinimum
minimum0
cost: Optional[int]

Estimated cost units for this invocation.

exclusiveMinimum
minimum0
duration: Optional[int]

Span duration in milliseconds.

exclusiveMinimum
minimum0
end_time: Optional[int]

Span end time as a Unix epoch in milliseconds.

minimum0
end_time_ns: Optional[str]

Span end time as a Unix epoch in nanoseconds.

error: Optional[str]

Error message, present when the log represents an error.

error_template: Optional[str]

Templatized version of the error message used for grouping similar errors.

fingerprint: Optional[str]

Content-based fingerprint used to group similar events.

level: Optional[str]

Log level (e.g. log, debug, info, warn, error).

message: Optional[str]

Log message text.

message_template: Optional[str]

Templatized version of the log message used for grouping similar messages.

metric_name: Optional[str]

Metric name when the event represents a metric data point.

origin: Optional[str]

Origin of the event (e.g. fetch, scheduled, queue).

parent_span_id: Optional[str]

Span ID of the parent span in the trace hierarchy.

provider: Optional[str]

Infrastructure provider identifier.

rayid: Optional[str]

Cloudflare Ray ID from the cf-ray header of the request that triggered the invocation.

region: Optional[str]

Cloudflare data center / region that handled the request.

request_id: Optional[str]

Cloudflare request ID that ties all logs from a single invocation together.

service: Optional[str]

Worker script name that produced this event.

span_id: Optional[str]

Span ID for this individual unit of work within a trace.

span_name: Optional[str]

Human-readable name for this span.

stack_id: Optional[str]

Stack / deployment identifier.

start_time: Optional[int]

Span start time as a Unix epoch in milliseconds.

minimum0
start_time_ns: Optional[str]

Span start time as a Unix epoch in nanoseconds.

status_code: Optional[int]

HTTP response status code returned by the Worker.

exclusiveMinimum
minimum0
timestamp_ns: Optional[str]

Event time as a Unix epoch in nanoseconds.

trace_duration: Optional[int]

Total duration of the entire trace in milliseconds.

exclusiveMinimum
minimum0
trace_id: Optional[str]

Distributed trace ID linking spans across services.

transaction_name: Optional[str]

Logical transaction name for this request.

trigger: Optional[str]

What triggered the invocation (e.g. GET /users, POST /orders, queue message).

type: Optional[str]

Event type classifier (e.g. cf-worker-event, cf-worker-log).

url: Optional[str]

Request URL that triggered the Worker invocation.

dataset: str

The dataset this event belongs to (e.g. cloudflare-workers).

source: Union[str, Dict[str, object]]

Raw log payload. May be a string or a structured object depending on how the log was emitted.

One of the following:
str
Dict[str, object]
timestamp: int

Event timestamp as a Unix epoch in milliseconds.

minimum0
containers: Optional[Dict[str, object]]

Cloudflare Containers event information that enriches your logs for identifying and debugging issues.

workers: Optional[InvocationWorkers]

Cloudflare Workers event information that enriches your logs for identifying and debugging issues.

One of the following:
class InvocationWorkersUnionMember0: …
event_type: Literal["fetch", "scheduled", "alarm", 9 more]
One of the following:
"fetch"
"scheduled"
"alarm"
"cron"
"queue"
"email"
"tail"
"rpc"
"jsrpc"
"websocket"
"workflow"
"unknown"
script_name: str
durable_object_id: Optional[str]
entrypoint: Optional[str]
event: Optional[Dict[str, object]]
execution_model: Optional[Literal["durableObject", "stateless"]]
One of the following:
"durableObject"
"stateless"
outcome: Optional[str]
preview: Optional[InvocationWorkersUnionMember0Preview]
id: Optional[str]
name: Optional[str]
slug: Optional[str]
request_id: Optional[str]
script_version: Optional[InvocationWorkersUnionMember0ScriptVersion]
id: Optional[str]
message: Optional[str]
tag: Optional[str]
span_id: Optional[str]
trace_id: Optional[str]
truncated: Optional[bool]
class InvocationWorkersUnionMember1: …
cpu_time_ms: float
event_type: Literal["fetch", "scheduled", "alarm", 9 more]
One of the following:
"fetch"
"scheduled"
"alarm"
"cron"
"queue"
"email"
"tail"
"rpc"
"jsrpc"
"websocket"
"workflow"
"unknown"
outcome: str
script_name: str
wall_time_ms: float
diagnostics_channel_events: Optional[List[InvocationWorkersUnionMember1DiagnosticsChannelEvent]]
channel: str
message: str
timestamp: float
dispatch_namespace: Optional[str]
durable_object_id: Optional[str]
entrypoint: Optional[str]
event: Optional[Dict[str, object]]
execution_model: Optional[Literal["durableObject", "stateless"]]
One of the following:
"durableObject"
"stateless"
preview: Optional[InvocationWorkersUnionMember1Preview]
id: Optional[str]
name: Optional[str]
slug: Optional[str]
request_id: Optional[str]
script_version: Optional[InvocationWorkersUnionMember1ScriptVersion]
id: Optional[str]
message: Optional[str]
tag: Optional[str]
span_id: Optional[str]
trace_id: Optional[str]
truncated: Optional[bool]
traces: Optional[List[Trace]]

Trace summaries matching the query. Present when the query view is ‘traces’. Each entry represents a distributed trace with its spans, duration, and services involved.

root_span_name: str

Name of the root span that initiated the trace.

root_transaction_name: str

Logical transaction name for the root span.

service: List[str]

List of Worker services involved in the trace.

spans: float

Total number of spans in the trace.

trace_duration_ms: float

Total duration of the trace in milliseconds.

trace_end_ms: float

Trace end time as a Unix epoch in milliseconds.

trace_id: str

Unique identifier for the distributed trace.

trace_start_ms: float

Trace start time as a Unix epoch in milliseconds.

errors: Optional[List[str]]

Error messages encountered during the trace, if any.

Run a query

import os
from cloudflare import Cloudflare

client = Cloudflare(
    api_email=os.environ.get("CLOUDFLARE_EMAIL"),  # This is the default and can be omitted
    api_key=os.environ.get("CLOUDFLARE_API_KEY"),  # This is the default and can be omitted
)
response = client.workers.observability.telemetry.query(
    account_id="account_id",
    query_id="queryId",
    timeframe={
        "from": 0,
        "to": 0,
    },
)
print(response.run)
{
  "errors": [
    {
      "message": "message"
    }
  ],
  "messages": [
    {
      "message": "Successful request"
    }
  ],
  "result": {
    "run": {
      "id": "id",
      "accountId": "accountId",
      "dry": true,
      "granularity": 0,
      "query": {
        "id": "id",
        "adhoc": true,
        "created": "string",
        "createdBy": "createdBy",
        "description": "Query description",
        "name": "x",
        "parameters": {
          "calculations": [
            {
              "operator": "count",
              "alias": "alias",
              "key": "key",
              "keyType": "string"
            }
          ],
          "datasets": [
            "string"
          ],
          "filterCombination": "and",
          "filters": [
            {
              "filterCombination": "and",
              "filters": [
                {}
              ],
              "kind": "group"
            }
          ],
          "groupBys": [
            {
              "type": "string",
              "value": "value"
            }
          ],
          "havings": [
            {
              "key": "key",
              "operation": "eq",
              "value": 0
            }
          ],
          "limit": 0,
          "needle": {
            "value": {
              "0": "s",
              "1": "t",
              "2": "r",
              "3": "i",
              "4": "n",
              "5": "g"
            },
            "isRegex": true,
            "matchCase": true
          },
          "orderBy": {
            "value": "value",
            "order": "asc"
          }
        },
        "updated": "string",
        "updatedBy": "updatedBy"
      },
      "status": "STARTED",
      "timeframe": {
        "from": 0,
        "to": 0
      },
      "userId": "userId",
      "created": "created",
      "statistics": {
        "bytes_read": 0,
        "elapsed": 0,
        "rows_read": 0,
        "abr_level": 0
      },
      "updated": "updated"
    },
    "statistics": {
      "bytes_read": 0,
      "elapsed": 0,
      "rows_read": 0,
      "abr_level": 0
    },
    "agents": [
      {
        "id": "id",
        "errors": [
          "string"
        ],
        "models": [
          "string"
        ],
        "providers": [
          "string"
        ],
        "services": [
          "string"
        ],
        "spans": 0,
        "status": "completed",
        "traceDurationMs": 0,
        "traceEndMs": 0,
        "traceId": "traceId",
        "traceStartMs": 0,
        "agentId": "agentId",
        "agentName": "agentName",
        "conversationId": "conversationId",
        "inputTokens": 0,
        "outputTokens": 0
      }
    ],
    "calculations": [
      {
        "aggregates": [
          {
            "count": 0,
            "interval": 0,
            "sampleInterval": 0,
            "value": 0,
            "groups": [
              {
                "key": "key",
                "value": "string"
              }
            ]
          }
        ],
        "calculation": "calculation",
        "series": [
          {
            "data": [
              {
                "count": 0,
                "interval": 0,
                "sampleInterval": 0,
                "value": 0,
                "firstSeen": "firstSeen",
                "groups": [
                  {
                    "key": "key",
                    "value": "string"
                  }
                ],
                "lastSeen": "lastSeen"
              }
            ],
            "time": "time"
          }
        ],
        "alias": "alias"
      }
    ],
    "compare": [
      {
        "aggregates": [
          {
            "count": 0,
            "interval": 0,
            "sampleInterval": 0,
            "value": 0,
            "groups": [
              {
                "key": "key",
                "value": "string"
              }
            ]
          }
        ],
        "calculation": "calculation",
        "series": [
          {
            "data": [
              {
                "count": 0,
                "interval": 0,
                "sampleInterval": 0,
                "value": 0,
                "firstSeen": "firstSeen",
                "groups": [
                  {
                    "key": "key",
                    "value": "string"
                  }
                ],
                "lastSeen": "lastSeen"
              }
            ],
            "time": "time"
          }
        ],
        "alias": "alias"
      }
    ],
    "distribution": {
      "bins": [
        "string"
      ],
      "bucketBoundaries": [
        0
      ],
      "bucketMode": "log",
      "buckets": [
        "string"
      ],
      "matrix": [
        [
          0
        ]
      ]
    },
    "events": {
      "count": 0,
      "events": [
        {
          "$metadata": {
            "id": "id",
            "account": "account",
            "cloudService": "cloudService",
            "coldStart": 1,
            "cost": 1,
            "duration": 1,
            "endTime": 0,
            "endTimeNs": "endTimeNs",
            "error": "error",
            "errorTemplate": "errorTemplate",
            "fingerprint": "fingerprint",
            "level": "level",
            "message": "message",
            "messageTemplate": "messageTemplate",
            "metricName": "metricName",
            "origin": "origin",
            "parentSpanId": "parentSpanId",
            "provider": "provider",
            "rayId": "rayId",
            "region": "region",
            "requestId": "requestId",
            "service": "service",
            "spanId": "spanId",
            "spanName": "spanName",
            "stackId": "stackId",
            "startTime": 0,
            "startTimeNs": "startTimeNs",
            "statusCode": 1,
            "timestampNs": "timestampNs",
            "traceDuration": 1,
            "traceId": "traceId",
            "transactionName": "transactionName",
            "trigger": "trigger",
            "type": "type",
            "url": "url"
          },
          "dataset": "dataset",
          "source": "string",
          "timestamp": 0,
          "$containers": {
            "foo": "bar"
          },
          "$workers": {
            "eventType": "fetch",
            "scriptName": "scriptName",
            "durableObjectId": "durableObjectId",
            "entrypoint": "entrypoint",
            "event": {
              "foo": "bar"
            },
            "executionModel": "durableObject",
            "outcome": "outcome",
            "preview": {
              "id": "id",
              "name": "name",
              "slug": "slug"
            },
            "requestId": "requestId",
            "scriptVersion": {
              "id": "id",
              "message": "message",
              "tag": "tag"
            },
            "spanId": "spanId",
            "traceId": "traceId",
            "truncated": true
          }
        }
      ],
      "fields": [
        {
          "key": "key",
          "type": "type"
        }
      ],
      "series": [
        {
          "data": [
            {
              "aggregates": {
                "_count": 1,
                "_interval": 1,
                "_firstSeen": "_firstSeen",
                "_lastSeen": "_lastSeen",
                "bin": {}
              },
              "count": 0,
              "interval": 0,
              "sampleInterval": 0,
              "errors": 0,
              "groups": {
                "foo": "string"
              }
            }
          ],
          "time": "time"
        }
      ]
    },
    "invocations": {
      "foo": [
        {
          "$metadata": {
            "id": "id",
            "account": "account",
            "cloudService": "cloudService",
            "coldStart": 1,
            "cost": 1,
            "duration": 1,
            "endTime": 0,
            "endTimeNs": "endTimeNs",
            "error": "error",
            "errorTemplate": "errorTemplate",
            "fingerprint": "fingerprint",
            "level": "level",
            "message": "message",
            "messageTemplate": "messageTemplate",
            "metricName": "metricName",
            "origin": "origin",
            "parentSpanId": "parentSpanId",
            "provider": "provider",
            "rayId": "rayId",
            "region": "region",
            "requestId": "requestId",
            "service": "service",
            "spanId": "spanId",
            "spanName": "spanName",
            "stackId": "stackId",
            "startTime": 0,
            "startTimeNs": "startTimeNs",
            "statusCode": 1,
            "timestampNs": "timestampNs",
            "traceDuration": 1,
            "traceId": "traceId",
            "transactionName": "transactionName",
            "trigger": "trigger",
            "type": "type",
            "url": "url"
          },
          "dataset": "dataset",
          "source": "string",
          "timestamp": 0,
          "$containers": {
            "foo": "bar"
          },
          "$workers": {
            "eventType": "fetch",
            "scriptName": "scriptName",
            "durableObjectId": "durableObjectId",
            "entrypoint": "entrypoint",
            "event": {
              "foo": "bar"
            },
            "executionModel": "durableObject",
            "outcome": "outcome",
            "preview": {
              "id": "id",
              "name": "name",
              "slug": "slug"
            },
            "requestId": "requestId",
            "scriptVersion": {
              "id": "id",
              "message": "message",
              "tag": "tag"
            },
            "spanId": "spanId",
            "traceId": "traceId",
            "truncated": true
          }
        }
      ]
    },
    "traces": [
      {
        "rootSpanName": "rootSpanName",
        "rootTransactionName": "rootTransactionName",
        "service": [
          "string"
        ],
        "spans": 0,
        "traceDurationMs": 0,
        "traceEndMs": 0,
        "traceId": "traceId",
        "traceStartMs": 0,
        "errors": [
          "string"
        ]
      }
    ]
  },
  "success": true
}
Returns Examples
{
  "errors": [
    {
      "message": "message"
    }
  ],
  "messages": [
    {
      "message": "Successful request"
    }
  ],
  "result": {
    "run": {
      "id": "id",
      "accountId": "accountId",
      "dry": true,
      "granularity": 0,
      "query": {
        "id": "id",
        "adhoc": true,
        "created": "string",
        "createdBy": "createdBy",
        "description": "Query description",
        "name": "x",
        "parameters": {
          "calculations": [
            {
              "operator": "count",
              "alias": "alias",
              "key": "key",
              "keyType": "string"
            }
          ],
          "datasets": [
            "string"
          ],
          "filterCombination": "and",
          "filters": [
            {
              "filterCombination": "and",
              "filters": [
                {}
              ],
              "kind": "group"
            }
          ],
          "groupBys": [
            {
              "type": "string",
              "value": "value"
            }
          ],
          "havings": [
            {
              "key": "key",
              "operation": "eq",
              "value": 0
            }
          ],
          "limit": 0,
          "needle": {
            "value": {
              "0": "s",
              "1": "t",
              "2": "r",
              "3": "i",
              "4": "n",
              "5": "g"
            },
            "isRegex": true,
            "matchCase": true
          },
          "orderBy": {
            "value": "value",
            "order": "asc"
          }
        },
        "updated": "string",
        "updatedBy": "updatedBy"
      },
      "status": "STARTED",
      "timeframe": {
        "from": 0,
        "to": 0
      },
      "userId": "userId",
      "created": "created",
      "statistics": {
        "bytes_read": 0,
        "elapsed": 0,
        "rows_read": 0,
        "abr_level": 0
      },
      "updated": "updated"
    },
    "statistics": {
      "bytes_read": 0,
      "elapsed": 0,
      "rows_read": 0,
      "abr_level": 0
    },
    "agents": [
      {
        "id": "id",
        "errors": [
          "string"
        ],
        "models": [
          "string"
        ],
        "providers": [
          "string"
        ],
        "services": [
          "string"
        ],
        "spans": 0,
        "status": "completed",
        "traceDurationMs": 0,
        "traceEndMs": 0,
        "traceId": "traceId",
        "traceStartMs": 0,
        "agentId": "agentId",
        "agentName": "agentName",
        "conversationId": "conversationId",
        "inputTokens": 0,
        "outputTokens": 0
      }
    ],
    "calculations": [
      {
        "aggregates": [
          {
            "count": 0,
            "interval": 0,
            "sampleInterval": 0,
            "value": 0,
            "groups": [
              {
                "key": "key",
                "value": "string"
              }
            ]
          }
        ],
        "calculation": "calculation",
        "series": [
          {
            "data": [
              {
                "count": 0,
                "interval": 0,
                "sampleInterval": 0,
                "value": 0,
                "firstSeen": "firstSeen",
                "groups": [
                  {
                    "key": "key",
                    "value": "string"
                  }
                ],
                "lastSeen": "lastSeen"
              }
            ],
            "time": "time"
          }
        ],
        "alias": "alias"
      }
    ],
    "compare": [
      {
        "aggregates": [
          {
            "count": 0,
            "interval": 0,
            "sampleInterval": 0,
            "value": 0,
            "groups": [
              {
                "key": "key",
                "value": "string"
              }
            ]
          }
        ],
        "calculation": "calculation",
        "series": [
          {
            "data": [
              {
                "count": 0,
                "interval": 0,
                "sampleInterval": 0,
                "value": 0,
                "firstSeen": "firstSeen",
                "groups": [
                  {
                    "key": "key",
                    "value": "string"
                  }
                ],
                "lastSeen": "lastSeen"
              }
            ],
            "time": "time"
          }
        ],
        "alias": "alias"
      }
    ],
    "distribution": {
      "bins": [
        "string"
      ],
      "bucketBoundaries": [
        0
      ],
      "bucketMode": "log",
      "buckets": [
        "string"
      ],
      "matrix": [
        [
          0
        ]
      ]
    },
    "events": {
      "count": 0,
      "events": [
        {
          "$metadata": {
            "id": "id",
            "account": "account",
            "cloudService": "cloudService",
            "coldStart": 1,
            "cost": 1,
            "duration": 1,
            "endTime": 0,
            "endTimeNs": "endTimeNs",
            "error": "error",
            "errorTemplate": "errorTemplate",
            "fingerprint": "fingerprint",
            "level": "level",
            "message": "message",
            "messageTemplate": "messageTemplate",
            "metricName": "metricName",
            "origin": "origin",
            "parentSpanId": "parentSpanId",
            "provider": "provider",
            "rayId": "rayId",
            "region": "region",
            "requestId": "requestId",
            "service": "service",
            "spanId": "spanId",
            "spanName": "spanName",
            "stackId": "stackId",
            "startTime": 0,
            "startTimeNs": "startTimeNs",
            "statusCode": 1,
            "timestampNs": "timestampNs",
            "traceDuration": 1,
            "traceId": "traceId",
            "transactionName": "transactionName",
            "trigger": "trigger",
            "type": "type",
            "url": "url"
          },
          "dataset": "dataset",
          "source": "string",
          "timestamp": 0,
          "$containers": {
            "foo": "bar"
          },
          "$workers": {
            "eventType": "fetch",
            "scriptName": "scriptName",
            "durableObjectId": "durableObjectId",
            "entrypoint": "entrypoint",
            "event": {
              "foo": "bar"
            },
            "executionModel": "durableObject",
            "outcome": "outcome",
            "preview": {
              "id": "id",
              "name": "name",
              "slug": "slug"
            },
            "requestId": "requestId",
            "scriptVersion": {
              "id": "id",
              "message": "message",
              "tag": "tag"
            },
            "spanId": "spanId",
            "traceId": "traceId",
            "truncated": true
          }
        }
      ],
      "fields": [
        {
          "key": "key",
          "type": "type"
        }
      ],
      "series": [
        {
          "data": [
            {
              "aggregates": {
                "_count": 1,
                "_interval": 1,
                "_firstSeen": "_firstSeen",
                "_lastSeen": "_lastSeen",
                "bin": {}
              },
              "count": 0,
              "interval": 0,
              "sampleInterval": 0,
              "errors": 0,
              "groups": {
                "foo": "string"
              }
            }
          ],
          "time": "time"
        }
      ]
    },
    "invocations": {
      "foo": [
        {
          "$metadata": {
            "id": "id",
            "account": "account",
            "cloudService": "cloudService",
            "coldStart": 1,
            "cost": 1,
            "duration": 1,
            "endTime": 0,
            "endTimeNs": "endTimeNs",
            "error": "error",
            "errorTemplate": "errorTemplate",
            "fingerprint": "fingerprint",
            "level": "level",
            "message": "message",
            "messageTemplate": "messageTemplate",
            "metricName": "metricName",
            "origin": "origin",
            "parentSpanId": "parentSpanId",
            "provider": "provider",
            "rayId": "rayId",
            "region": "region",
            "requestId": "requestId",
            "service": "service",
            "spanId": "spanId",
            "spanName": "spanName",
            "stackId": "stackId",
            "startTime": 0,
            "startTimeNs": "startTimeNs",
            "statusCode": 1,
            "timestampNs": "timestampNs",
            "traceDuration": 1,
            "traceId": "traceId",
            "transactionName": "transactionName",
            "trigger": "trigger",
            "type": "type",
            "url": "url"
          },
          "dataset": "dataset",
          "source": "string",
          "timestamp": 0,
          "$containers": {
            "foo": "bar"
          },
          "$workers": {
            "eventType": "fetch",
            "scriptName": "scriptName",
            "durableObjectId": "durableObjectId",
            "entrypoint": "entrypoint",
            "event": {
              "foo": "bar"
            },
            "executionModel": "durableObject",
            "outcome": "outcome",
            "preview": {
              "id": "id",
              "name": "name",
              "slug": "slug"
            },
            "requestId": "requestId",
            "scriptVersion": {
              "id": "id",
              "message": "message",
              "tag": "tag"
            },
            "spanId": "spanId",
            "traceId": "traceId",
            "truncated": true
          }
        }
      ]
    },
    "traces": [
      {
        "rootSpanName": "rootSpanName",
        "rootTransactionName": "rootTransactionName",
        "service": [
          "string"
        ],
        "spans": 0,
        "traceDurationMs": 0,
        "traceEndMs": 0,
        "traceId": "traceId",
        "traceStartMs": 0,
        "errors": [
          "string"
        ]
      }
    ]
  },
  "success": true
}