gitlab_quality-test_tooling 3.16.0 → 3.19.1

data/lib/gitlab_quality/test_tooling/code_coverage/per_test_coverage_exporter.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'logger'
+
+module GitlabQuality
+  module TestTooling
+    module CodeCoverage
+      # Standalone per-test coverage export: inserts per-test, per-source-file
+      # rows into `code_coverage.test_coverage_per_file` and, unless skipped,
+      # runs the daily `test_health_risk` aggregation.
+      #
+      # Unlike the full coverage-metrics export, this path needs only ClickHouse
+      # credentials and the per-test coverage glob, not the LCOV report, the
+      # Crystalball test map, or the responsibility patterns. Category enrichment
+      # (feature_category/group/stage/section per row) is optional: pass
+      # `test_reports` to map test files to feature categories via the test
+      # report JSON, otherwise those columns stay blank.
+      #
+      # `skip_aggregation` lets a batched caller insert without re-running the
+      # table-wide aggregation on every batch. The streaming export invokes this
+      # once per artifact batch with `skip_aggregation: true`, then runs the
+      # aggregation once at the end.
+      class PerTestCoverageExporter
+        # @param clickhouse [Hash] connection params (:url, :database, :username, :password)
+        def initialize(
+          coverage_glob:, clickhouse:,
+          test_reports: nil, jest_quarantine_file: nil,
+          captured_sha: ENV.fetch('CI_COMMIT_SHA', ''), skip_aggregation: false, logger: nil)
+          @coverage_glob = coverage_glob
+          @clickhouse = clickhouse
+          @test_reports = test_reports
+          @jest_quarantine_file = jest_quarantine_file
+          @captured_sha = captured_sha.to_s
+          @skip_aggregation = skip_aggregation
+          # Default to INFO. The export logs every batched INSERT at debug via
+          # the ClickHouse client, and at full-bucket scale that floods the CI
+          # job log past its size limit and buries real errors. Callers can pass
+          # a debug logger explicitly when they need the SQL.
+          @logger = logger || ::Logger.new($stdout, level: ::Logger::INFO)
+        end
+
+        # @return [void]
+        def run
+          coverage_files = Dir.glob(coverage_glob)
+          if coverage_files.empty?
+            logger.info(
+              "#{ClickHouse::LOG_PREFIX} No per-test coverage artifacts matched #{coverage_glob}; nothing to export."
+            )
+            return
+          end
+
+          insert(coverage_files)
+          jest_quarantine_error = ingest_jest_quarantine_best_effort
+          unless skip_aggregation
+            aggregate
+            snapshot_scores
+          end
+
+          # Re-raise only after aggregation has run, so a jest quarantine ingest
+          # failure can't silently stop the table-wide rollup while still
+          # failing the job loudly for follow-up.
+          raise jest_quarantine_error if jest_quarantine_error
+        end
+
+        private
+
+        attr_reader :coverage_glob, :clickhouse, :test_reports, :jest_quarantine_file,
+          :captured_sha, :skip_aggregation, :logger
+
+        def insert(coverage_files)
+          tests_to_categories, feature_categories_to_teams = resolve_categories
+
+          data = PerTestCoverageData.new(
+            coverage_files,
+            tests_to_categories: tests_to_categories,
+            feature_categories_to_teams: feature_categories_to_teams,
+            captured_sha: captured_sha
+          )
+
+          ClickHouse::PerTestCoverageTable.new(**clickhouse_credentials).push(data.as_db_table)
+        end
+
+        def ingest_jest_quarantine
+          return unless jest_quarantine_file
+
+          unless File.exist?(jest_quarantine_file)
+            logger.info(
+              "#{ClickHouse::LOG_PREFIX} Jest quarantine file not found at #{jest_quarantine_file}; " \
+                "skipping jest quarantine ingestion."
+            )
+            return
+          end
+
+          ClickHouse::JestQuarantinedTestsTable.new(**clickhouse_credentials)
+            .populate(quarantine_file: jest_quarantine_file)
+        end
+
+        # The jest quarantine snapshot is best-effort relative to the
+        # aggregation: a failure here (a transient ClickHouse error, say)
+        # shouldn't stop the rollup from running on the rows already inserted.
+        # Capture the error so #run can aggregate first, then re-raise it.
+        def ingest_jest_quarantine_best_effort
+          ingest_jest_quarantine
+          nil
+        rescue StandardError => e
+          logger.error(
+            "#{ClickHouse::LOG_PREFIX} Jest quarantine ingestion failed; continuing so the " \
+              "aggregation still runs: #{e.message}"
+          )
+          e
+        end
+
+        def aggregate
+          ClickHouse::TestHealthRiskAggregator.new(**clickhouse_credentials).run
+        end
+
+        # Freezes the day's per-pillar scores into test_health_score_history,
+        # right after the aggregation the score views read. Best-effort: the
+        # snapshot is a non-critical add-on, so a failure (for example before
+        # the score views exist) must not fail the daily job once the
+        # aggregation has succeeded. A missed freeze is recoverable because the
+        # dashboard reads the live view for today.
+        def snapshot_scores
+          ClickHouse::TestHealthScoreSnapshotter.new(**clickhouse_credentials).run
+        rescue StandardError => e
+          logger.error(
+            "#{ClickHouse::LOG_PREFIX} Score snapshot failed; the aggregation still " \
+              "succeeded, continuing: #{e.message}"
+          )
+        end
+
+        # `tests_to_categories` comes from the test report JSON; without it, rows
+        # carry blank categories. The category-to-team map is a ClickHouse read,
+        # so only build both when there are reports to enrich.
+        def resolve_categories
+          return [{}, {}] unless test_reports
+
+          # Comma-separated patterns, mirroring Artifacts#test_reports.
+          patterns = test_reports.split(',').map(&:strip).reject(&:empty?)
+          report_files = Dir.glob(patterns)
+          return [{}, {}] if report_files.empty?
+
+          [tests_to_categories_from(report_files), feature_categories_to_teams]
+        end
+
+        # Category to group/stage/section, read from `code_coverage.category_owners`
+        # (populated by sync-category-owners). This is the source the full
+        # coverage export already uses, and it retains categories the live
+        # stages.yml fetch has since dropped (global_search and the Duo/AI groups),
+        # so more rows resolve to a real group instead of blank. `owner_records`
+        # gives string-keyed values; PerTestCoverageData reads symbol keys.
+        def feature_categories_to_teams
+          ClickHouse::CategoryOwnersTable.new(**clickhouse_credentials).owner_records.transform_values do |owner|
+            { group: owner["group"], stage: owner["stage"], section: owner["section"] }
+          end
+        end
+
+        def tests_to_categories_from(report_files)
+          report_files.each_with_object({}) do |file, combined|
+            # Category enrichment is optional, so a malformed or vanished report
+            # shouldn't abort the per-test insert (the rows are the point). Warn
+            # and skip the file, leaving those tests with blank categories.
+            begin
+              report = TestReport.new(JSON.parse(File.read(file)))
+            rescue JSON::ParserError, Errno::ENOENT => e
+              logger.warn("#{ClickHouse::LOG_PREFIX} Skipping unreadable test report #{file}: #{e.message}")
+              next
+            end
+
+            combined.merge!(report.tests_to_categories) { |_, old_val, new_val| (old_val + new_val).uniq }
+          end
+        end
+
+        def clickhouse_credentials
+          clickhouse.merge(logger: logger)
+        end
+      end
+    end
+  end
+end

