Query Cloudflare Workers OTel in Strada

Cloudflare Workers OTel export via destinations

This document is a querying reference for agents and humans working with Cloudflare Workers telemetry inside Strada.

Use it to answer questions like:

Is this span from Cloudflare Workers?
Why is this request slow?
Did the Worker fail with an uncaught exception?
Is this a D1, KV, R2, RPC, Queue, or Durable Object span?
Which attributes should a SQL query filter on first?

Cloudflare Workers can export OpenTelemetry traces and logs to any OTLP HTTP endpoint configured as a destination in the Cloudflare dashboard.

For Strada, that means these endpoints are the important ones:

POST /v1/traces
POST /v1/logs

Cloudflare does not currently export metrics through this destination flow.

Quick answers

Is a row from Cloudflare Workers?

Usually filter on:

1ResourceAttributes['cloud.platform'] = 'cloudflare.workers'

or:

1ResourceAttributes['cloud.provider'] = 'cloudflare'

What are the most important attributes?

Start with these:

cloud.platform
cloud.provider
service.name
faas.invocation_id
cloudflare.ray_id
cloudflare.handler_type
cloudflare.entrypoint
cloudflare.execution_model
cloudflare.outcome
cloudflare.cpu_time_ms
cloudflare.wall_time_ms
url.path
http.request.method
http.response.status_code
cloudflare.colo

What attributes are best for slow requests?

Look at:

span Duration
cloudflare.wall_time_ms
cloudflare.cpu_time_ms
cloudflare.response.time_to_first_byte_ms
db.query.text
cloudflare.d1.response.sql_duration_ms
cloudflare.d1.response.rows_read
cloudflare.kv.response.cache_status
cloudflare.r2.operation

What attributes are best for failed Worker executions?

Look at:

cloudflare.outcome
http.response.status_code
cloudflare.ray_id
logs for surrounding context, especially:
- request log bodies like GET https://.../route
- app console.error() output
- framework-generated error log lines such as Spiceflow unhandled error: Error: ...

Validated note: in real Cloudflare destination exports, runtime crashes were reliably marked on traces, while logs did not include standard exception.* fields.

Important documented outcomes include:

ok
exception
exceededCpu
exceededMemory

What Cloudflare exports

Cloudflare Workers destinations export:

traces
logs

Cloudflare Workers destinations do not currently export:

metrics

So for Strada, the relevant ingest paths are:

https://<project>-ingest.strada.sh/v1/traces
https://<project>-ingest.strada.sh/v1/logs

Validated behavior from a real Cloudflare Worker

Strada now includes a real validation worker at example-app-cloudflare/ used to test actual Cloudflare destination export.

The collector had to support gzip-compressed OTLP first, because Cloudflare destinations send:

content-encoding: gzip

Without gzip decompression, the collector failed before any Cloudflare-specific behavior could be inspected.

Route matrix used for validation

Route	What it does	What Cloudflare exported	What matters for Strada
`/ok`	healthy request	request trace + request log + app log	baseline shape
`/caught`	error caught and converted into HTTP 500	request trace + request log + app log	not a runtime crash
`/throw`	thrown inside Spiceflow route	request trace + request log + framework error log	`cloudflare.outcome` stayed `ok`
`/throw-async`	async throw inside Spiceflow route	request trace + request log + framework error log	`cloudflare.outcome` stayed `ok`
`/crash-runtime`	throw before `app.handle()` in worker `fetch()`	request trace with `cloudflare.outcome = exception` + request log + app log	real runtime crash marker

Key validated findings

Framework-handled route errors are not Cloudflare runtime crashes.
Real Worker runtime crashes are marked by cloudflare.outcome = exception on the root span.
A real runtime crash also returned the Cloudflare runtime error page body error code: 1101 to the client.
Real destination-exported logs did not include:
- exception.type
- exception.message
- exception.stacktrace
- $workers.outcome
- $metadata.error
The most reliable signal for materializing Cloudflare runtime crashes into otel_errors is the trace root span fallback, not logs.

Example `wrangler.jsonc`

1234567891011121314151617{
  "name": "my-worker",
  "main": "src/index.ts",
  "compatibility_date": "2026-04-23",
  "observability": {
    "traces": {
      "enabled": true,
      "destinations": ["strada-traces"],
      "persist": false
    },
    "logs": {
      "enabled": true,
      "destinations": ["strada-logs"],
      "persist": false
    }
  }
}

Example OTLP payloads

Cloudflare documents destination export as standard OTLP over HTTP to /v1/traces and /v1/logs endpoints. The exact full payload shape for Cloudflare-generated uncaught exception logs is not fully documented, but the envelopes are standard OTLP.

Example traces payload

This example is representative of the shape Strada should expect when Cloudflare exports trace data.

