gitlab-exporter 13.4.1 → 14.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5841c9c02dc87806b53fd5bb4087dfcc63f1a249f9b47f178bb765401d02e6e4
-  data.tar.gz: f4ef520597e0c4feb314f6579639da75fd0c61d641048a60c4facb1db6441fc4
+  metadata.gz: 6420230ed0ec27d530fa71e46c0776ea2cb21b036a198335229fc304dcdfe3e0
+  data.tar.gz: 91205ee62a32b2e00f7978f9fc7ec063be203d593cade97ea481f85ee1388bbd
 SHA512:
-  metadata.gz: 8631a32ce6cbf2c2d74ac46cf5646635bc3e3fb4dbc8a1556b6e47a00e128bd12e248c29eaafb9719e171a1c1dc6e6b4f62ccdcb3bf1478216e5a5a5dadf0b40
-  data.tar.gz: ebe1e65ff91911c749650fa59e0e84229740d3fe251bd448a571cb8ce0e23ee6bf6a788656b91e6de870f0e6b2ef58dd349e7fe0e0db49728d2f1531408804e1
+  metadata.gz: 3be9966a1abe20b42169a4a85e20815649c87e46a31f853002dd5fb0eaff6437a692f5904334d42172fb1950627b0d3bba31a67c6992e5533051f367ed74144f
+  data.tar.gz: 20aefc5c04ee63033feeb80e986e6f239a711d9d88197859c154fe4e429573344d52d5c58ca9d9e611dace90804da5fba8341ed45ed5f592e33a5df8c3c6cc7e

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    gitlab-exporter (13.4.1)
+    gitlab-exporter (14.0.0)
       connection_pool (= 2.2.5)
       faraday (~> 1.8.0)
       pg (= 1.5.3)
@@ -107,4 +107,4 @@ DEPENDENCIES
   rubocop (~> 0.42)
 
 BUNDLED WITH
-   2.4.5
+   2.4.20

data/config/gitlab-exporter.yml.example

@@ -95,8 +95,6 @@ probes:
     opts:
       redis_url: "redis://localhost:6379"
       redis_enable_client: true
-      probe_namespaced: true
-      probe_non_namespaced: true
 
   ruby: &ruby
     class_name: RubyProber

data/lib/gitlab_exporter/database/ci_builds.rb

@@ -9,27 +9,27 @@ module GitLab
           <<~SQL.freeze
             SELECT
               projects.namespace_id,
-              ci_builds.status,
+              p_ci_builds.status,
               projects.shared_runners_enabled,
               (COALESCE(namespaces.shared_runners_minutes_limit, application_settings.shared_runners_minutes, 0) = 0 OR
                  COALESCE(namespace_statistics.shared_runners_seconds, 0) < COALESCE(namespaces.shared_runners_minutes_limit, application_settings.shared_runners_minutes, 0) * 60) as has_minutes,
               COUNT(*) AS count
-            FROM ci_builds
+            FROM p_ci_builds
             JOIN projects
-              ON projects.id = ci_builds.project_id
+              ON projects.id = p_ci_builds.project_id
             JOIN namespaces
               ON namespaces.id = projects.namespace_id
             LEFT JOIN namespace_statistics
               ON namespace_statistics.namespace_id = namespaces.id
             JOIN application_settings ON (TRUE)
-            WHERE ci_builds.type = 'Ci::Build'
-              AND ci_builds.status = '%s'
+            WHERE p_ci_builds.type = 'Ci::Build'
+              AND p_ci_builds.status = '%s'
               -- The created_at filter has been introduced for performance reasons only
-              AND ci_builds.created_at > NOW() - INTERVAL '7 days'
+              AND p_ci_builds.created_at > NOW() - INTERVAL '7 days'
               AND projects.pending_delete = 'f'
             GROUP BY
               projects.namespace_id,
-              ci_builds.status,
+              p_ci_builds.status,
               projects.shared_runners_enabled,
               namespaces.shared_runners_minutes_limit,
               namespace_statistics.shared_runners_seconds,
@@ -40,20 +40,20 @@ module GitLab
           <<~SQL.freeze
             SELECT
               projects.namespace_id,
-              ci_builds.status,
+              p_ci_builds.status,
               projects.shared_runners_enabled,
               COUNT(*) AS count
