datadog-ci 1.2.0 → 1.3.0

data/lib/datadog/ci/ext/telemetry.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Datadog
+  module CI
+    module Ext
+      module Telemetry
+        NAMESPACE = "civisibility"
+
+        METRIC_EVENT_CREATED = "event_created"
+        METRIC_EVENT_FINISHED = "event_finished"
+
+        METRIC_MANUAL_API_EVENTS = "manual_api_events"
+
+        METRIC_EVENTS_ENQUEUED = "events_enqueued_for_serialization"
+        METRIC_ENDPOINT_PAYLOAD_REQUESTS = "endpoint_payload.requests"
+        METRIC_ENDPOINT_PAYLOAD_REQUESTS_MS = "endpoint_payload.requests_ms"
+        METRIC_ENDPOINT_PAYLOAD_REQUESTS_ERRORS = "endpoint_payload.requests_errors"
+        METRIC_ENDPOINT_PAYLOAD_BYTES = "endpoint_payload.bytes"
+        METRIC_ENDPOINT_PAYLOAD_EVENTS_COUNT = "endpoint_payload.events_count"
+        METRIC_ENDPOINT_PAYLOAD_EVENTS_SERIALIZATION_MS = "endpoint_payload.events_serialization_ms"
+        METRIC_ENDPOINT_PAYLOAD_DROPPED = "endpoint_payload.dropped"
+
+        METRIC_GIT_COMMAND = "git.command"
+        METRIC_GIT_COMMAND_ERRORS = "git.command_errors"
+        METRIC_GIT_COMMAND_MS = "git.command_ms"
+
+        METRIC_GIT_REQUESTS_SEARCH_COMMITS = "git_requests.search_commits"
+        METRIC_GIT_REQUESTS_SEARCH_COMMITS_MS = "git_requests.search_commits_ms"
+        METRIC_GIT_REQUESTS_SEARCH_COMMITS_ERRORS = "git_requests.search_commits_errors"
+
+        METRIC_GIT_REQUESTS_OBJECT_PACK = "git_requests.objects_pack"
+        METRIC_GIT_REQUESTS_OBJECT_PACK_MS = "git_requests.objects_pack_ms"
+        METRIC_GIT_REQUESTS_OBJECT_PACK_ERRORS = "git_requests.objects_pack_errors"
+        METRIC_GIT_REQUESTS_OBJECT_PACK_BYTES = "git_requests.objects_pack_bytes"
+        METRIC_GIT_REQUESTS_OBJECT_PACK_FILES = "git_requests.objects_pack_files"
+
+        METRIC_GIT_REQUESTS_SETTINGS = "git_requests.settings"
+        METRIC_GIT_REQUESTS_SETTINGS_MS = "git_requests.settings_ms"
+        METRIC_GIT_REQUESTS_SETTINGS_ERRORS = "git_requests.settings_errors"
+        METRIC_GIT_REQUESTS_SETTINGS_RESPONSE = "git_requests.settings_response"
+
+        METRIC_ITR_SKIPPABLE_TESTS_REQUEST = "itr_skippable_tests.request"
+        METRIC_ITR_SKIPPABLE_TESTS_REQUEST_MS = "itr_skippable_tests.request_ms"
+        METRIC_ITR_SKIPPABLE_TESTS_REQUEST_ERRORS = "itr_skippable_tests.request_errors"
+        METRIC_ITR_SKIPPABLE_TESTS_RESPONSE_BYTES = "itr_skippable_tests.response_bytes"
+        METRIC_ITR_SKIPPABLE_TESTS_RESPONSE_TESTS = "itr_skippable_tests.response_tests"
+
+        METRIC_ITR_SKIPPED = "itr_skipped"
+        METRIC_ITR_UNSKIPPABLE = "itr_unskippable"
+        METRIC_ITR_FORCED_RUN = "itr_forced_run"
+
+        METRIC_CODE_COVERAGE_STARTED = "code_coverage_started"
+        METRIC_CODE_COVERAGE_FINISHED = "code_coverage_finished"
+        METRIC_CODE_COVERAGE_IS_EMPTY = "code_coverage.is_empty"
+        METRIC_CODE_COVERAGE_FILES = "code_coverage.files"
+
+        METRIC_TEST_SESSION = "test_session"
+
+        TAG_TEST_FRAMEWORK = "test_framework"
+        TAG_EVENT_TYPE = "event_type"
+        TAG_HAS_CODEOWNER = "has_codeowner"
+        TAG_IS_UNSUPPORTED_CI = "is_unsupported_ci"
+        TAG_BROWSER_DRIVER = "browser_driver"
+        TAG_IS_RUM = "is_rum"
+        TAG_LIBRARY = "library"
+        TAG_ENDPOINT = "endpoint"
+        TAG_ERROR_TYPE = "error_type"
+        TAG_EXIT_CODE = "exit_code"
+        TAG_STATUS_CODE = "status_code"
+        TAG_REQUEST_COMPRESSED = "rq_compressed"
+        TAG_RESPONSE_COMPRESSED = "rs_compressed"
+        TAG_COMMAND = "command"
+        TAG_COVERAGE_ENABLED = "coverage_enabled"
+        TAG_ITR_SKIP_ENABLED = "itrskip_enabled"
+        TAG_PROVIDER = "provider"
+        TAG_AUTO_INJECTED = "auto_injected"
+
+        module EventType
+          TEST = "test"
+          SUITE = "suite"
+          MODULE = "module"
+          SESSION = "session"
+        end
+
+        module Library
+          CUSTOM = "custom"
+        end
+
+        module Endpoint
+          CODE_COVERAGE = "code_coverage"
+          TEST_CYCLE = "test_cycle"
+        end
+
+        module ErrorType
+          NETWORK = "network"
+          TIMEOUT = "timeout"
+          STATUS_CODE = "status_code"
+        end
+
+        module ExitCode
+          MISSING = "missing"
+        end
+
+        module Command
+          GET_REPOSITORY = "get_repository"
+          GET_BRANCH = "get_branch"
+          CHECK_SHALLOW = "check_shallow"
+          UNSHALLOW = "unshallow"
+          GET_LOCAL_COMMITS = "get_local_commits"
+          GET_OBJECTS = "get_objects"
+          PACK_OBJECTS = "pack_objects"
+        end
+
+        module Provider
+          UNSUPPORTED = "unsupported"
+        end
+      end
+    end
+  end
+end

