Catchpoint

Catchpoint

Crawler Crawler

Overview

Catchpoint is a Digital Performance Analytics platform that gives you the power to deliver amazing user experiences.

Connect Catchpoint and Datadog to:

  • Configure comprehensive alerts in your event stream
  • Direct links to Analysis Charts in the Catchpoint Portal
  • Alert Type tags for easy filtering

Setup

Installation

No installation is required.

Configuration

To get Catchpoint alerts into your stream, login into the Catchpoint Portal and goto Settings -> API.

  1. In the Alerts API select Enable

  2. Enter the DataDog Endpoint URL.

    https://app.datadoghq.com/api/v1/events?api_key=<YOUR_DATADOG_API_KEY>
    

    Your DataDog API key can be created on the DataDog site.

  3. Set Status to Active

  4. Select Template for Format

  5. Add a new template

  6. Enter the template name, such as DataDog, and set the Format to JSON.

  7. Use the following JSON Template and Save it.

{
    "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', 'Unknown','2', 'Byte Length','3','Content Match','4', 'Host Failure','7', 'Timing','9', 'Test Failure', '10',Insight', '11','Javascript Failure', '12', 'Ping',13, 'Requests')}"
    ],
    "alert_type": "${switch(${notificationLevelId},'0','warning','1','error','3','success')}",
    "source_type_name": "catchpoint"
}

After setup, Catchpoint sends alerts directly to the Events stream in DataDog.

Metrics configuration

  1. In the Test Data Webhook add the Datadog API endpoint along with the API key
  2. Select “Template”
  3. Click “Add New” from drop-down
  4. Enter a name
  5. Select “JSON” under format
  6. Paste the following JSON template and Click 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"
    }
  ]
}

Data Collected

Metrics

catchpoint.network.timing.tcp_connect_time
(gauge)
TCP Connect Time
Shown as millisecond
catchpoint.network.timing.dns_resolution_time
(gauge)
DNS Resolution Time
Shown as millisecond
catchpoint.network.timing.send_time
(gauge)
Send Time
Shown as millisecond
catchpoint.network.timing.ssl_time
(gauge)
TLS/SSL Time
Shown as millisecond
catchpoint.network.timing.wait_time
(gauge)
Wait Time (AKA Time to First Byte)
Shown as millisecond
catchpoint.frontend.timing.client_time
(gauge)
Client Time
Shown as millisecond
catchpoint.frontend.timing.content_load_time
(gauge)
Content Load Time
Shown as millisecond
catchpoint.frontend.timing.document_complete_time
(gauge)
Load Event / Document Complete Time
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)
DOM Interactive Time
Shown as millisecond
catchpoint.frontend.timing.dom_load_time
(gauge)
DOM Load Time
Shown as millisecond
catchpoint.frontend.timing.first_party_zone_impact
(gauge)
First Party Zone Impact
Shown as millisecond
catchpoint.frontend.timing.third_party_zone_impact
(gauge)
Third Party Zone Impact
Shown as millisecond
catchpoint.frontend.timing.load_time
(gauge)
Load Time (AKA Recevie/Download)
Shown as millisecond
catchpoint.frontend.timing.total_root_request_redirect_time
(gauge)
Total Root Request Redirect Time
Shown as millisecond
catchpoint.frontend.timing.render_start_time
(gauge)
Render Start Time
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 to Title
Shown as millisecond
catchpoint.frontend.timing.webpage_response_time
(gauge)
Webpage Response Time
Shown as millisecond
catchpoint.frontend.timing.wire_time
(gauge)
Wire Time
Shown as millisecond
catchpoint.frontend.timing.total_test_time
(gauge)
Total Test Time
Shown as millisecond
catchpoint.frontend.timing.above_the_fold_time
(gauge)
Above the Fold Time
Shown as millisecond
catchpoint.frontend.timing.authentication_time
(gauge)
Authentication Time
Shown as millisecond
catchpoint.frontend.score.page_speed_score
(count)
Page Speed Score
catchpoint.frontend.score.speed_index_score
(count)
Speed Index Score
catchpoint.frontend.counter.total_number_of_connections
(count)
Total Number of Connections
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)
FTP Total Download Bytes
Shown as byte
catchpoint.ftp.bytes.total_get_bytes
(count)
FTP Total GET Bytes
Shown as byte
catchpoint.ftp.bytes.uploaded_bytes
(count)
FTP Uploaded Bytes
Shown as byte
catchpoint.ftp.timing.delete_time
(gauge)
FTP Delete Time
Shown as millisecond
catchpoint.ftp.timing.download_time
(gauge)
FTP Download Time
Shown as millisecond
catchpoint.ftp.timing.get_time
(gauge)
FTP GET Time
Shown as millisecond
catchpoint.ftp.timing.upload_time
(gauge)
FTP Upload Time
Shown as millisecond
catchpoint.imap.timing.message_fetch_time
(gauge)
IMAP Message Fetch Time
Shown as millisecond
catchpoint.imap.timing.message_list_time
(gauge)
IMAP Message List Time
Shown as millisecond
catchpoint.imap.timing.logout_time
(gauge)
IMAP Logout Time
Shown as millisecond
catchpoint.imap.timing.message_search_time
(gauge)
IMAP Message Search Time
Shown as millisecond
catchpoint.ntp.timing.ntp
(gauge)
NTP
Shown as millisecond
catchpoint.ntp.timing.root_delay_time
(gauge)
NTP Root Delay Time
Shown as millisecond
catchpoint.ntp.timing.root_dispersion_time
(gauge)
NTP Root Dispersion Time
Shown as millisecond
catchpoint.ntp.timing.round_trip_delay_time
(gauge)
NTP Round Trip Delay Time
Shown as millisecond
catchpoint.ping.percentage.ping_packet_loss
(gauge)
Ping Packet Loss
Shown as percent
catchpoint.ping.timing.ping_round_trip_time
(gauge)
Ping Round Trip Time
Shown as millisecond
catchpoint.error.boolean.error
(count)
Error count
Shown as error

Events

The Catchpoint integration pushes Catchpoint events to your Datadog event stream.

Service Checks

The Catchpoint integration does not include any service checks.

Troubleshooting

Need help? Contact Datadog support.