-            FROM ci_builds
+            FROM p_ci_builds
             JOIN projects
-              ON projects.id = ci_builds.project_id
-            WHERE ci_builds.type = 'Ci::Build'
-              AND ci_builds.status = '%s'
+              ON projects.id = p_ci_builds.project_id
+            WHERE p_ci_builds.type = 'Ci::Build'
+              AND p_ci_builds.status = '%s'
               -- The created_at filter has been introduced for performance reasons only
-              AND ci_builds.created_at > NOW() - INTERVAL '7 days'
+              AND p_ci_builds.created_at > NOW() - INTERVAL '7 days'
               AND projects.pending_delete = 'f'
             GROUP BY
               projects.namespace_id,
-              ci_builds.status,
+              p_ci_builds.status,
               projects.shared_runners_enabled
           SQL
 
@@ -61,53 +61,53 @@ module GitLab
           <<~SQL.freeze
             SELECT
               COUNT(*) AS count
-            FROM ci_builds
+            FROM p_ci_builds
             JOIN projects
-              ON projects.id = ci_builds.project_id
-            WHERE ci_builds.type = 'Ci::Build'
-              AND ci_builds.status = 'running'
-              AND ci_builds.updated_at < NOW() - INTERVAL '1 hour'
+              ON projects.id = p_ci_builds.project_id
+            WHERE p_ci_builds.type = 'Ci::Build'
+              AND p_ci_builds.status = 'running'
+              AND p_ci_builds.updated_at < NOW() - INTERVAL '1 hour'
               AND projects.pending_delete = 'f'
           SQL
 
         PER_RUNNER_QUERY_EE =
           <<~SQL.freeze
             SELECT
-              ci_builds.runner_id,
+              p_ci_builds.runner_id,
               ci_runners.runner_type,
               projects.namespace_id,
               projects.mirror,
               projects.mirror_trigger_builds,
               ci_pipelines.pipeline_schedule_id,
-              ci_builds.trigger_request_id,
+              p_ci_builds.trigger_request_id,
               (COALESCE(namespaces.shared_runners_minutes_limit, application_settings.shared_runners_minutes, 0) = 0 OR
                  COALESCE(namespace_statistics.shared_runners_seconds, 0) < COALESCE(namespaces.shared_runners_minutes_limit, application_settings.shared_runners_minutes, 0) * 60) as has_minutes,
               COUNT(*) AS count
-            FROM ci_builds
+            FROM p_ci_builds
             JOIN ci_runners
-              ON ci_runners.id = ci_builds.runner_id
+              ON ci_runners.id = p_ci_builds.runner_id
             JOIN projects
-              ON projects.id = ci_builds.project_id
+              ON projects.id = p_ci_builds.project_id
             JOIN ci_pipelines
-              ON ci_pipelines.id = ci_builds.commit_id
+              ON ci_pipelines.id = p_ci_builds.commit_id
             JOIN namespaces
               ON namespaces.id = projects.namespace_id
             LEFT JOIN namespace_statistics
               ON namespace_statistics.namespace_id = namespaces.id
             JOIN application_settings ON (TRUE)
-            WHERE ci_builds.type = 'Ci::Build'
-              AND ci_builds.status = 'running'
+            WHERE p_ci_builds.type = 'Ci::Build'
+              AND p_ci_builds.status = 'running'
               -- The created_at filter has been introduced for performance reasons only
-              AND ci_builds.created_at > NOW() - INTERVAL '7 days'
+              AND p_ci_builds.created_at > NOW() - INTERVAL '7 days'
               AND projects.pending_delete = 'f'
             GROUP BY
-              ci_builds.runner_id,
+              p_ci_builds.runner_id,
               ci_runners.runner_type,
               projects.namespace_id,
               projects.mirror,
               projects.mirror_trigger_builds,
               ci_pipelines.pipeline_schedule_id,
-              ci_builds.trigger_request_id,
+              p_ci_builds.trigger_request_id,
               namespaces.shared_runners_minutes_limit,
               namespace_statistics.shared_runners_seconds,
               application_settings.shared_runners_minutes
@@ -116,30 +116,30 @@ module GitLab
         PER_RUNNER_QUERY_CE =
           <<~SQL.freeze
             SELECT