data/lib/gitlab_quality/test_tooling/gitlab_client/issues_client.rb

@@ -43,6 +43,8 @@ module GitlabQuality
       # The GitLab client is used for API access: https://github.com/NARKOZ/gitlab
       class IssuesClient < GitlabClient
         REPORTER_ACCESS_LEVEL = 20
+        DUO_WORKFLOW_TIMEOUT = 30
+        DUO_WORKFLOW_DEFINITION = 'developer/v1'
 
         def assert_user_permission!
           handle_gitlab_client_exceptions do
@@ -123,6 +125,28 @@ module GitlabQuality
           end
         end
 
+        # Starts a GitLab Duo Agent Platform workflow (Flows API).
+        # The agent investigates and posts its own analysis back, so no follow-up call is needed.
+        #
+        # This is a best-effort helper: it deliberately does NOT use handle_gitlab_client_exceptions
+        # (which would retry with long backoffs and post failures to Slack) and uses a short timeout
+        # so a slow or unavailable Duo endpoint can never stall the reporting job. The caller is
+        # expected to rescue any error.
+        #
+        # project_id accepts either a numeric ID or a namespace path (e.g. 'gitlab-org/quality/...'),
+        # matching the GitLab API's project-identifier convention; the path form is verified working.
+        def start_duo_workflow(goal:, workflow_definition: DUO_WORKFLOW_DEFINITION, project_id: project)
+          client.post('/ai/duo_workflows/workflows',
+            timeout: DUO_WORKFLOW_TIMEOUT,
+            headers: { 'Content-Type' => 'application/json' },
+            body: {
+              project_id: project_id,
+              goal: goal,
+              workflow_definition: workflow_definition,
+              start_workflow: true
+            }.to_json)
+        end
+
         def edit_issue_note(issue_iid:, note_id:, note:)
           handle_gitlab_client_exceptions do
             client.edit_issue_note(project, issue_iid, note_id, note)