data/lib/datadog/ci/git/local_repository.rb

@@ -3,12 +3,25 @@
 require "open3"
 require "pathname"
 
+require_relative "../ext/telemetry"
+require_relative "telemetry"
 require_relative "user"
 
 module Datadog
   module CI
     module Git
       module LocalRepository
+        class GitCommandExecutionError < StandardError
+          attr_reader :output, :command, :status
+          def initialize(message, output:, command:, status:)
+            super(message)
+
+            @output = output
+            @command = command
+            @status = status
+          end
+        end
+
         COMMAND_RETRY_COUNT = 3
 
         def self.root
@@ -48,9 +61,18 @@ module Datadog
         end
 
         def self.git_repository_url
-          exec_git_command("git ls-remote --get-url")
+          Telemetry.git_command(Ext::Telemetry::Command::GET_REPOSITORY)
+          res = nil
+
+          duration_ms = Core::Utils::Time.measure(:float_millisecond) do
+            res = exec_git_command("git ls-remote --get-url")
+          end
+
+          Telemetry.git_command_ms(Ext::Telemetry::Command::GET_REPOSITORY, duration_ms)
+          res
         rescue => e
           log_failure(e, "git repository url")
+          telemetry_track_error(e, Ext::Telemetry::Command::GET_REPOSITORY)
           nil
         end
 
@@ -69,9 +91,18 @@ module Datadog
         end
 
         def self.git_branch
-          exec_git_command("git rev-parse --abbrev-ref HEAD")
+          Telemetry.git_command(Ext::Telemetry::Command::GET_BRANCH)
+          res = nil
+
+          duration_ms = Core::Utils::Time.measure(:float_millisecond) do
+            res = exec_git_command("git rev-parse --abbrev-ref HEAD")
+          end
+
+          Telemetry.git_command_ms(Ext::Telemetry::Command::GET_BRANCH, duration_ms)
+          res
         rescue => e
           log_failure(e, "git branch")
+          telemetry_track_error(e, Ext::Telemetry::Command::GET_BRANCH)
           nil
         end
 
@@ -116,29 +147,49 @@ module Datadog
 
         # returns maximum of 1000 latest commits in the last month
         def self.git_commits