1234567891011121314151617181920212223242526272829303132333435363738394041{
  "resourceSpans": [
    {
      "resource": {
        "attributes": [
          { "key": "cloud.provider", "value": { "stringValue": "cloudflare" } },
          { "key": "cloud.platform", "value": { "stringValue": "cloudflare.workers" } },
          { "key": "service.name", "value": { "stringValue": "my-worker" } },
          { "key": "faas.name", "value": { "stringValue": "my-worker" } },
          { "key": "cloudflare.colo", "value": { "stringValue": "SFO" } }
        ]
      },
      "scopeSpans": [
        {
          "spans": [
            {
              "traceId": "4bf92f3577b34da6a3ce929d0e0e4736",
              "spanId": "00f067aa0ba902b7",
              "name": "fetch",
              "kind": 1,
              "startTimeUnixNano": "1713890000000000000",
              "endTimeUnixNano": "1713890000200000000",
              "attributes": [
                { "key": "faas.trigger", "value": { "stringValue": "http" } },
                { "key": "cloudflare.ray_id", "value": { "stringValue": "87d3abc123" } },
                { "key": "cloudflare.handler_type", "value": { "stringValue": "fetch" } },
                { "key": "cloudflare.outcome", "value": { "stringValue": "ok" } },
                { "key": "cloudflare.cpu_time_ms", "value": { "doubleValue": 12 } },
                { "key": "cloudflare.wall_time_ms", "value": { "doubleValue": 48 } },
                { "key": "url.full", "value": { "stringValue": "https://example.com/api/users?id=1" } },
                { "key": "url.path", "value": { "stringValue": "/api/users" } },
                { "key": "http.request.method", "value": { "stringValue": "GET" } },
                { "key": "http.response.status_code", "value": { "intValue": "200" } }
              ]
            }
          ]
        }
      ]
    }
  ]
}

Example logs payload

This example reflects the validated shape seen from a real Cloudflare destination export. For runtime crashes, the exported OTLP logs contained request logs and app/framework log lines, but not standard exception.* attributes.

123456789101112131415161718192021222324252627{
  "resourceLogs": [
    {
      "resource": {
        "attributes": [
          { "key": "cloud.provider", "value": { "stringValue": "cloudflare" } },
          { "key": "cloud.platform", "value": { "stringValue": "cloudflare.workers" } },
          { "key": "service.name", "value": { "stringValue": "my-worker" } }
        ]
      },
      "scopeLogs": [
        {
          "logRecords": [
            {
              "timeUnixNano": "1713890000100000000",
              "severityText": "ERROR",
              "body": { "stringValue": "Spiceflow unhandled error: Error: uncaught cloudflare validation error" },
              "attributes": [
                { "key": "cloudflare.ray_id", "value": { "stringValue": "87d3abc123" } }
              ]
            }
          ]
        }
      ]
    }
  ]
}

Querying strategy for agents

Filter early

For Cloudflare data, start with:

1WHERE ResourceAttributes['cloud.platform'] = 'cloudflare.workers'

Then narrow by one of:

SpanAttributes['cloudflare.handler_type']
SpanAttributes['cloudflare.entrypoint']
SpanAttributes['cloudflare.execution_model']
SpanAttributes['cloudflare.outcome']
SpanAttributes['url.path']
SpanAttributes['http.request.method']

Good first questions

Slow request

Filter by:

url.path
http.request.method
Duration
cloudflare.wall_time_ms
cloudflare.cpu_time_ms

Then inspect child spans like D1, KV, R2, fetch, or Durable Object storage.

Worker crash or uncaught exception

Filter by:

cloudflare.outcome = 'exception'

Then inspect:

same trace
related logs with same TraceId
exception fields on logs if present

D1 slowness

Filter by:

db.system.name
db.operation.name
cloudflare.d1.response.sql_duration_ms

Durable Object RPC failures

Filter by:

cloudflare.jsrpc.method
cloudflare.entrypoint
cloudflare.outcome

Example queries

Failed Worker invocations

12345678910111213SELECT
  Timestamp,
  ServiceName,
  SpanName,
  SpanAttributes['cloudflare.outcome'] AS outcome,
  SpanAttributes['cloudflare.handler_type'] AS handler_type,
  SpanAttributes['cloudflare.entrypoint'] AS entrypoint,
  SpanAttributes['cloudflare.ray_id'] AS ray_id
FROM otel_traces
WHERE ResourceAttributes['cloud.platform'] = 'cloudflare.workers'
  AND SpanAttributes['cloudflare.outcome'] != 'ok'
ORDER BY Timestamp DESC
LIMIT 100

Slow requests

1234567891011121314SELECT
  Timestamp,
  ServiceName,
  SpanName,
  Duration,
  SpanAttributes['http.request.method'] AS method,
  SpanAttributes['url.path'] AS path,
  SpanAttributes['cloudflare.cpu_time_ms'] AS cpu_ms,
  SpanAttributes['cloudflare.wall_time_ms'] AS wall_ms
FROM otel_traces
WHERE ResourceAttributes['cloud.platform'] = 'cloudflare.workers'
  AND SpanAttributes['cloudflare.handler_type'] = 'fetch'
ORDER BY Duration DESC
LIMIT 100

Uncaught exception traces

12345678910111213SELECT
  Timestamp,
  ServiceName,
  SpanName,
  TraceId,
  SpanAttributes['cloudflare.handler_type'] AS handler_type,
  SpanAttributes['cloudflare.entrypoint'] AS entrypoint,
  SpanAttributes['cloudflare.ray_id'] AS ray_id
FROM otel_traces
WHERE ResourceAttributes['cloud.platform'] = 'cloudflare.workers'
  AND SpanAttributes['cloudflare.outcome'] = 'exception'
ORDER BY Timestamp DESC
LIMIT 100

D1 bottlenecks

12345678910111213SELECT
  Timestamp,
  ServiceName,
  SpanName,
  SpanAttributes['db.operation.name'] AS operation,
  SpanAttributes['cloudflare.d1.response.sql_duration_ms'] AS sql_ms,
  SpanAttributes['cloudflare.d1.response.rows_read'] AS rows_read,
  SpanAttributes['cloudflare.d1.response.rows_written'] AS rows_written
FROM otel_traces
WHERE ResourceAttributes['cloud.platform'] = 'cloudflare.workers'
  AND SpanAttributes['cloudflare.binding.type'] = 'd1'
