Configuración de Code Coverage

Este producto no es compatible con el sitio Datadog seleccionado. ().

Resumen

Puedes configurar el comportamiento de Code Coverage creando un archivo de configuración llamado code-coverage.datadog.yml o code-coverage.datadog.yaml en la raíz de tu repositorio.

Ejemplo de archivo de configuración:

schema-version: v1
services:
  - id: frontend
    paths:
      - frontend/
      - shared/ui/**
  - id: backend-api
    paths:
      - backend/api/**
      - backend/.*\.go
ignore:
  - "test/**/*"
  - "**/*.pb.go"
gates:
  - type: total_coverage_percentage
    config:
      threshold: 85
  - type: patch_coverage_percentage
    config:
      threshold: 95

Configuración de servicios

Usar Integración del Software Catalog es el enfoque recomendado para definir servicios, ya que las ubicaciones de código configuradas en el Software Catalog pueden ser utilizadas por múltiples productos de Datadog. Utiliza la configuración manual solo cuando la integración del Software Catalog no esté disponible.

Puedes definir servicios en tu archivo de configuración para dividir los datos de cobertura por servicio en monorepos. Esto es útil cuando múltiples proyectos o equipos comparten un solo repositorio y deseas ver las métricas de cobertura para cada servicio de manera independiente.

schema-version: v1
services:
  - id: frontend
    paths:
      - frontend/**
      - shared/ui/**
  - id: backend-api
    paths:
      - backend/api/**
  • schema-version (requerido): Debe ser v1
  • services: Lista de definiciones de servicio
    • id (requerido): Identificador único para el servicio
    • paths (requerido): Lista de patrones de ruta que pertenecen a este servicio (ver Sintaxis de patrones )

Para detalles completos sobre el soporte de monorepo, incluyendo la integración del Software Catalog y la división basada en propietarios de código, consulta Soporte de Monorepo.

Ejemplos

code-coverage.datadog.yml

schema-version: v1
services:
  - id: web-app
    paths:
      - packages/web/**
      - packages/shared/ui/**
  - id: mobile-app
    paths:
      - packages/mobile/**
      - packages/shared/core/**
  - id: admin-dashboard
    paths:
      - packages/admin/**

code-coverage.datadog.yml

schema-version: v1
services:
  - id: backend-service
    paths:
      - services/backend/**
      - services/backend/.*\.go
  - id: frontend-web
    paths:
      - services/frontend/**
      - services/frontend/.*\.(ts|tsx)
  - id: data-processing
    paths:
      - services/data/**
      - scripts/.*\.py

Ignorando rutas

Puedes excluir archivos o directorios específicos del informe de cobertura de código utilizando el campo ignore. Esto es útil para excluir archivos de prueba, código generado, dependencias de proveedores y otros archivos que no deberían incluirse en las métricas de cobertura. Los patrones de ruta soportan glob, regex y coincidencias de prefijo (ver Sintaxis de patrones).

ignore:
  - "test/**/*"           # Exclude all files in test directory
  - "*.pb.go"             # Exclude all protobuf generated files
  - "vendor/"             # Exclude vendor directory

Excepciones

Agrega ! antes de un patrón para crear una excepción a tus reglas de exclusión. Esto te permite incluir archivos o carpetas específicos que de otro modo serían excluidos.

ignore:
  - "generated/"          # Ignore all generated code
  - "!generated/core/"    # Except core generated files

Importante: Los patrones negativos tienen prioridad sobre los patrones positivos. Si algún patrón negativo coincide con una ruta de archivo, esa ruta no es ignorada.

Ejemplos

ignore:
  - "**/*_test.go"        # Exclude Go test files
  - "**/*.pb.go"          # Exclude protobuf files
  - "vendor/"             # Exclude vendor directory
  - "mocks/"              # Exclude mock files
ignore:
  - "generated/"          # Ignore all generated code
  - "!generated/core/"    # Except core generated files
  - "test/"               # Ignore test directory
  - "!test/integration/"  # Except integration tests
ignore:
  - "^vendor/.*"          # Regex: exclude vendor (anchored)
  - "**/*.min.js"         # Glob: exclude minified JS files
  - "dist/"               # Prefix: exclude dist directory
  - ".*\\.pb\\.go$"       # Regex: exclude protobuf files

Puertas de PR

Puedes definir Puertas de PR en el archivo de configuración para hacer cumplir los umbrales de cobertura de código en las solicitudes de extracción. Si las puertas también están configuradas en el Datadog UI, Datadog evalúa tanto las reglas del archivo de configuración como las reglas del [Datadog UI] cuando se abre o actualiza una PR.

Si tanto el archivo de configuración como el [Datadog UI] definen puertas para el mismo alcance, la solicitud de extracción debe cumplir con cada umbral definido.
gates:
  - type: total_coverage_percentage
    config:
      threshold: 85

  - type: patch_coverage_percentage
    config:
      threshold: 95