-              ci_builds.runner_id,
+              p_ci_builds.runner_id,
               ci_runners.runner_type,
               projects.namespace_id,
               ci_pipelines.pipeline_schedule_id,
-              ci_builds.trigger_request_id,
+              p_ci_builds.trigger_request_id,
               COUNT(*) AS count
-            FROM ci_builds
+            FROM p_ci_builds
             JOIN ci_runners
-              ON ci_runners.id = ci_builds.runner_id
+              ON ci_runners.id = p_ci_builds.runner_id
             JOIN projects
-              ON projects.id = ci_builds.project_id
+              ON projects.id = p_ci_builds.project_id
             JOIN ci_pipelines
-              ON ci_pipelines.id = ci_builds.commit_id
-            WHERE ci_builds.type = 'Ci::Build'
-              AND ci_builds.status = 'running'
+              ON ci_pipelines.id = p_ci_builds.commit_id
+            WHERE p_ci_builds.type = 'Ci::Build'
+              AND p_ci_builds.status = 'running'
               -- The created_at filter has been introduced for performance reasons only
-              AND ci_builds.created_at > NOW() - INTERVAL '7 days'
+              AND p_ci_builds.created_at > NOW() - INTERVAL '7 days'
               AND projects.pending_delete = 'f'
             GROUP BY
-              ci_builds.runner_id,
+              p_ci_builds.runner_id,
               ci_runners.runner_type,
               projects.namespace_id,
               ci_pipelines.pipeline_schedule_id,
-              ci_builds.trigger_request_id
+              p_ci_builds.trigger_request_id
           SQL
 
         EE_CHECK_QUERY =
@@ -151,15 +151,15 @@ module GitLab
           <<~SQL.freeze
             SELECT
               COUNT(*) as count
-            FROM ci_builds
+            FROM p_ci_builds
             JOIN ci_build_trace_chunks
-              ON ci_build_trace_chunks.build_id = ci_builds.id
+              ON ci_build_trace_chunks.build_id = p_ci_builds.id
             LEFT JOIN ci_job_artifacts
-              ON ci_job_artifacts.job_id = ci_builds.id
+              ON ci_job_artifacts.job_id = p_ci_builds.id
               AND ci_job_artifacts.file_type = 3
-            WHERE ci_builds.type = 'Ci::Build'
-              AND ci_builds.status IN ('success', 'failed', 'canceled')
-              AND ci_builds.finished_at < '%s'
+            WHERE p_ci_builds.type = 'Ci::Build'
+              AND p_ci_builds.status IN ('success', 'failed', 'canceled')
+              AND p_ci_builds.finished_at < '%s'
               AND ci_job_artifacts.job_id IS NULL
           SQL
 

data/lib/gitlab_exporter/sidekiq.rb

@@ -7,7 +7,6 @@ module GitLab
     # A prober for Sidekiq queues
     #
     # It takes the Redis URL Sidekiq is connected to
-    # rubocop:disable Metrics/ClassLength
     class SidekiqProber
       # The maximum depth (from the head) of each queue to probe. Probing the
       # entirety of a very large queue will take longer and run the risk of
@@ -41,24 +40,35 @@ module GitLab
         @opts    = opts
         @metrics = metrics
         @logger  = logger
-
-        @probe_namespaced = !!opts[:probe_namespaced] # rubocop:disable Style/DoubleNegation
-        @probe_non_namespaced = !!opts[:probe_non_namespaced] # rubocop:disable Style/DoubleNegation
-
-        # to maintain backward compatibility if the config is missing values
-        @probe_namespaced = true if opts[:probe_namespaced].nil? && opts[:probe_non_namespaced].nil?
       end
 
       def probe_stats
-        with_sidekiq { _probe_stats } if @probe_namespaced
-        with_sidekiq(false) { _probe_stats(false) } if @probe_non_namespaced
+        with_sidekiq do
+          stats = Sidekiq::Stats.new
+
+          @metrics.add("sidekiq_jobs_processed_total", stats.processed)
+          @metrics.add("sidekiq_jobs_failed_total", stats.failed)
+          @metrics.add("sidekiq_jobs_enqueued_size", stats.enqueued)
+          @metrics.add("sidekiq_jobs_scheduled_size", stats.scheduled_size)
+          @metrics.add("sidekiq_jobs_retry_size", stats.retry_size)
+          @metrics.add("sidekiq_jobs_dead_size", stats.dead_size)
+
+          @metrics.add("sidekiq_default_queue_latency_seconds", stats.default_queue_latency)
+          @metrics.add("sidekiq_processes_size", stats.processes_size)
+          @metrics.add("sidekiq_workers_size", stats.workers_size)
+        end
 
         self
       end
 
       def probe_queues