ORDER BY toFloat64OrZero(SpanAttributes['cloudflare.d1.response.sql_duration_ms']) DESC
LIMIT 100

Logs with runtime-crash context

123456789101112SELECT
  Timestamp,
  ServiceName,
  SeverityText,
  Body,
  TraceId,
  LogAttributes['cloudflare.ray_id'] AS ray_id
FROM otel_logs
WHERE ResourceAttributes['cloud.platform'] = 'cloudflare.workers'
  AND TraceId = '<trace-id-from-failing-root-span>'
ORDER BY Timestamp DESC
LIMIT 100

Logs with standard exception fields if present

Some app code or SDKs may still emit normal exception.* fields. Query them separately when needed:

12345678910111213141516SELECT
  Timestamp,
  ServiceName,
  SeverityText,
  Body,
  TraceId,
  LogAttributes['exception.type'] AS exception_type,
  LogAttributes['exception.message'] AS exception_message
FROM otel_logs
WHERE ResourceAttributes['cloud.platform'] = 'cloudflare.workers'
  AND (
    mapContains(LogAttributes, 'exception.type')
    OR mapContains(LogAttributes, 'exception.message')
  )
ORDER BY Timestamp DESC
LIMIT 100

Attribute reference

This section lists the documented Cloudflare Workers trace attributes with one attribute per section. Each entry explains:

what it means
why it matters
common query usage

Resource and invocation identity

`cloud.provider`

Meaning: Cloud provider name. Cloudflare sets this to cloudflare.

Why it matters: Good coarse filter across multi-cloud telemetry.

Common query use:

1ResourceAttributes['cloud.provider'] = 'cloudflare'

`cloud.platform`

Meaning: Cloud runtime platform. Cloudflare sets this to cloudflare.workers.

Why it matters: Best top-level filter for Cloudflare Workers telemetry.

Common query use:

1ResourceAttributes['cloud.platform'] = 'cloudflare.workers'

`faas.name`

Meaning: Worker name in serverless naming.

Why it matters: Helps identify the function or Worker service.

Common query use: compare with service.name when normalizing service identity.

`faas.invocation_id`

Meaning: Unique identifier for a specific Worker invocation.

Why it matters: Useful for correlating spans and logs from a single execution.

Common query use: drill into one specific invocation.

`faas.version`

Meaning: Deployed version tag of the Worker.

Why it matters: Helpful for release correlation and regressions.

`faas.invoked_region`

Meaning: Region where the Worker was invoked.

Why it matters: Useful for regional performance or routing issues.

`service.name`

Meaning: Worker service name.

Why it matters: One of the most important grouping dimensions in Strada.

Common query use:

1ServiceName = 'my-worker'

`cloudflare.colo`

Meaning: Three-letter Cloudflare colo code like SFO or LHR.

Why it matters: Very useful for edge-specific debugging.

`cloudflare.script_name`

Meaning: Worker script name.

Why it matters: Another service identity field, often similar to service.name.

`cloudflare.script_tags`

Meaning: Tags associated with the Worker deployment.

Why it matters: Useful when deployments are grouped by internal tags.

`cloudflare.script_version.id`

Meaning: Cloudflare version identifier of the deployed Worker.

Why it matters: Important for deploy regression analysis.

`cloudflare.invocation.sequence.number`

Meaning: Ordering number used by Cloudflare when timestamps are identical.

Why it matters: Helps with precise ordering in logs and spans from the same invocation.

`telemetry.sdk.language`

Meaning: SDK language. For Workers docs this is javascript.

Why it matters: Mostly informational.

`telemetry.sdk.name`

Meaning: SDK name. Cloudflare docs say this is cloudflare.

Why it matters: Helpful to distinguish Cloudflare runtime-generated telemetry from app SDK telemetry.

Root invocation outcome and lifecycle

`faas.trigger`

Meaning: Invocation trigger like http, cron, queue, or email.

Why it matters: Important top-level classifier.

`cloudflare.ray_id`

Meaning: Cloudflare request ID.

Why it matters: One of the best identifiers for debugging specific requests.

`cloudflare.handler_type`

Meaning: Handler type like fetch, scheduled, queue, email, or alarm.

Why it matters: Very important for narrowing the kind of Worker execution.

`cloudflare.entrypoint`

Meaning: Invoked entrypoint, for example a Durable Object class.

Why it matters: Important for Durable Object and RPC exploration.

`cloudflare.execution_model`

Meaning: Execution model such as stateless or stateful.

Why it matters: Useful for distinguishing normal Workers from Durable Object-like execution.

`cloudflare.outcome`

Meaning: Outcome of the invocation, such as ok, exception, exceededCpu, or exceededMemory.

Why it matters: One of the most important attributes in the whole document.

Common query use:

1SpanAttributes['cloudflare.outcome'] = 'exception'

`cloudflare.cpu_time_ms`

Meaning: CPU time used by the invocation in milliseconds.

Why it matters: Great for separating CPU-bound from IO-bound slowness.

`cloudflare.wall_time_ms`

Meaning: Total wall time used by the invocation in milliseconds.

Why it matters: Great for slow-request analysis.

HTTP and fetch request attributes

`network.protocol.name`

Meaning: Network protocol name.

Why it matters: Usually minor, but useful for debugging protocol behavior.

`network.protocol.version`

Meaning: Network protocol version.

Why it matters: Can help explain transport differences.

`url.full`

Meaning: Full URL.

Why it matters: Useful for debugging individual requests.

Caution: Often high-cardinality.

