Add telemetry fields and CI matrix for telemetry variants

- Add standard telemetry fields to tracing spans:
  * hostname: Host header from incoming request (tracked even when worker not found)
  * http_method: HTTP method (GET, POST, etc.)
  * response_status_code: HTTP response status code for all responses
- Add error_response_with_span() helper to record status code in error paths
- Add CI matrix to build both v8 and v8-telemetry Docker image variants
- Update Dockerfile and Dockerfile.multi to conditionally compile telemetry feature based on TELEMETRY build arg
- Update dependencies (Cargo.lock)

Author: max-lt

.github/workflows/docker.yml

@@ -14,11 +14,12 @@ on:
 
 jobs:
   build:
-    name: Build (${{ matrix.runtime }})
+    name: Build (${{ matrix.runtime }}${{ matrix.telemetry && '-telemetry' || '' }})
     runs-on: ubuntu-24.04
     strategy:
       matrix:
         runtime: [v8] # deno disabled (requires core 0.5, we're on 0.6)
+        telemetry: [false, true]
     steps:
       - name: Check Out Repo
         uses: actions/checkout@v4
@@ -29,10 +30,10 @@ jobs:
           images: |
             ghcr.io/${{ github.repository }}
           tags: |
-            type=raw,value=${{ matrix.runtime }},enable={{is_default_branch}}
-            type=raw,value=latest,enable=${{ github.ref == 'refs/heads/master' && matrix.runtime == 'v8' }}
-            type=ref,event=branch,suffix=-${{ matrix.runtime }}
-            type=ref,event=tag,suffix=-${{ matrix.runtime }}
+            type=raw,value=${{ matrix.runtime }}${{ matrix.telemetry && '-telemetry' || '' }},enable={{is_default_branch}}
+            type=raw,value=latest,enable=${{ github.ref == 'refs/heads/master' && matrix.runtime == 'v8' && !matrix.telemetry }}
+            type=ref,event=branch,suffix=-${{ matrix.runtime }}${{ matrix.telemetry && '-telemetry' || '' }}
+            type=ref,event=tag,suffix=-${{ matrix.runtime }}${{ matrix.telemetry && '-telemetry' || '' }}
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v3
       - name: Login to GitHub Container Registry
@@ -50,7 +51,8 @@ jobs:
           tags: ${{ steps.metadata.outputs.tags }}
           build-args: |
             RUNTIME=${{ matrix.runtime }}
-          cache-from: type=gha,scope=${{ matrix.runtime }}
-          cache-to: type=gha,mode=max,scope=${{ matrix.runtime }}
+            TELEMETRY=${{ matrix.telemetry }}
+          cache-from: type=gha,scope=${{ matrix.runtime }}-${{ matrix.telemetry }}
+          cache-to: type=gha,mode=max,scope=${{ matrix.runtime }}-${{ matrix.telemetry }}
           # TODO: re-enable linux/arm64 once openworkers-v8 provides prebuilt binaries for aarch64-unknown-linux-gnu
           platforms: linux/amd64

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "openworkers-runner"
-version = "0.12.8"
+version = "0.12.9"
 edition = "2024"
 license = "MIT"
 default-run = "openworkers-runner"

Cargo.toml

@@ -9,8 +9,8 @@ RUN cargo chef prepare --recipe-path recipe.json
 FROM chef AS builder
 
 ARG RUNTIME=v8
+ARG TELEMETRY=false
 
-ENV FEATURES=$RUNTIME,database,telemetry
 ENV RUST_BACKTRACE=1
 ENV RUNTIME_SNAPSHOT_PATH=/build/snapshot.bin
 
@@ -21,6 +21,8 @@ COPY --from=planner /build/recipe.json recipe.json
 RUN --mount=type=cache,target=$CARGO_HOME/git \
     --mount=type=cache,target=$CARGO_HOME/registry \
     --mount=type=cache,target=/build/target \
+    FEATURES="$RUNTIME,database"; \
+    if [ "$TELEMETRY" = "true" ]; then FEATURES="$FEATURES,telemetry"; fi; \
     cargo chef cook --release --features=$FEATURES --recipe-path recipe.json
 
 # Build application
