Airflow

Supported OS Linux Mac OS Windows

Intégrationv3.1.0

Présentation

L’Agent Datadog recueille de nombreuses métriques à partir d’Airflow, notamment pour :

  • Les DAG (Directed Acyclic Graphs, ou graphes orientés acycliques) : nombre de processus DAG, taille des dagbags, etc.
  • Les tâches : tâches non réussies, réussies, arrêtées, etc.
  • Les pools : emplacements libres, emplacements utilisés, etc.
  • Les exécuteurs : emplacements libres, tâches en attente, tâches en cours d’exécution, etc.

Les métriques sont recueillies via le plugin StatsD pour Airflow puis envoyées à Datadog DogStatsD.

En plus des métriques, l’Agent Datadog envoie également des checks de service liés à l’état de santé d’Airflow.

Configuration

Installation

Les étapes ci-dessous sont toutes nécessaires pour faire fonctionner l’intégration Airflow. Avant de commencer, installez l’Agent Datadog version >=6.17 ou >=7.17 pour bénéficier de la fonctionnalité de mappage StatsD/DogStatsD.

Configuration

L’intégration Airflow se présente sous deux formes. Il y a d’abord l’intégration de l’Agent Datadog, qui effectue des requêtes vers un endpoint spécifié pour permettre à Airflow de signaler s’il peut établir une connexion et s’il est fonctionnel. Puis il y a la portion StatsD pour Airflow, grâce à laquelle il est possible de configurer Airflow de façon à envoyer des métriques à l’Agent Datadog, qui peut alors remapper la notation Airflow vers une notation Datadog.

Host

Configurer l’intégration Airflow de l’Agent Datadog

Configurez le check Airflow inclus avec le package de l’Agent Datadog pour recueillir ses métriques de santé et ses checks de service. Pour ce faire, modifiez le paramètre url du fichier airflow.d/conf.yaml dans le dossier conf.d/ à la racine du répertoire de configuration de votre Agent pour commencer à recueillir vos checks de service Airflow. Consultez le fichier d’exemple airflow.d/conf.yaml pour découvrir toutes les options de configuration disponibles.

Vérifiez que le paramètre url possède la même valeur que le paramètre base_url du serveur Web d’Airflow (l’URL permettant de se connecter à votre instance Airflow).

Connecter Airflow à DogStatsD

Connectez Airflow à DogStatsD (inclus avec l’Agent Datadog) via la fonctionnalité statsd pour recueillir des métriques. Pour en savoir plus sur les métriques transmises par la version d’Airflow utilisée et sur les options de configuration supplémentaires, consultez la documentation Airflow ci-dessous :