-          output = exec_git_command("git log --format=%H -n 1000 --since=\"1 month ago\"")
+          Telemetry.git_command(Ext::Telemetry::Command::GET_LOCAL_COMMITS)
+
+          output = nil
+          duration_ms = Core::Utils::Time.measure(:float_millisecond) do
+            output = exec_git_command("git log --format=%H -n 1000 --since=\"1 month ago\"")
+          end
+
+          Telemetry.git_command_ms(Ext::Telemetry::Command::GET_LOCAL_COMMITS, duration_ms)
+
           return [] if output.nil?
 
+          # @type var output: String
           output.split("\n")
         rescue => e
           log_failure(e, "git commits")
+          telemetry_track_error(e, Ext::Telemetry::Command::GET_LOCAL_COMMITS)
           []
         end
 
         def self.git_commits_rev_list(included_commits:, excluded_commits:)
+          Telemetry.git_command(Ext::Telemetry::Command::GET_OBJECTS)
           included_commits = filter_invalid_commits(included_commits).join(" ")
           excluded_commits = filter_invalid_commits(excluded_commits).map! { |sha| "^#{sha}" }.join(" ")
 
-          exec_git_command(
-            "git rev-list " \
-            "--objects " \
-            "--no-object-names " \
-            "--filter=blob:none " \
-            "--since=\"1 month ago\" " \
-            "#{excluded_commits} #{included_commits}"
-          )
+          res = nil
+
+          duration_ms = Core::Utils::Time.measure(:float_millisecond) do
+            res = exec_git_command(
+              "git rev-list " \
+              "--objects " \
+              "--no-object-names " \
+              "--filter=blob:none " \
+              "--since=\"1 month ago\" " \
+              "#{excluded_commits} #{included_commits}"
+            )
+          end
+
+          Telemetry.git_command_ms(Ext::Telemetry::Command::GET_OBJECTS, duration_ms)
+
+          res
         rescue => e
           log_failure(e, "git commits rev list")
+          telemetry_track_error(e, Ext::Telemetry::Command::GET_OBJECTS)
           nil
         end
 
@@ -150,35 +201,59 @@ module Datadog
 
           basename = SecureRandom.hex(4)
 
-          exec_git_command(
-            "git pack-objects --compression=9 --max-pack-size=3m #{path}/#{basename}",
-            stdin: commit_tree
-          )
+          Telemetry.git_command(Ext::Telemetry::Command::PACK_OBJECTS)
+
+          duration_ms = Core::Utils::Time.measure(:float_millisecond) do
+            exec_git_command(
+              "git pack-objects --compression=9 --max-pack-size=3m #{path}/#{basename}",
+              stdin: commit_tree
+            )
+          end
+          Telemetry.git_command_ms(Ext::Telemetry::Command::PACK_OBJECTS, duration_ms)
 
           basename
         rescue => e
           log_failure(e, "git generate packfiles")
+          telemetry_track_error(e, Ext::Telemetry::Command::PACK_OBJECTS)
           nil
         end
 
         def self.git_shallow_clone?
-          exec_git_command("git rev-parse --is-shallow-repository") == "true"
+          Telemetry.git_command(Ext::Telemetry::Command::CHECK_SHALLOW)
+          res = false
+
+          duration_ms = Core::Utils::Time.measure(:float_millisecond) do
+            res = exec_git_command("git rev-parse --is-shallow-repository") == "true"
+          end
+          Telemetry.git_command_ms(Ext::Telemetry::Command::CHECK_SHALLOW, duration_ms)
+
+          res
         rescue => e
           log_failure(e, "git shallow clone")
+          telemetry_track_error(e, Ext::Telemetry::Command::CHECK_SHALLOW)
           false
         end
 
         def self.git_unshallow