`url.scheme`

Meaning: URL scheme such as https.

Why it matters: Mostly informational.

`url.path`

Meaning: Request path.

Why it matters: One of the best attributes for grouping endpoints.

`url.query`

Meaning: Request query string.

Why it matters: Useful for debugging, but often high-cardinality.

`server.port`

Meaning: Target server port.

Why it matters: Mostly relevant for outbound fetch() spans.

`server.address`

Meaning: Target server address.

Why it matters: Useful for outbound dependency debugging.

`user_agent.original`

Meaning: Raw user agent string.

Why it matters: Useful for browser or client analysis.

`http.request.method`

Meaning: HTTP method like GET or POST.

Why it matters: One of the most common filters for request analysis.

`http.request.header.content-type`

Meaning: Request content type header.

Why it matters: Useful for API debugging.

`http.request.header.content-length`

Meaning: Request content length header.

Why it matters: Helpful for payload-size issues.

`http.request.header.accept`

Meaning: Request Accept header.

Why it matters: Useful for content negotiation debugging.

`http.request.header.accept-encoding`

Meaning: Request Accept-Encoding header.

Why it matters: Useful for compression-related issues.

`http.request.body.size`

Meaning: Request body size.

Why it matters: Good for spotting unusually large inputs.

`http.response.status_code`

Meaning: HTTP response status code.

Why it matters: Core success/failure signal.

`http.response.body.size`

Meaning: Response body size.

Why it matters: Useful for latency and bandwidth analysis.

Fetch handler enrichment

`cloudflare.verified_bot_category`

Meaning: Verified bot category assigned by Cloudflare.

Why it matters: Useful for bot traffic analysis.

`cloudflare.asn`

Meaning: Client ASN.

Why it matters: Useful for ISP-specific issues.

`cloudflare.response.time_to_first_byte_ms`

Meaning: Time to first byte in milliseconds.

Why it matters: Very useful for end-user latency analysis.

`geo.timezone`

Meaning: Client timezone.

Why it matters: Useful for geo slicing.

`geo.continent.code`

Meaning: Client continent code.

Why it matters: Useful for regional traffic analysis.

`geo.country.code`

Meaning: Client country code.

Why it matters: Very common geo filter.

`geo.locality.name`

Meaning: Client locality name.

Why it matters: Useful for deep geo debugging.

`geo.locality.region`

Meaning: Client locality region.

Why it matters: Useful for geo debugging.

`user_agent.os.name`

Meaning: OS name parsed from the user agent.

Why it matters: Useful for client platform analysis.

`user_agent.os.version`

Meaning: OS version.

Why it matters: Helpful for compatibility debugging.

`user_agent.browser.name`

Meaning: Browser name.

Why it matters: Common browser grouping field.

`user_agent.browser.major_version`

Meaning: Browser major version.

Why it matters: Good for coarse compatibility grouping.

`user_agent.browser.version`

Meaning: Full browser version.

Why it matters: Good for precise compatibility debugging.

`user_agent.engine.name`

Meaning: Browser engine name.

Why it matters: Can help explain browser behavior.

`user_agent.engine.version`

Meaning: Browser engine version.

Why it matters: Mostly detailed compatibility context.

`user_agent.device.type`

Meaning: Device type like mobile or desktop.

Why it matters: Very useful segmentation field.

`user_agent.device.vendor`

Meaning: Device vendor.

Why it matters: Useful for client debugging.

`user_agent.device.model`

Meaning: Device model.

Why it matters: Useful for rare device-specific issues.

`http.request.header.accept-language`

Meaning: Request Accept-Language header.

Why it matters: Useful for localization debugging.

Scheduled, queue, RPC, email, tail, alarm

`faas.cron`

Meaning: Cron expression for scheduled invocation.

Why it matters: Useful for identifying scheduled jobs.

`cloudflare.scheduled_time`

Meaning: Scheduled timestamp for scheduled or alarm execution.

Why it matters: Useful for cron and alarm debugging.

`cloudflare.queue.name`

Meaning: Queue name.

Why it matters: Important for queue consumer analysis.

`cloudflare.queue.batch_size`

Meaning: Queue batch size.

Why it matters: Good for throughput analysis.

`cloudflare.jsrpc.method`

Meaning: RPC method name.

Why it matters: Very important for Durable Object RPC exploration.

`cloudflare.email.from`

Meaning: Sender email.

Why it matters: Useful for email Worker debugging.

`cloudflare.email.to`

Meaning: Recipient email.

Why it matters: Useful for email flow debugging.

`cloudflare.email.size`

Meaning: Email size.

Why it matters: Useful for payload-size issues.

`cloudflare.trace.count`

Meaning: Trace count on tail handler telemetry.

Why it matters: Mostly tail-specific context.

Cache API

`cache.request.url`

Meaning: Cache request URL.

Why it matters: Useful for cache key debugging.

`cache.request.method`

Meaning: Cache request method.

Why it matters: Useful for cache behavior analysis.

`cache.request.payload.status_code`

Meaning: Cached payload status code.

Why it matters: Helpful when debugging cache storage behavior.

`cache.request.payload.header.cache_control`

Meaning: Cached response cache-control header.

Why it matters: Helpful for cache semantics.

`cache.request.payload.header.cache_tag`

Meaning: Cached cache-tag header.

Why it matters: Useful for tag-based invalidation debugging.

`cache.request.payload.header.etag`

Meaning: Cached ETag header.

Why it matters: Useful for validation flows.

`cache.request.payload.header.expires`

Meaning: Cached expires header.