Remarque : les métriques StatsD transmises par Airflow peuvent varier en fonction de l’exécuteur Airflow utilisé. Par exemple, les métriques airflow.ti_failures/successes, airflow.operator_failures/successes et airflow.dag.task.duration ne sont pas transmises pour KubernetesExecutor.

  1. Installez le plugin StatsD pour Airflow.

    pip install 'apache-airflow[statsd]'
    
  2. Modifiez le fichier de configuration airflow.cfg d’Airflow pour y ajouter les paramètres suivants :

    [scheduler]
    statsd_on = True
    statsd_host = localhost  # Hostname or IP of server running the Datadog Agent
    statsd_port = 8125       # DogStatsD port configured in the Datadog Agent
    statsd_prefix = airflow
    
  3. Modifiez le fichier de configuration principal de l’Agent Datadog datadog.yaml pour y ajouter les paramètres suivants :

    # dogstatsd_mapper_cache_size: 1000  # default to 1000
    dogstatsd_mapper_profiles:
      - name: airflow
        prefix: "airflow."
        mappings:
          - match: "airflow.*_start"
            name: "airflow.job.start"
            tags:
              job_name: "$1"
          - match: "airflow.*_end"
            name: "airflow.job.end"
            tags:
              job_name: "$1"
          - match: "airflow.*_heartbeat_failure"
            name: airflow.job.heartbeat.failure
            tags:
              job_name: "$1"
          - match: "airflow.operator_failures_*"
            name: "airflow.operator_failures"
            tags:
              operator_name: "$1"
          - match: "airflow.operator_successes_*"
            name: "airflow.operator_successes"
            tags:
              operator_name: "$1"
          - match: 'airflow\.dag_processing\.last_runtime\.(.*)'
            match_type: "regex"
            name: "airflow.dag_processing.last_runtime"
            tags:
              dag_file: "$1"
          - match: 'airflow\.dag_processing\.last_run\.seconds_ago\.(.*)'
            match_type: "regex"
            name: "airflow.dag_processing.last_run.seconds_ago"
            tags:
              dag_file: "$1"
          - match: 'airflow\.dag\.loading-duration\.(.*)'
            match_type: "regex"
            name: "airflow.dag.loading_duration"
            tags:
              dag_file: "$1"
          - match: "airflow.dagrun.*.first_task_scheduling_delay"
            name: "airflow.dagrun.first_task_scheduling_delay"
            tags:
              dag_id: "$1"
          - match: "airflow.pool.open_slots.*"
            name: "airflow.pool.open_slots"
            tags:
              pool_name: "$1"
          - match: "pool.queued_slots.*"
            name: "airflow.pool.queued_slots"
            tags:
              pool_name: "$1"
          - match: "pool.running_slots.*"
            name: "airflow.pool.running_slots"
            tags:
              pool_name: "$1"
          - match: "airflow.pool.used_slots.*"
            name: "airflow.pool.used_slots"
            tags:
              pool_name: "$1"
          - match: "airflow.pool.starving_tasks.*"
            name: "airflow.pool.starving_tasks"
            tags:
              pool_name: "$1"
          - match: 'airflow\.dagrun\.dependency-check\.(.*)'
            match_type: "regex"
            name: "airflow.dagrun.dependency_check"
            tags:
              dag_id: "$1"
          - match: 'airflow\.dag\.(.*)\.([^.]*)\.duration'
            match_type: "regex"
            name: "airflow.dag.task.duration"
            tags:
              dag_id: "$1"
              task_id: "$2"
          - match: 'airflow\.dag_processing\.last_duration\.(.*)'
            match_type: "regex"
            name: "airflow.dag_processing.last_duration"
            tags:
              dag_file: "$1"
          - match: 'airflow\.dagrun\.duration\.success\.(.*)'
            match_type: "regex"
            name: "airflow.dagrun.duration.success"
            tags:
              dag_id: "$1"
          - match: 'airflow\.dagrun\.duration\.failed\.(.*)'
            match_type: "regex"
            name: "airflow.dagrun.duration.failed"
            tags:
              dag_id: "$1"
          - match: 'airflow\.dagrun\.schedule_delay\.(.*)'
            match_type: "regex"
            name: "airflow.dagrun.schedule_delay"
            tags:
              dag_id: "$1"
          - match: 'scheduler.tasks.running'
            name: "airflow.scheduler.tasks.running"
          - match: 'scheduler.tasks.starving'
            name: "airflow.scheduler.tasks.starving"
          - match: sla_email_notification_failure
            name: 'airflow.sla_email_notification_failure'
          - match: 'airflow\.task_removed_from_dag\.(.*)'
            match_type: "regex"
            name: "airflow.dag.task_removed"
            tags:
              dag_id: "$1"
          - match: 'airflow\.task_restored_to_dag\.(.*)'
            match_type: "regex"
            name: "airflow.dag.task_restored"
            tags:
              dag_id: "$1"
          - match: "airflow.task_instance_created-*"
            name: "airflow.task.instance_created"
            tags:
              task_class: "$1"
          - match: "ti.start.*.*"
            name: "airflow.ti.start"
            tags:
              dagid: "$1"
              taskid: "$2"
          - match: "ti.finish.*.*.*"
            name: "airflow.ti.finish"
            tags:
              dagid: "$1"
              taskid: "$2"
              state: "$3"
    
Redémarrer l’Agent Datadog et Airflow
  1. Redémarrez l’Agent.
  2. Redémarrez Airflow pour commencer à envoyer vos métriques Airflow à l’endpoint DogStatsD de l’Agent Datadog.
Checks de service de l’intégration

Utilisez la configuration par défaut de votre fichier airflow.d/conf.yaml pour activer vos checks de service Airflow. Consultez le fichier d’exemple airflow.d/conf.yaml pour découvrir toutes les options de configuration disponibles.

Collecte de logs