@@ -31,6 +33,8 @@ RUN touch $RUNTIME_SNAPSHOT_PATH
 RUN --mount=type=cache,target=$CARGO_HOME/git \
     --mount=type=cache,target=$CARGO_HOME/registry \
     --mount=type=cache,target=/build/target \
+    FEATURES="$RUNTIME,database"; \
+    if [ "$TELEMETRY" = "true" ]; then FEATURES="$FEATURES,telemetry"; fi; \
     cargo run --release --features=$FEATURES --bin snapshot && \
     # Build the runner and copy executable out of the cache so it can be used in the next stage
     cargo build --release --features=$FEATURES && cp /build/target/release/openworkers-runner /build/output

Dockerfile

@@ -36,9 +36,9 @@ RUN cargo chef prepare --recipe-path recipe.json
 FROM prepare AS platform
 
 ARG RUNTIME=v8
+ARG TELEMETRY=false
 ARG TARGETPLATFORM
-
-ENV FEATURES=$RUNTIME,database,telemetry
+    
 ENV RUST_BACKTRACE=1
 ENV RUNTIME_SNAPSHOT_PATH=/build/snapshot.bin
 
@@ -49,12 +49,13 @@ RUN touch $RUNTIME_SNAPSHOT_PATH
 # Copy recipe from planner
 COPY --from=planner /build/recipe.json recipe.json
 
-RUN echo "Building for $TARGETPLATFORM with features $FEATURES"
-
 # Build dependencies for target platform
-RUN --mount=type=cache,id=cargo-$TARGETPLATFORM-$RUNTIME,sharing=locked,target=$CARGO_HOME/git \
-    --mount=type=cache,id=cargo-$TARGETPLATFORM-$RUNTIME,sharing=locked,target=$CARGO_HOME/registry \
-    --mount=type=cache,id=cargo-$TARGETPLATFORM-$RUNTIME,sharing=locked,target=/build/target \
+RUN --mount=type=cache,id=cargo-$TARGETPLATFORM-$RUNTIME-$TELEMETRY,sharing=locked,target=$CARGO_HOME/git \
+    --mount=type=cache,id=cargo-$TARGETPLATFORM-$RUNTIME-$TELEMETRY,sharing=locked,target=$CARGO_HOME/registry \
+    --mount=type=cache,id=cargo-$TARGETPLATFORM-$RUNTIME-$TELEMETRY,sharing=locked,target=/build/target \
+    FEATURES="$RUNTIME,database"; \
+    if [ "$TELEMETRY" = "true" ]; then FEATURES="$FEATURES,telemetry"; fi; \
+    echo "Building for $TARGETPLATFORM with features $FEATURES"; \
     case "$TARGETPLATFORM" in \
         "linux/arm64") cargo chef cook --release --features=$FEATURES --target aarch64-unknown-linux-gnu --recipe-path recipe.json ;; \
         "linux/amd64") cargo chef cook --release --features=$FEATURES --target x86_64-unknown-linux-gnu --recipe-path recipe.json ;; \
@@ -68,9 +69,11 @@ COPY . /build
 # 1. Build the snapshot generator for the TARGET platform
 # 2. Run it (via QEMU emulation explicitly) to generate the snapshot.bin
 # 3. Build the final runner which embeds the snapshot.bin
-RUN --mount=type=cache,id=cargo-$TARGETPLATFORM-$RUNTIME,sharing=locked,target=$CARGO_HOME/git \
-    --mount=type=cache,id=cargo-$TARGETPLATFORM-$RUNTIME,sharing=locked,target=$CARGO_HOME/registry \
-    --mount=type=cache,id=cargo-$TARGETPLATFORM-$RUNTIME,sharing=locked,target=/build/target \
+RUN --mount=type=cache,id=cargo-$TARGETPLATFORM-$RUNTIME-$TELEMETRY,sharing=locked,target=$CARGO_HOME/git \
+    --mount=type=cache,id=cargo-$TARGETPLATFORM-$RUNTIME-$TELEMETRY,sharing=locked,target=$CARGO_HOME/registry \
+    --mount=type=cache,id=cargo-$TARGETPLATFORM-$RUNTIME-$TELEMETRY,sharing=locked,target=/build/target \
+    FEATURES="$RUNTIME,database"; \
+    if [ "$TELEMETRY" = "true" ]; then FEATURES="$FEATURES,telemetry"; fi; \
     case "$TARGETPLATFORM" in \
         "linux/arm64") \
             # Build snapshot generator for target \