Why it matters: Useful for TTL behavior.

`cache.request.payload.header.last_modified`

Meaning: Cached last-modified header.

Why it matters: Useful for conditional request debugging.

`cache.request.payload.size`

Meaning: Cached payload size.

Why it matters: Helpful for storage-size debugging.

`cache.response.success`

Meaning: Whether cache operation succeeded.

Why it matters: Good success/failure signal.

`cache.request.ignore_method`

Meaning: Whether method was ignored when matching or deleting.

Why it matters: Useful for cache semantics.

`cache.request.header.range`

Meaning: Range header used in cache match.

Why it matters: Useful for partial content debugging.

`cache.request.header.if_modified_since`

Meaning: Conditional header for cache match.

Why it matters: Useful for cache validation analysis.

`cache.request.header.if_none_match`

Meaning: Conditional ETag header for cache match.

Why it matters: Useful for cache validation analysis.

`cache.response.body.size`

Meaning: Cache response body size.

Why it matters: Useful for payload-size debugging.

`cache.response.cache_status`

Meaning: Cache status result.

Why it matters: Useful for hit/miss style analysis.

`cache.response.status_code`

Meaning: Cache response status code.

Why it matters: Useful for cache debugging.

D1

`db.system.name`

Meaning: Database system identifier.

Why it matters: Standard database filter.

`db.operation.name`

Meaning: Database operation name.

Why it matters: Important for query grouping.

`db.query.text`

Meaning: SQL query text.

Why it matters: Extremely useful for diagnosing slowness.

Caution: Often sensitive and high-cardinality.

`cloudflare.binding.type`

Meaning: Binding type.

Why it matters: Important for classifying spans like D1, KV, R2.

`cloudflare.d1.response.size_after`

Meaning: Size after operation.

Why it matters: Useful for D1 mutation/debug context.

`cloudflare.d1.response.rows_read`

Meaning: Number of rows read.

Why it matters: Very useful for expensive query analysis.

`cloudflare.d1.response.rows_written`

Meaning: Number of rows written.

Why it matters: Useful for write cost analysis.

`cloudflare.d1.response.last_row_id`

Meaning: Last inserted row id.

Why it matters: Mostly mutation context.

`cloudflare.d1.response.changed_db`

Meaning: Whether the DB changed.

Why it matters: Mutation context.

`cloudflare.d1.response.changes`

Meaning: Number of changes made.

Why it matters: Mutation analysis.

`cloudflare.d1.response.served_by_region`

Meaning: Region serving the D1 response.

Why it matters: Useful for regional behavior.

`cloudflare.d1.response.served_by_primary`

Meaning: Whether served by primary.

Why it matters: Useful for replication/topology debugging.

`cloudflare.d1.response.sql_duration_ms`

Meaning: SQL duration in milliseconds.

Why it matters: One of the most important D1 attrs.

`cloudflare.d1.response.total_attempts`

Meaning: Total attempts made.

Why it matters: Useful for retry visibility.

`db.operation.batch.size`

Meaning: Batch size for d1_batch.

Why it matters: Important for batch-cost analysis.

`cloudflare.d1.query.bookmark`

Meaning: Query bookmark sent with the request.

Why it matters: Useful for paging or replication state analysis.

`cloudflare.d1.response.bookmark`

Meaning: Bookmark returned by the response.

Why it matters: Useful for paging or replication state analysis.

KV

`cloudflare.binding.name`

Meaning: Bound resource name.

Why it matters: Helpful for distinguishing namespaces or buckets.

`cloudflare.kv.query.keys`

Meaning: KV key or keys used in the request.

Why it matters: Useful for debugging, but can be high-cardinality.

`cloudflare.kv.query.keys.count`

Meaning: Number of keys queried.

Why it matters: Helpful for batch access analysis.

`cloudflare.kv.query.type`

Meaning: KV query type.

Why it matters: Useful for read behavior analysis.

`cloudflare.kv.query.cache_ttl`

Meaning: Cache TTL used for the query.

Why it matters: Useful for cache effectiveness debugging.

`cloudflare.kv.response.size`

Meaning: Size of the returned value.

Why it matters: Helpful for payload analysis.

`cloudflare.kv.response.returned_rows`

Meaning: Number of rows returned.

Why it matters: Useful for list/get behavior.

`cloudflare.kv.response.metadata`

Meaning: Returned metadata.

Why it matters: Useful when metadata affects behavior.

`cloudflare.kv.response.cache_status`

Meaning: Cache status.

Why it matters: One of the most useful KV attrs.

`cloudflare.kv.query.value_type`

Meaning: Value type used for put.

Why it matters: Useful for write debugging.

`cloudflare.kv.query.expiration`

Meaning: Absolute expiration.

Why it matters: TTL debugging.

`cloudflare.kv.query.expiration_ttl`

Meaning: TTL duration.

Why it matters: TTL debugging.

`cloudflare.kv.query.metadata`

Meaning: Metadata supplied on write.

Why it matters: Useful for write debugging.

`cloudflare.kv.query.payload.size`

Meaning: Write payload size.

Why it matters: Useful for payload debugging.

`cloudflare.kv.query.prefix`

Meaning: Prefix used in list.

Why it matters: Useful for list scans.

`cloudflare.kv.query.limit`

Meaning: List limit.

Why it matters: Useful for paging analysis.

`cloudflare.kv.query.cursor`

Meaning: List cursor.

Why it matters: Useful for paging analysis.

`cloudflare.kv.response.list_complete`

Meaning: Whether list is complete.

Why it matters: Useful for paging logic.

