datadog-ci 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7f96afc61b44202e506967dc7b2d6ec956c02561a99ec7e9eae4dc26902688b7
-  data.tar.gz: f6d66d038f8c5a5632f6c27ed2a3c70d9f85394fca2c237825041cb523063ec4
+  metadata.gz: 61f6379b9a5ac0c29ff9ee6b1687c1c2add77d6a5031dfd5758eb34a66cc6235
+  data.tar.gz: a795d8d69513925ee5ea6cf113cb54cec3711fe65ae5e928fcdeb8e1454323af
 SHA512:
-  metadata.gz: a6a548db92e125ae6fdb23301554efec581f72ca63b9a32384be33162eb90daa79ebf67ccb5834f2347b094f8d131129cd4a6963a817c55beaed83e0cd10b96b
-  data.tar.gz: e6da7ae7f7607955b206859e8a6c583d65aea03c59d538de2c3c7de41433a0b9942fe48e6d79db9bc7cb6546100b001dfd90b421c7ed392aa6d10e14034ecd08
+  metadata.gz: 3ea51d0baa70ecb4e66fb49712f4f291582ecb04455b2d32ec1328bb8ea3c112c4c25d80e450db542ee4f29408786b09a82b5f94fb1c7ef8c96b98d301e61e9b
+  data.tar.gz: 4f066970c2d9ed93001f35f9096cefcf2a4447a86cf7c1d89435853b1da00389c587924304c7a213e56f58f64b191523d202e34f86da535ded271583881411ac

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 ## [Unreleased]
 