-        with_sidekiq { _probe_queues } if @probe_namespaced
-        with_sidekiq(false) { _probe_queues(false) } if @probe_non_namespaced
+        with_sidekiq do
+          Sidekiq::Queue.all.each do |queue|
+            @metrics.add("sidekiq_queue_size", queue.size, name: queue.name)
+            @metrics.add("sidekiq_queue_latency_seconds", queue.latency, name: queue.name)
+            @metrics.add("sidekiq_queue_paused", queue.paused? ? 1 : 0, name: queue.name)
+          end
+        end
 
         self
       end
@@ -71,8 +81,24 @@ module GitLab
       end
 
       def probe_future_sets
-        with_sidekiq { _probe_future_sets } if @probe_namespaced
-        with_sidekiq(false) { _probe_future_sets(false) } if @probe_non_namespaced
+        now = Time.now.to_f
+        with_sidekiq do
+          Sidekiq.redis do |conn|
+            Sidekiq::Scheduled::SETS.each do |set|
+              # Default to 0; if all jobs are due in the future, there is no "negative" delay.
+              delay = 0
+
+              _job, timestamp = conn.zrangebyscore(set, "-inf", now.to_s, limit: [0, 1], withscores: true).first
+              delay = now - timestamp if timestamp
+
+              @metrics.add("sidekiq_#{set}_set_processing_delay_seconds", delay)
+
+              # zcount is O(log(N)) (prob. binary search), so is still quick even with large sets
+              @metrics.add("sidekiq_#{set}_set_backlog_count",
+                           conn.zcount(set, "-inf", now.to_s))
+            end
+          end
+        end
       end
 
       # Count worker classes present in Sidekiq queues. This only looks at the
@@ -82,22 +108,57 @@ module GitLab
       # will not have completely accurate statistics, but the probe performance
       # will also not degrade as the queue gets larger.
       def probe_jobs_limit
-        with_sidekiq { _probe_jobs_limit } if @probe_namespaced
-        with_sidekiq(false) { _probe_jobs_limit(false) } if @probe_non_namespaced
+        with_sidekiq do
+          job_stats = Hash.new(0)
+
+          Sidekiq::Queue.all.each do |queue|
+            Sidekiq.redis do |conn|
+              conn.lrange("queue:#{queue.name}", 0, PROBE_JOBS_LIMIT).each do |job|
+                job_class = Sidekiq.load_json(job)["class"]
+
+                job_stats[job_class] += 1
+              end
+            end
+          end
+
+          job_stats.each do |class_name, count|
+            @metrics.add("sidekiq_enqueued_jobs", count, name: class_name)
+          end
+        end
 
         self
       end
 
       def probe_workers
-        with_sidekiq { _probe_workers } if @probe_namespaced
-        with_sidekiq(false) { _probe_workers(false) } if @probe_non_namespaced
+        with_sidekiq do
+          worker_stats = Hash.new(0)
+
+          Sidekiq::Workers.new.map do |_pid, _tid, work|
+            job_klass = work["payload"]["class"]
+
+            worker_stats[job_klass] += 1
+          end
+
+          worker_stats.each do |class_name, count|
+            @metrics.add("sidekiq_running_jobs", count, name: class_name)
+          end
+        end
 
         self
       end
 
       def probe_retries
-        with_sidekiq { _probe_retries } if @probe_namespaced
-        with_sidekiq(false) { _probe_retries(false) } if @probe_non_namespaced
+        with_sidekiq do
+          retry_stats = Hash.new(0)
+
+          Sidekiq::RetrySet.new.map do |job|
+            retry_stats[job.klass] += 1
+          end
+
+          retry_stats.each do |class_name, count|
+            @metrics.add("sidekiq_to_be_retried_jobs", count, name: class_name)
+          end
+        end
 
         self
       end
@@ -119,104 +180,10 @@ module GitLab
 
       private
 
