datadog-ci 1.0.0.beta6 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a905eacfa2face6f297e027aa344b9b36f99d7f7f2120ab6946b2e9c650c390b
-  data.tar.gz: 537bd49690464320a74f88d9a0c392dcac10b83575407d703cf756a71ea8c29e
+  metadata.gz: 73bd9b05aba53e1197420cc0e4a529339b6526e13775467fa326b4949e44043a
+  data.tar.gz: 7613c476a2a3f2cf28d7dd99dd53da2fa6c921c9a03de18a6997f25e3fe0f27a
 SHA512:
-  metadata.gz: 8c87d7be67c31a970d0f6e75fcc4a0305719604afe02eac4061fd9c43a2539632f7a6f9199aafdaf55438913e721280ec2e5ac30f75d5921dd4bb3bdc1638f5a
-  data.tar.gz: '0838f7ce0df3bdf19a9a9c2c0df6c1b8ef0a96421e7043bfa339b6aa8d7a04f204a8c2a0dcb1cccb80f13df4a47a5da16c127a756d5064512120ea35a9beb8d0'
+  metadata.gz: fc66a07d4ccceb71f18b26d290e387b6b403d7efbb46169ced3db9ad0e67e2f29ec163bdaa43a7f7508c6511ca0c68d99257d32d3a25e62b42e00219d7ef44a1
+  data.tar.gz: 6fb71c67ecea77fc61238fa7f739192a7670f51d8f4c052d436d2f4d69743f1202f27e27cf84fa76ce74860145d13badb00862c1c03b37d93dc9a33e597afb3d

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 ## [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
+
+
+### Changed
+* automatically trace with correct time even when time is stubbed by timecop ([#185][])
+* depend on gem datadog ~> 2.0 ([#190][])
+
 ## [1.0.0.beta6] - 2024-05-29
 
 ### Added
@@ -254,7 +267,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.beta6...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
 [1.0.0.beta4]: https://github.com/DataDog/datadog-ci-rb/compare/v1.0.0.beta3...v1.0.0.beta4
@@ -353,9 +368,13 @@ 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
 [#175]: https://github.com/DataDog/datadog-ci-rb/issues/175
 [#180]: https://github.com/DataDog/datadog-ci-rb/issues/180
-[#183]: https://github.com/DataDog/datadog-ci-rb/issues/183
+[#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/README.md

@@ -1,13 +1,23 @@
-# Datadog CI Visibility for Ruby
+# Datadog Test Visibility for Ruby
 
 [![Gem Version](https://badge.fury.io/rb/datadog-ci.svg)](https://badge.fury.io/rb/datadog-ci)
 [![YARD documentation](https://img.shields.io/badge/YARD-documentation-blue)](https://datadoghq.dev/datadog-ci-rb/)
 [![codecov](https://codecov.io/gh/DataDog/datadog-ci-rb/branch/main/graph/badge.svg)](https://app.codecov.io/gh/DataDog/datadog-ci-rb/branch/main)
 [![CircleCI](https://dl.circleci.com/status-badge/img/gh/DataDog/datadog-ci-rb/tree/main.svg?style=svg)](https://dl.circleci.com/status-badge/redirect/gh/DataDog/datadog-ci-rb/tree/main)
 
-Datadog's Ruby Library for instrumenting your test and continuous integration pipeline.
+Datadog's Ruby Library for instrumenting your tests.
 Learn more on our [official website](https://docs.datadoghq.com/tests/) and check out our [documentation for this library](https://docs.datadoghq.com/tests/setup/ruby/?tab=cloudciprovideragentless).
 
+## Features
+
+- [Test Visibility](https://docs.datadoghq.com/tests/) - collect metrics and results for your tests
+- [Intelligent test runner](https://docs.datadoghq.com/intelligent_test_runner/) - save time by selectively running only tests affected by code changes
+- [Search and manage CI tests](https://docs.datadoghq.com/tests/search/)
+- [Enhance developer workflows](https://docs.datadoghq.com/tests/developer_workflows)
+- [Flaky test management](https://docs.datadoghq.com/tests/guides/flaky_test_management/)
+- [Add custom measures to your tests](https://docs.datadoghq.com/tests/guides/add_custom_measures/?tab=ruby)
+- [Browser tests integration with Datadog RUM](https://docs.datadoghq.com/tests/browser_tests)
+
 ## Installation
 
 Add to your Gemfile.
@@ -22,210 +32,10 @@ end
 
 If you used [test visibility for Ruby](https://docs.datadoghq.com/tests/setup/ruby/) with [ddtrace](https://github.com/datadog/dd-trace-rb) gem, check out our [upgrade guide](/docs/UpgradeGuide.md).
 
-## Usage
-
-### RSpec
-
-To activate `RSpec` integration, add this to the `spec_helper.rb` file:
-
-```ruby
-require 'rspec'
-require 'datadog/ci'
-
-# Only activates test instrumentation on CI
-if ENV["DD_ENV"] == "ci"
-  Datadog.configure do |c|
-    # The name of the service or library under test
-    c.service = 'my-ruby-app'
-    c.ci.enabled = true
-    c.ci.instrument :rspec
-  end
-end
-```
-
-### Minitest
-
-The Minitest integration will trace all executions of tests when using `minitest` test framework.
-
-To activate your integration, use the `Datadog.configure` method:
-
-```ruby
-require 'minitest'
-require 'datadog/ci'
-
-# Only activates test instrumentation on CI
-if ENV["DD_ENV"] == "ci"
-# Configure default Minitest integration
-  Datadog.configure do |c|
-    # The name of the service or library under test
-    c.service = 'my-ruby-app'
-    c.ci.enabled = true
-    c.ci.instrument :minitest
-  end
-end
-```
-
-> [!IMPORTANT]
-> When using `minitest/autorun` the order of requires matters: `datadog/ci` must be
-> always required before `minitest/autorun`.
-
-Example using `minitest/autorun`
-
-```ruby
-require 'datadog/ci'
-require 'minitest/autorun'
-
-if ENV["DD_ENV"] == "ci"
-  Datadog.configure do |c|
-    c.service = 'my-ruby-app'
-    c.ci.enabled = true
-    c.ci.instrument :minitest
-  end
-end
-```
-
-### Cucumber
-
-Activate `Cucumber` integration with configuration
-
-```ruby
-require 'cucumber'
-require 'datadog/ci'
-
-# Only activates test instrumentation on CI
-if ENV["DD_ENV"] == "ci"
-  Datadog.configure do |c|
-    # The name of the service or library under test
-    c.service = 'my-ruby-app'
-    c.ci.enabled = true
-    c.ci.instrument :cucumber
-  end
-end
-```
-
-### Instrumentation options
-
-Configuration `ci.instrument` accepts the following optional parameters:
+## Setup
 
-- `enabled` (default: `true`) - defines whether tests should be traced (useful for temporarily disabling tracing)
-- `service_name` - name of the service or library under test (when you want it to be different for a test framework)
-
-Example usage:
-
-```ruby
-  Datadog.configure do |c|
-    c.service = 'my-ruby-app'
-    c.ci.enabled = true
-    c.ci.instrument :cucumber, service_name: 'my-cucumber-features', enabled: true
-    c.ci.instrument :minitest, service_name: 'my-unit-tests', enabled: false
-  end
-```
-
-## Agentless mode
-
-If you are using a cloud CI provider without access to the underlying worker nodes, such as GitHub Actions or CircleCI, configure the library to use the Agentless mode. For this, set the following environment variables:
-`DD_CIVISIBILITY_AGENTLESS_ENABLED=true (Required)` and `DD_API_KEY=your_secret_api_key (Required)`.
-
-Additionally, configure which [Datadog site](https://docs.datadoghq.com/getting_started/site/) you want to send data to:
-`DD_SITE=your.datadoghq.com` (datadoghq.com by default).
-
-Agentless mode can also be enabled via `Datadog.configure` (but don't forget to set DD_API_KEY environment variable):
-
-```ruby
-Datadog.configure { |c| c.ci.agentless_mode_enabled = true }
-```
-
-## Additional configuration
-
-### Add tracing instrumentations
-
-It can be useful to have rich tracing information about your tests that includes time spent performing database operations
-or other external calls like here:
-
-![Test trace with redis instrumented](./docs/screenshots/test-trace-with-redis.png)
-
-To achieve this, add Datadog tracing instrumentations in your `Datadog.configure` block:
-
-```ruby
-Datadog.configure do |c|
-  #  ... ci configs and instrumentation here ...
-  c.tracing.instrument :redis
-  c.tracing.instrument :pg
-end
-```
-
-...or enable auto instrumentation in your test_helper/spec_helper:
-
-```ruby
-require "datadog/auto_instrument"
-```
-
-Note: in CI mode these traces are going to be submitted to CI Visibility,
-they will **not** show up in Datadog APM.
-
-For the full list of available instrumentations see [datadog documentation](https://github.com/DataDog/dd-trace-rb/blob/master/docs/GettingStarted.md)
-
-### WebMock
-
-[WebMock](https://github.com/bblimke/webmock)
-is a popular Ruby library that stubs HTTP requests when running tests.
-By default it fails when used together with datadog-ci as traces are being sent
-to Datadog via HTTP calls.
-
-In order to allow HTTP connections for Datadog backend you would need to configure
-Webmock accordingly.
-
-```ruby
-# when using agentless mode
-WebMock.disable_net_connect!(:allow => /datadoghq/)
-
-# when using agent
-WebMock.disable_net_connect!(:allow_localhost => true)
-
-# or for more granular setting set your agent URL
-WebMock.disable_net_connect!(:allow => "localhost:8126")
-```
-
-### VCR
-
-[VCR](https://github.com/vcr/vcr) is another popular testing library for HTTP interactions.
-
-It requires additional configuration to correctly work with datadog-ci:
-
-```ruby
-VCR.configure do |config|
-  # ... your usual configuration here ...
-
-  # when using agent
-  config.ignore_hosts "127.0.0.1", "localhost"
-
-  # when using agentless mode
-  config.ignore_request do |request|
-    # ignore all requests to datadoghq hosts
-    request.uri =~ /datadoghq/
-  end
-end
-```
-
-### Disabling startup logs
-
-Startup logs produce a report of tracing state when the application is initially configured.
-These logs are activated by default in test mode, if you don't want them you can disable this
-via `DD_TRACE_STARTUP_LOGS=0` or in the `Datadog.configure` block:
-
-```ruby
-Datadog.configure { |c| c.diagnostics.startup_logs.enabled = false }
-```
-
-### Enabling debug mode
-
-Switching the library into debug mode will produce verbose, detailed logs about tracing activity, including any suppressed errors. This output can be helpful in identifying errors, confirming trace output, or catching HTTP transport issues.
-
-You can enable this via `DD_TRACE_DEBUG=1` or in the `Datadog.configure` block:
-
-```ruby
-Datadog.configure { |c| c.diagnostics.debug = true }
-```
+- [Test visibility setup](https://docs.datadoghq.com/tests/setup/ruby/?tab=cloudciprovideragentless)
+- [Intelligent test runner setup](https://docs.datadoghq.com/intelligent_test_runner/setup/ruby) (test visibility setup is required before setting up intelligent test runner)
 
 ## Contributing
 

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/codeowners/matcher.rb

@@ -87,7 +87,7 @@ module Datadog
           return pattern if pattern == "*"
 
           # if pattern ends with a slash then it matches everything deeply nested in this directory
-          pattern += "**" if pattern.end_with?(::File::SEPARATOR)
+          pattern << "**" if pattern.end_with?(::File::SEPARATOR)
 
           # if pattern doesn't start with a slash then it matches anywhere in the repository
           if !pattern.start_with?(::File::SEPARATOR, "**#{::File::SEPARATOR}", "*#{::File::SEPARATOR}")

data/lib/datadog/ci/codeowners/parser.rb

@@ -8,11 +8,11 @@ module Datadog
       # Responsible for parsing a CODEOWNERS file
       class Parser
         DEFAULT_LOCATION = "CODEOWNERS"
-        POSSIBLE_CODEOWNERS_LOCATIONS = [
-          "CODEOWNERS",
-          ".github/CODEOWNERS",
-          ".gitlab/CODEOWNERS",
-          "docs/CODEOWNERS"
+        POSSIBLE_CODEOWNERS_LOCATIONS = %w[
+          CODEOWNERS
+          .github/CODEOWNERS
+          .gitlab/CODEOWNERS
+          docs/CODEOWNERS
         ].freeze
 
         def initialize(root_file_path)

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

@@ -70,6 +70,17 @@ module Datadog
           # Choose user defined TraceFlush or default to CI TraceFlush
           settings.tracing.test_mode.trace_flush = settings.ci.trace_flush || CI::TestVisibility::Flush::Partial.new
 
+          # When timecop is present, Time.now is mocked and .now_without_mock_time is added on Time to
+          # get the current time without the mock.
+          if timecop?
+            settings.time_now_provider = -> do
+              Time.now_without_mock_time
+            rescue NoMethodError
+              # fallback to normal Time.now if Time.now_without_mock_time is not defined for any reason
+              Time.now
+            end
+          end
+
           # startup logs are useless for CI visibility and create noise
           settings.diagnostics.startup_logs.enabled = false
 
@@ -118,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)
@@ -191,6 +203,10 @@ module Datadog
             "Please make sure to set valid site in DD_SITE environment variable"
           end
         end
+
+        def timecop?
+          Gem.loaded_specs.key?("timecop") || defined?(Timecop)
+        end
       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/cucumber/formatter.rb

@@ -187,7 +187,7 @@ module Datadog
           def ok?(result, strict)
             # in minor update in Cucumber 9.2.0, the arity of the `ok?` method changed
             parameters = result.method(:ok?).parameters
-            if parameters == [[:opt, :be_strict]]
+            if parameters == [%i[opt be_strict]]
               result.ok?(strict)
             else
               result.ok?(strict: strict)

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

@@ -23,7 +23,7 @@ module Datadog
               test_name = full_description.strip
               if metadata[:description].empty?
                 # for unnamed it blocks this appends something like "example at ./spec/some_spec.rb:10"
-                test_name += " #{description}"
+                test_name << " #{description}"
               end
 
               test_suite_description = fetch_top_level_example_group[:description]
@@ -33,7 +33,7 @@ module Datadog
               test_name = test_name.sub(test_suite_description, "").strip
 
               if ci_queue?
-                suite_name += " (ci-queue running example [#{test_name}])"
+                suite_name = "#{suite_name} (ci-queue running example [#{test_name}])"
                 test_suite_span = CI.start_test_suite(suite_name)
               end
 
@@ -83,9 +83,12 @@ module Datadog
             private
 
             def fetch_top_level_example_group
-              return metadata[:example_group] unless metadata[:example_group][:parent_example_group]
+              example_group = metadata[:example_group]
+              parent_example_group = example_group[:parent_example_group]
 
-              res = metadata[:example_group][:parent_example_group]
+              return example_group unless parent_example_group
+
+              res = parent_example_group
               while (parent = res[:parent_example_group])
                 res = parent
               end

data/lib/datadog/ci/ext/environment/providers/gitlab.rb

@@ -75,12 +75,12 @@ module Datadog
             end
 
             def git_commit_author_name
-              name, _ = extract_name_email
+              name, _email = extract_name_email
               name
             end
 
             def git_commit_author_email
-              _, email = extract_name_email
+              _name, email = extract_name_email
               email
             end
 

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

@@ -23,10 +23,7 @@ module Datadog
         TAG_NODE_NAME = "ci.node.name"
         TAG_CI_ENV_VARS = "_dd.ci.env_vars"
 
-        POSSIBLE_BUNDLE_LOCATIONS = [
-          "vendor/bundle",
-          ".bundle"
-        ].freeze
+        POSSIBLE_BUNDLE_LOCATIONS = %w[vendor/bundle .bundle].freeze
 
         module_function
 

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

@@ -13,15 +13,16 @@ 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 = [
-          "datadoghq.com",
-          "us3.datadoghq.com",
-          "us5.datadoghq.com",
-          "datadoghq.eu",
-          "ddog-gov.com",
-          "ap1.datadoghq.com"
+        DD_SITE_ALLOWLIST = %w[
+          datadoghq.com
+          us3.datadoghq.com
+          us5.datadoghq.com
+          datadoghq.eu
+          ddog-gov.com
+          ap1.datadoghq.com
         ].freeze
       end
     end

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

@@ -21,7 +21,7 @@ module Datadog
           def valid?
             valid = true
 
-            [:test_id, :test_suite_id, :test_session_id, :coverage].each do |key|
+            %i[test_id test_suite_id test_session_id coverage].each do |key|
               next unless send(key).nil?
 
               Datadog.logger.warn("citestcov event is invalid: [#{key}] is nil. Event: #{self}")

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/test_visibility/serializers/base.rb

@@ -20,13 +20,7 @@ module Datadog
             "type" => "span_type"
           ].freeze
 
-          REQUIRED_FIELDS = [
-            "error",
-            "name",
-            "resource",
-            "start",
-            "duration"
-          ].freeze
+          REQUIRED_FIELDS = %w[error name resource start duration].freeze
 
           attr_reader :trace, :span, :meta, :options
 

data/lib/datadog/ci/test_visibility/serializers/span.rb

@@ -7,11 +7,11 @@ module Datadog
     module TestVisibility
       module Serializers
         class Span < Base
-          CONTENT_FIELDS = (["trace_id", "span_id", "parent_id"] + Base::CONTENT_FIELDS).freeze
+          CONTENT_FIELDS = (%w[trace_id span_id parent_id] + Base::CONTENT_FIELDS).freeze
 
           CONTENT_MAP_SIZE = calculate_content_map_size(CONTENT_FIELDS)
 
-          REQUIRED_FIELDS = (["trace_id", "span_id"] + Base::REQUIRED_FIELDS).freeze
+          REQUIRED_FIELDS = (%w[trace_id span_id] + Base::REQUIRED_FIELDS).freeze
 
           def content_fields
             CONTENT_FIELDS

data/lib/datadog/ci/test_visibility/serializers/test_module.rb

@@ -8,11 +8,11 @@ module Datadog
     module TestVisibility
       module Serializers
         class TestModule < Base
-          CONTENT_FIELDS = (["test_session_id", "test_module_id"] + Base::CONTENT_FIELDS).freeze
+          CONTENT_FIELDS = (%w[test_session_id test_module_id] + Base::CONTENT_FIELDS).freeze
 
           CONTENT_MAP_SIZE = calculate_content_map_size(CONTENT_FIELDS)
 
-          REQUIRED_FIELDS = (["test_session_id", "test_module_id"] + Base::REQUIRED_FIELDS).freeze
+          REQUIRED_FIELDS = (%w[test_session_id test_module_id] + Base::REQUIRED_FIELDS).freeze
 
           def content_fields
             CONTENT_FIELDS

data/lib/datadog/ci/test_visibility/serializers/test_session.rb

@@ -8,11 +8,11 @@ module Datadog
     module TestVisibility
       module Serializers
         class TestSession < Base
-          CONTENT_FIELDS = (["test_session_id"] + Base::CONTENT_FIELDS).freeze
+          CONTENT_FIELDS = (%w[test_session_id] + Base::CONTENT_FIELDS).freeze
 
           CONTENT_MAP_SIZE = calculate_content_map_size(CONTENT_FIELDS)
 
-          REQUIRED_FIELDS = (["test_session_id"] + Base::REQUIRED_FIELDS).freeze
+          REQUIRED_FIELDS = (%w[test_session_id] + Base::REQUIRED_FIELDS).freeze
 
           def content_fields
             CONTENT_FIELDS

data/lib/datadog/ci/test_visibility/serializers/test_suite.rb

@@ -8,11 +8,11 @@ module Datadog
     module TestVisibility
       module Serializers
         class TestSuite < Base
-          CONTENT_FIELDS = (["test_session_id", "test_module_id", "test_suite_id"] + Base::CONTENT_FIELDS).freeze
+          CONTENT_FIELDS = (%w[test_session_id test_module_id test_suite_id] + Base::CONTENT_FIELDS).freeze
 
           CONTENT_MAP_SIZE = calculate_content_map_size(CONTENT_FIELDS)
 
-          REQUIRED_FIELDS = (["test_session_id", "test_module_id", "test_suite_id"] + Base::REQUIRED_FIELDS).freeze
+          REQUIRED_FIELDS = (%w[test_session_id test_module_id test_suite_id] + Base::REQUIRED_FIELDS).freeze
 
           def content_fields
             CONTENT_FIELDS

data/lib/datadog/ci/test_visibility/serializers/test_v1.rb

@@ -8,11 +8,11 @@ module Datadog
     module TestVisibility
       module Serializers
         class TestV1 < Base
-          CONTENT_FIELDS = (["trace_id", "span_id"] + Base::CONTENT_FIELDS).freeze
+          CONTENT_FIELDS = (%w[trace_id span_id] + Base::CONTENT_FIELDS).freeze
 
           CONTENT_MAP_SIZE = calculate_content_map_size(CONTENT_FIELDS)
 
-          REQUIRED_FIELDS = (["trace_id", "span_id"] + Base::REQUIRED_FIELDS).freeze
+          REQUIRED_FIELDS = (%w[trace_id span_id] + Base::REQUIRED_FIELDS).freeze
 
           def content_fields
             CONTENT_FIELDS

data/lib/datadog/ci/test_visibility/serializers/test_v2.rb

@@ -8,15 +8,15 @@ module Datadog
     module TestVisibility
       module Serializers
         class TestV2 < TestV1
-          CONTENT_FIELDS = (["test_session_id", "test_module_id", "test_suite_id"] + TestV1::CONTENT_FIELDS).freeze
+          CONTENT_FIELDS = (%w[test_session_id test_module_id test_suite_id] + TestV1::CONTENT_FIELDS).freeze
 
-          CONTENT_FIELDS_WITH_ITR_CORRELATION_ID = (CONTENT_FIELDS + ["itr_correlation_id"]).freeze
+          CONTENT_FIELDS_WITH_ITR_CORRELATION_ID = (CONTENT_FIELDS + %w[itr_correlation_id]).freeze
 
           CONTENT_MAP_SIZE = calculate_content_map_size(CONTENT_FIELDS)
 
           CONTENT_MAP_SIZE_WITH_ITR_CORRELATION_ID = calculate_content_map_size(CONTENT_FIELDS_WITH_ITR_CORRELATION_ID)
 
-          REQUIRED_FIELDS = (["test_session_id", "test_module_id", "test_suite_id"] + TestV1::REQUIRED_FIELDS).freeze
+          REQUIRED_FIELDS = (%w[test_session_id test_module_id test_suite_id] + TestV1::REQUIRED_FIELDS).freeze
 
           def content_fields
             return CONTENT_FIELDS if itr_correlation_id.nil?

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

@@ -124,6 +124,7 @@ module Datadog
           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?
 

data/lib/datadog/ci/version.rb

@@ -3,10 +3,10 @@
 module Datadog
   module CI
     module VERSION
-      MAJOR = "1"
-      MINOR = "0"
-      PATCH = "0"
-      PRE = "beta6"
+      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.beta6
+  version: 1.0.1
 platform: ruby
 authors:
 - Datadog, Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-05-29 00:00:00.000000000 Z
+date: 2024-06-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: datadog
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.0.0.beta2
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.0.0.beta2
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: msgpack
   requirement: !ruby/object:Gem::Requirement
@@ -201,7 +201,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 2.0.0
 requirements: []
-rubygems_version: 3.4.19
+rubygems_version: 3.5.9
 signing_key: 
 specification_version: 4
 summary: Datadog CI visibility for your ruby application