-          exec_git_command(
-            "git fetch " \
-            "--shallow-since=\"1 month ago\" " \
-            "--update-shallow " \
-            "--filter=\"blob:none\" " \
-            "--recurse-submodules=no " \
-            "$(git config --default origin --get clone.defaultRemoteName) $(git rev-parse HEAD)"
-          )
+          Telemetry.git_command(Ext::Telemetry::Command::UNSHALLOW)
+          res = nil
+
+          duration_ms = Core::Utils::Time.measure(:float_millisecond) do
+            res = exec_git_command(
+              "git fetch " \
+              "--shallow-since=\"1 month ago\" " \
+              "--update-shallow " \
+              "--filter=\"blob:none\" " \
+              "--recurse-submodules=no " \
+              "$(git config --default origin --get clone.defaultRemoteName) $(git rev-parse HEAD)"
+            )
+          end
+          Telemetry.git_command_ms(Ext::Telemetry::Command::UNSHALLOW, duration_ms)
+
+          res
         rescue => e
           log_failure(e, "git unshallow")
+          telemetry_track_error(e, Ext::Telemetry::Command::UNSHALLOW)
           nil
         end
 
@@ -209,7 +284,12 @@ module Datadog
             end
 
             if status.nil? || !status.success?
-              raise "Failed to run git command [#{cmd}] with input [#{stdin}] and output [#{out}]"
+              raise GitCommandExecutionError.new(
+                "Failed to run git command [#{cmd}] with input [#{stdin}] and output [#{out}]",
+                output: out,
+                command: cmd,
+                status: status
+              )
             end
 
             # Sometimes Encoding.default_external is somehow set to US-ASCII which breaks
@@ -231,6 +311,17 @@ module Datadog
               "Unable to perform #{action}: #{e.class.name} #{e.message} at #{Array(e.backtrace).first}"
             )
           end
+
+          def telemetry_track_error(e, command)
+            case e
+            when Errno::ENOENT
+              Telemetry.git_command_errors(command, executable_missing: true)
+            when GitCommandExecutionError
+              Telemetry.git_command_errors(command, exit_code: e.status&.to_i)
+            else
+              Telemetry.git_command_errors(command, exit_code: -9000)
+            end
+          end
         end
       end
     end

data/lib/datadog/ci/git/search_commits.rb

@@ -3,8 +3,11 @@
 require "json"
 require "set"
 
+require_relative "../ext/telemetry"
 require_relative "../ext/transport"
+require_relative "../transport/telemetry"
 require_relative "../utils/git"
+require_relative "../utils/telemetry"
 
 module Datadog
   module CI
@@ -25,7 +28,23 @@ module Datadog
             path: Ext::Transport::DD_API_GIT_SEARCH_COMMITS_PATH,
             payload: request_payload(repository_url, commits)
           )
-          raise ApiError, "Failed to search commits: #{http_response.inspect}" unless http_response.ok?
+
+          Transport::Telemetry.api_requests(
+            Ext::Telemetry::METRIC_GIT_REQUESTS_SEARCH_COMMITS,
+            1,
+            compressed: http_response.request_compressed
+          )
+          Utils::Telemetry.distribution(Ext::Telemetry::METRIC_GIT_REQUESTS_SEARCH_COMMITS_MS, http_response.duration_ms)
+
+          unless http_response.ok?
+            Transport::Telemetry.api_requests_errors(
+              Ext::Telemetry::METRIC_GIT_REQUESTS_SEARCH_COMMITS_ERRORS,
+              1,
+              error_type: http_response.telemetry_error_type,
+              status_code: http_response.code
+            )
+            raise ApiError, "Failed to search commits: #{http_response.inspect}"
+          end
 
           response_payload = parse_json_response(http_response)
           extract_commits(response_payload)

data/lib/datadog/ci/git/telemetry.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Datadog
+  module CI
+    module Git
+      module Telemetry
+        def self.git_command(command)
+          Utils::Telemetry.inc(Ext::Telemetry::METRIC_GIT_COMMAND, 1, tags_for_command(command))
+        end
+
+        def self.git_command_errors(command, exit_code: nil, executable_missing: false)
+          tags = tags_for_command(command)
+
+          exit_code_tag_value = exit_code_for(exit_code: exit_code, executable_missing: executable_missing)
+          tags[Ext::Telemetry::TAG_EXIT_CODE] = exit_code_tag_value if exit_code_tag_value
+
+          Utils::Telemetry.inc(Ext::Telemetry::METRIC_GIT_COMMAND_ERRORS, 1, tags)
+        end
+
+        def self.git_command_ms(command, duration_ms)
+          Utils::Telemetry.distribution(Ext::Telemetry::METRIC_GIT_COMMAND_MS, duration_ms, tags_for_command(command))
+        end
+
+        def self.tags_for_command(command)
+          {Ext::Telemetry::TAG_COMMAND => command}
+        end
+
+        def self.exit_code_for(exit_code: nil, executable_missing: false)
+          return Ext::Telemetry::ExitCode::MISSING if executable_missing
+          return exit_code.to_s if exit_code
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/datadog/ci/git/tree_uploader.rb