data/lib/gitlab_quality/test_tooling/report/relate_failure_issue.rb

@@ -83,12 +83,13 @@ module GitlabQuality
           @metrics_files = Array(metrics_files)
           @group_similar = group_similar
           @environment_issues_output_file = environment_issues_output_file
+          @duo_analysis_modes = Array(kwargs[:duo_analysis])
         end
 
         private
 
         attr_reader :max_diff_ratio, :system_logs, :base_issue_labels, :exclude_labels_for_search, :metrics_files, :ops_gitlab_client, :group_similar,
-          :environment_issues_output_file
+          :environment_issues_output_file, :duo_analysis_modes
 
         def run!
           puts "Reporting test failures in `#{files.join(',')}` as issues in project `#{project}` via the API at `#{Runtime::Env.gitlab_api_base}`."
@@ -294,9 +295,47 @@ module GitlabQuality
           # On a dry run, created_issue may not be populated
           test.failure_issue ||= created_issue&.web_url
 
+          trigger_duo_analysis(created_issue, test) if duo_analysis_modes.include?('create')
+
           created_issue
         end
 
+        # Best-effort: start a GitLab Duo workflow to investigate the issue; the agent comments its
+        # analysis back. A failure here must never block issue creation or the pipeline.
+        def trigger_duo_analysis(issue, test)
+          return unless issue&.web_url
+
+          gitlab.start_duo_workflow(goal: duo_analysis_goal(issue, test))
+          puts "  => Triggered Duo failure analysis workflow for #{issue.web_url}"
+        rescue StandardError => e
+          warn("  => Could not trigger Duo failure analysis for #{issue.web_url} (ignored): #{e.class}: #{e.message}")
+        end
+
+        def duo_analysis_goal(issue, test)
+          <<~GOAL.chomp
+            Investigate the newly-reported end-to-end test failure described in this issue: #{issue.web_url}
+            (failing spec: `#{test.name}`). Read the issue for the failing spec and stack trace.
+
+            Investigate the `gitlab-org/gitlab` project (where the product code and E2E specs live —
+            note this is NOT the project hosting this issue): inspect its recent commits and merge
+            requests on the default branch using GitLab tools, and consult the Orbit knowledge graph
+            via MCP tools if it is available. Using those, identify the most likely cause of this
+            failure. Then post a comment on that issue with your analysis.
+
+            The failure may be caused by a product code change, or it may be environmental — for
+            example a flaky test, an infrastructure/environment issue, or a CI runner problem. Decide
+            which is more likely:
+
+            - If a specific change or merge request looks responsible, name the likely author in your
+              comment and ask them to confirm. Frame this as advisory ("this looks likely related —
+              please confirm"), never as an assertion of blame.
+            - If the failure looks environmental, flaky, or otherwise not attributable to a specific
+              change, explain why — but do not ping or attribute it to anyone.
+
+            This is an automated, best-effort request to speed up triage of newly-detected failures.
+          GOAL
+        end
+
         def pipeline_issues_with_similar_stacktrace(test)
           search_labels = (base_issue_labels + Set.new(%w[test failure::new])).to_a
           not_labels = exclude_labels_for_search.to_a
@@ -428,6 +467,10 @@ module GitlabQuality
         end
 
         def generate_diff_link
+          # Outside CI (e.g. local runs) there is no pipeline to diff against, so skip gracefully
+          # rather than crashing on a nil pipeline URL or an unsupported project.
+          return "No commit diff available (no CI pipeline context)." unless Runtime::Env.ci_pipeline_url
+
           initialize_gitlab_ops_client
 
           if Runtime::Env.ci_pipeline_url.include?('ops.gitlab.net')

data/lib/gitlab_quality/test_tooling/version.rb

@@ -2,6 +2,6 @@
 
 module GitlabQuality
   module TestTooling
-    VERSION = "3.16.0"
+    VERSION = "3.19.1"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gitlab_quality-test_tooling
 version: !ruby/object:Gem::Version
-  version: 3.16.0
+  version: 3.19.1
 platform: ruby
 authors:
 - GitLab Quality
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-05-26 00:00:00.000000000 Z
+date: 2026-07-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: climate_control
@@ -499,9 +499,12 @@ files:
 - lib/gitlab_quality/test_tooling/code_coverage/click_house/test_file_mappings_table.rb
 - lib/gitlab_quality/test_tooling/code_coverage/click_house/test_health_risk_aggregation.sql
 - lib/gitlab_quality/test_tooling/code_coverage/click_house/test_health_risk_aggregator.rb
+- lib/gitlab_quality/test_tooling/code_coverage/click_house/test_health_score_snapshot.sql
+- lib/gitlab_quality/test_tooling/code_coverage/click_house/test_health_score_snapshotter.rb
 - lib/gitlab_quality/test_tooling/code_coverage/coverage_data.rb
 - lib/gitlab_quality/test_tooling/code_coverage/lcov_file.rb
 - lib/gitlab_quality/test_tooling/code_coverage/per_test_coverage_data.rb
+- lib/gitlab_quality/test_tooling/code_coverage/per_test_coverage_exporter.rb
 - lib/gitlab_quality/test_tooling/code_coverage/responsibility_classifier.rb
 - lib/gitlab_quality/test_tooling/code_coverage/responsibility_patterns_config.rb
 - lib/gitlab_quality/test_tooling/code_coverage/rspec_report.rb
@@ -594,11 +597,6 @@ files:
 - lib/gitlab_quality/test_tooling/test_meta/test_meta_updater.rb
 - lib/gitlab_quality/test_tooling/test_metric/json_test_metric.rb
 - lib/gitlab_quality/test_tooling/test_metrics/json_test_metric_collection.rb
-- lib/gitlab_quality/test_tooling/test_metrics_exporter/client.rb
-- lib/gitlab_quality/test_tooling/test_metrics_exporter/config.rb
-- lib/gitlab_quality/test_tooling/test_metrics_exporter/config_helper.rb
-- lib/gitlab_quality/test_tooling/test_metrics_exporter/formatter.rb
-- lib/gitlab_quality/test_tooling/test_metrics_exporter/test_metrics.rb
 - lib/gitlab_quality/test_tooling/test_quarantine/quarantine_formatter.rb
 - lib/gitlab_quality/test_tooling/test_quarantine/quarantine_helper.rb
 - lib/gitlab_quality/test_tooling/test_result/base_test_result.rb

data/lib/gitlab_quality/test_tooling/test_metrics_exporter/client.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-require "httparty"
-require "json"
-
-module GitlabQuality
-  module TestTooling
-    module TestMetricsExporter
-      class Client
-        ResponseError = Class.new(StandardError)
-
-        TESTS_PATH = "/api/v1/tests"
-        # Observer enforces a per-request cap; batch above this size to avoid silent failures.
-        MAX_BATCH_SIZE = 10_000
-
-        def initialize(url:, token:)
-          @url = url
-          @token = token
-        end
-
-        # POST array of test metric records to the observer service.
-        # Wraps each batch as { "tests" => [...] } and splits oversized payloads
-        # into chunks of at most MAX_BATCH_SIZE records.
-        #
-        # @param tests [Array<Hash>]
-        # @return [Boolean] true when every batch succeeds (or input is empty)
-        # @raise [ResponseError] on the first non-2xx batch response
-        def post_tests(tests)
-          tests.each_slice(MAX_BATCH_SIZE) do |batch|
-            response = HTTParty.post(
-              "#{url.to_s.chomp('/')}#{TESTS_PATH}",
-              body: { tests: batch }.to_json,
-              headers: {
-                "X-Gitlab-Token" => token,
-                "Content-Type" => "application/json"
-              }
-            )
-            raise ResponseError, "Observer request failed with status #{response.code}: #{response.body}" unless response.success?
-          end
-
-          true
-        end
-
-        private
-
-        attr_reader :url, :token
-      end
-    end
-  end
-end

data/lib/gitlab_quality/test_tooling/test_metrics_exporter/config.rb

@@ -1,88 +0,0 @@
-# frozen_string_literal: true
-
-require "logger"
-require "singleton"
-
-module GitlabQuality
-  module TestTooling
-    module TestMetricsExporter
-      class Config
-        include Singleton
-
-        class << self
-          def configuration
-            Config.instance
-          end
-
-          def configure
-            yield(configuration)
-          end
-        end
-
-        attr_accessor :run_type,
-          :observer_url,
-          :observer_token
-        attr_writer :extra_rspec_metadata_keys,
-          :skip_record_proc,
-          :test_retried_proc,
-          :custom_metrics_proc,
-          :spec_file_path_prefix,
-          :logger
-
-        # Whether observer export is configured
-        #
-        # Export is considered enabled when all required attributes are set
-        #
-        # @return [Boolean]
-        def observer_configured?
-          [observer_url, observer_token].none? { |value| value.nil? || value.to_s.empty? }
-        end
-
-        # Extra rspec metadata keys to include in exported metrics
-        #
-        # @return [Array<Symbol>]
-        def extra_rspec_metadata_keys
-          @extra_rspec_metadata_keys ||= []
-        end
-
-        # Extra path prefix for constructing full file path within mono-repository setups
-        #
-        # @return [String]
-        def spec_file_path_prefix
-          @spec_file_path_prefix ||= ""
-        end
-
-        # A lambda that determines whether to skip recording a test result
-        #
-        # This is useful when you would want to skip initial failure when retrying specs is set up in a separate process
-        # and you want to avoid duplicate records
-        #
-        # @return [Proc]
-        def skip_record_proc
-          @skip_record_proc ||= ->(_example) { false }
-        end
-
-        # A lambda that determines whether a test was retried or not
-        #
-        # @return [Proc]
-        def test_retried_proc
-          @test_retried_proc ||= ->(_example) { false }
-        end
-
-        # A lambda that return hash with additional custom metrics
-        #
-        # @return [Proc]
-        def custom_metrics_proc
-          @custom_metrics_proc ||= ->(_example) { {} }
-        end
-
-        # Logger instance
-        #
-        # @return [Logger]
-        def logger
-          @logger ||= Logger.new($stdout, level: Logger::INFO)
-        end
-      end
-    end
-  end
-end

data/lib/gitlab_quality/test_tooling/test_metrics_exporter/config_helper.rb

@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-
-require 'logger'
-require 'active_support/core_ext/object/blank'
-
-require_relative 'config'
-require_relative 'formatter'
-
-module GitlabQuality
-  module TestTooling
-    module TestMetricsExporter
-      class ConfigHelper
-        REQUIRED_OBSERVER_ENV_VARS = %w[
-          GLCI_OBSERVER_URL
-          GLCI_OBSERVER_AUTH_TOKEN
-        ].freeze
-
-        class << self
-          def configure!(run_type = test_run_type)
-            return unless ENV.fetch("CI", nil) && ENV.fetch("GLCI_EXPORT_TEST_METRICS", "true") == "true" && run_type
-
-            RSpec.configure do |rspec_config|
-              next if rspec_config.dry_run?
-
-              Config.configure do |exporter_config|
-                self.logger = exporter_config.logger
-                next warn_missing_observer_variables unless observer_env_vars_present?
-
-                yield(exporter_config) if block_given?
-                configure_exporter!(exporter_config, run_type)
-
-                rspec_config.add_formatter Formatter
-
-                logger.info("Test metrics export is enabled for run type: #{run_type}")
-              end
-            end
-          end
-
-          private
-
-          attr_writer :logger
-
-          def logger
-            @logger ||= Logger.new($stdout)
-          end
-
-          def observer_env_vars_present?
-            REQUIRED_OBSERVER_ENV_VARS.all? { |var| ENV.fetch(var, nil) && !ENV[var].empty? }
-          end
-
-          def configure_exporter!(config, run_type)
-            config.run_type = run_type
-            config.custom_metrics_proc = custom_metrics_proc
-
-            configure_observer!(config)
-          end
-
-          def configure_observer!(config)
-            config.observer_url = observer_url
-            config.observer_token = observer_token
-          end
-
-          def warn_missing_observer_variables
-            missing = REQUIRED_OBSERVER_ENV_VARS.reject { |var| ENV.fetch(var, nil) && !ENV[var].empty? }
-            logger.warn("Test metrics export is enabled but missing environment variables: #{missing.join(', ')}")
-          end
-
-          def custom_metrics_proc
-            proc do |_example|
-              { pipeline_type: pipeline_type, ci_pipeline_id: ci_pipeline_id }
-            end
-          end
-
-          def default_branch?
-            ENV["CI_COMMIT_REF_NAME"] == ENV["CI_DEFAULT_BRANCH"]
-          end
-
-          def pipeline_type
-            @pipeline_type ||= if default_branch? && ENV["SCHEDULE_TYPE"].present?
-                                 "default_branch_scheduled_pipeline"
-                               elsif default_branch?
-                                 "default_branch_pipeline"
-                               elsif ENV["CI_COMMIT_REF_NAME"]&.match?(/^[\d-]+-stable-ee$/)
-                                 "stable_branch_pipeline"
-                               elsif ENV["CI_MERGE_REQUEST_TARGET_BRANCH_NAME"]&.match?(/^[\d-]+-stable-ee$/)
-                                 "backport_merge_request_pipeline"
-                               elsif ENV["CI_MERGE_REQUEST_IID"].present?
-                                 "merge_request_pipeline"
-                               elsif ENV["CI_PIPELINE_SOURCE"] == "pipeline"
-                                 "downstream_pipeline"
-                               else
-                                 "unknown"
-                               end
-          end
-
-          def test_run_type
-            @run_type ||= ENV.fetch("GLCI_TEST_METRICS_RUN_TYPE", nil)
-          end
-
-          def observer_url
-            ENV.fetch("GLCI_OBSERVER_URL", nil)
-          end
-
-          def observer_token
-            ENV.fetch("GLCI_OBSERVER_AUTH_TOKEN", nil)
-          end
-
-          def ci_pipeline_id
-            (ENV["PARENT_PIPELINE_ID"] || ENV.fetch("CI_PIPELINE_ID", nil)).to_i
-          end
-        end
-      end
-    end
-  end
-end

data/lib/gitlab_quality/test_tooling/test_metrics_exporter/formatter.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-require "rspec/core/formatters/base_formatter"
-
-require_relative "test_metrics"
-require_relative "client"
-
-module GitlabQuality
-  module TestTooling
-    module TestMetricsExporter
-      class Formatter < RSpec::Core::Formatters::BaseFormatter
-        RSpec::Core::Formatters.register(self, :stop)
-
-        LOG_PREFIX = "[MetricsExporter]"
-
-        def stop(notification)
-          logger.debug("#{LOG_PREFIX} Starting test metrics export")
-          data = notification.examples.filter_map do |example|
-            next if config.skip_record_proc.call(example)
-
-            TestMetrics.new(example, time).data
-          end
-          return logger.warn("#{LOG_PREFIX} No test execution records found, metrics will not be exported!") if data.empty?
-
-          push_to_observer(data)
-        end
-
-        private
-
-        def config
-          Config.configuration
-        end
-
-        def logger
-          config.logger
-        end
-
-        # Single common timestamp for all exported example metrics to keep data points consistently grouped
-        #
-        # @return [String]
-        def time
-          return @time if @time
-
-          ci_created_at = ENV.fetch("CI_PIPELINE_CREATED_AT", nil)
-          @time = (ci_created_at ? Time.strptime(ci_created_at, '%Y-%m-%dT%H:%M:%S%z') : Time.now.utc).strftime('%Y-%m-%dT%H:%M:%S.%6N')
-        end
-
-        # Push data to observer service
-        #
-        # @param data [Array<Hash>]
-        # @return [void]
-        def push_to_observer(data)
-          return logger.debug("#{LOG_PREFIX} Observer configuration missing, skipping export!") unless config.observer_configured?
-
-          observer_client.post_tests(data)
-          logger.info("#{LOG_PREFIX} Successfully pushed #{data.size} entries to Observer!")
-        rescue StandardError => e
-          logger.error("#{LOG_PREFIX} Error occurred while pushing metrics to Observer: #{e.message}")
-        end
-
-        def observer_client
-          Client.new(url: config.observer_url, token: config.observer_token)
-        end
-      end
-    end
-  end
-end