-      def _probe_workers(namespace = true)
-        labels = add_namespace_labels? ? { namespaced: namespace } : {}
-        worker_stats = Hash.new(0)
-
-        Sidekiq::Workers.new.map do |_pid, _tid, work|
-          job_klass = work["payload"]["class"]
-
-          worker_stats[job_klass] += 1
-        end
-
-        worker_stats.each do |class_name, count|
-          @metrics.add("sidekiq_running_jobs", count, **labels.merge({ name: class_name }))
-        end
-      end
-
-      def _probe_future_sets(namespace = true)
-        labels = add_namespace_labels? ? { namespaced: namespace } : {}
-        now = Time.now.to_f
-        Sidekiq.redis do |conn|
-          Sidekiq::Scheduled::SETS.each do |set|
-            # Default to 0; if all jobs are due in the future, there is no "negative" delay.
-            delay = 0
-
-            _job, timestamp = conn.zrangebyscore(set, "-inf", now.to_s, limit: [0, 1], withscores: true).first
-            delay = now - timestamp if timestamp
-
-            @metrics.add("sidekiq_#{set}_set_processing_delay_seconds", delay, **labels)
-
-            # zcount is O(log(N)) (prob. binary search), so is still quick even with large sets
-            @metrics.add("sidekiq_#{set}_set_backlog_count",
-                         conn.zcount(set, "-inf", now.to_s), **labels)
-          end
-        end
-      end
-
-      def _probe_stats(namespace = true)
-        stats = Sidekiq::Stats.new
-        labels = add_namespace_labels? ? { namespaced: namespace } : {}
-
-        @metrics.add("sidekiq_jobs_processed_total", stats.processed, **labels)
-        @metrics.add("sidekiq_jobs_failed_total", stats.failed, **labels)
-        @metrics.add("sidekiq_jobs_enqueued_size", stats.enqueued, **labels)
-        @metrics.add("sidekiq_jobs_scheduled_size", stats.scheduled_size, **labels)
-        @metrics.add("sidekiq_jobs_retry_size", stats.retry_size, **labels)
-        @metrics.add("sidekiq_jobs_dead_size", stats.dead_size, **labels)
-
-        @metrics.add("sidekiq_default_queue_latency_seconds", stats.default_queue_latency, **labels)
-        @metrics.add("sidekiq_processes_size", stats.processes_size, **labels)
-        @metrics.add("sidekiq_workers_size", stats.workers_size, **labels)
-      end
-
-      def _probe_queues(namespace = true)
-        Sidekiq::Queue.all.each do |queue|
-          labels = { name: queue.name }
-          labels[:namespaced] = namespace if add_namespace_labels?
-
-          @metrics.add("sidekiq_queue_size", queue.size, **labels)
-          @metrics.add("sidekiq_queue_latency_seconds", queue.latency, **labels)
-          @metrics.add("sidekiq_queue_paused", queue.paused? ? 1 : 0, **labels)
-        end
-      end
-
-      def _probe_jobs_limit(namespace = true)
-        labels = add_namespace_labels? ? { namespaced: namespace } : {}
-        job_stats = Hash.new(0)
-
-        Sidekiq::Queue.all.each do |queue|
-          Sidekiq.redis do |conn|
-            conn.lrange("queue:#{queue.name}", 0, PROBE_JOBS_LIMIT).each do |job|
-              job_class = Sidekiq.load_json(job)["class"]
-
-              job_stats[job_class] += 1
-            end
-          end
-        end
-
-        job_stats.each do |class_name, count|
-          @metrics.add("sidekiq_enqueued_jobs", count, **labels.merge({ name: class_name }))
-        end
-      end
-
-      def _probe_retries(namespace = true)
-        labels = add_namespace_labels? ? { namespaced: namespace } : {}
-        retry_stats = Hash.new(0)
-
-        Sidekiq::RetrySet.new.map do |job|
-          retry_stats[job.klass] += 1
-        end
-
-        retry_stats.each do |class_name, count|
-          @metrics.add("sidekiq_to_be_retried_jobs", count, **labels.merge({ name: class_name }))
-        end
-      end
-
-      def with_sidekiq(namespaced = true)
+      def with_sidekiq
         SIDEKIQ_REDIS_LOCK.synchronize {
           Sidekiq.configure_client do |config|
-            config.redis = self.class.connection_pool[redis_options(namespaced)]
+            config.redis = self.class.connection_pool[redis_options]
           end
 
           return unless connected?
@@ -225,14 +192,13 @@ module GitLab
         }
       end
 