`cloudflare.kv.response.cursor`

Meaning: Response cursor.

Why it matters: Useful for paging logic.

`cloudflare.kv.response.expiration`

Meaning: Returned expiration.

Why it matters: Useful for TTL visibility.

R2

`cloudflare.r2.bucket`

Meaning: R2 bucket name.

Why it matters: Core grouping field for R2.

`cloudflare.r2.operation`

Meaning: R2 operation name.

Why it matters: One of the most useful R2 attrs.

`cloudflare.r2.response.success`

Meaning: Whether the R2 operation succeeded.

Why it matters: Core success/failure signal.

`cloudflare.r2.error.message`

Meaning: R2 error message.

Why it matters: Useful failure detail.

`cloudflare.r2.error.code`

Meaning: R2 error code.

Why it matters: Useful failure detail.

`cloudflare.r2.request.key`

Meaning: Object key.

Why it matters: Very useful for debugging, but high-cardinality.

`cloudflare.r2.response.etag`

Meaning: Object ETag.

Why it matters: Useful for validation/debugging.

`cloudflare.r2.response.size`

Meaning: Object size.

Why it matters: Important performance context.

`cloudflare.r2.response.uploaded`

Meaning: Uploaded timestamp.

Why it matters: Useful object metadata context.

`cloudflare.r2.response.checksum.value`

Meaning: Object checksum value.

Why it matters: Integrity/debug context.

`cloudflare.r2.response.checksum.type`

Meaning: Checksum type.

Why it matters: Integrity/debug context.

`cloudflare.r2.response.storage_class`

Meaning: Storage class.

Why it matters: Useful for storage policy analysis.

`cloudflare.r2.response.ssec_key`

Meaning: SSE-C key indicator.

Why it matters: Encryption/debug context.

`cloudflare.r2.response.content_type`

Meaning: Content type.

Why it matters: Useful for content debugging.

`cloudflare.r2.response.content_encoding`

Meaning: Content encoding.

Why it matters: Useful for compression debugging.

`cloudflare.r2.response.content_disposition`

Meaning: Content disposition.

Why it matters: Useful for download behavior debugging.

`cloudflare.r2.response.content_language`

Meaning: Content language.

Why it matters: Useful for localization/content debugging.

`cloudflare.r2.response.cache_control`

Meaning: Cache control metadata.

Why it matters: Useful for cache policy debugging.

`cloudflare.r2.response.cache_expiry`

Meaning: Cache expiry metadata.

Why it matters: Useful for TTL/cache policy debugging.

`cloudflare.r2.response.custom_metadata`

Meaning: Custom metadata.

Why it matters: Useful for app-specific object metadata.

`cloudflare.r2.request.range.offset`

Meaning: Range offset.

Why it matters: Useful for partial-read debugging.

`cloudflare.r2.request.range.length`

Meaning: Range length.

Why it matters: Useful for partial-read debugging.

`cloudflare.r2.request.range.suffix`

Meaning: Range suffix.

Why it matters: Useful for partial-read debugging.

`cloudflare.r2.request.range`

Meaning: Range descriptor.

Why it matters: Useful for partial-read debugging.

`cloudflare.r2.request.ssec_key`

Meaning: SSE-C key request field.

Why it matters: Encryption/debug context.

`cloudflare.r2.request.only_if.etag_matches`

Meaning: Conditional ETag match.

Why it matters: Conditional operation debugging.

`cloudflare.r2.request.only_if.etag_does_not_match`

Meaning: Conditional ETag mismatch.

Why it matters: Conditional operation debugging.

`cloudflare.r2.request.only_if.uploaded_before`

Meaning: Conditional upload time check.

Why it matters: Conditional operation debugging.

`cloudflare.r2.request.only_if.uploaded_after`

Meaning: Conditional upload time check.

Why it matters: Conditional operation debugging.

`cloudflare.r2.request.size`

Meaning: Request object size.

Why it matters: Helpful for upload analysis.

`cloudflare.r2.request.checksum.type`

Meaning: Request checksum type.

Why it matters: Integrity/debug context.

`cloudflare.r2.request.checksum.value`

Meaning: Request checksum value.

Why it matters: Integrity/debug context.

`cloudflare.r2.request.custom_metadata`

Meaning: Custom metadata supplied on write.

Why it matters: Useful for application behavior.

`cloudflare.r2.request.http_metadata.content_type`

Meaning: HTTP metadata content type on write.

Why it matters: Useful for upload debugging.

`cloudflare.r2.request.http_metadata.content_encoding`

Meaning: HTTP metadata content encoding on write.

Why it matters: Useful for upload debugging.

`cloudflare.r2.request.http_metadata.content_disposition`

Meaning: HTTP metadata content disposition on write.

Why it matters: Useful for upload debugging.

`cloudflare.r2.request.http_metadata.content_language`

Meaning: HTTP metadata content language on write.

Why it matters: Useful for upload debugging.

`cloudflare.r2.request.http_metadata.cache_control`

Meaning: HTTP metadata cache control on write.

Why it matters: Useful for cache policy debugging.

`cloudflare.r2.request.http_metadata.cache_expiry`

Meaning: HTTP metadata cache expiry on write.

Why it matters: Useful for cache policy debugging.

`cloudflare.r2.request.storage_class`

Meaning: Requested storage class.

Why it matters: Useful for storage policy analysis.

`cloudflare.r2.request.limit`

Meaning: List limit.

Why it matters: Useful for paging analysis.

`cloudflare.r2.request.prefix`

Meaning: List prefix.

