datadog-ci 1.25.0 → 1.27.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e68ff85fe19330eb395ad72da915dbad1bf98c02f5c917402da73b4f5ebab745
-  data.tar.gz: aa30fff0bb9f8349e3c9caa5d9ff77cbdd57b7c1cf8e61fdd19d98ebcb271711
+  metadata.gz: 47e2dae93f942112cea718e6772f7c586214d97a4d3fb9d8ecf9643826c4e9a0
+  data.tar.gz: 80558ee95a33818f80f937981b9c0533c8e638444ac181a31683ea22d53c7ad7
 SHA512:
-  metadata.gz: '0668a4e35ef63218065e169ab00dfe7e7bfc4439c35f6020611d35a2a625dbdb20d38aa3e7edd3a5cf3769e15bd31077717141029223637cabeb34b172069aa8'
-  data.tar.gz: 119fef9be7bd8ab89c013fa545dd3d09b8013fa6ef79db438e59c12b8fd1acc42734bc9faa8f0f3ff63d28fec0b3480c7f43e89ca10a5ce83ee7b6e7a26b1422
+  metadata.gz: d442d8921f4ba7fd8ae372544f518edeaac97a6a4b89aa52d2cc8e6ff8035e3131d61104fc4bce7030634970fc2cd52a13d929944ad08497e7abfcf174634ccb
+  data.tar.gz: 4f58631b0792099fdff630a65c10f162e3c933ac2e5c32b53addbaebc4533daf4c87ae7112b69abbd4cf113257a4ac1cc58dc59fb2f8b63184ba3f9abb1aec8d

data/CHANGELOG.md

@@ -1,5 +1,32 @@
 ## [Unreleased]
 
