How can I propagate a trace ID from a Cloud Function to a Cloud Run service for unified logging?

Below is an explanation of how you can correlate the Cloud Function invocation with subsequent Cloud Run logs using the trace context:

Overview

• Trace Propagation: The key is to generate (or extract) a trace ID in your Cloud Function and explicitly pass it along in the HTTP request header (using the standard trace header format) when calling the Cloud Run service.
• Structured Logging: In Cloud Run, you configure your logger to include the property logging.googleapis.com/trace in your structured JSON logs. When that field is set, logs can be linked to a trace in Cloud Trace.
• Manual Correlation: Cloud Functions (v1) do not automatically handle this correlation with Cloud Run. However, by manually propagating the trace context from your Cloud Function to Cloud Run, you can see the complete picture across both services in Cloud Trace.

How to Implement the Propagation

1. Generate/Extract the Trace ID in Your Cloud Function
   In your Cloud Function, when handling the Cloud Storage event, you can either:

   • Generate a new trace ID.
   • Or extract a trace ID if one already exists (depending on your tracing strategy).

2. Pass the Trace Context to Cloud Run
   When making the HTTP request to Cloud Run, include the trace information in the request headers. For example, you can use the header X-Cloud-Trace-Context or the W3C traceparent header.

   Here's a sample snippet in Node.js:

   JSCopied
   const axios = require('axios');
   const { v4: uuidv4 } = require('uuid');
   
   exports.myCloudFunction = async (event, context) => {
     // Generate a trace id. Note: In actual production, you might want a more consistent format.
     const traceId = uuidv4().replace(/-/g, '');
     
     // Construct the value for X-Cloud-Trace-Context.
     // The format is: TRACE_ID/SPAN_ID;o=TRACE_TRUE
     // For example, using a dummy span id "1" and trace enabled option:
     const traceHeader = `${traceId}/1;o=1`;
   
     try {
       const response = await axios.get('https://your-cloud-run-url', {
         headers: {
           'X-Cloud-Trace-Context': traceHeader
           // Optionally, also include the W3C traceparent header:
           // 'traceparent': `00-${traceId}-${'0000000000000001'}-01`
         }
       });
       console.log(JSON.stringify({
         message: "Cloud Run called successfully",
         trace: `projects/your-project-id/traces/${traceId}`  // Useful for structured logging.
       }));
       return response.data;
     } catch (err) {
       console.error('Error calling Cloud Run:', err);
       throw err;
     }
   };

3. Using the Trace in Cloud Run Logs
   Inside your Cloud Run service, ensure that your logger captures the X-Cloud-Trace-Context (or traceparent) header from the incoming HTTP request. Then, include the trace ID in the logging.googleapis.com/trace field in your structured logs.

   For example, if you’re using a structured logging library, you might do something similar to:

   JSCopied
   // In your Cloud Run service handler (Node.js example)
   const express = require('express');
   const app = express();
   
   app.get('/', (req, res) => {
     // Extract the trace header
     const traceHeader = req.header('X-Cloud-Trace-Context') || '';
     const traceId = traceHeader.split('/')[0];
   
     // Logging with structured trace info
     console.log(JSON.stringify({
       message: "Handling request in Cloud Run",
       // Make sure the format matches: projects/your-project-id/traces/TRACE_ID
       'logging.googleapis.com/trace': `projects/your-project-id/traces/${traceId}`
     }));
   
     res.send('Hello from Cloud Run!');
   });
   
   const port = process.env.PORT || 8080;
   app.listen(port, () => {
     console.log(`Cloud Run service listening on port ${port}`);
   });

Summary

By manually propagating the trace ID from your Cloud Function (via the appropriate header) to your Cloud Run service, you can link the logs from the function invocation and the Cloud Run request. This manual approach enables you to see a unified trace in Cloud Trace and properly correlate logs across services.

Remember that both Cloud Functions and Cloud Run logs must be structured consistently (including the full trace field, which contains your project ID) for Cloud Trace to correlate them correctly. While there isn’t an out-of-the-box solution that automatically correlates these in Cloud Functions v1, following this propagation model will achieve the desired correlation.