@@ -8,6 +8,9 @@ require_relative "search_commits"
 require_relative "upload_packfile"
 require_relative "packfiles"
 
+require_relative "../ext/telemetry"
+require_relative "../utils/telemetry"
+
 module Datadog
   module CI
     module Git
@@ -63,12 +66,16 @@ module Datadog
             head_commit_sha: head_commit,
             repository_url: repository_url
           )
+          packfiles_count = 0
           Packfiles.generate(included_commits: new_commits, excluded_commits: known_commits) do |filepath|
+            packfiles_count += 1
             uploader.call(filepath: filepath)
           rescue UploadPackfile::ApiError => e
             Datadog.logger.debug("Packfile upload failed with #{e}")
             break
           end
+
+          Utils::Telemetry.distribution(Ext::Telemetry::METRIC_GIT_REQUESTS_OBJECT_PACK_FILES, packfiles_count.to_f)
         ensure
           Datadog.logger.debug("Git tree upload finished")
         end

data/lib/datadog/ci/git/upload_packfile.rb

@@ -3,6 +3,11 @@
 require "json"
 require "securerandom"
 
+require_relative "../ext/transport"
+require_relative "../ext/telemetry"
+require_relative "../transport/telemetry"
+require_relative "../utils/telemetry"
+
 module Datadog
   module CI
     module Git
@@ -34,7 +39,23 @@ module Datadog
             headers: {Ext::Transport::HEADER_CONTENT_TYPE => content_type}
           )
 
-          raise ApiError, "Failed to upload packfile: #{http_response.inspect}" unless http_response.ok?
+          Transport::Telemetry.api_requests(
+            Ext::Telemetry::METRIC_GIT_REQUESTS_OBJECT_PACK,
+            1,
+            compressed: http_response.request_compressed
+          )
+          Utils::Telemetry.distribution(Ext::Telemetry::METRIC_GIT_REQUESTS_OBJECT_PACK_MS, http_response.duration_ms)
+          Utils::Telemetry.distribution(Ext::Telemetry::METRIC_GIT_REQUESTS_OBJECT_PACK_BYTES, http_response.request_size.to_f)
+
+          unless http_response.ok?
+            Transport::Telemetry.api_requests_errors(
+              Ext::Telemetry::METRIC_GIT_REQUESTS_OBJECT_PACK_ERRORS,
+              1,
+              error_type: http_response.telemetry_error_type,
+              status_code: http_response.code
+            )
+            raise ApiError, "Failed to upload packfile: #{http_response.inspect}"
+          end
         end
 
         private

data/lib/datadog/ci/test.rb

@@ -3,6 +3,7 @@
 require "json"
 
 require_relative "span"
+require_relative "test_optimisation/telemetry"
 require_relative "utils/test_run"
 
 module Datadog
@@ -80,9 +81,13 @@ module Datadog
       #
       # @return [void]
       def itr_unskippable!
+        TestOptimisation::Telemetry.itr_unskippable
         set_tag(Ext::Test::TAG_ITR_UNSKIPPABLE, "true")
+
         if skipped_by_itr?
           clear_tag(Ext::Test::TAG_ITR_SKIPPED_BY_ITR)
+
+          TestOptimisation::Telemetry.itr_forced_run
           set_tag(Ext::Test::TAG_ITR_FORCED_RUN, "true")
         end
       end

data/lib/datadog/ci/test_optimisation/component.rb

@@ -5,14 +5,17 @@ require "pp"
 require "datadog/core/utils/forking"
 
 require_relative "../ext/test"
+require_relative "../ext/telemetry"
 require_relative "../ext/transport"
 
 require_relative "../git/local_repository"
 
 require_relative "../utils/parsing"
+require_relative "../utils/telemetry"
 
 require_relative "coverage/event"
 require_relative "skippable"
+require_relative "telemetry"
 
 module Datadog
   module CI
@@ -104,15 +107,20 @@ module Datadog
 
         def start_coverage(test)
           return if !enabled? || !code_coverage?
