datadog-ci 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7f96afc61b44202e506967dc7b2d6ec956c02561a99ec7e9eae4dc26902688b7
-  data.tar.gz: f6d66d038f8c5a5632f6c27ed2a3c70d9f85394fca2c237825041cb523063ec4
+  metadata.gz: 73bd9b05aba53e1197420cc0e4a529339b6526e13775467fa326b4949e44043a
+  data.tar.gz: 7613c476a2a3f2cf28d7dd99dd53da2fa6c921c9a03de18a6997f25e3fe0f27a
 SHA512:
-  metadata.gz: a6a548db92e125ae6fdb23301554efec581f72ca63b9a32384be33162eb90daa79ebf67ccb5834f2347b094f8d131129cd4a6963a817c55beaed83e0cd10b96b
-  data.tar.gz: e6da7ae7f7607955b206859e8a6c583d65aea03c59d538de2c3c7de41433a0b9942fe48e6d79db9bc7cb6546100b001dfd90b421c7ed392aa6d10e14034ecd08
+  metadata.gz: fc66a07d4ccceb71f18b26d290e387b6b403d7efbb46169ced3db9ad0e67e2f29ec163bdaa43a7f7508c6511ca0c68d99257d32d3a25e62b42e00219d7ef44a1
+  data.tar.gz: 6fb71c67ecea77fc61238fa7f739192a7670f51d8f4c052d436d2f4d69743f1202f27e27cf84fa76ce74860145d13badb00862c1c03b37d93dc9a33e597afb3d

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 ## [Unreleased]
 
+## [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 +267,8 @@ 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.0.1...main
+[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 +368,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 +376,5 @@ 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
+[#189]: https://github.com/DataDog/datadog-ci-rb/issues/189
 [#190]: https://github.com/DataDog/datadog-ci-rb/issues/190

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)

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/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/version.rb

@@ -3,9 +3,9 @@
 module Datadog
   module CI
     module VERSION
-      MAJOR = "1"
-      MINOR = "0"
-      PATCH = "0"
+      MAJOR = 1
+      MINOR = 0
+      PATCH = 1
       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.0.1
 platform: ruby
 authors:
 - Datadog, Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-06-06 00:00:00.000000000 Z
+date: 2024-06-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: datadog