Why it matters: Useful for bucket browsing analysis.

`cloudflare.r2.request.cursor`

Meaning: List cursor.

Why it matters: Useful for paging analysis.

`cloudflare.r2.request.delimiter`

Meaning: List delimiter.

Why it matters: Useful for pseudo-folder analysis.

`cloudflare.r2.request.start_after`

Meaning: Start-after key.

Why it matters: Useful for paging analysis.

`cloudflare.r2.request.include.http_metadata`

Meaning: Whether list includes HTTP metadata.

Why it matters: Useful for cost/shape understanding.

`cloudflare.r2.request.include.custom_metadata`

Meaning: Whether list includes custom metadata.

Why it matters: Useful for cost/shape understanding.

`cloudflare.r2.response.returned_objects`

Meaning: Number of returned objects.

Why it matters: Useful for list analysis.

`cloudflare.r2.response.delimited_prefixes`

Meaning: Returned delimited prefixes.

Why it matters: Useful for pseudo-folder analysis.

`cloudflare.r2.response.truncated`

Meaning: Whether list is truncated.

Why it matters: Useful for paging analysis.

`cloudflare.r2.response.cursor`

Meaning: Response cursor.

Why it matters: Useful for paging analysis.

`cloudflare.r2.request.keys`

Meaning: Keys used for delete.

Why it matters: Useful for delete debugging.

`cloudflare.r2.response.upload_id`

Meaning: Multipart upload ID.

Why it matters: Important for multipart flow debugging.

`cloudflare.r2.request.upload_id`

Meaning: Multipart upload ID on request.

Why it matters: Important for multipart flow debugging.

`cloudflare.r2.request.part_number`

Meaning: Multipart part number.

Why it matters: Useful for multipart debugging.

`cloudflare.r2.request.uploaded_parts`

Meaning: Uploaded parts summary.

Why it matters: Useful for multipart completion debugging.

Durable Object storage SQL and KV

`cloudflare.durable_object.query.bindings`

Meaning: Query bindings for DO SQL execution.

Why it matters: Useful for SQL debugging.

`cloudflare.durable_object.response.rows_read`

Meaning: Rows read in DO SQL.

Why it matters: Useful for expensive-query analysis.

`cloudflare.durable_object.response.rows_written`

Meaning: Rows written in DO SQL.

Why it matters: Useful for mutation analysis.

`cloudflare.durable_object.response.db_size`

Meaning: DO embedded DB size.

Why it matters: Useful for storage growth analysis.

`cloudflare.durable_object.kv.query.keys`

Meaning: DO KV keys queried.

Why it matters: Useful for debugging, but often high-cardinality.

`cloudflare.durable_object.kv.query.keys.count`

Meaning: Count of DO KV keys.

Why it matters: Useful for batch analysis.

`cloudflare.durable_object.kv.response.deleted_count`

Meaning: Deleted key count.

Why it matters: Useful for delete analysis.

`cloudflare.durable_object.kv.query.start`

Meaning: Start key for list.

Why it matters: Useful for paging analysis.

`cloudflare.durable_object.kv.query.startAfter`

Meaning: Start-after key for list.

Why it matters: Useful for paging analysis.

`cloudflare.durable_object.kv.query.end`

Meaning: End key for list.

Why it matters: Useful for range scans.

`cloudflare.durable_object.kv.query.prefix`

Meaning: Prefix for list.

Why it matters: Useful for namespaced scans.

`cloudflare.durable_object.kv.query.reverse`

Meaning: Reverse-order listing flag.

Why it matters: Useful for paging/debugging.

`cloudflare.durable_object.kv.query.limit`

Meaning: List limit.

Why it matters: Useful for paging analysis.

Images

`cloudflare.images.options.format`

Meaning: Requested output format.

Why it matters: Useful for image transform debugging.

`cloudflare.images.options.quality`

Meaning: Requested quality.

Why it matters: Useful for performance vs quality tradeoffs.

`cloudflare.images.options.background`

Meaning: Background option.

Why it matters: Useful for transformation debugging.

`cloudflare.images.options.anim`

Meaning: Animation option.

Why it matters: Useful for animated image handling.

`cloudflare.images.options.transforms`

Meaning: Image transforms.

Why it matters: Useful for understanding expensive transforms.

`cloudflare.images.error.code`

Meaning: Image processing error code.

Why it matters: Useful failure detail.

`cloudflare.images.options.encoding`

Meaning: Input encoding option.

Why it matters: Useful for transformation debugging.

`cloudflare.images.result.format`

Meaning: Result format.

Why it matters: Useful for output analysis.

`cloudflare.images.result.file_size`

Meaning: Output file size.

Why it matters: Useful for payload/performance analysis.

`cloudflare.images.result.width`

Meaning: Output width.

Why it matters: Useful for transform verification.

`cloudflare.images.result.height`

Meaning: Output height.

Why it matters: Useful for transform verification.

Important gaps and caveats

Cloudflare logs are less fully documented than traces

Cloudflare clearly documents the trace attributes above.

Cloudflare also documents that logs include:

console.log() output
system-generated logs
uncaught exceptions in Workers logs products

Validation against a real Worker export confirmed that destination OTLP logs did not expose a structured uncaught-exception payload with fields like:

exception.type
exception.message
exception.stacktrace

So agents should use this rule:

for failures, trust traces first via cloudflare.outcome
for detailed error grouping, inspect logs second for surrounding context, but do not assume exception.* exists

Recommended mental model for agents

When investigating Cloudflare Worker problems in Strada:

Filter to Cloudflare with cloud.platform = 'cloudflare.workers'
Find the root span and inspect:
- cloudflare.handler_type
- cloudflare.entrypoint
- cloudflare.outcome
- cloudflare.cpu_time_ms
- cloudflare.wall_time_ms
Inspect child spans for D1, KV, R2, fetch, or Durable Object work
If the request failed, search logs on the same trace for exception.*
If the problem is slowness, compare total duration vs CPU vs child-span durations

Best docs to cross-check

Exporting OpenTelemetry Data
https://developers.cloudflare.com/workers/observability/exporting-opentelemetry-data/
Traces
https://developers.cloudflare.com/workers/observability/traces/
Spans and attributes
https://developers.cloudflare.com/workers/observability/traces/spans-and-attributes/
Workers Logs
https://developers.cloudflare.com/workers/observability/logs/workers-logs/
Workers Logpush dataset docs
https://developers.cloudflare.com/logs/logpush/logpush-job/datasets/account/workers_trace_events/
Export to Sentry
https://developers.cloudflare.com/workers/observability/exporting-opentelemetry-data/sentry/
Export to Grafana Cloud
https://developers.cloudflare.com/workers/observability/exporting-opentelemetry-data/grafana-cloud/
Export to Axiom
https://developers.cloudflare.com/workers/observability/exporting-opentelemetry-data/axiom/

Cloudflare Workers OTel export via destinations

Quick answers

Is a row from Cloudflare Workers?

What are the most important attributes?

What attributes are best for slow requests?

What attributes are best for failed Worker executions?

What Cloudflare exports

Validated behavior from a real Cloudflare Worker

Route matrix used for validation

Key validated findings

Example wrangler.jsonc

Example OTLP payloads

Example traces payload

Example logs payload

Querying strategy for agents

Filter early

Good first questions

Slow request

Worker crash or uncaught exception

D1 slowness

Durable Object RPC failures

Example queries

Failed Worker invocations

Slow requests

Uncaught exception traces

D1 bottlenecks

Logs with runtime-crash context

Logs with standard exception fields if present

Attribute reference

Resource and invocation identity

cloud.provider

cloud.platform

faas.name

faas.invocation_id

faas.version

faas.invoked_region

service.name

cloudflare.colo

cloudflare.script_name

cloudflare.script_tags

cloudflare.script_version.id

cloudflare.invocation.sequence.number

telemetry.sdk.language

telemetry.sdk.name

Root invocation outcome and lifecycle

faas.trigger

cloudflare.ray_id

cloudflare.handler_type

cloudflare.entrypoint

cloudflare.execution_model

cloudflare.outcome

cloudflare.cpu_time_ms

cloudflare.wall_time_ms

HTTP and fetch request attributes

network.protocol.name

network.protocol.version

url.full

url.scheme

url.path

url.query

server.port

server.address

user_agent.original

http.request.method

http.request.header.content-type

http.request.header.content-length

http.request.header.accept

http.request.header.accept-encoding

http.request.body.size

http.response.status_code

http.response.body.size

Fetch handler enrichment

cloudflare.verified_bot_category

cloudflare.asn

cloudflare.response.time_to_first_byte_ms

geo.timezone

geo.continent.code

geo.country.code

geo.locality.name

geo.locality.region

Example `wrangler.jsonc`

`cloud.provider`

`cloud.platform`

`faas.name`

`faas.invocation_id`

`faas.version`

`faas.invoked_region`

`service.name`

`cloudflare.colo`

`cloudflare.script_name`

`cloudflare.script_tags`

`cloudflare.script_version.id`

`cloudflare.invocation.sequence.number`

`telemetry.sdk.language`

`telemetry.sdk.name`

`faas.trigger`

`cloudflare.ray_id`

`cloudflare.handler_type`

`cloudflare.entrypoint`

`cloudflare.execution_model`

`cloudflare.outcome`

`cloudflare.cpu_time_ms`

`cloudflare.wall_time_ms`

`network.protocol.name`

`network.protocol.version`

`url.full`

`url.scheme`

`url.path`

`url.query`

`server.port`

`server.address`

`user_agent.original`

`http.request.method`

`http.request.header.content-type`

`http.request.header.content-length`

`http.request.header.accept`

`http.request.header.accept-encoding`

`http.request.body.size`

`http.response.status_code`

`http.response.body.size`

`cloudflare.verified_bot_category`

`cloudflare.asn`

`cloudflare.response.time_to_first_byte_ms`

`geo.timezone`

`geo.continent.code`

`geo.country.code`

`geo.locality.name`

`geo.locality.region`

`user_agent.os.name`

`user_agent.os.version`

`user_agent.browser.name`

`user_agent.browser.major_version`

`user_agent.browser.version`

`user_agent.engine.name`

`user_agent.engine.version`

`user_agent.device.type`

`user_agent.device.vendor`

`user_agent.device.model`

`http.request.header.accept-language`

`faas.cron`

`cloudflare.scheduled_time`

`cloudflare.queue.name`

`cloudflare.queue.batch_size`

`cloudflare.jsrpc.method`

`cloudflare.email.from`

`cloudflare.email.to`

`cloudflare.email.size`

`cloudflare.trace.count`

`cache.request.url`

`cache.request.method`

`cache.request.payload.status_code`

`cache.request.payload.header.cache_control`

`cache.request.payload.header.cache_tag`

`cache.request.payload.header.etag`

`cache.request.payload.header.expires`

`cache.request.payload.header.last_modified`

`cache.request.payload.size`

`cache.response.success`

`cache.request.ignore_method`

`cache.request.header.range`