Catchpoint

Présentation

Catchpoint est une plateforme d’analyse des performances numériques vous permettant d’optimiser les expériences client que vous offrez.

Associez Catchpoint à Datadog pour :

Configurer des alertes exhaustives dans votre flux d’événements
Créer des liens directs vers des tableaux d’analyse du portail Catchpoint
Ajouter des tags relatifs au type d’alerte afin de filtrer facilement les données

Configuration

Installation

Aucune installation n’est requise.

Procédure à suivre

Pour afficher des alertes Catchpoint dans votre flux, connectez-vous au portail Catchpoint et accédez à Settings -> API.

Sous Alerts API, sélectionnez Enable.
Saisissez l’URL de l’endpoint Datadog.
```
https://app.datadoghq.com/api/v1/events?api_key=<YOUR_DATADOG_API_KEY>
```
Vous pouvez créer votre clé d’API Datadog depuis le site Datadog.
Définissez Status sur Active.
Sélectionnez le format Template.
Ajoutez un nouveau modèle.
Saisissez le nom du modèle, par exemple DataDog, puis définissez son format sur JSON.
Utilisez le modèle JSON suivant, puis enregistrez-le :

{
    "title": "${TestName} [${TestId}] - ${switch(${notificationLevelId},'0','WARNING','1','CRITICAL','3','OK')}",
    "text": "${TestName} - http://portal.catchpoint.com/ui/Content/Charts/Performance.aspx?tList=${testId}&uts=${alertProcessingTimestampUtc}&z=&chartView=1",
    "priority": "normal",
    "tags": [
        "alertType:${Switch(${AlertTypeId},'0', 'Inconnu','2', 'Longueur d\'octet','3','Correspondance de contenu','4', 'Échec du host','7', 'Calcul du temps','9', 'Échec du test', '10','Information', '11','Échec JavaScript', '12', 'Ping',13, 'Requête')}"
    ],
    "alert_type": "${switch(${notificationLevelId},'0','warning','1','error','3','success')}",
    "source_type_name": "catchpoint"
}

Une fois la configuration terminée, Catchpoint envoie directement les alertes au flux d’événements dans Datadog.

Configuration de métriques

Dans le webhook de données de test, ajoutez l’endpoint de l’API Datadog avec la clé d’API.
Sélectionnez « Template ».
Cliquez sur « Add New » dans le menu déroulant.
Saisissez un nom.
Sélectionnez « JSON » comme format.
Copiez le modèle JSON suivant et cliquez sur Save.

