datadog-ci 0.8.3 → 1.0.0.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bf750f24412b0800ba1599f22c5b12e8679dddc1d0e9a30aed98d0a51a6badd3
-  data.tar.gz: 652631fac9702beb340f136e32d4b72b3b38d7c84a8de7dc8ce4f203dc67983b
+  metadata.gz: 6b3e03ab226d98aac3dd518b1c554452a4c3812cb67e9a1d64762e2fe8767633
+  data.tar.gz: eac352d2b2488d16f979004f617097efe109364069f1c7b78cecfceef5365efa
 SHA512:
-  metadata.gz: 3295d136609aca4be41cc041613873297a5e91bb37a428a6612a1e62f7e547db2bb2c836f4a0348fdd4466d085a29ec78a26962d48f1c59e05163dcb26668783
-  data.tar.gz: 5446bba62689a4133a75b64437efd47f8369814e863c8ddab0c91d52692b5bf71b5be2a4f4264839ec81374ff3c4ff498e4c2cd7a8c54f566e63558cb1f55cff
+  metadata.gz: c56ab91025f2a224e86bd732a5c891e961af184b29618241f8853756780ccba894c11955b00020a70139d72e47f57d22dfdf1f2ed6437f1d4e4a9d998453d7a4
+  data.tar.gz: e7c1aa73096d8d8b49800bbed168f288b7676d8fa328011c3e9c4f7024c86c17cf2c210a94a64dcd80f94121a80b36a824f0ca4e3aa6ccb1c35f682a1fb9e18b

data/CHANGELOG.md

@@ -1,5 +1,32 @@
 ## [Unreleased]
 