-
+          Telemetry.code_coverage_started(test)
           coverage_collector&.start
         end
 
         def stop_coverage(test)
           return if !enabled? || !code_coverage?
 
+          Telemetry.code_coverage_finished(test)
+
           coverage = coverage_collector&.stop
-          return if coverage.nil? || coverage.empty?
+          if coverage.nil? || coverage.empty?
+            Telemetry.code_coverage_is_empty
+            return
+          end
 
           return if test.skipped?
 
@@ -121,6 +129,8 @@ module Datadog
           # cucumber's gherkin files are not covered by the code coverage collector
           ensure_test_source_covered(test_source_file, coverage) unless test_source_file.nil?
 
+          Telemetry.code_coverage_files(coverage.size)
+
           event = Coverage::Event.new(
             test_id: test.id.to_s,
             test_suite_id: test.test_suite_id.to_s,
@@ -162,6 +172,8 @@ module Datadog
           end
 
           @mutex.synchronize do
+            Telemetry.itr_skipped
+
             @skipped_tests_count += 1
           end
         end
@@ -229,6 +241,8 @@ module Datadog
           Datadog.logger.debug { "Fetched skippable tests: \n #{@skippable_tests}" }
           Datadog.logger.debug { "Found #{@skippable_tests.count} skippable tests." }
           Datadog.logger.debug { "ITR correlation ID: #{@correlation_id}" }
+
+          Utils::Telemetry.inc(Ext::Telemetry::METRIC_ITR_SKIPPABLE_TESTS_RESPONSE_TESTS, @skippable_tests.count)
         end
 
         def code_coverage_mode

data/lib/datadog/ci/test_optimisation/coverage/transport.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
 require_relative "event"
+require_relative "../../ext/telemetry"
 require_relative "../../transport/event_platform_transport"
+require_relative "../../transport/telemetry"
 
 module Datadog
   module CI
@@ -10,6 +12,10 @@ module Datadog
         class Transport < Datadog::CI::Transport::EventPlatformTransport
           private
 
+          def telemetry_endpoint_tag
+            Ext::Telemetry::Endpoint::CODE_COVERAGE
+          end
+
           def send_payload(encoded_payload)
             api.citestcov_request(
               path: Ext::Transport::TEST_COVERAGE_INTAKE_PATH,
@@ -19,7 +25,10 @@ module Datadog
 
           def encode_events(events)
             events.filter_map do |event|
-              next unless event.valid?
+              unless event.valid?
+                CI::Transport::Telemetry.endpoint_payload_dropped(1, endpoint: telemetry_endpoint_tag)
+                next
+              end
 
               encoded = encoder.encode(event)
               next if event_too_large?(event, encoded)

data/lib/datadog/ci/test_optimisation/skippable.rb

@@ -2,9 +2,12 @@
 
 require "json"
 
+require_relative "../ext/telemetry"
 require_relative "../ext/transport"
 require_relative "../ext/test"
+require_relative "../transport/telemetry"
 require_relative "../utils/test_run"
+require_relative "../utils/telemetry"
 
 module Datadog
   module CI
@@ -75,6 +78,27 @@ module Datadog
             payload: request_payload
           )
 
+          Transport::Telemetry.api_requests(
+            Ext::Telemetry::METRIC_ITR_SKIPPABLE_TESTS_REQUEST,
+            1,
+            compressed: http_response.request_compressed
+          )
+          Utils::Telemetry.distribution(Ext::Telemetry::METRIC_ITR_SKIPPABLE_TESTS_REQUEST_MS, http_response.duration_ms)
+          Utils::Telemetry.distribution(
+            Ext::Telemetry::METRIC_ITR_SKIPPABLE_TESTS_RESPONSE_BYTES,
+            http_response.response_size.to_f,
+            {Ext::Telemetry::TAG_RESPONSE_COMPRESSED => http_response.gzipped_content?.to_s}
+          )
+
+          unless http_response.ok?
+            Transport::Telemetry.api_requests_errors(
+              Ext::Telemetry::METRIC_ITR_SKIPPABLE_TESTS_REQUEST_ERRORS,
+              1,
+              error_type: http_response.telemetry_error_type,
+              status_code: http_response.code
+            )
+          end
+
           Response.new(http_response)
         end