{
  "series": [
    {
      "metric": "catchpoint.error.error",
      "points": [
        [
          "${timestampepoch}",
          "${if('${errorany}', 1, 0)}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}",
        "ErrorCode : ${errorcode}",
        "ErrorDescription : ${errorconnection}${errordns}${errorload}${errorloadobjects}${errorssl}${errorsystemlimit}${errortimeout}${errortransaction}"
      ],
      "type": "count"
    },
    {
      "metric": "catchpoint.frontend.client_time",
      "points": [
        [
          "${timestampepoch}",
          "${timingclient}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge",
      "unit": "millisecond"
    },
    {
      "metric": "catchpoint.network.tcp_connect_time",
      "points": [
        [
          "${timestampepoch}",
          "${timingconnect}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge",
      "unit": "millisecond"
    },
    {
      "metric": "catchpoint.frontend.content_load_time",
      "points": [
        [
          "${timestampepoch}",
          "${timingcontentload}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge",
      "unit": "millisecond"
    },
    {
      "metric": "catchpoint.network.dns_resolution_time",
      "points": [
        [
          "${timestampepoch}",
          "${timingdns}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge",
      "unit": "millisecond"
    },
    {
      "metric": "catchpoint.frontend.document_complete_time",
      "points": [
        [
          "${timestampepoch}",
          "${timingdocumentcomplete}",
          "TestUrl: ${testurl}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge",
      "unit": "millisecond"
    },
    {
      "metric": "catchpoint.frontend.dom_content_load_time",
      "points": [
        [
          "${timestampepoch}",
          "${timingdomcontentloadedevent}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge",
      "unit": "millisecond"
    },
    {
      "metric": "catchpoint.frontend.dom_interactive_time",
      "points": [
        [
          "${timestampepoch}",
          "${timingdominteractive}",
          "TestName: ${TestName}",
          "TestUrl: ${testurl}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}"
      ],
      "type": "gauge",
      "unit": "millisecond"
    },
    {
      "metric": "catchpoint.frontend.dom_load_time",
      "points": [
        [
          "${timestampepoch}",
          "${timingdomload}",
          "TestName: ${TestName}",
          "TestUrl: ${testurl}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}"
      ],
      "type": "gauge",
      "unit": "millisecond"
    },
    {
      "metric": "catchpoint.frontend.first_party_zone_impact",
      "points": [
        [
          "${timestampepoch}",
          "${timingimpactself}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge",
      "unit": "millisecond"
    },
    {
      "metric": "catchpoint.frontend.third_party_zone_impact",
      "points": [
        [
          "${timestampepoch}",
          "${timingimpactthirdparty}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge",
      "unit": "millisecond"
    },
    {
      "metric": "catchpoint.frontend.load_time",
      "points": [
        [
          "${timestampepoch}",
          "${timingload}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge",
      "unit": "millisecond"
    },
    {
      "metric": "catchpoint.frontend.total_root_request_redirect_time",
      "points": [
        [
          "${timestampepoch}",
          "${timingredirect}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge",
      "unit": "millisecond"
    },
    {
      "metric": "catchpoint.frontend.render_start_time",
      "points": [
        [
          "${timestampepoch}",
          "${timingrenderstart}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge",
      "unit": "millisecond"
    },
    {
      "metric": "catchpoint.frontend.total_root_request_time",
      "points": [
        [
          "${timestampepoch}",
          "${timingresponse}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge",
      "unit": "millisecond"
    },
    {
      "metric": "catchpoint.network.send_time",
      "points": [
        [
          "${timestampepoch}",
          "${timingsend}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge",
      "unit": "millisecond"
    },
    {
      "metric": "catchpoint.network.ssl_time",
      "points": [
        [
          "${timestampepoch}",
          "${timingssl}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge",
      "unit": "millisecond"
    },
    {
      "metric": "catchpoint.frontend.time_to_title",
      "points": [
        [
          "${timestampepoch}",
          "${timingtimetotitle}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge",
      "unit": "millisecond"
    },
    {
      "metric": "catchpoint.frontend.total_test_time",
      "points": [
        [
          "${timestampepoch}",
          "${timingtotal}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge",
      "unit": "millisecond"
    },
    {
      "metric": "catchpoint.network.wait_time",
      "points": [
        [
          "${timestampepoch}",
          "${timingwait}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge",
      "unit": "millisecond"
    },
    {
      "metric": "catchpoint.frontend.webpage_response_time",
      "points": [
        [
          "${timestampepoch}",
          "${timingwebpageresponse}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge",
      "unit": "millisecond"
    },
    {
      "metric": "catchpoint.frontend.wire_time",
      "points": [
        [
          "${timestampepoch}",
          "${timingwire}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge",
      "unit": "millisecond"
    },
    {
      "metric": "catchpoint.ping.percentage.ping_packet_loss",
      "points": [
        [
          "${timestampepoch}",
          "${pingpacketlosspct}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge",
      "unit": "millisecond"
    },
    {
      "metric": "catchpoint.ping.ping_round_trip_time",
      "points": [
        [
          "${timestampepoch}",
          "${pingroundtriptimeavg}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge",
      "unit": "millisecond"
    },
    {
      "metric": "catchpoint.imap.message_fetch_time",
      "points": [
        [
          "${timestampepoch}",
          "${timingfetch}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge",
      "unit": "millisecond"
    },
    {
      "metric": "catchpoint.imap.message_list_time",
      "points": [
        [
          "${timestampepoch}",
          "${timinglist}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge",
      "unit": "millisecond"
    },
    {
      "metric": "catchpoint.imap.logout_time",
      "points": [
        [
          "${timestampepoch}",
          "${timinglogout}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge",
      "unit": "millisecond"
    },
    {
      "metric": "catchpoint.imap.message_search_time",
      "points": [
        [
          "${timestampepoch}",
          "${timingsearch}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge",
      "unit": "millisecond"
    },
    {
      "metric": "catchpoint.ftp.total_download_bytes",
      "points": [
        [
          "${timestampepoch}",
          "${bytedownload}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge",
      "unit": "millisecond"
    },
    {
      "metric": "catchpoint.ftp.total_get_bytes",
      "points": [
        [
          "${timestampepoch}",
          "${byteget}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge",
      "unit": "millisecond"
    },
    {
      "metric": "catchpoint.ftp.uploaded_bytes",
      "points": [
        [
          "${timestampepoch}",
          "${byteupload}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge",
      "unit": "millisecond"
    },
    {
      "metric": "catchpoint.ftp.delete_time",
      "points": [
        [
          "${timestampepoch}",
          "${timingdelete}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge",
      "unit": "millisecond"
    },
    {
      "metric": "catchpoint.ftp.download_time",
      "points": [
        [
          "${timestampepoch}",
          "${timingdownload}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge",
      "unit": "millisecond"
    },
    {
      "metric": "catchpoint.ftp.get_time",
      "points": [
        [
          "${timestampepoch}",
          "${timingget}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge",
      "unit": "millisecond"
    },
    {
      "metric": "catchpoint.ftp.upload_time",
      "points": [
        [
          "${timestampepoch}",
          "${timingupload}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge",
      "unit": "millisecond"
    },
    {
      "metric": "catchpoint.ntp.root_delay_time",
      "points": [
        [
          "${timestampepoch}",
          "${timingrootdelay}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge",
      "unit": "millisecond"
    },
    {
      "metric": "catchpoint.ntp.root_dispersion_time",
      "points": [
        [
          "${timestampepoch}",
          "${timingrootdispersion}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge",
      "unit": "millisecond"
    },
    {
      "metric": "catchpoint.ntp.round_trip_delay_time",
      "points": [
        [
          "${timestampepoch}",
          "${timingroundtripdelay}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge",
      "unit": "millisecond"
    },
    {
      "metric": "catchpoint.ntp.ntp_time",
      "points": [
        [
          "${timestampepoch}",
          "${timinglocalclockoffset}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge",
      "unit": "millisecond"
    },
    {
      "metric": "catchpoint.frontend.total_self_zone_bytes",
      "points": [
        [
          "${timestampepoch}",
          "${byteresponseselfzone}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge",
      "unit": "byte"
    },
    {
      "metric": "catchpoint.frontend.total_response_content_bytes",
      "points": [
        [
          "${timestampepoch}",
          "${byteresponsetotalcontent}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge",
      "unit": "byte"
    },
    {
      "metric": "catchpoint.frontend.total_response_header_bytes",
      "points": [
        [
          "${timestampepoch}",
          "${byteresponsetotalheaders}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge",
      "unit": "byte"
    },
    {
      "metric": "catchpoint.frontend.root_request_response_content_bytes",
      "points": [
        [
          "${timestampepoch}",
          "${byteresponsecontent}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge",
      "unit": "byte"
    },
    {
      "metric": "catchpoint.frontend.root_request_response_header_bytes",
      "points": [
        [
          "${timestampepoch}",
          "${byteresponseheaders}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge",
      "unit": "byte"
    },
    {
      "metric": "catchpoint.frontend.total_downloaded_bytes",
      "points": [
        [
          "${timestampepoch}",
          "${bytereceive}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge",
      "unit": "byte"
    },
    {
      "metric": "catchpoint.frontend.total_number_of_connections",
      "points": [
        [
          "${timestampepoch}",
          "${counterconnections}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge"
    },
    {
      "metric": "catchpoint.frontend.total_number_of_failed_requests",
      "points": [
        [
          "${timestampepoch}",
          "${counterfailedrequests}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge"
    },
    {
      "metric": "catchpoint.frontend.total_number_of_filmstrip_images",
      "points": [
        [
          "${timestampepoch}",
          "${counterfilmstripimages}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge"
    },
    {
      "metric": "catchpoint.frontend.total_number_of_hosts",
      "points": [
        [
          "${timestampepoch}",
          "${counterhosts}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge"
    },
    {
      "metric": "catchpoint.frontend.total_number_of_js_errors",
      "points": [
        [
          "${timestampepoch}",
          "${counterjsfailures}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge"
    },
    {
      "metric": "catchpoint.frontend.total_number_of_redirect",
      "points": [
        [
          "${timestampepoch}",
          "${counterredirections}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge"
    },
    {
      "metric": "catchpoint.frontend.total_number_of_requests",
      "points": [
        [
          "${timestampepoch}",
          "${counterrequests}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge"
    },
    {
      "metric": "catchpoint.frontend.page_speed_score",
      "points": [
        [
          "${timestampepoch}",
          "${scorepagespeed}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge"
    },
    {
      "metric": "catchpoint.frontend.speed_index_score",
      "points": [
        [
          "${timestampepoch}",
          "${scorespeedindex}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge"
    },
    {
      "metric": "catchpoint.frontend.above_the_fold_time",
      "points": [
        [
          "${timestampepoch}",
          "${timingabovethefold}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge"
    },
    {
      "metric": "catchpoint.frontend.authentication_time",
      "points": [
        [
          "${timestampepoch}",
          "${timingauth}"
        ]
      ],
      "tags": [
        "NodeName: ${nodename}",
        "TestId:${testid}",
        "TestName: ${TestName}",
        "TestUrl: ${testurl}"
      ],
      "type": "gauge"
    }
  ]
}

Données collectées

Métriques

catchpoint.network.timing.tcp_connect_time (gauge)	The time it took to establish a TCP connection with the server. Shown as millisecond
catchpoint.network.timing.dns_resolution_time (gauge)	The time it took to resolve the domain name to an IP address. Shown as millisecond
catchpoint.network.timing.send_time (gauge)	The time it took to send the request to the server. Shown as millisecond
catchpoint.network.timing.ssl_time (gauge)	The time it took to complete the SSL handshake with the server. Shown as millisecond
catchpoint.network.timing.wait_time (gauge)	The time from when the request was sent to the server until the first response packet was received. (Known as "First Byte" in some tools) Shown as millisecond
catchpoint.frontend.timing.client_time (gauge)	The total amount of time where no request was on wire, from the start of the test or step to Document Complete. Shown as millisecond
catchpoint.frontend.timing.content_load_time (gauge)	The time it took to load the entire content of the webpage after the connection was established with the primary URL server. This is the time from the end of Send (ms) until the final element, or object, on the page was loaded. Content Load excludes DNS, Connect, SSL, and Send time. For Object monitor tests, this value is equivalent to Load (ms). Shown as millisecond
catchpoint.frontend.timing.document_complete_time (gauge)	The time it took from the initial URL request being issued until the browser triggered the "onload" event. Any inline requests or requests inserted via "document.write" must complete loading before the event is fired. Document Complete does not account for dynamic requests that may be generated later via JavaScript and/or DOM manipulation. Shown as millisecond
catchpoint.frontend.timing.dom_content_load_time (gauge)	DOM Content Load Time Shown as millisecond
catchpoint.frontend.timing.dom_interactive_time (gauge)	The time when the page first became interactive. TTI marks the point at which the webpage is both visually rendered and capable of reliably responding to user input. Shown as millisecond
catchpoint.frontend.timing.dom_load_time (gauge)	The time it took to load the Document Object Model (DOM) for the webpage. Shown as millisecond
catchpoint.frontend.timing.first_party_zone_impact (gauge)	First Party Zone Impact time in miliseconds. Shown as millisecond
catchpoint.frontend.timing.third_party_zone_impact (gauge)	Third Party Zone Impact time in miliseconds. Shown as millisecond
catchpoint.frontend.timing.load_time (gauge)	The time from the first packet to the last packet of data for the response. (Other tools might call this metric "Receive" or "Receiving") Shown as millisecond
catchpoint.frontend.timing.total_root_request_redirect_time (gauge)	Total Root Request Redirect Time reposted in miliseconds. Shown as millisecond
catchpoint.frontend.timing.render_start_time (gauge)	Time from the start of navigation to the end of the last Redirect. Shown as millisecond
catchpoint.frontend.timing.total_root_request_time (gauge)	Total Root Request Time Shown as millisecond
catchpoint.frontend.timing.time_to_title (gauge)	Time take to parse the title tag. Shown as millisecond
catchpoint.frontend.timing.webpage_response_time (gauge)	time taken to load the entire webpage, this includes all the page components. Shown as millisecond
catchpoint.frontend.timing.wire_time (gauge)	The total amount of time where at least one request was on the wire, from the start of the test or step to Document Complete. Shown as millisecond
catchpoint.frontend.timing.total_test_time (gauge)	One cohesive metric that applies to all test types and indicates the total duration of the test run. Test Time is equivalent to Response, Test Response (Transaction and Web tests) and Ping RTT (Trace Route tests), and is used when calculating Apdex. Test Time is not available for Request, Host, or Zone charting. Shown as millisecond
catchpoint.frontend.timing.above_the_fold_time (gauge)	Time taken to load the above the Fold content on a webpage. Shown as millisecond
catchpoint.frontend.timing.authentication_time (gauge)	The time it took to authenticate with the SMTP server. Shown as millisecond
catchpoint.frontend.score.page_speed_score (count)	Google's PageSpeed Score, which represents how well a webpage utilizes various performance-optimization techniques.
catchpoint.frontend.score.speed_index_score (count)	A calculated metric that represents how quickly the page rendered the initial user-visible content above the fold. A lower Speed Index indicates faster rendering of visible content.
catchpoint.frontend.counter.total_number_of_connections (count)	The total number of TCP connections established during the test.
catchpoint.frontend.counter.total_number_of_failed_requests (count)	Total Number of Failed Requests
catchpoint.frontend.counter.total_number_of_filmstrip_images (count)	Total Number of Filmstrip Images
catchpoint.frontend.counter.total_number_of_hosts (count)	Total Number of Hosts Shown as host
catchpoint.frontend.counter.total_number_of_js_errors (count)	Total Number of JS Errors
catchpoint.frontend.counter.total_number_of_redirect (count)	Total Number of Redirects
catchpoint.frontend.counter.total_number_of_requests (count)	Total Number of Requests Shown as request
catchpoint.frontend.bytes.total_downloaded_bytes (count)	Total Downloaded Bytes. Shown as byte
catchpoint.frontend.bytes.root_request_response_content_bytes (count)	Root Request Response Content Bytes Shown as byte
catchpoint.frontend.bytes.root_request_response_header_bytes (count)	Root Request Response Header Bytes Shown as byte
catchpoint.frontend.bytes.total_self_zone_bytes (count)	Total Self-Zone Bytes Shown as byte
catchpoint.frontend.bytes.total_response_content_bytes (count)	Total Response Content Bytes Shown as byte
catchpoint.frontend.bytes.total_response_header_bytes (count)	Total Response Header Bytes Shown as byte
catchpoint.ftp.bytes.total_download_bytes (count)	Total FTP Total Download Bytes by the test. Shown as byte
catchpoint.ftp.bytes.total_get_bytes (count)	Total FTP Total GET Bytes by the test. Shown as byte
catchpoint.ftp.bytes.uploaded_bytes (count)	Total FTP Uploaded Bytes by the test. Shown as byte
catchpoint.ftp.timing.delete_time (gauge)	The time it took to delete the specified file from the FTP server. Shown as millisecond
catchpoint.ftp.timing.download_time (gauge)	The time it took to download the entire file from the FTP server. Shown as millisecond
catchpoint.ftp.timing.get_time (gauge)	The time it took to connect to the FTP server and query it for the file size. Shown as millisecond
catchpoint.ftp.timing.upload_time (gauge)	The time it took to upload the specified file to the FTP server. Shown as millisecond
catchpoint.imap.timing.message_fetch_time (gauge)	The time it took to fetch the message from the IMAP server. Shown as millisecond
catchpoint.imap.timing.message_list_time (gauge)	The time it took to list folders. Shown as millisecond
catchpoint.imap.timing.logout_time (gauge)	The time it took to log out from the IMAP server. Shown as millisecond
catchpoint.imap.timing.message_search_time (gauge)	The time it took to search for messages. Shown as millisecond
catchpoint.ntp.timing.ntp (gauge)	NTP total time. Shown as millisecond
catchpoint.ntp.timing.root_delay_time (gauge)	The estimated delay between the local system clock and the root clock. Shown as millisecond
catchpoint.ntp.timing.root_dispersion_time (gauge)	The estimated error in the local system clock since it was last synchronized with the upstream clock. Shown as millisecond
catchpoint.ntp.timing.round_trip_delay_time (gauge)	The total amount of time that the NTP request packet and response packet were traveling between the Node and the NTP server. Shown as millisecond
catchpoint.ping.percentage.ping_packet_loss (gauge)	The percentage of pings packets sent which did not receive a response. Calculated as: (# packets received / # packets sent) * 100 Shown as percent
catchpoint.ping.timing.ping_round_trip_time (gauge)	Average time between sending a ping packet and receiving a response. Shown as millisecond
catchpoint.error.boolean.error (count)	All failure error count, include child request failures. Shown as error
catchpoint.success.rate (count)	Test failure error count Shown as error

Événements

L’intégration Catchpoint envoie les événements Catchpoint à votre flux d’événements Datadog.

Checks de service

L’intégration Catchpoint n’inclut aucun check de service.

Dépannage

Besoin d’aide ? Contactez l’assistance Datadog.