Instrumentación de una función de Cloud Run en Python

Documentación > Serverless > Google Cloud Run > Instrumentación de funciones de Cloud Run > Instrumentación de una función de Cloud Run en Python

Una aplicación de muestra está disponible en GitHub.

Configuración

Instale el SDK de Python de Datadog.
Agregue ddtrace a su requirements.txt o pyproject.toml. Esto garantiza que el SDK se incluya en la imagen de su contenedor cuando se compile y se implemente. Puede encontrar la versión más reciente en PyPI:
requirements.txt
```
ddtrace==<VERSION>
```
Para obtener más información, consulte Trazas de aplicaciones Python.
Instale serverless-init como sidecar.
Setup
Install the Datadog CLI
npm install -g @datadog/datadog-ci @datadog/datadog-ci-plugin-cloud-run
Install the gcloud CLI and authenticate with gcloud auth login.
Configuration
Configure the Datadog site and Datadog API key, and define the service name to use in Datadog.
export DATADOG_SITE="<DATADOG_SITE>" export DD_API_KEY="<DD_API_KEY>" export DD_SERVICE="<SERVICE_NAME>"
Instrument
If you are new to Datadog serverless monitoring, launch the Datadog CLI in interactive mode to guide your first installation for a quick start.
datadog-ci cloud-run instrument -i
To set up the Datadog sidecar for your applications, run the instrument command after your normal deployment. You can specify multiple services to instrument by passing multiple --service flags.
datadog-ci cloud-run instrument --project <GCP-PROJECT-ID> --service <CLOUD-RUN-SERVICE-NAME> --region <GCP-REGION>
You can pin to a specific image with the --sidecar-image flag. See the latest releases on Docker Hub.
Additional parameters can be found in the CLI documentation.
The Datadog Terraform module for Google Cloud Run wraps the google_cloud_run_v2_service resource and automatically configures your Cloud Run app for Datadog Serverless Monitoring by adding required environment variables and the serverless-init sidecar.
If you don’t already have Terraform set up, install Terraform, create a new directory, and make a file called main.tf.
Then, add the following to your Terraform configuration, updating it as necessary based on your needs:
variable "datadog_api_key" { description = "Your Datadog API key" type = string sensitive = true } module "my-cloud-run-app" { source = "DataDog/cloud-run-datadog/google" version = "~> 1.0" project = "my-gcp-project" name = "my-cloud-run-app" location = "us-central1" datadog_api_key = var.datadog_api_key datadog_service = "test-service" // your application service datadog_version = "0.0.0" // your code version datadog_env = "prod" // your application environment datadog_enable_logging = true deletion_protection = false build_config = { function_target = "helloHttp" // your function entry point image_uri = "us-docker.pkg.dev/cloudrun/container/hello" base_image = "us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/your-runtime" // base image for your runtime enable_automatic_updates = true } template = { containers = [ { name = "main" image = "us-docker.pkg.dev/cloudrun/container/hello" base_image_uri = "us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/your-runtime" // base image for your runtime resources = { limits = { cpu = "1" memory = "512Mi" } } ports = { container_port = 8080 } env = [ { name = "DD_TRACE_ENABLED", value = "true" }, ] }, ] } }
See the Environment Variables for more information on the configuration options available through the env.
Ensure the container port for the main container is the same as the one exposed in your Dockerfile/service.
If you haven’t already, initialize your Terraform project:
terraform init
To deploy your app, run:
terraform apply
After deploying your Cloud Run app, you can manually modify your app’s settings to enable Datadog monitoring.
1. Create a Volume with In-Memory volume type.
2. Add a new container with image URL: gcr.io/datadoghq/serverless-init:<YOUR_TAG>. See the latest releases on Docker Hub to pin a specific version.
3. Add the volume mount to every container in your application. Choose a path such as /shared-volume, and remember it for the next step.
4. Add the following environment variables to your serverless-init sidecar container:
  DD_SERVICE: A name for your service. For example, gcr-sidecar-test.
  DD_ENV: A name for your environment. For example, dev.
  DD_SERVERLESS_LOG_PATH: Your log path. For example, /shared-volume/logs/*.log. The path must begin with the mount path you defined in the previous step.
  DD_API_KEY: Your Datadog API key.
  FUNCTION_TARGET: The entry point of your function. For example, Main.
  For a list of all environment variables, including additional tags, see Environment variables.
Configure los registros.
En el paso anterior, creó un volumen compartido. Es posible que también haya configurado la variable de entorno DD_SERVERLESS_LOG_PATH, que tiene como valor predeterminado /shared-volume/logs/app.log.
En este paso, configure su biblioteca de registro para escribir registros en el archivo establecido en DD_SERVERLESS_LOG_PATH. También puede establecer un formato personalizado para la correlación de registros/trazas y otras funciones. Datadog recomienda configurar las siguientes variables de entorno:
- PYTHONUNBUFFERED=1: En su contenedor principal. Asegúrese de que las salidas de Python aparezcan inmediatamente en los registros del contenedor en lugar de almacenarse en búfer.
- DD_LOGS_INJECTION=true: En su contenedor principal. Habilite la correlación de registros/trazas para los registradores compatibles.
- DD_SOURCE=python: En su contenedor sidecar. Habilite el parseo avanzado de registros de Datadog.
Luego, actualice su biblioteca de registro. Por ejemplo, puede usar la biblioteca nativa logging de Python:
```
LOG_FILE = "/shared-volume/logs/app.log"
os.makedirs(os.path.dirname(LOG_FILE), exist_ok=True)

FORMAT = ('%(asctime)s %(levelname)s [%(name)s] [%(filename)s:%(lineno)d] '
        '[dd.service=%(dd.service)s dd.env=%(dd.env)s dd.version=%(dd.version)s dd.trace_id=%(dd.trace_id)s dd.span_id=%(dd.span_id)s] '
        '- %(message)s')

logging.basicConfig(
    level=logging.INFO,
    format=FORMAT,
    handlers=[
        logging.FileHandler(LOG_FILE),
        logging.StreamHandler(sys.stdout)
    ]
)
logger = logging.getLogger(__name__)
logger.level = logging.INFO

logger.info('Hello world!')
```
Para obtener más información, consulte Correlación de registros y trazas de Python.
Add a service label in Google Cloud. In your Cloud Run service’s info panel, add a label with the following key and value:
Key Value
service The name of your service. Matches the value provided as the DD_SERVICE environment variable.
See Configure labels for services in the Cloud Run documentation for instructions.

Key	Value
`service`	The name of your service. Matches the value provided as the `DD_SERVICE` environment variable.

Enviar métricas personalizadas.
Para enviar métricas personalizadas, instale el cliente DogStatsD y vea ejemplos de código. En Serverless Monitoring, solo se admite el tipo de métrica distribution.
Habilite la generación de perfiles (vista previa).
Para habilitar el Continuous Profiler, establezca la variable de entorno DD_PROFILING_ENABLED=true en el contenedor de su aplicación y agregue import ddtrace.auto en la parte superior de su archivo de función:
```
import ddtrace.auto

# ... rest of your function code
```
El Continuous Profiler de Datadog está disponible en vista previa para las funciones de Cloud Run de segunda generación.

Environment variables

Variable	Description	Container
`DD_API_KEY`	Datadog API key - Required	Sidecar container
`DD_SITE`	Datadog site - Required	Sidecar container
`DD_SERVICE`	Datadog Service name. Required	Both containers
`DD_SERVERLESS_LOG_PATH`	The path where the sidecar should tail logs from. Recommended to set to `/shared-volume/logs/app.log`.	Sidecar container
`DD_LOGS_INJECTION`	When true, enrich all logs with trace data for supported loggers. See Correlate Logs and Traces for more information.	Application container
`DD_VERSION`	See Unified Service Tagging.	Both containers
`DD_ENV`	See Unified Service Tagging.	Both containers
`DD_SOURCE`	Set the log source to enable a Log Pipeline for advanced parsing. To automatically apply language-specific parsing rules, set to `python`, or use your custom pipeline. Defaults to `cloudrun`.	Sidecar container
`DD_TAGS`	Add custom tags to your logs, metrics, and traces. Tags should be comma separated in key/value format (for example: `key1:value1,key2:value2`).	Sidecar container
`FUNCTION_TARGET`	Required for correct tagging. The entry point of your function. For example, `Main`. You can also find `FUNCTION_TARGET` on the source tab inside Google console: `Function entry point`.	Sidecar container

Do not set the following environment variables in your serverless environment. They should only be set in non-serverless environments.

DD_AGENT_HOST
DD_TRACE_AGENT_URL

Seguimiento distribuido con Pub/Sub

Establezca DD_TRACE_INFERRED_PROXY_SERVICES_ENABLED=true en el contenedor de la aplicación. Esto crea un tramo gcp.pubsub.receive inferido para la solicitud push.

La traza de suscripciones push de Google Cloud Pub/Sub requiere la versión 4.8.0 o posterior de ddtrace.

To get end-to-end distributed traces between Pub/Sub producers and Cloud Run, configure your push subscriptions with the --push-no-wrapper and --push-no-wrapper-write-metadata flags. This moves message attributes from the JSON body to HTTP headers, allowing Datadog to extract producer trace context and create span links.

For more information, see Producer-aware tracing for Google Cloud Pub/Sub and Cloud Run and Payload unwrapping in the Google Cloud documentation.

Configure push subscriptions for full trace visibility

Create a new push subscription:

gcloud pubsub subscriptions create order-processor-sub \
  --topic=orders \
  --push-endpoint=https://order-processor-xyz.run.app/pubsub \
  --push-no-wrapper \
  --push-no-wrapper-write-metadata

Update an existing push subscription:

gcloud pubsub subscriptions update order-processor-sub \
  --push-no-wrapper \
  --push-no-wrapper-write-metadata

Configure Eventarc Pub/Sub triggers

Eventarc Pub/Sub triggers use push subscriptions as the underlying delivery mechanism. When you create an Eventarc trigger, GCP automatically creates a managed push subscription. However, Eventarc does not expose --push-no-wrapper-write-metadata as a trigger creation parameter, so you must manually update the auto-created subscription.

Create the Eventarc trigger:

gcloud eventarc triggers create order-processor-trigger \
  --destination-run-service=order-processor \
  --destination-run-region=us-central1 \
  --event-filters="type=google.cloud.pubsub.topic.v1.messagePublished" \
  --transport-topic=projects/my-project/topics/orders \
  --location=us-central1

Find the auto-created subscription:

gcloud pubsub subscriptions list \
  --filter="topic:projects/my-project/topics/orders" \
  --format="table(name,pushConfig.pushEndpoint)"

Example output:

NAME                                                          PUSH_ENDPOINT
eventarc-us-central1-order-processor-trigger-abc-sub-def      https://order-processor-xyz.run.app

Update the subscription for trace propagation:

gcloud pubsub subscriptions update \
  eventarc-us-central1-order-processor-trigger-abc-sub-def \
  --push-no-wrapper \
  --push-no-wrapper-write-metadata

Solución de problemas

This integration depends on your runtime having a full SSL implementation. If you are using a slim image, you may need to add the following command to your Dockerfile to include certificates:

RUN apt-get update && apt-get install -y ca-certificates

To have your Cloud Run services appear in the software catalog, you must set the DD_SERVICE, DD_VERSION, and DD_ENV environment variables.

Lecturas adicionales

Documentación, enlaces y artículos útiles adicionales:

Trazas de aplicaciones PythonDOCUMENTACIÓN

Correlación de registros y trazas de PythonDOCUMENTACIÓN

Instrumentación de una función de Cloud Run en Python

Configuración

Setup

Configuration

Instrument