Dockerfile.multi

@@ -153,8 +153,10 @@ async fn handle_request(
     let span = tracing::info_span!(
         "request",
         request_id = %request_id,
-        method = %method,
+        http_method = %method,
         uri = %uri,
+        hostname = tracing::field::Empty,
+        response_status_code = tracing::field::Empty,
         worker_id = tracing::field::Empty,
         worker_name = tracing::field::Empty,
         user_id = tracing::field::Empty,
@@ -188,6 +190,11 @@ async fn handle_worker_request(
         .and_then(|h| h.to_str().ok())
         .map(|s| s.to_string());
 
+    // Record hostname (even if worker not found)
+    if let Some(ref hostname) = host {
+        span.record("hostname", hostname.as_str());
+    }
+
     let worker_id = headers
         .get("x-worker-id")
         .and_then(|h| h.to_str().ok())
@@ -244,7 +251,13 @@ async fn handle_worker_request(
 
                             match worker {
                                 Some(w) => w,
-                                None => return Ok(error_response(404, "Worker not found")),
+                                None => {
+                                    return Ok(error_response_with_span(
+                                        &span,
+                                        404,
+                                        "Worker not found",
+                                    ));
+                                }
                             }
                         } else {
                             return Ok(error_response(
@@ -299,8 +312,13 @@ async fn handle_worker_request(
                                     metrics_timer.start.elapsed().as_millis()
                                 );
 
-                                // Convert HttpResponse to hyper::Response (handles streaming too!)
-                                return Ok(http_response.into_hyper());
+                                // Record status code and convert to hyper response
+                                let hyper_response = http_response.into_hyper();
+                                span.record(
+                                    "response_status_code",
+                                    hyper_response.status().as_u16(),
+                                );
+                                return Ok(hyper_response);
                             }
                             Err(e) => {
                                 debug!(
@@ -309,6 +327,7 @@ async fn handle_worker_request(
                                 );
 
                                 error!("Failed to fetch from storage: {}", e);
+                                span.record("response_status_code", 404u16);
                                 return Ok(error_response(404, "File not found"));
                             }
                         }
@@ -325,17 +344,22 @@ async fn handle_worker_request(
 
                 match worker {
                     Some(w) => w,
-                    None => return Ok(error_response(404, "Worker not found")),
+                    None => return Ok(error_response_with_span(&span, 404, "Worker not found")),
                 }
             } else {
-                return Ok(error_response(
+                return Ok(error_response_with_span(
+                    &span,
                     500,
                     "Invalid resolution: no worker_id or project_id",
                 ));
             }
         }
         None => {
-            return Ok(error_response(404, "Endpoint or route not found"));
+            return Ok(error_response_with_span(
+                &span,
+                404,
+                "Endpoint or route not found",
+            ));
         }
     };
 
@@ -475,7 +499,8 @@ async fn handle_worker_request(
 
     debug!("handle_request done in {}ms", start.elapsed().as_millis());
 
-    // Record metrics
+    // Record response status code and metrics
+    span.record("response_status_code", response.status().as_u16());
     metrics_timer.record_http_request(success);
 
     Ok(response)
@@ -493,6 +518,15 @@ fn error_response(status: u16, message: &str) -> Response<HyperBody> {
         .unwrap()
 }
 
+fn error_response_with_span(
+    span: &tracing::Span,
+    status: u16,
+    message: &str,
+) -> Response<HyperBody> {
+    span.record("response_status_code", status);
+    error_response(status, message)
+}
+
 #[tokio::main(flavor = "multi_thread", worker_threads = 4)]
 async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
     dotenvy::dotenv().ok();