Legacy Google Cloud Run Functions Gen 1

Documentos > Serverless > Google Cloud Run > Legacy Google Cloud Run Functions Gen 1

This page is not yet available in Spanish. We are working on its translation.
If you have any questions or feedback about our current translation project, feel free to reach out to us!

Overview

This page explains how to collect traces, trace metrics, runtime metrics, and custom metrics from your Cloud Run Functions Gen 1 (formerly known as Cloud Functions) utilizing serverless compatibility layer.

This page is only for legacy 1st Gen Cloud Run Functions. For Gen 2 support, see 2nd Gen Functions, and to collect additional metrics, install the Google Cloud integration.

Google has integrated Cloud Run functions into Cloud Run UI. Starting August 2025, creating legacy 1st Gen functions will only be possible using the Google Cloud CLI, API, or Terraform. Datadog recommends upgrading your cloud run function to Gen 2 for more features and Datadog support. Reach out to Google for more information on the migration to Cloud Run.

Setup

Install dependencies. Run the following commands:
```
pip install datadog-serverless-compat
pip install ddtrace
```
Datadog recommends using the latest versions of both datadog-serverless-compat and ddtrace to ensure you have access to enhancements and bug fixes.
For more information, see Tracing Python Applications.
Initialize the Datadog Python tracer and serverless compatibility layer. Add the following lines to your main application entry point file:
```
from datadog_serverless_compat import start
from ddtrace import tracer, patch_all

start()
patch_all()
```
(Optional) Enable runtime metrics. See Python Runtime Metrics.
(Optional) Enable custom metrics. See Metric Submission: DogStatsD.

Name	Value
`JAVA_TOOL_OPTIONS`	`-javaagent:/path/to/dd-serverless-compat-java-agent.jar -javaagent:/path/to/dd-java-agent.jar`

Deploy your function. Use gcloud or Google Console to deploy your 1st Gen Cloud Run Function:
Follow Google Cloud’s Deploy a Cloud Run function (1st gen) instructions to utilize gcloud function deploy <FUNCTION_NAME> --no-gen2 to deploy a 1st Gen Cloud Run Function.
Use the --source flag to point to the directory of your function code with dd-java-agent.jar and dd-serverless-compat-java-agent.jar at the top level.
For more information, see Google Cloud’s gcloud functions deploy documentation for more flags for the gcloud command.
Configure Datadog intake. Add the following environment variables to your function’s application settings:
Name Value
DD_API_KEY Your Datadog API key.
DD_SITE Your Datadog site. For example, datadoghq.com.

Name	Value
`DD_API_KEY`	Your Datadog API key.
`DD_SITE`	Your Datadog site. For example, `datadoghq.com`.

Configure Unified Service Tagging. You can collect metrics from your Cloud Run Function by installing the Google Cloud integration. To correlate these metrics with your traces, first set the env, service, and version tags on your resource in Google Cloud. Then, configure the following environment variables. You can add custom tags as DD_TAGS.

Name	Value
`DD_ENV`	How you want to tag your env for Unified Service Tagging. For example, `prod`.
`DD_SERVICE`	How you want to tag your service for Unified Service Tagging.
`DD_VERSION`	How you want to tag your version for Unified Service Tagging.
`DD_TAGS`	Your comma-separated custom tags. For example, `key1:value1,key2:value2`.

Add Service Label in the info panel. Tag your GCP entity with the service label to correlate your traces with your service:
Add the same value from DD_SERVICE to a service label on your cloud function, inside the info panel of your function.
Name Value
service The name of your service matching the DD_SERVICE env var.
For more information on how to add labels, see Google Cloud’s Configure labels for services documentation.

Name	Value
`service`	The name of your service matching the `DD_SERVICE` env var.

Example Functions

The following example contains a sample function with tracing and metrics set up.

# Example of a simple Cloud Run Function with traces and custom metrics
import functions_framework
import ddtrace
from datadog import initialize, statsd

ddtrace.patch(logging=True)
initialize(**{'statsd_port': 8125})

@ddtrace.tracer.wrap()
@functions_framework.http
def dd_log_forwader(request):
   with ddtrace.tracer.trace('sending_trace') as span:
      span.set_tag('test', 'ninja')
      statsd.increment('dd.function.sent', tags=["runtime:python"])
   return "Welcome To Datadog! 💜"

// Example of a simple Cloud Run Function with traces and custom metrics
package com.example;

import com.google.cloud.functions.HttpFunction;
import com.google.cloud.functions.HttpRequest;
import com.google.cloud.functions.HttpResponse;
import java.io.BufferedWriter;
import com.timgroup.statsd.NonBlockingStatsDClientBuilder;
import com.timgroup.statsd.StatsDClient;

public class Example implements HttpFunction {
  @Override
  public void service(HttpRequest request, HttpResponse response) throws Exception {
    StatsDClient Statsd = new NonBlockingStatsDClientBuilder()
            .hostname("localhost")
            .port(8125)
            .build();
    BufferedWriter writer = response.getWriter();
    Statsd.incrementCounter("dd.function.sent", new String[]{"runtime:java"});
    writer.write("Welcome to Datadog!");
  }
}

You can also install the tracer using the following Maven dependency:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>cloudfunctions</groupId>
    <artifactId>http-function</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.release>17</maven.compiler.release>
    </properties>

    <dependencies>
        <dependency>
            <groupId>com.google.cloud.functions</groupId>
            <artifactId>functions-framework-api</artifactId>
            <version>1.0.1</version>
        </dependency>
        <dependency>
            <groupId>com.datadoghq</groupId>
            <artifactId>java-dogstatsd-client</artifactId>
            <version>4.4.3</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <excludes>
                        <exclude>.google/</exclude>
                    </excludes>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-antrun-plugin</artifactId>
                <version>1.8</version>
                <executions>
                    <execution>
                        <phase>initialize</phase>
                        <configuration>
                            <tasks>
                                <get src="https://dtdg.co/latest-serverless-compat-java-agent" dest="dd-serverless-compat-java-agent.jar" />
                                <get src="https://dtdg.co/latest-java-tracer" dest="dd-java-agent.jar" />
                            </tasks>
                        </configuration>
                        <goals>
                            <goal>run</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            
        </plugins>
    </build>
</project>

What’s next?

You can view your Cloud Run Functions traces in Trace Explorer. Search for the service name you set in the DD_SERVICE environment variable to see your traces.
You can use the Serverless > Cloud Run Functions page to see your traces enriched with telemetry collected by the Google Cloud integration.

Enable/disable trace metrics

Trace metrics are enabled by default. To configure trace metrics, use the following environment variable:

DD_TRACE_STATS_COMPUTATION_ENABLED: Enables (true) or disables (false) trace metrics. Defaults to true.
Values: true, false

Troubleshooting

Enable debug logs

You can collect debug logs for troubleshooting. To configure debug logs, use the following environment variables:

DD_TRACE_DEBUG: Enables (true) or disables (false) debug logging for the Datadog Tracing Library. Defaults to false.
Values: true, false
DD_LOG_LEVEL: Sets logging level for the Datadog Serverless Compatibility Layer. Defaults to info.
Values: trace, debug, info, warn, error, critical, off