+## [1.0.0.beta2] - 2024-04-23
+
+### Added
+
+* Code coverage events writer ([#150])
+* Git tree upload - git command line integration ([#151])
+* Add Git::SearchCommits api client ([#152])
+* Upload packfiles API client ([#153])
+* Git tree uploader ([#154])
+* Git repository unshallowing logic ([#155])
+* Git upload async worker ([#156])
+* Reduce ITR-induced code coverage overhead for default branch ([#157])
+* Skippable tests api client ([#158])
+* Request skippable tests when configuring ITR ([#159])
+* Test skipping implementation ([#160])
+
+## [1.0.0.beta1] - 2024-03-25
+
+### Added
+
+* datadog-cov native extension for per test code coverage ([#137])
+* citestcov transport to serialize and send code coverage events ([#148])
+
+### Removed
+
+* Ruby 2.1-2.6 support is dropped
+
 ## [0.8.3] - 2024-03-20
 
 ### Fixed
@@ -188,6 +215,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/v0.8.3...main
+[1.0.0.beta2]: https://github.com/DataDog/datadog-ci-rb/compare/v1.0.0.beta1...v1.0.0.beta2
+[1.0.0.beta1]: https://github.com/DataDog/datadog-ci-rb/compare/v0.8.3...v1.0.0.beta1
 [0.8.3]: https://github.com/DataDog/datadog-ci-rb/compare/v0.8.2...v0.8.3
 [0.8.2]: https://github.com/DataDog/datadog-ci-rb/compare/v0.8.1...v0.8.2
 [0.8.1]: https://github.com/DataDog/datadog-ci-rb/compare/v0.8.0...v0.8.1
@@ -258,7 +287,20 @@ Currently test suite level visibility is not used by our instrumentation: it wil
 [#123]: https://github.com/DataDog/datadog-ci-rb/issues/123
 [#131]: https://github.com/DataDog/datadog-ci-rb/issues/131
 [#134]: https://github.com/DataDog/datadog-ci-rb/issues/134
+[#137]: https://github.com/DataDog/datadog-ci-rb/issues/137
 [#139]: https://github.com/DataDog/datadog-ci-rb/issues/139
 [#141]: https://github.com/DataDog/datadog-ci-rb/issues/141
 [#142]: https://github.com/DataDog/datadog-ci-rb/issues/142
 [#145]: https://github.com/DataDog/datadog-ci-rb/issues/145
+[#148]: https://github.com/DataDog/datadog-ci-rb/issues/148
+[#150]: https://github.com/DataDog/datadog-ci-rb/issues/150
+[#151]: https://github.com/DataDog/datadog-ci-rb/issues/151
+[#152]: https://github.com/DataDog/datadog-ci-rb/issues/152
+[#153]: https://github.com/DataDog/datadog-ci-rb/issues/153
+[#154]: https://github.com/DataDog/datadog-ci-rb/issues/154
+[#155]: https://github.com/DataDog/datadog-ci-rb/issues/155
+[#156]: https://github.com/DataDog/datadog-ci-rb/issues/156
+[#157]: https://github.com/DataDog/datadog-ci-rb/issues/157
+[#158]: https://github.com/DataDog/datadog-ci-rb/issues/158
+[#159]: https://github.com/DataDog/datadog-ci-rb/issues/159
+[#160]: https://github.com/DataDog/datadog-ci-rb/issues/160

data/LICENSE-3rdparty.csv

@@ -1,3 +1,3 @@
 Component,Origin,License,Copyright
-dd-trace-rb,https://github.com/DataDog/dd-trace-rb,Apache 2.0,"Copyright 2016-Present Datadog, Inc."
+datadog,https://github.com/DataDog/dd-trace-rb,Apache 2.0,"Copyright 2016-Present Datadog, Inc."
 msgpack,https://rubygems.org/gems/msgpack,Apache-2.0,"Copyright (c) 2008-2015 Sadayuki Furuhashi"

data/README.md

@@ -8,19 +8,20 @@
 Datadog's Ruby Library for instrumenting your test and continuous integration pipeline.
 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).
 
-> [!IMPORTANT]
-> The `datadog-ci` gem is currently a component of [`ddtrace`](https://github.com/datadog/dd-trace-rb) and should not be used without it.
->
-> We expect this to change in the future.
-
 ## Installation
 
 Add to your Gemfile.
 
 ```ruby
-gem "ddtrace"
+group :test do
+  gem "datadog-ci"
+end
 ```
 
+## Upgrade from ddtrace v1.x
+
+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
@@ -34,26 +35,14 @@ require 'datadog/ci'
 # Only activates test instrumentation on CI
 if ENV["DD_ENV"] == "ci"
   Datadog.configure do |c|
-    # Configures the tracer to ensure results delivery
-    c.ci.enabled = true
-
     # The name of the service or library under test
     c.service = 'my-ruby-app'
-
-    # Enables the RSpec instrumentation
-    c.ci.instrument :rspec, **options
+    c.ci.enabled = true
+    c.ci.instrument :rspec
   end
 end
 ```
 
-`options` are the following keyword arguments:
-
-| Key | Description | Default |
-| --- | ----------- | ------- |
-| `enabled` | Defines whether RSpec tests should be traced. Useful for temporarily disabling tracing. `true` or `false` | `true` |
-| `service_name` | Service name used for `rspec` instrumentation. | `'rspec'` |
-| `operation_name` | *DEPRECATED, to be removed in 1.0* Operation name used for `rspec` instrumentation (has no effect in agentless mode or when using newer agent versions). | `'rspec.example'` |
-
 ### Minitest
 
 The Minitest integration will trace all executions of tests when using `minitest` test framework.
@@ -68,13 +57,10 @@ require 'datadog/ci'
 if ENV["DD_ENV"] == "ci"
 # Configure default Minitest integration
   Datadog.configure do |c|
-    # Configures the tracer to ensure results delivery
-    c.ci.enabled = true
-
     # The name of the service or library under test
     c.service = 'my-ruby-app'
-
-    c.ci.instrument :minitest, **options
+    c.ci.enabled = true
+    c.ci.instrument :minitest
   end
 end
 ```
@@ -91,21 +77,13 @@ require 'minitest/autorun'
 
 if ENV["DD_ENV"] == "ci"
   Datadog.configure do |c|
-    c.ci.enabled = true
     c.service = 'my-ruby-app'
+    c.ci.enabled = true
     c.ci.instrument :minitest
   end
 end
 ```
 
-`options` are the following keyword arguments:
-
-| Key | Description | Default |
-| --- | ----------- | ------- |
-| `enabled` | Defines whether Minitest tests should be traced. Useful for temporarily disabling tracing. `true` or `false` | `true` |
-| `service_name` | Service name used for `minitest` instrumentation. | `'minitest'` |
-| `operation_name` | *DEPRECATED, to be removed in 1.0* Operation name used for `minitest` instrumentation (has no effect in agentless mode or when using newer agent versions). | `'minitest.test'` |
-
 ### Cucumber
 
 Activate `Cucumber` integration with configuration
@@ -117,25 +95,31 @@ require 'datadog/ci'
 # Only activates test instrumentation on CI
 if ENV["DD_ENV"] == "ci"
   Datadog.configure do |c|
-    # Configures the tracer to ensure results delivery
-    c.ci.enabled = true
-
     # The name of the service or library under test
     c.service = 'my-ruby-app'
-
-    # Enables the Cucumber instrumentation
-    c.ci.instrument :cucumber, **options
+    c.ci.enabled = true
+    c.ci.instrument :cucumber
   end
 end
 ```
 
-`options` are the following keyword arguments:
+### Instrumentation options
+
+Configuration `ci.instrument` accepts the following optional parameters:
+
+- `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)
 
-| Key | Description | Default |
-| --- | ----------- | ------- |
-| `enabled` | Defines whether Cucumber tests should be traced. Useful for temporarily disabling tracing. `true` or `false` | `true` |
-| `service_name` | Service name used for `cucumber` instrumentation. | `'cucumber'` |
-| `operation_name` | *DEPRECATED, to be removed in 1.0* Operation name used for `cucumber` instrumentation (has no effect in agentless mode or when using newer agent versions). | `'cucumber.test'` |
+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
 
@@ -160,7 +144,7 @@ or other external calls like here:
 
 ![Test trace with redis instrumented](./docs/screenshots/test-trace-with-redis.png)
 
-In order to achieve this you can configure ddtrace instrumentations in your configure block:
+To achieve this, add Datadog tracing instrumentations in your `Datadog.configure` block:
 
 ```ruby
 Datadog.configure do |c|
@@ -173,13 +157,13 @@ end
 ...or enable auto instrumentation in your test_helper/spec_helper:
 
 ```ruby
-require "ddtrace/auto_instrument"
+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 [ddtrace documentation](https://github.com/DataDog/dd-trace-rb/blob/master/docs/GettingStarted.md)
+For the full list of available instrumentations see [datadog documentation](https://github.com/DataDog/dd-trace-rb/blob/master/docs/GettingStarted.md)
 
 ### WebMock
 
@@ -193,8 +177,7 @@ Webmock accordingly.
 
 ```ruby
 # when using agentless mode
-# note to use the correct datadog site (e.g. datadoghq.eu, etc)
-WebMock.disable_net_connect!(:allow => /datadoghq.com/)
+WebMock.disable_net_connect!(:allow => /datadoghq/)
 
 # when using agent
 WebMock.disable_net_connect!(:allow_localhost => true)
@@ -217,8 +200,10 @@ VCR.configure do |config|
   config.ignore_hosts "127.0.0.1", "localhost"
 
   # when using agentless mode
-  # note to use the correct datadog site (e.g. datadoghq.eu, etc)
-  config.ignore_hosts "citestcycle-intake.datadoghq.com", "api.datadoghq.com"
+  config.ignore_request do |request|
+    # ignore all requests to datadoghq hosts
+    request.uri =~ /datadoghq/
+  end
 end
 ```
 
@@ -226,7 +211,7 @@ end
 
 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 `diagnostics.startup_logs.enabled = false` or `DD_TRACE_STARTUP_LOGS=0`.
+via `DD_TRACE_STARTUP_LOGS=0` or in the `Datadog.configure` block:
 
 ```ruby
 Datadog.configure { |c| c.diagnostics.startup_logs.enabled = false }
@@ -236,7 +221,7 @@ Datadog.configure { |c| c.diagnostics.startup_logs.enabled = false }
 
 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 `diagnostics.debug = true` or `DD_TRACE_DEBUG=1`.
+You can enable this via `DD_TRACE_DEBUG=1` or in the `Datadog.configure` block:
 
 ```ruby
 Datadog.configure { |c| c.diagnostics.debug = true }

data/ext/datadog_cov/datadog_cov.c

@@ -0,0 +1,192 @@
+#include <ruby.h>
+#include <ruby/debug.h>
+
+// constants
+#define DD_COV_TARGET_FILES 1
+#define DD_COV_TARGET_LINES 2
+
+// Data structure
+struct dd_cov_data
+{
+  VALUE root;
+  int mode;
+  VALUE coverage;
+};
+
+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);
+}
+
+static void dd_cov_free(void *ptr)
+{
+  struct dd_cov_data *dd_cov_data = ptr;
+
+  xfree(dd_cov_data);
+}
+
+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);
+}
+
+const rb_data_type_t dd_cov_data_type = {
+    .wrap_struct_name = "dd_cov",
+    .function = {
+        .dmark = dd_cov_mark,
+        .dfree = dd_cov_free,
+        .dsize = NULL,
+        .dcompact = dd_cov_compact},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY};
+
+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->mode = DD_COV_TARGET_FILES;
+  return obj;
+}
+
+// DDCov methods
+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")));
+  if (!RTEST(rb_root))
+  {
+    rb_raise(rb_eArgError, "root is required");
+  }
+
+  VALUE rb_mode = rb_hash_lookup(opt, ID2SYM(rb_intern("mode")));
+  if (!RTEST(rb_mode) || rb_mode == ID2SYM(rb_intern("files")))
+  {
+    mode = DD_COV_TARGET_FILES;
+  }
+  else if (rb_mode == ID2SYM(rb_intern("lines")))
+  {
+    mode = DD_COV_TARGET_LINES;
+  }
+  else
+  {
+    rb_raise(rb_eArgError, "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->mode = mode;
+
+  return Qnil;
+}
+
+static void dd_cov_update_line_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)
+  {
+    return;
+  }
+
+  if (dd_cov_data->root == Qnil)
+  {
+    return;
+  }
+
+  char *c_root = RSTRING_PTR(dd_cov_data->root);
+  if (c_root == NULL)
+  {
+    return;
+  }
+  long root_len = RSTRING_LEN(dd_cov_data->root);
+  // check that root is a prefix of the filename
+  // so this file is located under the given root
+  if (strncmp(c_root, filename, root_len) != 0)
+  {
+    return;
+  }
+
+  VALUE rb_str_source_file = rb_str_new2(filename);
+
+  if (dd_cov_data->mode == DD_COV_TARGET_FILES)
+  {
+    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)
+  {
+    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);
+  }
+}
+
+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);
+
+  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;
+
+  dd_cov_data->coverage = rb_hash_new();
+
+  return cov;
+}
+
+void Init_datadog_cov(void)
+{
+  VALUE mDatadog = rb_define_module("Datadog");
+  VALUE mCI = rb_define_module_under(mDatadog, "CI");
+  VALUE mITR = rb_define_module_under(mCI, "ITR");
+  VALUE mCoverage = rb_define_module_under(mITR, "Coverage");
+  VALUE cDatadogCov = rb_define_class_under(mCoverage, "DDCov", rb_cObject);
+
+  rb_define_alloc_func(cDatadogCov, dd_cov_allocate);
+
+  rb_define_method(cDatadogCov, "initialize", dd_cov_initialize, -1);
+  rb_define_method(cDatadogCov, "start", dd_cov_start, 0);
+  rb_define_method(cDatadogCov, "stop", dd_cov_stop, 0);
+}

data/ext/datadog_cov/extconf.rb

@@ -0,0 +1,18 @@
+if RUBY_ENGINE != "ruby" || Gem.win_platform?
+  warn(
+    "WARN: Skipping build of code coverage native extension because of unsupported platform."
+  )
+
+  File.write("Makefile", "all install clean: # dummy makefile that does nothing")
+  exit
+end
+
+require "mkmf"
+
+# Tag the native extension library with the Ruby version and Ruby platform.
+# This makes it easier for development (avoids "oops I forgot to rebuild when I switched my Ruby") and ensures that
+# the wrong library is never loaded.
+# When requiring, we need to use the exact same string, including the version and the platform.
+EXTENSION_NAME = "datadog_cov.#{RUBY_VERSION}_#{RUBY_PLATFORM}".freeze
+
+create_makefile(EXTENSION_NAME)

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

@@ -1,7 +1,10 @@
 # frozen_string_literal: true
 
 require_relative "../ext/settings"
+require_relative "../git/tree_uploader"
 require_relative "../itr/runner"
+require_relative "../itr/coverage/transport"
+require_relative "../itr/coverage/writer"
 require_relative "../test_visibility/flush"
 require_relative "../test_visibility/recorder"
 require_relative "../test_visibility/null_recorder"
@@ -10,25 +13,34 @@ require_relative "../test_visibility/serializers/factories/test_suite_level"
 require_relative "../test_visibility/transport"
 require_relative "../transport/api/builder"
 require_relative "../transport/remote_settings_api"
+require_relative "../worker"
 
 module Datadog
   module CI
     module Configuration
       # Adds CI behavior to Datadog trace components
       module Components
-        attr_reader :ci_recorder
+        attr_reader :ci_recorder, :itr
 
         def initialize(settings)
           # Activate CI mode if enabled
           if settings.ci.enabled
             activate_ci!(settings)
           else
+            @itr = nil
             @ci_recorder = TestVisibility::NullRecorder.new
           end
 
           super
         end
 
+        def shutdown!(replacement = nil)
+          super
+
+          @ci_recorder&.shutdown!
+          @itr&.shutdown!
+        end
+
         def activate_ci!(settings)
           # Configure ddtrace library for CI visibility mode
           # Deactivate telemetry
@@ -49,10 +61,17 @@ module Datadog
 
           # transport creation
           writer_options = settings.ci.writer_options
+          coverage_writer = nil
           test_visibility_api = build_test_visibility_api(settings)
 
           if test_visibility_api
-            writer_options[:transport] = Datadog::CI::TestVisibility::Transport.new(
+            # setup writer for code coverage payloads
+            coverage_writer = ITR::Coverage::Writer.new(
+              transport: ITR::Coverage::Transport.new(api: test_visibility_api)
+            )
+
+            # configure tracing writer to send traces to CI visibility backend
+            writer_options[:transport] = TestVisibility::Transport.new(
               api: test_visibility_api,
               serializers_factory: serializers_factory(settings),
               dd_env: settings.env
@@ -71,21 +90,36 @@ module Datadog
 
           settings.tracing.test_mode.writer_options = writer_options
 
-          itr = Datadog::CI::ITR::Runner.new(
-            enabled: settings.ci.enabled && settings.ci.itr_enabled
-          )
-
           remote_settings_api = Transport::RemoteSettingsApi.new(
             api: test_visibility_api,
             dd_env: settings.env
           )
 
+          itr = ITR::Runner.new(
+            api: test_visibility_api,
+            dd_env: settings.env,
+            coverage_writer: coverage_writer,
+            enabled: settings.ci.enabled && settings.ci.itr_enabled
+          )
+
+          git_tree_uploader = Git::TreeUploader.new(api: test_visibility_api)
+          git_tree_upload_worker = if settings.ci.git_metadata_upload_enabled
+            Worker.new do |repository_url|
+              git_tree_uploader.call(repository_url)
+            end
+          else
+            DummyWorker.new
+          end
+
           # CI visibility recorder global instance
           @ci_recorder = TestVisibility::Recorder.new(
             test_suite_level_visibility_enabled: !settings.ci.force_test_level_visibility,
             itr: itr,
-            remote_settings_api: remote_settings_api
+            remote_settings_api: remote_settings_api,
+            git_tree_upload_worker: git_tree_upload_worker
           )
+
+          @itr = itr
         end
 
         def build_test_visibility_api(settings)
@@ -122,9 +156,9 @@ module Datadog
 
         def serializers_factory(settings)
           if settings.ci.force_test_level_visibility
-            Datadog::CI::TestVisibility::Serializers::Factories::TestLevel
+            TestVisibility::Serializers::Factories::TestLevel
           else
-            Datadog::CI::TestVisibility::Serializers::Factories::TestSuiteLevel
+            TestVisibility::Serializers::Factories::TestSuiteLevel
           end
         end
 

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

@@ -47,7 +47,7 @@ module Datadog
                 o.after_set do |value|
                   if value
                     Datadog::Core.log_deprecation do
-                      "The experimental_test_suite_level_visibility_enabled setting has no effect and will be removed in 1.0. " \
+                      "The experimental_test_suite_level_visibility_enabled setting has no effect and will be removed in 2.0. " \
                         "Test suite level visibility is now enabled by default. " \
                         "If you want to disable test suite level visibility set configuration.ci.force_test_level_visibility = true."
                     end
@@ -61,6 +61,12 @@ module Datadog
                 o.default false
               end
 
+              option :git_metadata_upload_enabled do |o|
+                o.type :bool
+                o.env CI::Ext::Settings::ENV_GIT_METADATA_UPLOAD_ENABLED
+                o.default true
+              end
+
               define_method(:instrument) do |integration_name, options = {}, &block|
                 return unless enabled
 

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

@@ -26,21 +26,6 @@ module Datadog
                 Utils::Configuration.fetch_service_name(Ext::DEFAULT_SERVICE_NAME)
               end
             end
-
-            # @deprecated Will be removed in 1.0
-            option :operation_name do |o|
-              o.type :string
-              o.env Ext::ENV_OPERATION_NAME
-              o.default Ext::OPERATION_NAME
-
-              o.after_set do |value|
-                if value && value != Ext::OPERATION_NAME
-                  Datadog::Core.log_deprecation do
-                    "The operation_name setting has no effect and will be removed in 1.0"
-                  end
-                end
-              end
-            end
           end
         end
       end

data/lib/datadog/ci/contrib/cucumber/ext.rb

@@ -5,7 +5,7 @@ module Datadog
     module Contrib
       module Cucumber
         # Cucumber integration constants
-        # TODO: mark as `@public_api` when GA, to protect from resource and tag name changes.
+        # @public_api
         module Ext
           ENV_ENABLED = "DD_TRACE_CUCUMBER_ENABLED"
           DEFAULT_SERVICE_NAME = "cucumber"
@@ -13,10 +13,6 @@ module Datadog
           FRAMEWORK = "cucumber"
 
           STEP_SPAN_TYPE = "step"
-
-          # TODO: remove in 1.0
-          ENV_OPERATION_NAME = "DD_TRACE_CUCUMBER_OPERATION_NAME"
-          OPERATION_NAME = "cucumber.test"
         end
       end
     end