+## [1.27.0] - 2026-01-22
+
+
+### Added
+
+* Add context-level code coverage tracking for RSpec to improve Test Impact Analysis correctness ([#460][])
+* Add automatic uploading of code coverage reports to Datadog Code Coverage product ([#456][])
+
+### Changed
+
+* Use pagination for known tests API ([#455][]) ([#458][])
+* GitHub Actions: extract numeric job ID for accurate job URLs ([#457][])
+
+### Fixed
+
+* RSpec: take into account Test Management disabled tests when deciding to skip context hooks ([#463][])
+* Fix for attempt-to-fix flow: don't mask failures for flaky tests being fixed ([#464][])
+* Pass -c safe.directory to all git commands to fix dubious ownership errors ([#454][])
+* fix: rename DD_TRACE_CI_ENABLED to DD_CIVISIBILITY_ENABLED with backwards compatibility ([#453][])
+
+## [1.26.0] - 2026-01-09
+
+========== Changelog ==========
+### Changed
+
+* Track constants usage in each Ruby file as a static dependency to enrich Test Impact Analysis data ([#442][])
+
 ## [1.25.0] - 2025-12-19
 
 ### Added
@@ -571,7 +598,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.25.0...main
+[Unreleased]: https://github.com/DataDog/datadog-ci-rb/compare/v1.27.0...main
+[1.27.0]: https://github.com/DataDog/datadog-ci-rb/compare/v1.26.0...v1.27.0
+[1.26.0]: https://github.com/DataDog/datadog-ci-rb/compare/v1.25.0...v1.26.0
 [1.25.0]: https://github.com/DataDog/datadog-ci-rb/compare/v1.24.0...v1.25.0
 [1.24.0]: https://github.com/DataDog/datadog-ci-rb/compare/v1.23.3...v1.24.0
 [1.23.3]: https://github.com/DataDog/datadog-ci-rb/compare/v1.23.2...v1.23.3
@@ -809,5 +838,15 @@ Currently test suite level visibility is not used by our instrumentation: it wil
 [#433]: https://github.com/DataDog/datadog-ci-rb/issues/433
 [#436]: https://github.com/DataDog/datadog-ci-rb/issues/436
 [#440]: https://github.com/DataDog/datadog-ci-rb/issues/440
+[#442]: https://github.com/DataDog/datadog-ci-rb/issues/442
 [#444]: https://github.com/DataDog/datadog-ci-rb/issues/444
-[#446]: https://github.com/DataDog/datadog-ci-rb/issues/446
+[#446]: https://github.com/DataDog/datadog-ci-rb/issues/446
+[#453]: https://github.com/DataDog/datadog-ci-rb/issues/453
+[#454]: https://github.com/DataDog/datadog-ci-rb/issues/454
+[#455]: https://github.com/DataDog/datadog-ci-rb/issues/455
+[#456]: https://github.com/DataDog/datadog-ci-rb/issues/456
+[#457]: https://github.com/DataDog/datadog-ci-rb/issues/457
+[#458]: https://github.com/DataDog/datadog-ci-rb/issues/458
+[#460]: https://github.com/DataDog/datadog-ci-rb/issues/460
+[#463]: https://github.com/DataDog/datadog-ci-rb/issues/463
+[#464]: https://github.com/DataDog/datadog-ci-rb/issues/464

data/ext/datadog_ci_native/ci.c

@@ -1,10 +1,12 @@
 #include "datadog_cov.h"
-#include "datadog_source_code.h"
+#include "datadog_method_inspect.h"
+#include "iseq_collector.h"
 
 void Init_datadog_ci_native(void) {
   // Coverage::DDCov
   Init_datadog_cov();
 
-  // Utils::SourceCode
-  Init_datadog_source_code();
+  // SourceCode
+  Init_datadog_method_inspect();
+  Init_iseq_collector();
 }

data/ext/datadog_ci_native/datadog_common.c

@@ -0,0 +1,64 @@
+#include "datadog_common.h"
+#include <ruby.h>
+#include <string.h>
+
+bool dd_ci_is_path_included(const char *path, const char *root_path,
+                            long root_path_len, const char *ignored_path,
+                            long ignored_path_len) {
+  if (strncmp(root_path, path, root_path_len) != 0) {
+    return false;
+  }
+  if (ignored_path_len > 0 &&
+      strncmp(ignored_path, path, ignored_path_len) == 0) {
+    return false;
+  }
+  return true;
+}
+
+char *dd_ci_ruby_strndup(const char *str, size_t size) {
+  char *dup;
+
+  dup = xmalloc(size + 1);
+  memcpy(dup, str, size);
+  dup[size] = '\0';
+
+  return dup;
+}
+
+VALUE dd_ci_rescue_nil(VALUE (*function_to_call_safely)(VALUE),
+                       VALUE function_to_call_safely_arg) {
+  int exception_state;
+  // rb_protect sets exception_state to non-zero if an exception occurs
+  VALUE result = rb_protect(function_to_call_safely,
+                            function_to_call_safely_arg, &exception_state);
+  if (exception_state != 0) {
+    rb_set_errinfo(Qnil); // Clear the exception
+    return Qnil;
+  }
+  return result;
+}
+
+VALUE dd_ci_get_const_source_location(VALUE const_name_str) {
+  return rb_funcall(rb_cObject, rb_intern("const_source_location"), 1,
+                    const_name_str);
+}
+
+VALUE dd_ci_safely_get_const_source_location(VALUE const_name_str) {
+  return dd_ci_rescue_nil(dd_ci_get_const_source_location, const_name_str);
+}
+
+VALUE dd_ci_resolve_const_to_file(VALUE const_name_str) {
+  VALUE source_location =
+      dd_ci_safely_get_const_source_location(const_name_str);
+  if (NIL_P(source_location) || !RB_TYPE_P(source_location, T_ARRAY) ||
+      RARRAY_LEN(source_location) == 0) {
+    return Qnil;
+  }
+
+  VALUE filename = RARRAY_AREF(source_location, 0);
+  if (NIL_P(filename) || !RB_TYPE_P(filename, T_STRING)) {
+    return Qnil;
+  }
+
+  return filename;
+}

data/ext/datadog_ci_native/datadog_common.h

@@ -0,0 +1,60 @@
+#ifndef DATADOG_COMMON_H
+#define DATADOG_COMMON_H
+
+#include <ruby.h>
+#include <stdbool.h>
+
+/* ---- Path filtering ----------------------------------------------------- */
+
+/**
+ * Check if a file path is under root_path and not under ignored_path.
+ * Returns true if the path should be included, false otherwise.
+ *
+ * @param path          The file path to check
+ * @param root_path     The root path prefix (required)
+ * @param root_path_len Length of root_path
+ * @param ignored_path  Path prefix to exclude (can be NULL)
+ * @param ignored_path_len Length of ignored_path (0 if not set)
+ */
+bool dd_ci_is_path_included(const char *path, const char *root_path,
+                            long root_path_len, const char *ignored_path,
+                            long ignored_path_len);
+
+/* ---- Utility functions -------------------------------------------------- */
+
+/**
+ * Duplicate a string of given size using Ruby's memory allocator.
+ * The returned string is null-terminated.
+ */
+char *dd_ci_ruby_strndup(const char *str, size_t size);
+
+/**
+ * Safe exception handling - equivalent to Ruby's "begin/rescue nil".
+ * Calls function_to_call_safely with the given argument and returns Qnil
+ * if an exception occurs (clearing the exception state).
+ */
+VALUE dd_ci_rescue_nil(VALUE (*function_to_call_safely)(VALUE),
+                       VALUE function_to_call_safely_arg);
+
+/**
+ * Get source location for a given constant name string.
+ * Calls Object.const_source_location(const_name_str).
+ * Returns an array [filename, lineno] or nil if not found.
+ */
+VALUE dd_ci_get_const_source_location(VALUE const_name_str);
+
+/**
+ * Safely get source location for a given constant name string.
+ * Returns Qnil if an exception occurs (e.g., for C-defined or anonymous
+ * classes).
+ */
+VALUE dd_ci_safely_get_const_source_location(VALUE const_name_str);
+
+/**
+ * Resolve a constant name to its source file path.
+ * Returns the filename (String) where the constant is defined, or Qnil if not
+ * found.
+ */
+VALUE dd_ci_resolve_const_to_file(VALUE const_name_str);
+
+#endif /* DATADOG_COMMON_H */

data/ext/datadog_ci_native/datadog_cov.c

@@ -4,6 +4,8 @@
 
 #include <stdbool.h>
 
+#include "datadog_common.h"
+
 // This is a native extension that collects a list of Ruby files that were
 // executed during the test run. It is used to optimize the test suite by
 // running only the tests that are affected by the changes.
@@ -16,35 +18,6 @@ enum threading_mode { single, multi };
 // functions declarations
 static void on_newobj_event(VALUE tracepoint_data, void *data);
 
-// utility functions
-static char *ruby_strndup(const char *str, size_t size) {
-  char *dup;
-
-  dup = xmalloc(size + 1);
-  memcpy(dup, str, size);
-  dup[size] = '\0';
-
-  return dup;
-}
-
-// Equivalent to Ruby "begin/rescue nil" call, where we call a C function and
-// swallow the exception if it occurs - const_source_location often fails with
-// exceptions for classes that are defined in C or for anonymous classes.
-static VALUE rescue_nil(VALUE (*function_to_call_safely)(VALUE),
-                        VALUE function_to_call_safely_arg) {
-  int exception_state;
-  // rb_protect sets exception_state to non-zero if an exception occurs
-  // see
-  // https://github.com/ruby/ruby/blob/3219ecf4f659908674f534491d8934ba54e1143d/include/ruby/internal/intern/proc.h#L349
-  VALUE result = rb_protect(function_to_call_safely,
-                            function_to_call_safely_arg, &exception_state);
-  if (exception_state != 0) {
-    return Qnil;
-  }
-
-  return result;
-}
-
 static int mark_key_for_gc_i(st_data_t key, st_data_t _value, st_data_t _data) {
   VALUE klass = (VALUE)key;
   // mark klass link for GC as non-movable to avoid changing hashtable's keys
@@ -158,18 +131,9 @@ static VALUE dd_cov_allocate(VALUE klass) {
 // not in the ignored folder) and adds it to the impacted_files hash.
 static bool record_impacted_file(struct dd_cov_data *dd_cov_data,
                                  VALUE filename) {
-  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) {
-    return false;
-  }
-
-  // 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) {
+  if (!dd_ci_is_path_included(RSTRING_PTR(filename), dd_cov_data->root,
+                              dd_cov_data->root_len, dd_cov_data->ignored_path,
+                              dd_cov_data->ignored_path_len)) {
     return false;
   }
 
@@ -211,25 +175,14 @@ static void on_line_event(rb_event_flag_t event, VALUE data, VALUE self, ID id,
   record_impacted_file(dd_cov_data, filename);
 }
 
-// Get source location for a given class name
-static VALUE get_source_location(VALUE klass_name) {
-  return rb_funcall(rb_cObject, rb_intern("const_source_location"), 1,
-                    klass_name);
-}
-
-// Get source location for a given class name and swallow any exceptions
-static VALUE safely_get_source_location(VALUE klass_name) {
-  return rescue_nil(get_source_location, klass_name);
-}
-
 // Safely get class name, returns Qnil on any error
 static VALUE safely_get_class_name(VALUE klass) {
-  return rescue_nil(rb_class_name, klass);
+  return dd_ci_rescue_nil(rb_class_name, klass);
 }
 
 // Safely get module ancestors, returns Qnil on any error
 static VALUE safely_get_mod_ancestors(VALUE klass) {
-  return rescue_nil(rb_mod_ancestors, klass);
+  return dd_ci_rescue_nil(rb_mod_ancestors, klass);
 }
 
 static bool record_impacted_klass(struct dd_cov_data *dd_cov_data,
@@ -239,14 +192,8 @@ static bool record_impacted_klass(struct dd_cov_data *dd_cov_data,
     return false;
   }
 
-  VALUE source_location = safely_get_source_location(klass_name);
-  if (source_location == Qnil || !RB_TYPE_P(source_location, T_ARRAY) ||
-      RARRAY_LEN(source_location) == 0) {
-    return false;
-  }
-
-  VALUE filename = RARRAY_AREF(source_location, 0);
-  if (filename == Qnil || !RB_TYPE_P(filename, T_STRING)) {
+  VALUE filename = dd_ci_resolve_const_to_file(klass_name);
+  if (filename == Qnil) {
     return false;
   }
 
@@ -349,12 +296,13 @@ static VALUE dd_cov_initialize(int argc, VALUE *argv, VALUE self) {
 
   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);
+  dd_cov_data->root =
+      dd_ci_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);
+    dd_cov_data->ignored_path = dd_ci_ruby_strndup(
+        RSTRING_PTR(rb_ignored_path), dd_cov_data->ignored_path_len);
   }
 
   if (rb_allocation_tracing_enabled == Qtrue) {

data/ext/datadog_ci_native/datadog_method_inspect.c

@@ -0,0 +1,22 @@
+#include <ruby.h>
+
+#include "ruby_internal.h"
+
+static VALUE last_line_from_iseq(VALUE self, VALUE iseqw) {
+  const rb_iseq_t *iseq = rb_iseqw_to_iseq(iseqw);
+
+  int line;
+  rb_iseq_code_location(iseq, NULL, NULL, &line, NULL);
+
+  return INT2NUM(line);
+}
+
+void Init_datadog_method_inspect(void) {
+  VALUE mDatadog = rb_define_module("Datadog");
+  VALUE mCI = rb_define_module_under(mDatadog, "CI");
+  VALUE mSourceCode = rb_define_module_under(mCI, "SourceCode");
+  VALUE mMethodInspect = rb_define_module_under(mSourceCode, "MethodInspect");
+
+  rb_define_singleton_method(mMethodInspect, "_native_last_line_from_iseq",
+                             last_line_from_iseq, 1);
+}

data/ext/datadog_ci_native/datadog_method_inspect.h

@@ -0,0 +1,4 @@
+#pragma once
+
+void Init_datadog_method_inspect(void);
+

data/ext/datadog_ci_native/imemo_helpers.c

@@ -0,0 +1,16 @@
+#include "imemo_helpers.h"
+#include "ruby_internal.h"
+
+int dd_ci_imemo_type(VALUE imemo) {
+  return (RBASIC(imemo)->flags >> FL_USHIFT) & DD_CI_IMEMO_MASK;
+}
+
+bool dd_ci_imemo_iseq_p(VALUE v) {
+  if (!rb_objspace_internal_object_p(v))
+    return false;
+  if (!RB_TYPE_P(v, T_IMEMO))
+    return false;
+  if (dd_ci_imemo_type(v) != DD_CI_IMEMO_TYPE_ISEQ)
+    return false;
+  return true;
+}

data/ext/datadog_ci_native/imemo_helpers.h

@@ -0,0 +1,32 @@
+#ifndef IMEMO_HELPERS_H
+#define IMEMO_HELPERS_H
+
+#include <ruby.h>
+#include <stdbool.h>
+
+/*
+  Here we are using the same trick that debug gem uses here:
+
+  https://github.com/ruby/debug/blob/master/ext/debug/iseq_collector.c
+
+  These functions allow us to check if the VALUE is an ISeq object
+*/
+
+/*
+ * IMEMO (internal memo) helpers for working with Ruby's internal objects.
+ */
+
+#define DD_CI_IMEMO_TYPE_ISEQ 7
+#define DD_CI_IMEMO_MASK 0x0f
+
+/**
+ * Get the IMEMO type from flags.
+ */
+int dd_ci_imemo_type(VALUE imemo);
+
+/**
+ * Check if a VALUE is an internal ISeq object.
+ */
+bool dd_ci_imemo_iseq_p(VALUE v);
+
+#endif /* IMEMO_HELPERS_H */

data/ext/datadog_ci_native/iseq_collector.c

@@ -0,0 +1,65 @@
+#include <ruby.h>
+
+#include "imemo_helpers.h"
+#include "ruby_internal.h"
+
+/*
+ * Callback for rb_objspace_each_objects.
+ *
+ * The callback receives a range of object slots [vstart, vend) with given
+ * stride. Each slot may contain a live object, a freed slot, or garbage.
+ * We check each slot for ISeq objects and add them to the result array.
+ *
+ * See:
+ * https://github.com/ruby/ruby/blob/c99670d6683fec770271d35c2ae082514b1abce3/gc.c#L3550
+ */
+static int collect_iseqs_callback(void *vstart, void *vend, size_t stride,
+                                  void *data) {
+  VALUE iseqs_array = (VALUE)data;
+
+  for (VALUE v = (VALUE)vstart; v != (VALUE)vend; v += stride) {
+    if (dd_ci_imemo_iseq_p(v)) {
+      VALUE iseq = rb_iseqw_new((void *)v);
+      rb_ary_push(iseqs_array, iseq);
+    }
+  }
+  return 0;
+}
+
+/*
+ * ISeqCollector.collect_iseqs
+ *
+ * Walk all live objects in the Ruby object space and collect all
+ * instruction sequences (ISeqs) into an array.
+ *
+ * @return [Array<RubyVM::InstructionSequence>] Array of all live ISeqs
+ *
+ * NOTE:
+ * - Only sees ISeqs that still exist (top-level file ISeqs might be GC'd).
+ *   Method ISeqs usually survive longer.
+ * - The returned ISeqs include all types: method bodies, class bodies,
+ *   blocks, etc.
+
+ * It is very similar to iseq_collector from debug gem:
+ * https://github.com/ruby/debug/blob/master/ext/debug/iseq_collector.c
+*/
+
+static VALUE iseq_collector_collect(VALUE self) {
+  VALUE iseqs_array = rb_ary_new();
+
+  rb_objspace_each_objects(collect_iseqs_callback, (void *)iseqs_array);
+
+  return iseqs_array;
+}
+
+/* ---- Module initialization ---------------------------------------------- */
+
+void Init_iseq_collector(void) {
+  VALUE mDatadog = rb_define_module("Datadog");
+  VALUE mCI = rb_define_module_under(mDatadog, "CI");
+  VALUE mSourceCode = rb_define_module_under(mCI, "SourceCode");
+  VALUE mISeqCollector = rb_define_module_under(mSourceCode, "ISeqCollector");
+
+  rb_define_singleton_method(mISeqCollector, "collect_iseqs",
+                             iseq_collector_collect, 0);
+}

data/ext/datadog_ci_native/iseq_collector.h

@@ -0,0 +1,6 @@
+#ifndef ISEQ_COLLECTOR_H
+#define ISEQ_COLLECTOR_H
+
+void Init_iseq_collector(void);
+
+#endif /* ISEQ_COLLECTOR_H */

data/ext/datadog_ci_native/ruby_internal.h

@@ -0,0 +1,48 @@
+#ifndef RUBY_INTERNAL_H
+#define RUBY_INTERNAL_H
+
+#include <ruby.h>
+
+/*
+ * Ruby MRI internal functions and structures.
+ *
+ * These are not part of Ruby's public C API and are resolved via dynamic
+ * linking against libruby. They may change between Ruby versions.
+ */
+
+/* ---- ISeq structures and functions -------------------------------------- */
+
+typedef struct rb_iseq_struct rb_iseq_t;
+
+/**
+ * Convert an ISeq wrapper VALUE to internal rb_iseq_t pointer.
+ */
+const rb_iseq_t *rb_iseqw_to_iseq(VALUE iseqw);
+
+/**
+ * Get code location (line/column info) from an ISeq.
+ */
+void rb_iseq_code_location(const rb_iseq_t *iseq, int *first_lineno,
+                           int *first_column, int *last_lineno,
+                           int *last_column);
+
+/**
+ * Wrap an internal iseq pointer as RubyVM::InstructionSequence.
+ */
+VALUE rb_iseqw_new(const void *iseq);
+
+/* ---- Object space functions --------------------------------------------- */
+
+/**
+ * Check if an object is internal (not visible to Ruby code).
+ */
+int rb_objspace_internal_object_p(VALUE obj);
+
+/**
+ * Iterate over all objects in the Ruby object space.
+ */
+void rb_objspace_each_objects(int (*callback)(void *start, void *end,
+                                              size_t stride, void *data),
+                              void *data);
+
+#endif /* RUBY_INTERNAL_H */

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative "../ext/environment"
+require_relative "transport"
+
+module Datadog
+  module CI
+    module CodeCoverage
+      # CodeCoverage component is responsible for uploading code coverage reports
+      # to Datadog's Code Coverage product.
+      class Component
+        COVERAGE_REPORT_TYPE = "coverage_report"
+
+        attr_reader :enabled
+
+        def initialize(enabled:, transport:)
+          @enabled = enabled
+          @transport = transport
+        end
+
+        def configure(library_configuration)
+          @enabled &&= library_configuration.coverage_report_upload_enabled?
+
+          Datadog.logger.debug do
+            "[#{self.class.name}] Configured with enabled=#{@enabled}"
+          end
+        end
+
+        def upload(serialized_report:, format:)
+          return unless @enabled
+          return if serialized_report.nil?
+
+          Datadog.logger.debug { "[#{self.class.name}] Uploading coverage report..." }
+
+          event = build_event(format)
+
+          @transport.send_coverage_report(event: event, coverage_report: serialized_report)
+        end
+
+        def shutdown!
+          # noop - transport is synchronous
+        end
+
+        private
+
+        def build_event(format)
+          {
+            "type" => COVERAGE_REPORT_TYPE,
+            "format" => format
+          }.merge(Ext::Environment.tags(ENV))
+        end
+      end
+    end
+  end
+end

data/lib/datadog/ci/code_coverage/null_component.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Datadog
+  module CI
+    module CodeCoverage
+      class NullComponent
+        attr_reader :enabled
+
+        def initialize
+          @enabled = false
+        end
+
+        def configure(library_configuration)
+        end
+
+        def upload(serialized_report:, format:)
+        end
+
+        def shutdown!
+        end
+      end
+    end
+  end
+end