Cada puerta tiene los siguientes campos:

  • type (requerido): El tipo de puerta de cobertura. Valores admitidos:
    • total_coverage_percentage: El porcentaje mínimo de cobertura general para el repositorio (o para los servicios o propietarios de código específicos).
    • patch_coverage_percentage: El porcentaje mínimo de cobertura en el código cambiado en la solicitud de extracción.
  • config (requerido): Opciones de configuración de la puerta. Valores admitidos:
    • threshold (requerido): El porcentaje mínimo de cobertura (0-100).
    • services: (opcional) Una lista de patrones de nombres de servicio para limitar la puerta. Utiliza * como un comodín. Prefija un valor con ! para excluir servicios coincidentes. Cuando se establece, la cobertura se evalúa por separado para cada servicio coincidente.
    • codeowners: (opcional) Una lista de patrones de propietarios de código para limitar la puerta. Utiliza * como un comodín. Prefija un valor con ! para excluir propietarios de código coincidentes. Cuando se establece, la cobertura se evalúa por separado para cada propietario de código coincidente.
    • flags: (opcional) Una lista de patrones de nombres de flag para limitar la puerta. Utiliza * como un comodín. Prefija un valor con ! para excluir flags coincidentes. Cuando se establece, la cobertura se evalúa por separado para cada flag coincidente.

Ejemplos

code-coverage.datadog.yml

schema-version: v1
gates:
  - type: total_coverage_percentage
    config:
      threshold: 80

  - type: patch_coverage_percentage
    config:
      threshold: 90

code-coverage.datadog.yml

schema-version: v1
services:
  - id: backend-api
    paths:
      - backend/api/**
  - id: frontend-web
    paths:
      - frontend/**
gates:
  - type: patch_coverage_percentage
    config:
      threshold: 90
      services:
        - "*"

  - type: total_coverage_percentage
    config:
      threshold: 85
      services:
        - "backend-api"

code-coverage.datadog.yml

schema-version: v1
gates:
  - type: patch_coverage_percentage
    config:
      threshold: 95
      codeowners:
        - "@DataDog/backend-team"
        - "@DataDog/api-*"

  - type: total_coverage_percentage
    config:
      threshold: 80
      codeowners:
        - "@DataDog/frontend-team"

code-coverage.datadog.yml

schema-version: v1
gates:
  - type: total_coverage_percentage
    config:
      threshold: 80
      flags:
        - "unit-tests"

  - type: patch_coverage_percentage
    config:
      threshold: 90
      flags:
        - "integration-tests"

Utiliza el prefijo ! para excluir servicios específicos, propietarios de código o flags de una puerta. Por ejemplo, para hacer cumplir la cobertura en todos los servicios excepto los experimentales, y en todos los flags excepto las pruebas nocturnas:

code-coverage.datadog.yml

schema-version: v1
gates:
  - type: total_coverage_percentage
    config:
      threshold: 80
      services:
        - "*"
        - "!experimental-*"

  - type: patch_coverage_percentage
    config:
      threshold: 90
      flags:
        - "*"
        - "!nightly-*"

Sintaxis de patrones

Las opciones de configuración que aceptan rutas de archivo admiten tres tipos de patrones:

  • regex
  • glob
  • path_prefix

El tipo de patrón se detecta automáticamente según la sintaxis que utilices.

Patrones de expresiones regulares

Los patrones que contienen caracteres específicos de regex (+, {, }, |, (, ), ^, $, \) se tratan como expresiones regulares:

  • ".*\\.pb\\.go$" - Coincide con archivos que terminan en .pb.go
  • "^generated/.*" - Coincide con archivos en el directorio generado
  • ".*_test\\.go$" - Coincide con archivos de prueba

Nota: Los patrones de regex se anclan automáticamente con ^...$ para coincidencias de ruta completa. Utiliza barras diagonales (/) como separadores de ruta en patrones de regex.

Patrones glob

Los patrones que contienen caracteres específicos de glob (*, ?, [, ]) se tratan como patrones glob:

  • "**/*.java" - Coincide con todos los archivos Java
  • "src/test/**/*" - Coincide con todos los archivos en src/test
  • "*.pb.go" - Coincide con archivos protobuf en cualquier directorio

Nota: Usa ** para coincidir con directorios de manera recursiva. El patrón folder/* coincide solo con los hijos directos, mientras que folder/**/* coincide con todos los descendientes.

Patrones de prefijo

Los prefijos de ruta simples sin caracteres especiales se tratan como coincidencias de prefijo:

  • "vendor/" - Coincide con todos los archivos en el directorio vendor
  • "third_party/" - Coincide con código de terceros
  • "generated/" - Coincide con código generado

Lectura adicional.