-      def redis_options(namespaced = true)
+      def redis_options
         options = {
           url: @opts[:redis_url],
           connect_timeout: 1,
           reconnect_attempts: 0
         }
 
-        options[:namespace] = "resque:gitlab" if namespaced
         options[:id] = nil unless redis_enable_client?
         options
       end
@@ -253,11 +219,6 @@ module GitLab
         @logger&.error "Error connecting to the Redis: #{e}"
         @connected = false
       end
-
-      def add_namespace_labels?
-        @probe_namespaced && @probe_non_namespaced
-      end
     end
-    # rubocop:enable Metrics/ClassLength
   end
 end

data/lib/gitlab_exporter/version.rb

@@ -1,5 +1,5 @@
 module GitLab
   module Exporter
-    VERSION = "13.4.1".freeze
+    VERSION = "14.0.0".freeze
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gitlab-exporter
 version: !ruby/object:Gem::Version
-  version: 13.4.1
+  version: 14.0.0
 platform: ruby
 authors:
 - Pablo Carranza
@@ -236,7 +236,6 @@ files:
 - spec/memstats_spec.rb
 - spec/prometheus_metrics_spec.rb
 - spec/ruby_spec.rb
-- spec/sidekiq_spec.rb
 - spec/spec_helper.rb
 - spec/util_spec.rb
 homepage: https://gitlab.com/gitlab-org/ruby/gems/gitlab-exporter
@@ -275,6 +274,5 @@ test_files:
 - spec/memstats_spec.rb
 - spec/prometheus_metrics_spec.rb
 - spec/ruby_spec.rb
-- spec/sidekiq_spec.rb
 - spec/spec_helper.rb
 - spec/util_spec.rb

data/spec/sidekiq_spec.rb

@@ -1,64 +0,0 @@
-require "spec_helper"
-require "gitlab_exporter/sidekiq"
-
-describe GitLab::Exporter::SidekiqProber do
-  let(:probe_list) { %w[probe_stats probe_queues probe_future_sets probe_jobs_limit probe_workers probe_retries] }
-  let(:opt) { {} }
-  let(:probe) { described_class.new(**opt) }
-
-  before do
-    # stub connection as we want check if the probe methods are called
-    # with the right namespace argument
-    allow(probe).to receive(:connected?).and_return(true)
-  end
-
-  context "when no namespace options are defined" do
-    it "defaults to probing non-namespaced keys only" do
-      probe_list.each do |probe_type|
-        expect(probe).not_to receive("_#{probe_type}".to_sym).with(false)
-        expect(probe).to receive("_#{probe_type}".to_sym).with(no_args)
-
-        probe.send(probe_type)
-      end
-    end
-  end
-
-  context "when probing both namespaces" do
-    let(:opt) { { probe_non_namespaced: true, probe_namespaced: true } }
-
-    it "probes both namespaces" do
-      probe_list.each do |probe_type|
-        expect(probe).to receive("_#{probe_type}".to_sym).with(false)
-        expect(probe).to receive("_#{probe_type}".to_sym).with(no_args)
-
-        probe.send(probe_type)
-      end
-    end
-  end
-
-  context "when probing non-namespaced only" do
-    let(:opt) { { probe_non_namespaced: true } }
-
-    it "probes non-namespaced only" do
-      probe_list.each do |probe_type|
-        expect(probe).to receive("_#{probe_type}".to_sym).with(false)
-        expect(probe).not_to receive("_#{probe_type}".to_sym).with(no_args)
-
-        probe.send(probe_type)
-      end
-    end
-  end
-
-  context "when probing namespace only" do
-    let(:opt) { { probe_namespaced: true } }
-
-    it "probes namespaced only" do
-      probe_list.each do |probe_type|
-        expect(probe).not_to receive("_#{probe_type}".to_sym).with(false)
-        expect(probe).to receive("_#{probe_type}".to_sym).with(no_args)
-
-        probe.send(probe_type)
-      end
-    end
-  end
-end