Disponible à partir des versions > 6.0 de l’Agent

  1. La collecte de logs est désactivée par défaut dans l’Agent Datadog. Vous devez l’activer dans datadog.yaml :

    logs_enabled: true
    
  2. Supprimez la mise en commentaire du bloc de configuration suivant en bas de votre fichier airflow.d/conf.yaml, puis modifiez-le : Modifiez les valeurs des paramètres path et service et configurez-les pour votre environnement.

    • Configuration des logs pour le planificateur et le gestionnaire de processeurs DAG :

      logs:
        - type: file
          path: "<PATH_TO_AIRFLOW>/logs/dag_processor_manager/dag_processor_manager.log"
          source: airflow
          log_processing_rules:
            - type: multi_line
              name: new_log_start_with_date
              pattern: \[\d{4}\-\d{2}\-\d{2}
        - type: file
          path: "<PATH_TO_AIRFLOW>/logs/scheduler/latest/*.log"
          source: airflow
          log_processing_rules:
            - type: multi_line
              name: new_log_start_with_date
              pattern: \[\d{4}\-\d{2}\-\d{2}
      

      Il est conseillé d’effectuer un nettoyage régulier des logs du planificateur, en réalisant une rotation quotidienne des logs.

    • Configuration supplémentaire pour les logs des tâches DAG :

      logs:
        - type: file
          path: "<PATH_TO_AIRFLOW>/logs/!(scheduler)/*/*.log"
          source: airflow
          log_processing_rules:
            - type: multi_line
              name: new_log_start_with_date
              pattern: \[\d{4}\-\d{2}\-\d{2}
      

      Attention : par défaut, Airflow utilise le modèle de fichier de log suivant pour les tâches : log_filename_template = {{ ti.dag_id }}/{{ ti.task_id }}/{{ ts }}/{{ try_number }}.log. Le nombre de logs augmentera considérablement si vous n’effectuez pas un nettoyage régulier. Ce modèle est utilisé par l’interface d’Airflow pour afficher tous les logs de chaque tâche exécutée.

      Si vous ne consultez pas vos logs depuis l’interface Airflow, nous vous conseillons plutôt d’utiliser la configuration suivante dans airflow.cfg : log_filename_template = dag_tasks.log. Effectuez ensuite une rotation des logs de ce fichier et utilisez cette configuration :

      logs:
        - type: file
          path: "<PATH_TO_AIRFLOW>/logs/dag_tasks.log"
          source: airflow
          log_processing_rules:
            - type: multi_line
              name: new_log_start_with_date
              pattern: \[\d{4}\-\d{2}\-\d{2}
      
  3. Redémarrez l’Agent.

Environnement conteneurisé

Configurer l’intégration Airflow de l’Agent Datadog

Consultez la documentation relative aux modèles d’intégration Autodiscovery pour découvrir comment appliquer les paramètres ci-dessous à un environnement conteneurisé.

ParamètreValeur
<NOM_INTÉGRATION>airflow
<CONFIG_INIT>vide ou {}
<CONFIG_INSTANCE>{"url": "http://%%host%%:8080"}

Vérifiez que le paramètre url possède la même valeur que le paramètre base_url du serveur Web d’Airflow (l’URL permettant de se connecter à votre instance Airflow). Remplacez localhost par la template variable %%host%%.

Connecter Airflow à DogStatsD

Connectez Airflow à DogStatsD (inclus avec l’Agent Datadog) via la fonctionnalité statsd pour recueillir des métriques. Pour en savoir plus sur les métriques transmises par la version d’Airflow utilisée et sur les options de configuration supplémentaires, consultez la documentation Airflow ci-dessous :

Remarque : les métriques StatsD transmises par Airflow peuvent varier en fonction de l’exécuteur Airflow utilisé. Par exemple, les métriques airflow.ti_failures/successes, airflow.operator_failures/successes, airflow.dag.task.duration ne sont pas transmises pour KubernetesExecutor.

Remarque : les variables d’environnement utilisées pour Airflow peuvent varier d’une version à l’autre. Par exemple, Airflow 2.0.0 utilise la variable d’environnement AIRFLOW__METRICS__STATSD_HOST, tandis qu’Airflow 1.10.15 utilise AIRFLOW__SCHEDULER__STATSD_HOST.

La configuration de StatsD pour Airflow peut être activée avec les variables d’environnement suivantes dans un déploiement Kubernetes :

env:
  - name: AIRFLOW__SCHEDULER__STATSD_ON
    value: "True"
  - name: AIRFLOW__SCHEDULER__STATSD_PORT
    value: "8125"
  - name: AIRFLOW__SCHEDULER__STATSD_PREFIX
    value: "airflow"
  - name: AIRFLOW__SCHEDULER__STATSD_HOST
    valueFrom:
      fieldRef:
        fieldPath: status.hostIP

La variable d’environnement pour l’endpoint de host AIRFLOW__SCHEDULER__STATSD_HOST est fournie avec l’adresse IP du host du nœud pour acheminer les données StatsD au pod de l’Agent Datadog sur le même nœud que le pod Airflow. Cette configuration nécessite également que l’Agent dispose d’un hostPort ouvert pour ce port 8125 et accepte le trafic StatsD non local. Pour en savoir plus, consultez la section sur la configuration de DogStatsD sur Kubernetes.

Cette configuration doit rediriger le trafic StatsD provenant du conteneur Airflow vers un Agent Datadog prêt à accepter les données entrantes. La dernière étape consiste à mettre à jour l’Agent Datadog avec les dogstatsd_mapper_profiles correspondants. Pour ce faire, copiez les dogstatsd_mapper_profiles fournis dans l’installation de host dans votre fichier datadog.yaml. Vous pouvez également déployer votre Agent Datadog avec la configuration JSON équivalente dans la variable d’environnement DD_DOGSTATSD_MAPPER_PROFILES. Pour Kubernetes, la notation de variable d’environnement équivalente est la suivante :

env: 
  - name: DD_DOGSTATSD_MAPPER_PROFILES
    value: >
            [{"prefix":"airflow.","name":"airflow","mappings":[{"name":"airflow.job.start","match":"airflow.*_start","tags":{"job_name":"$1"}},{"name":"airflow.job.end","match":"airflow.*_end","tags":{"job_name":"$1"}},{"name":"airflow.job.heartbeat.failure","match":"airflow.*_heartbeat_failure","tags":{"job_name":"$1"}},{"name":"airflow.operator_failures","match":"airflow.operator_failures_*","tags":{"operator_name":"$1"}},{"name":"airflow.operator_successes","match":"airflow.operator_successes_*","tags":{"operator_name":"$1"}},{"match_type":"regex","name":"airflow.dag_processing.last_runtime","match":"airflow\\.dag_processing\\.last_runtime\\.(.*)","tags":{"dag_file":"$1"}},{"match_type":"regex","name":"airflow.dag_processing.last_run.seconds_ago","match":"airflow\\.dag_processing\\.last_run\\.seconds_ago\\.(.*)","tags":{"dag_file":"$1"}},{"match_type":"regex","name":"airflow.dag.loading_duration","match":"airflow\\.dag\\.loading-duration\\.(.*)","tags":{"dag_file":"$1"}},{"name":"airflow.dagrun.first_task_scheduling_delay","match":"airflow.dagrun.*.first_task_scheduling_delay","tags":{"dag_id":"$1"}},{"name":"airflow.pool.open_slots","match":"airflow.pool.open_slots.*","tags":{"pool_name":"$1"}},{"name":"airflow.pool.queued_slots","match":"pool.queued_slots.*","tags":{"pool_name":"$1"}},{"name":"airflow.pool.running_slots","match":"pool.running_slots.*","tags":{"pool_name":"$1"}},{"name":"airflow.pool.used_slots","match":"airflow.pool.used_slots.*","tags":{"pool_name":"$1"}},{"name":"airflow.pool.starving_tasks","match":"airflow.pool.starving_tasks.*","tags":{"pool_name":"$1"}},{"match_type":"regex","name":"airflow.dagrun.dependency_check","match":"airflow\\.dagrun\\.dependency-check\\.(.*)","tags":{"dag_id":"$1"}},{"match_type":"regex","name":"airflow.dag.task.duration","match":"airflow\\.dag\\.(.*)\\.([^.]*)\\.duration","tags":{"dag_id":"$1","task_id":"$2"}},{"match_type":"regex","name":"airflow.dag_processing.last_duration","match":"airflow\\.dag_processing\\.last_duration\\.(.*)","tags":{"dag_file":"$1"}},{"match_type":"regex","name":"airflow.dagrun.duration.success","match":"airflow\\.dagrun\\.duration\\.success\\.(.*)","tags":{"dag_id":"$1"}},{"match_type":"regex","name":"airflow.dagrun.duration.failed","match":"airflow\\.dagrun\\.duration\\.failed\\.(.*)","tags":{"dag_id":"$1"}},{"match_type":"regex","name":"airflow.dagrun.schedule_delay","match":"airflow\\.dagrun\\.schedule_delay\\.(.*)","tags":{"dag_id":"$1"}},{"name":"airflow.scheduler.tasks.running","match":"scheduler.tasks.running"},{"name":"airflow.scheduler.tasks.starving","match":"scheduler.tasks.starving"},{"name":"airflow.sla_email_notification_failure","match":"sla_email_notification_failure"},{"match_type":"regex","name":"airflow.dag.task_removed","match":"airflow\\.task_removed_from_dag\\.(.*)","tags":{"dag_id":"$1"}},{"match_type":"regex","name":"airflow.dag.task_restored","match":"airflow\\.task_restored_to_dag\\.(.*)","tags":{"dag_id":"$1"}},{"name":"airflow.task.instance_created","match":"airflow.task_instance_created-*","tags":{"task_class":"$1"}},{"name":"airflow.ti.start","match":"ti.start.*.*","tags":{"dagid":"$1","taskid":"$2"}},{"name":"airflow.ti.finish","match":"ti.finish.*.*.*","tags":{"dagid":"$1","state":"$3","taskid":"$2"}}]}]

Consultez le référentiel integrations-core Datadog pour découvrir un exemple de configuration.

Collecte de logs

Disponible à partir des versions > 6.0 de l’Agent

La collecte des logs est désactivée par défaut dans l’Agent Datadog. Pour l’activer, consultez la section Collecte de logs avec Kubernetes.

ParamètreValeur
<CONFIG_LOG>{"source": "airflow", "service": "<NOM_APPLICATION>"}

Validation

Lancez la sous-commande status de l’Agent et cherchez airflow dans la section Checks.

Annexe

Hook Datadog pour Airflow

Un hook Datadog pour Airflow peut également être utilisé pour interagir avec Datadog :

  • Envoyer des métriques
  • Interroger des métriques
  • Envoyer des événements

Données collectées

Métriques

airflow.can_connect
(count)
1 if can connect to Airflow, otherwise 0
airflow.collect_db_dags
(gauge)
Milliseconds taken for fetching all Serialized Dags from DB
Shown as millisecond
airflow.healthy
(count)
1 if Airflow is healthy, otherwise 0
airflow.job.start
(count)
Number of started <job_name> job, ex. SchedulerJob, LocalTaskJob
Shown as job
airflow.job.end
(count)
Number of ended <job_name> job, ex. SchedulerJob, LocalTaskJob
Shown as job
airflow.job.heartbeat.failure
(count)
Number of failed Heartbeats for a <job_name> job, ex. SchedulerJob, LocalTaskJob
Shown as error
airflow.operator_failures
(count)
Operator <operator_name> failures
airflow.operator_successes
(count)
Operator <operator_name> successes
airflow.ti_failures
(count)
Overall task instances failures
Shown as task
airflow.ti_successes
(count)
Overall task instances successes
Shown as task
airflow.previously_succeeded
(count)
Number of previously succeeded task instances
Shown as task
airflow.zombies_killed
(count)
Zombie tasks killed
Shown as task
airflow.scheduler_heartbeat
(count)
Scheduler heartbeats
airflow.dag_processing.processes
(count)
Number of currently running DAG parsing processes
airflow.dag_processing.manager_stalls
(count)
Number of stalled DagFileProcessorManager
airflow.dag_file_refresh_error
(count)
Number of failures loading any DAG files
Shown as error
airflow.scheduler.critical_section_duration
(gauge)
Milliseconds spent in the critical section of scheduler loop -- only a single scheduler can enter this loop at a time
Shown as millisecond
airflow.scheduler.tasks.killed_externally
(count)
Number of tasks killed externally
Shown as task
airflow.scheduler.orphaned_tasks.cleared
(count)
Number of Orphaned tasks cleared by the Scheduler
Shown as task
airflow.scheduler.orphaned_tasks.adopted
(count)
Number of Orphaned tasks adopted by the Scheduler
Shown as task
airflow.scheduler.critical_section_busy
(count)
Count of times a scheduler process tried to get a lock on the critical section (needed to send tasks to the executor) and found it locked by another process.
Shown as operation
airflow.scheduler.tasks.running
(count)
Number of tasks running in executor
Shown as task
airflow.scheduler.tasks.starving
(count)
Number of tasks that cannot be scheduled because of no open slot in pool
Shown as task
airflow.dagbag_size
(gauge)
DAG bag size
airflow.dag_processing.import_errors
(gauge)
Number of errors from trying to parse DAG files
Shown as error
airflow.dag_processing.total_parse_time
(gauge)
Seconds taken to scan and import all DAG files once
Shown as second
airflow.dag_processing.last_runtime
(gauge)
Seconds spent processing <dag_file> (in most recent iteration)
Shown as second
airflow.dag_processing.last_run.seconds_ago
(gauge)
Seconds since <dag_file> was last processed
Shown as second
airflow.dag_processing.processor_timeouts
(gauge)
Number of file processors that have been killed due to taking too long
airflow.executor.open_slots
(gauge)
Number of open slots on executor
airflow.executor.queued_tasks
(gauge)
Number of queued tasks on executor
Shown as task
airflow.executor.running_tasks
(gauge)
Number of running tasks on executor
Shown as task
airflow.pool.open_slots
(gauge)
Number of open slots in the pool
airflow.pool.queued_slots
(gauge)
Number of queued slots in the pool
airflow.pool.used_slots
(gauge)
Number of used slots in the pool
airflow.pool.running_slots
(gauge)
Number of running slots in the pool
airflow.pool.starving_tasks
(gauge)
Number of starving tasks in the pool
Shown as task
airflow.dagrun.dependency_check
(gauge)
Milliseconds taken to check DAG dependencies
Shown as millisecond
airflow.dag.task.duration
(gauge)
Milliseconds taken to finish a task
Shown as millisecond
airflow.dag_processing.last_duration
(gauge)
Milliseconds taken to load the given DAG file
Shown as millisecond
airflow.dagrun.duration.success
(gauge)
Milliseconds taken for a DagRun to reach success state
Shown as millisecond
airflow.dagrun.duration.failed
(gauge)
Milliseconds taken for a DagRun to reach failed state
Shown as millisecond
airflow.dagrun.schedule_delay
(gauge)
Milliseconds of delay between the scheduled DagRun start date and the actual DagRun start date
Shown as millisecond
airflow.dagrun.first_task_scheduling_delay
(gauge)
Milliseconds elapsed between first task start_date and dagrun expected start
Shown as millisecond
airflow.dag.loading_duration
(gauge)
DAG loading duration in seconds (deprecated)
Shown as second
airflow.dag.task_removed
(gauge)
Tasks removed from DAG
Shown as second
airflow.dag.task_restored
(gauge)
Tasks restored to DAG
Shown as second
airflow.sla_email_notification_failure
(count)
Number of failed SLA miss email notification attempts
Shown as task
airflow.task.instance_created
(gauge)
Task instances created
Shown as second
airflow.ti.start
(count)
Number of started task in a given dag.
Shown as task
airflow.ti.finish
(count)
Number of completed task in a given dag.
Shown as task
airflow.dag.callback_exceptions
(count)
Number of exceptions raised from DAG callbacks. When this happens, it means DAG callback is not working
Shown as error
airflow.celery.task_timeout_error
(count)
Number of AirflowTaskTimeout errors raised when publishing Task to Celery Broker.
Shown as error
airflow.task_removed_from_dag
(count)
Number of tasks removed for a given dag (i.e. task no longer exists in DAG)
Shown as task
airflow.task_restored_to_dag
(count)
Number of tasks restored for a given dag (i.e. task instance which was previously in REMOVED state in the DB is added to DAG file)
Shown as task
airflow.task_instance_created
(count)
Number of tasks instances created for a given Operator
Shown as task
airflow.scheduler.tasks.without_dagrun
(count)
Number of tasks without DagRuns or with DagRuns not in Running state
Shown as task
airflow.scheduler.tasks.executable
(count)
Number of tasks that are ready for execution (set to queued) with respect to pool limits, dag concurrency, executor state, and priority.
Shown as task
airflow.smart_sensor_operator.poked_tasks
(count)
Number of tasks poked by the smart sensor in the previous poking loop
Shown as task
airflow.smart_sensor_operator.poked_success
(count)
Number of newly succeeded tasks poked by the smart sensor in the previous poking loop
Shown as task
airflow.smart_sensor_operator.poked_exception
(count)
Number of exceptions in the previous smart sensor poking loop
Shown as error
airflow.smart_sensor_operator.exception_failures
(count)
Number of failures caused by exception in the previous smart sensor poking loop
Shown as error
airflow.smart_sensor_operator.infra_failures
(count)
Number of infrastructure failures in the previous smart sensor poking loop
Shown as error

Événements

Le check Airflow n’inclut aucun événement.

Checks de service

airflow.can_connect
Returns CRITICAL if unable to connect to Airflow. Returns OK otherwise.
Statuses: ok, critical

airflow.healthy
Returns CRITICAL if Airflow is not healthy. Returns OK otherwise.
Statuses: ok, critical

Dépannage

Besoin d’aide ? Contactez l’assistance Datadog.