+## [1.1.0] - 2024-07-01
+
+### Added
+* Ignore Webmock automatically when making HTTP calls ([#193][])
+
+## [1.0.1] - 2024-06-11
+
+### Fixed
+* multi threaded code coverage support for datadog_cov ([#189][])
+* code coverage extension fixes and improvements ([#171][])
+
 ## [1.0.0] - 2024-06-06
 
 
@@ -261,7 +272,9 @@ Currently test suite level visibility is not used by our instrumentation: it wil
 
 - Ruby versions < 2.7 no longer supported ([#8][])
 
-[Unreleased]: https://github.com/DataDog/datadog-ci-rb/compare/v1.0.0...main
+[Unreleased]: https://github.com/DataDog/datadog-ci-rb/compare/v1.1.0...main
+[1.1.0]: https://github.com/DataDog/datadog-ci-rb/compare/v1.0.1...v1.1.0
+[1.0.1]: https://github.com/DataDog/datadog-ci-rb/compare/v1.0.0...v1.0.1
 [1.0.0]: https://github.com/DataDog/datadog-ci-rb/compare/v1.0.0.beta6...v1.0.0
 [1.0.0.beta6]: https://github.com/DataDog/datadog-ci-rb/compare/v1.0.0.beta5...v1.0.0.beta6
 [1.0.0.beta5]: https://github.com/DataDog/datadog-ci-rb/compare/v1.0.0.beta4...v1.0.0.beta5
@@ -361,6 +374,7 @@ Currently test suite level visibility is not used by our instrumentation: it wil
 [#167]: https://github.com/DataDog/datadog-ci-rb/issues/167
 [#168]: https://github.com/DataDog/datadog-ci-rb/issues/168
 [#170]: https://github.com/DataDog/datadog-ci-rb/issues/170
+[#171]: https://github.com/DataDog/datadog-ci-rb/issues/171
 [#172]: https://github.com/DataDog/datadog-ci-rb/issues/172
 [#173]: https://github.com/DataDog/datadog-ci-rb/issues/173
 [#174]: https://github.com/DataDog/datadog-ci-rb/issues/174
@@ -368,4 +382,6 @@ Currently test suite level visibility is not used by our instrumentation: it wil
 [#180]: https://github.com/DataDog/datadog-ci-rb/issues/180
 [#183]: https://github.com/DataDog/datadog-ci-rb/issues/183
 [#185]: https://github.com/DataDog/datadog-ci-rb/issues/185
-[#190]: https://github.com/DataDog/datadog-ci-rb/issues/190
+[#189]: https://github.com/DataDog/datadog-ci-rb/issues/189
+[#190]: https://github.com/DataDog/datadog-ci-rb/issues/190
+[#193]: https://github.com/DataDog/datadog-ci-rb/issues/193

data/ext/datadog_cov/datadog_cov.c

@@ -1,55 +1,54 @@
 #include <ruby.h>
 #include <ruby/debug.h>
 
-// constants
-#define DD_COV_TARGET_FILES 1
-#define DD_COV_TARGET_LINES 2
+#define PROFILE_FRAMES_BUFFER_SIZE 1
 
-static int is_prefix(VALUE prefix, const char *str)
+// threading modes
+#define SINGLE_THREADED_COVERAGE_MODE 0
+#define MULTI_THREADED_COVERAGE_MODE 1
+
+char *ruby_strndup(const char *str, size_t size)
 {
-  if (prefix == Qnil)
-  {
-    return 0;
-  }
+  char *dup;
 
-  const char *c_prefix = RSTRING_PTR(prefix);
-  if (c_prefix == NULL)
-  {
-    return 0;
-  }
+  dup = xmalloc(size + 1);
+  memcpy(dup, str, size);
+  dup[size] = '\0';
 
-  long prefix_len = RSTRING_LEN(prefix);
-  if (strncmp(c_prefix, str, prefix_len) == 0)
-  {
-    return 1;
-  }
-  else
-  {
-    return 0;
-  }
+  return dup;
 }
 
 // Data structure
 struct dd_cov_data
 {
-  VALUE root;
-  VALUE ignored_path;
-  int mode;
+  char *root;
+  long root_len;
+
+  char *ignored_path;
+  long ignored_path_len;
+
   VALUE coverage;
+
+  uintptr_t last_filename_ptr;
+
+  // for single threaded mode: thread that is being covered
+  VALUE th_covered;
+
+  int threading_mode;
 };
 
 static void dd_cov_mark(void *ptr)
 {
   struct dd_cov_data *dd_cov_data = ptr;
   rb_gc_mark_movable(dd_cov_data->coverage);
-  rb_gc_mark_movable(dd_cov_data->root);
-  rb_gc_mark_movable(dd_cov_data->ignored_path);
+  rb_gc_mark_movable(dd_cov_data->th_covered);
 }
 
 static void dd_cov_free(void *ptr)
 {
   struct dd_cov_data *dd_cov_data = ptr;
-
+  xfree(dd_cov_data->root);
+  xfree(dd_cov_data->ignored_path);
   xfree(dd_cov_data);
 }
 
@@ -57,8 +56,7 @@ static void dd_cov_compact(void *ptr)
 {
   struct dd_cov_data *dd_cov_data = ptr;
   dd_cov_data->coverage = rb_gc_location(dd_cov_data->coverage);
-  dd_cov_data->root = rb_gc_location(dd_cov_data->root);
-  dd_cov_data->ignored_path = rb_gc_location(dd_cov_data->ignored_path);
+  dd_cov_data->th_covered = rb_gc_location(dd_cov_data->th_covered);
 }
 
 const rb_data_type_t dd_cov_data_type = {
@@ -74,10 +72,15 @@ static VALUE dd_cov_allocate(VALUE klass)
 {
   struct dd_cov_data *dd_cov_data;
   VALUE obj = TypedData_Make_Struct(klass, struct dd_cov_data, &dd_cov_data_type, dd_cov_data);
+
   dd_cov_data->coverage = rb_hash_new();
-  dd_cov_data->root = Qnil;
-  dd_cov_data->ignored_path = Qnil;
-  dd_cov_data->mode = DD_COV_TARGET_FILES;
+  dd_cov_data->root = NULL;
+  dd_cov_data->root_len = 0;
+  dd_cov_data->ignored_path = NULL;
+  dd_cov_data->ignored_path_len = 0;
+  dd_cov_data->last_filename_ptr = 0;
+  dd_cov_data->threading_mode = MULTI_THREADED_COVERAGE_MODE;
+
   return obj;
 }
 
@@ -85,7 +88,6 @@ static VALUE dd_cov_allocate(VALUE klass)
 static VALUE dd_cov_initialize(int argc, VALUE *argv, VALUE self)
 {
   VALUE opt;
-  int mode;
 
   rb_scan_args(argc, argv, "10", &opt);
   VALUE rb_root = rb_hash_lookup(opt, ID2SYM(rb_intern("root")));
@@ -93,113 +95,141 @@ static VALUE dd_cov_initialize(int argc, VALUE *argv, VALUE self)
   {
     rb_raise(rb_eArgError, "root is required");
   }
-
   VALUE rb_ignored_path = rb_hash_lookup(opt, ID2SYM(rb_intern("ignored_path")));
 
-  VALUE rb_mode = rb_hash_lookup(opt, ID2SYM(rb_intern("mode")));
-  if (!RTEST(rb_mode) || rb_mode == ID2SYM(rb_intern("files")))
+  VALUE rb_threading_mode = rb_hash_lookup(opt, ID2SYM(rb_intern("threading_mode")));
+  int threading_mode;
+  if (rb_threading_mode == ID2SYM(rb_intern("multi")))
   {
-    mode = DD_COV_TARGET_FILES;
+    threading_mode = MULTI_THREADED_COVERAGE_MODE;
   }
-  else if (rb_mode == ID2SYM(rb_intern("lines")))
+  else if (rb_threading_mode == ID2SYM(rb_intern("single")))
   {
-    mode = DD_COV_TARGET_LINES;
+    threading_mode = SINGLE_THREADED_COVERAGE_MODE;
   }
   else
   {
-    rb_raise(rb_eArgError, "mode is invalid");
+    rb_raise(rb_eArgError, "threading mode is invalid");
   }
 
   struct dd_cov_data *dd_cov_data;
   TypedData_Get_Struct(self, struct dd_cov_data, &dd_cov_data_type, dd_cov_data);
 
-  dd_cov_data->root = rb_root;
-  dd_cov_data->ignored_path = rb_ignored_path;
-  dd_cov_data->mode = mode;
+  dd_cov_data->threading_mode = threading_mode;
+  dd_cov_data->root_len = RSTRING_LEN(rb_root);
+  dd_cov_data->root = ruby_strndup(RSTRING_PTR(rb_root), dd_cov_data->root_len);
+
+  if (RTEST(rb_ignored_path))
+  {
+    dd_cov_data->ignored_path_len = RSTRING_LEN(rb_ignored_path);
+    dd_cov_data->ignored_path = ruby_strndup(RSTRING_PTR(rb_ignored_path), dd_cov_data->ignored_path_len);
+  }
 
   return Qnil;
 }
 
-static void dd_cov_update_line_coverage(rb_event_flag_t event, VALUE data, VALUE self, ID id, VALUE klass)
+static void dd_cov_update_coverage(rb_event_flag_t event, VALUE data, VALUE self, ID id, VALUE klass)
 {
   struct dd_cov_data *dd_cov_data;
   TypedData_Get_Struct(data, struct dd_cov_data, &dd_cov_data_type, dd_cov_data);
 
-  const char *filename = rb_sourcefile();
-  if (filename == NULL)
+  const char *c_filename = rb_sourcefile();
+
+  // skip if we cover the same file again
+  uintptr_t current_filename_ptr = (uintptr_t)c_filename;
+  if (dd_cov_data->last_filename_ptr == current_filename_ptr)
   {
     return;
   }
+  dd_cov_data->last_filename_ptr = current_filename_ptr;
 
-  // if given filename is not located under the root, we skip it
-  if (is_prefix(dd_cov_data->root, filename) == 0)
+  VALUE top_frame;
+  int captured_frames = rb_profile_frames(
+      0 /* stack starting depth */,
+      PROFILE_FRAMES_BUFFER_SIZE,
+      &top_frame,
+      NULL);
+
+  if (captured_frames != PROFILE_FRAMES_BUFFER_SIZE)
   {
     return;
   }
 
-  // if ignored_path is provided and given filename is located under the ignored_path, we skip it too
-  // this is useful for ignoring bundled gems location
-  if (RTEST(dd_cov_data->ignored_path) && is_prefix(dd_cov_data->ignored_path, filename) == 1)
+  VALUE filename = rb_profile_frame_path(top_frame);
+  if (filename == Qnil)
   {
     return;
   }
 
-  VALUE rb_str_source_file = rb_str_new2(filename);
-
-  if (dd_cov_data->mode == DD_COV_TARGET_FILES)
+  char *filename_ptr = RSTRING_PTR(filename);
+  // if the current filename is not located under the root, we skip it
+  if (strncmp(dd_cov_data->root, filename_ptr, dd_cov_data->root_len) != 0)
   {
-    rb_hash_aset(dd_cov_data->coverage, rb_str_source_file, Qtrue);
     return;
   }
 
-  // this isn't optimized yet, this is a POC to show that lines coverage is possible
-  // ITR beta is going to use files coverage, we'll get back to this part when
-  // we need to implement lines coverage
-  if (dd_cov_data->mode == DD_COV_TARGET_LINES)
+  // if ignored_path is provided and the current filename is located under the ignored_path, we skip it too
+  // this is useful for ignoring bundled gems location
+  if (dd_cov_data->ignored_path_len != 0 && strncmp(dd_cov_data->ignored_path, filename_ptr, dd_cov_data->ignored_path_len) == 0)
   {
-    int line_number = rb_sourceline();
-    if (line_number <= 0)
-    {
-      return;
-    }
-
-    VALUE rb_lines = rb_hash_aref(dd_cov_data->coverage, rb_str_source_file);
-    if (rb_lines == Qnil)
-    {
-      rb_lines = rb_hash_new();
-      rb_hash_aset(dd_cov_data->coverage, rb_str_source_file, rb_lines);
-    }
-
-    rb_hash_aset(rb_lines, INT2FIX(line_number), Qtrue);
+    return;
   }
+
+  rb_hash_aset(dd_cov_data->coverage, filename, Qtrue);
 }
 
 static VALUE dd_cov_start(VALUE self)
 {
-  // get current thread
-  VALUE thval = rb_thread_current();
 
-  // add event hook
-  rb_thread_add_event_hook(thval, dd_cov_update_line_coverage, RUBY_EVENT_LINE, self);
+  struct dd_cov_data *dd_cov_data;
+  TypedData_Get_Struct(self, struct dd_cov_data, &dd_cov_data_type, dd_cov_data);
+
+  if (dd_cov_data->root_len == 0)
+  {
+    rb_raise(rb_eRuntimeError, "root is required");
+  }
+
+  if (dd_cov_data->threading_mode == SINGLE_THREADED_COVERAGE_MODE)
+  {
+    VALUE thval = rb_thread_current();
+    rb_thread_add_event_hook(thval, dd_cov_update_coverage, RUBY_EVENT_LINE, self);
+    dd_cov_data->th_covered = thval;
+  }
+  else
+  {
+    rb_add_event_hook(dd_cov_update_coverage, RUBY_EVENT_LINE, self);
+  }
 
   return self;
 }
 
 static VALUE dd_cov_stop(VALUE self)
 {
-  // get current thread
-  VALUE thval = rb_thread_current();
-  // remove event hook for the current thread
-  rb_thread_remove_event_hook(thval, dd_cov_update_line_coverage);
-
   struct dd_cov_data *dd_cov_data;
   TypedData_Get_Struct(self, struct dd_cov_data, &dd_cov_data_type, dd_cov_data);
 
-  VALUE cov = dd_cov_data->coverage;
+  if (dd_cov_data->threading_mode == SINGLE_THREADED_COVERAGE_MODE)
+  {
+    VALUE thval = rb_thread_current();
+    if (!rb_equal(thval, dd_cov_data->th_covered))
+    {
+      rb_raise(rb_eRuntimeError, "Coverage was not started by this thread");
+    }
+
+    rb_thread_remove_event_hook(dd_cov_data->th_covered, dd_cov_update_coverage);
+    dd_cov_data->th_covered = Qnil;
+  }
+  else
+  {
+    rb_remove_event_hook(dd_cov_update_coverage);
+  }
+
+  VALUE res = dd_cov_data->coverage;
 
   dd_cov_data->coverage = rb_hash_new();
+  dd_cov_data->last_filename_ptr = 0;
 
-  return cov;
+  return res;
 }
 
 void Init_datadog_cov(void)

data/lib/datadog/ci/configuration/components.rb

@@ -129,7 +129,8 @@ module Datadog
             config_tags: custom_configuration_tags,
             coverage_writer: coverage_writer,
             enabled: settings.ci.enabled && settings.ci.itr_enabled,
-            bundle_location: settings.ci.itr_code_coverage_excluded_bundle_path
+            bundle_location: settings.ci.itr_code_coverage_excluded_bundle_path,
+            use_single_threaded_coverage: settings.ci.itr_code_coverage_use_single_threaded_mode
           )
 
           git_tree_uploader = Git::TreeUploader.new(api: test_visibility_api)
@@ -204,7 +205,7 @@ module Datadog
         end
 
         def timecop?
-          Gem.loaded_specs.key?("timecop") || defined?(Timecop)
+          Gem.loaded_specs.key?("timecop") || !!defined?(Timecop)
         end
       end
     end

data/lib/datadog/ci/configuration/settings.rb

@@ -76,6 +76,12 @@ module Datadog
                 end
               end
 
+              option :itr_code_coverage_use_single_threaded_mode do |o|
+                o.type :bool
+                o.env CI::Ext::Settings::ENV_ITR_CODE_COVERAGE_USE_SINGLE_THREADED_MODE
+                o.default false
+              end
+
               define_method(:instrument) do |integration_name, options = {}, &block|
                 return unless enabled
 

data/lib/datadog/ci/contrib/rspec/example.rb

@@ -100,7 +100,7 @@ module Datadog
             end
 
             def ci_queue?
-              defined?(::RSpec::Queue::ExampleExtension) &&
+              !!defined?(::RSpec::Queue::ExampleExtension) &&
                 self.class.ancestors.include?(::RSpec::Queue::ExampleExtension)
             end
           end

data/lib/datadog/ci/contrib/rspec/patcher.rb

@@ -42,15 +42,15 @@ module Datadog
           end
 
           def ci_queue?
-            defined?(::RSpec::Queue::Runner)
+            !!defined?(::RSpec::Queue::Runner)
           end
 
           def knapsack_pro?
             knapsack_version = Gem.loaded_specs["knapsack_pro"]&.version
 
             # additional instrumentation is needed for KnapsackPro version 7 and later
-            defined?(::KnapsackPro) &&
-              knapsack_version && knapsack_version >= Gem::Version.new("7")
+            !!defined?(::KnapsackPro) &&
+              !knapsack_version.nil? && knapsack_version >= Gem::Version.new("7")
           end
         end
       end

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

@@ -13,6 +13,7 @@ module Datadog
         ENV_ITR_ENABLED = "DD_CIVISIBILITY_ITR_ENABLED"
         ENV_GIT_METADATA_UPLOAD_ENABLED = "DD_CIVISIBILITY_GIT_METADATA_UPLOAD_ENABLED"
         ENV_ITR_CODE_COVERAGE_EXCLUDED_BUNDLE_PATH = "DD_CIVISIBILITY_ITR_CODE_COVERAGE_EXCLUDED_BUNDLE_PATH"
+        ENV_ITR_CODE_COVERAGE_USE_SINGLE_THREADED_MODE = "DD_CIVISIBILITY_ITR_CODE_COVERAGE_USE_SINGLE_THREADED_MODE"
 
         # Source: https://docs.datadoghq.com/getting_started/site/
         DD_SITE_ALLOWLIST = %w[

data/lib/datadog/ci/itr/coverage/writer.rb

@@ -22,6 +22,8 @@ module Datadog
           DEFAULT_BUFFER_MAX_SIZE = 10_000
           DEFAULT_SHUTDOWN_TIMEOUT = 60
 
+          DEFAULT_INTERVAL = 3
+
           def initialize(transport:, options: {})
             @transport = transport
 
@@ -32,7 +34,7 @@ module Datadog
             self.fork_policy = Core::Workers::Async::Thread::FORK_POLICY_RESTART
 
             # Workers::IntervalLoop settings
-            self.loop_base_interval = options[:interval] if options.key?(:interval)
+            self.loop_base_interval = options[:interval] || DEFAULT_INTERVAL
             self.loop_back_off_ratio = options[:back_off_ratio] if options.key?(:back_off_ratio)
             self.loop_back_off_max = options[:back_off_max] if options.key?(:back_off_max)
 

data/lib/datadog/ci/itr/runner.rb

@@ -31,7 +31,8 @@ module Datadog
           api: nil,
           coverage_writer: nil,
           enabled: false,
-          bundle_location: nil
+          bundle_location: nil,
+          use_single_threaded_coverage: false
         )
           @enabled = enabled
           @api = api
@@ -43,6 +44,7 @@ module Datadog
           else
             bundle_location
           end
+          @use_single_threaded_coverage = use_single_threaded_coverage
 
           @test_skipping_enabled = false
           @code_coverage_enabled = false
@@ -186,12 +188,15 @@ module Datadog
         def coverage_collector
           Thread.current[:dd_coverage_collector] ||= Coverage::DDCov.new(
             root: Git::LocalRepository.root,
-            ignored_path: @bundle_location
+            ignored_path: @bundle_location,
+            threading_mode: code_coverage_mode
           )
         end
 
         def load_datadog_cov!
           require "datadog_cov.#{RUBY_VERSION}_#{RUBY_PLATFORM}"
+
+          Datadog.logger.debug("Loaded Datadog code coverage collector, using coverage mode: #{code_coverage_mode}")
         rescue LoadError => e
           Datadog.logger.error("Failed to load coverage collector: #{e}. Code coverage will not be collected.")
 
@@ -222,6 +227,10 @@ module Datadog
           Datadog.logger.debug { "Found #{@skippable_tests.count} skippable tests." }
           Datadog.logger.debug { "ITR correlation ID: #{@correlation_id}" }
         end
+
+        def code_coverage_mode
+          @use_single_threaded_coverage ? :single : :multi
+        end
       end
     end
   end

data/lib/datadog/ci/transport/adapters/net.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require "datadog/core/transport/response"
+require "datadog/core/transport/ext"
+
+require_relative "../gzip"
+require_relative "../../ext/transport"
+
+module Datadog
+  module CI
+    module Transport
+      module Adapters
+        # Adapter for Net::HTTP
+        class Net
+          attr_reader \
+            :hostname,
+            :port,
+            :timeout,
+            :ssl
+
+          def initialize(hostname:, port:, ssl:, timeout_seconds:)
+            @hostname = hostname
+            @port = port
+            @timeout = timeout_seconds
+            @ssl = ssl
+          end
+
+          def open(&block)
+            req = net_http_client.new(hostname, port)
+
+            req.use_ssl = ssl
+            req.open_timeout = req.read_timeout = timeout
+
+            req.start(&block)
+          end
+
+          def call(path:, payload:, headers:, verb:)
+            headers ||= {}
+            # skip tracing for internal DD requests
+            headers[Core::Transport::Ext::HTTP::HEADER_DD_INTERNAL_UNTRACED_REQUEST] = "1"
+
+            if respond_to?(verb)
+              send(verb, path: path, payload: payload, headers: headers)
+            else
+              raise "Unknown HTTP method [#{verb}]"
+            end
+          end
+
+          def post(path:, payload:, headers:)
+            post = ::Net::HTTP::Post.new(path, headers)
+            post.body = payload
+
+            # Connect and send the request
+            http_response = open do |http|
+              http.request(post)
+            end
+
+            # Build and return response
+            Response.new(http_response)
+          end
+
+          class Response
+            include Datadog::Core::Transport::Response
+
+            attr_reader :http_response
+
+            def initialize(http_response)
+              @http_response = http_response
+            end
+
+            def payload
+              return @decompressed_payload if defined?(@decompressed_payload)
+              return http_response.body unless gzipped_content?
+              return http_response.body unless gzipped_body?(http_response.body)
+
+              Datadog.logger.debug("Decompressing gzipped response payload")
+              @decompressed_payload = Gzip.decompress(http_response.body)
+            end
+
+            def header(name)
+              http_response[name]
+            end
+
+            def code
+              http_response.code.to_i
+            end
+
+            def ok?
+              code.between?(200, 299)
+            end
+
+            def unsupported?
+              code == 415
+            end
+
+            def not_found?
+              code == 404
+            end
+
+            def client_error?
+              code.between?(400, 499)
+            end
+
+            def server_error?
+              code.between?(500, 599)
+            end
+
+            def gzipped_content?
+              header(Ext::Transport::HEADER_CONTENT_ENCODING) == Ext::Transport::CONTENT_ENCODING_GZIP
+            end
+
+            def gzipped_body?(body)
+              return false if body.nil? || body.empty?
+
+              # no-dd-sa
+              first_bytes = body[0, 2]
+              return false if first_bytes.nil? || first_bytes.empty?
+
+              first_bytes.b == Ext::Transport::GZIP_MAGIC_NUMBER
+            end
+
+            def inspect
+              "#{super}, http_response:#{http_response}"
+            end
+          end
+
+          private
+
+          def net_http_client
+            return ::Net::HTTP unless defined?(WebMock::HttpLibAdapters::NetHttpAdapter::OriginalNetHTTP)
+
+            WebMock::HttpLibAdapters::NetHttpAdapter::OriginalNetHTTP
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/ci/transport/api/agentless.rb

@@ -37,7 +37,7 @@ module Datadog
           end
 
           def citestcov_request(path:, payload:, headers: {}, verb: "post")
-            super(path: path, payload: payload, headers: headers, verb: verb)
+            super
 
             perform_request(@citestcov_http, path: path, payload: @citestcov_payload, headers: headers, verb: verb)
           end
@@ -60,7 +60,7 @@ module Datadog
 
             Datadog::CI::Transport::HTTP.new(
               host: uri.host,
-              port: uri.port,
+              port: uri.port || 80,
               ssl: uri.scheme == "https" || uri.port == 443,
               compress: compress
             )

data/lib/datadog/ci/transport/api/evp_proxy.rb

@@ -39,7 +39,7 @@ module Datadog
           end
 
           def citestcov_request(path:, payload:, headers: {}, verb: "post")
-            super(path: path, payload: payload, headers: headers, verb: verb)
+            super
 
             headers[Ext::Transport::HEADER_EVP_SUBDOMAIN] = Ext::Transport::TEST_COVERAGE_INTAKE_HOST_PREFIX
 

data/lib/datadog/ci/transport/http.rb

@@ -1,12 +1,10 @@
 # frozen_string_literal: true
 
 require "delegate"
-require "datadog/core/transport/http/adapters/net"
-require "datadog/core/transport/http/env"
-require "datadog/core/transport/request"
 require "socket"
 
 require_relative "gzip"
+require_relative "adapters/net"
 require_relative "../ext/transport"
 
 module Datadog
@@ -24,7 +22,7 @@ module Datadog
         MAX_RETRIES = 3
         INITIAL_BACKOFF = 1
 
-        def initialize(host:, timeout: DEFAULT_TIMEOUT, port: nil, ssl: true, compress: false)
+        def initialize(host:, port:, timeout: DEFAULT_TIMEOUT, ssl: true, compress: false)
           @host = host
           @port = port
           @timeout = timeout
@@ -70,7 +68,7 @@ module Datadog
 
         def perform_http_call(path:, payload:, headers:, verb:, retries: MAX_RETRIES, backoff: INITIAL_BACKOFF)
           adapter.call(
-            build_env(path: path, payload: payload, headers: headers, verb: verb)
+            path: path, payload: payload, headers: headers, verb: verb
           )
         rescue Timeout::Error, Errno::EINVAL, Errno::ECONNRESET, EOFError, SocketError, Net::HTTPBadResponse => e
           Datadog.logger.debug("Failed to send request with #{e} (#{e.message})")
@@ -87,65 +85,17 @@ module Datadog
           end
         end
 
-        def build_env(path:, payload:, headers:, verb:)
-          env = Datadog::Core::Transport::HTTP::Env.new(
-            Datadog::Core::Transport::Request.new
-          )
-          env.body = payload
-          env.path = path
-          env.headers = headers
-          env.verb = verb
-          env
-        end
-
         def adapter
-          settings = AdapterSettings.new(hostname: host, port: port, ssl: ssl, timeout_seconds: timeout)
-          @adapter ||= Datadog::Core::Transport::HTTP::Adapters::Net.new(settings)
+          @adapter ||= Datadog::CI::Transport::Adapters::Net.new(
+            hostname: host, port: port, ssl: ssl, timeout_seconds: timeout
+          )
         end
 
-        # adds compatibility with Datadog::Tracing transport and
-        # provides ungzipping capabilities
+        # adds compatibility with Datadog::Tracing transport
         class ResponseDecorator < ::SimpleDelegator
-          def payload
-            return @decompressed_payload if defined?(@decompressed_payload)
-
-            if gzipped?(__getobj__.payload)
-              Datadog.logger.debug("Decompressing gzipped response payload")
-              @decompressed_payload = Gzip.decompress(__getobj__.payload)
-            else
-              __getobj__.payload
-            end
-          end
-
           def trace_count
             0
           end
-
-          def gzipped?(payload)
-            return false if payload.nil? || payload.empty?
-
-            # no-dd-sa
-            first_bytes = payload[0, 2]
-            return false if first_bytes.nil? || first_bytes.empty?
-
-            first_bytes.b == Datadog::CI::Ext::Transport::GZIP_MAGIC_NUMBER
-          end
-        end
-
-        class AdapterSettings
-          attr_reader :hostname, :port, :ssl, :timeout_seconds
-
-          def initialize(hostname:, port: nil, ssl: true, timeout_seconds: nil)
-            @hostname = hostname
-            @port = port
-            @ssl = ssl
-            @timeout_seconds = timeout_seconds
-          end
-
-          def ==(other)
-            hostname == other.hostname && port == other.port && ssl == other.ssl &&
-              timeout_seconds == other.timeout_seconds
-          end
         end
       end
     end

data/lib/datadog/ci/version.rb

@@ -3,9 +3,9 @@
 module Datadog
   module CI
     module VERSION
-      MAJOR = "1"
-      MINOR = "0"
-      PATCH = "0"
+      MAJOR = 1
+      MINOR = 1
+      PATCH = 0
       PRE = nil
       BUILD = nil
       # PRE and BUILD above are modified for dev gems during gem build GHA workflow

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: datadog-ci
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Datadog, Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-06-06 00:00:00.000000000 Z
+date: 2024-07-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: datadog
@@ -160,6 +160,7 @@ files:
 - lib/datadog/ci/test_visibility/serializers/test_v1.rb
 - lib/datadog/ci/test_visibility/serializers/test_v2.rb
 - lib/datadog/ci/test_visibility/transport.rb
+- lib/datadog/ci/transport/adapters/net.rb
 - lib/datadog/ci/transport/api/agentless.rb
 - lib/datadog/ci/transport/api/base.rb
 - lib/datadog/ci/transport/api/builder.rb
@@ -201,7 +202,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 2.0.0
 requirements: []
-rubygems_version: 3.5.9
+rubygems_version: 3.5.11
 signing_key: 
 specification_version: 4
 summary: Datadog CI visibility for your ruby application