gitlab-exporter 13.0.3 → 13.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 772759981296901f1bd6ed3d38a9f98cf882ddbc851605c8dfb31b47aceed046
-  data.tar.gz: 82f8e5ce3795f3349dd1cd053161302cf01eafe0c57485ec3074e7a8844606a9
+  metadata.gz: 1faa75a67146917f990466c949a63cc5b53c4c4280bcaae76601071a88c5fb0c
+  data.tar.gz: acd50e384eb4e03fdbf2ba20c8f030a47b886822a3e87cdddded7326790e5f25
 SHA512:
-  metadata.gz: ed3d74142e8da3b4bf367c9bf26b91b1e55a42f904e494479797d1bc10f07324e0734247a271a44e1a6db6ca745dddaddf97688d0ba659ff3e27f3f927fa6973
-  data.tar.gz: f0af44afc5e5c3d425bdfe09e1d846b550b53f9b1bc24cad7549715a8d18dc751f60dda5a8e7c934d1a0b6c2f0285ea533c64419deaab78087ef102c2161d40b
+  metadata.gz: 6dbab1d6bce735e67ced073506ca2e9ddf1111ccd1b4a6e45a2289ce5a0ed069f5f004c2cda272a298d6328f7fe0fbd96cff30d434c722f01c1f1448b49199ce
+  data.tar.gz: c625442a214949794bad144d38a511c96161af0261380cac50f509f421c7da03c6549b94059451322c9f23498ca33ccc9ce528c02f4874357c79b21bf9486e04

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    gitlab-exporter (13.0.3)
+    gitlab-exporter (13.2.0)
       connection_pool (= 2.2.5)
       faraday (~> 1.8.0)
       pg (= 1.5.3)

data/config/gitlab-exporter.yml.example

@@ -95,6 +95,8 @@ 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/row_count.rb

@@ -8,7 +8,7 @@ module GitLab
       # This class works under the assumption you do COUNT(*) queries, define
       # queries in the QUERIES constant. If in doubt how these work, read
       # #construct_query
-      class RowCountCollector < Base
+      class RowCountCollector < Base # rubocop:disable Metrics/ClassLength
         # We ignore mirrors with a next_execution_timestamp before
         # 2020-03-28 because this is when we stopped processing mirrors
         # for private projects on the free plan. Skipping those can
@@ -29,6 +29,15 @@ module GitLab
           check: "SELECT 1 FROM information_schema.tables WHERE table_name='plans'"
         }.freeze
 
+        CONTAINER_REPOSITORIES_CLEANUP_ENABLED_QUERY = {
+          select: :container_repositories,
+          joins: <<~SQL,
+            INNER JOIN container_expiration_policies
+            ON container_repositories.project_id = container_expiration_policies.project_id
+          SQL
+          where: "container_expiration_policies.enabled = TRUE"
+        }.freeze
+
         QUERIES = {
           mirrors_ready_to_sync: MIRROR_QUERY.merge( # EE only
             where: <<~SQL
@@ -117,6 +126,52 @@ module GitLab
               visibility_level: {},
               root: { definition: "(parent_id IS NULL)" }
             }
+          },
+          container_repositories: { select: :container_repositories },
+          container_repositories_delete_scheduled: { select: :container_repositories, where: "status = 0" },
+          container_repositories_delete_failed: { select: :container_repositories, where: "status = 1" },
+          container_repositories_delete_ongoing: { select: :container_repositories, where: "status = 2" },
+          container_repositories_delete_staled: {
+            select: :container_repositories,
+            where: "status = 2 AND delete_started_at < (NOW() - INTERVAL '30 minutes')"
+          },
+          container_repositories_cleanup_enabled: CONTAINER_REPOSITORIES_CLEANUP_ENABLED_QUERY,
+          container_repositories_cleanup_pending: CONTAINER_REPOSITORIES_CLEANUP_ENABLED_QUERY.merge(
+            where: <<~SQL
+              container_expiration_policies.enabled = TRUE
+              AND container_repositories.expiration_policy_cleanup_status IN (0, 1)
+              AND (container_repositories.expiration_policy_started_at IS NULL OR container_repositories.expiration_policy_started_at < container_expiration_policies.next_run_at)
+              AND (container_expiration_policies.next_run_at < NOW())
+            SQL
+          ),
+          container_repositories_cleanup_unfinished: CONTAINER_REPOSITORIES_CLEANUP_ENABLED_QUERY.merge(
+            where: <<~SQL
+              container_expiration_policies.enabled = TRUE
+              AND container_repositories.expiration_policy_cleanup_status = 2
+            SQL
+          ),
+          container_repositories_cleanup_unscheduled: CONTAINER_REPOSITORIES_CLEANUP_ENABLED_QUERY.merge(
+            where: <<~SQL
+              container_expiration_policies.enabled = TRUE
+              AND container_repositories.expiration_policy_cleanup_status = 0
+            SQL
+          ),
+          container_repositories_cleanup_scheduled: CONTAINER_REPOSITORIES_CLEANUP_ENABLED_QUERY.merge(
+            where: <<~SQL
+              container_expiration_policies.enabled = TRUE
+              AND container_repositories.expiration_policy_cleanup_status = 1
+            SQL
+          ),
+          container_repositories_cleanup_ongoing: {
+            select: :container_repositories,
+            where: "expiration_policy_cleanup_status = 3"
+          },
+          container_repositories_cleanup_staled: {
+            select: :container_repositories,
+            where: <<~SQL
+              expiration_policy_cleanup_status = 3
+              AND (expiration_policy_started_at < (NOW() - INTERVAL '35 minutes') OR expiration_policy_started_at IS NULL)
+            SQL
           }
         }.freeze
 

data/lib/gitlab_exporter/sidekiq.rb

@@ -7,6 +7,7 @@ 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
@@ -37,35 +38,24 @@ 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 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
+        with_sidekiq { _probe_stats } if @probe_namespaced
+        with_sidekiq(false) { _probe_stats(false) } if @probe_non_namespaced
 
         self
       end
 
       def probe_queues
-        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
+        with_sidekiq { _probe_queues } if @probe_namespaced
+        with_sidekiq(false) { _probe_queues(false) } if @probe_non_namespaced
 
         self
       end
@@ -78,24 +68,8 @@ module GitLab
       end
 
       def probe_future_sets
-        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
+        with_sidekiq { _probe_future_sets } if @probe_namespaced
+        with_sidekiq(false) { _probe_future_sets(false) } if @probe_non_namespaced
       end
 
       # Count worker classes present in Sidekiq queues. This only looks at the
@@ -105,57 +79,22 @@ 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 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
+        with_sidekiq { _probe_jobs_limit } if @probe_namespaced
+        with_sidekiq(false) { _probe_jobs_limit(false) } if @probe_non_namespaced
 
         self
       end
 
       def probe_workers
-        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
+        with_sidekiq { _probe_workers } if @probe_namespaced
+        with_sidekiq(false) { _probe_workers(false) } if @probe_non_namespaced
 
         self
       end
 
       def probe_retries
-        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
+        with_sidekiq { _probe_retries } if @probe_namespaced
+        with_sidekiq(false) { _probe_retries(false) } if @probe_non_namespaced
 
         self
       end
@@ -177,12 +116,106 @@ module GitLab
 
       private
 
-      def with_sidekiq
+      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)
         # TODO: this is not concurrent safe as we change global context
         # It means that we are unable to use many different sidekiq's
         # which is not a problem as of now
         Sidekiq.configure_client do |config|
-          config.redis = self.class.connection_pool[redis_options]
+          config.redis = self.class.connection_pool[redis_options(namespaced)]
         end
 
         return unless connected?
@@ -190,14 +223,14 @@ module GitLab
         yield
       end
 
-      def redis_options
+      def redis_options(namespaced = true)
         options = {
           url: @opts[:redis_url],
-          namespace: "resque:gitlab",
           connect_timeout: 1,
           reconnect_attempts: 0
         }
 
+        options[:namespace] = "resque:gitlab" if namespaced
         options[:id] = nil unless redis_enable_client?
         options
       end
@@ -218,6 +251,11 @@ 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.0.3".freeze
+    VERSION = "13.2.0".freeze
   end
 end

data/spec/sidekiq_spec.rb

@@ -0,0 +1,64 @@
+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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gitlab-exporter
 version: !ruby/object:Gem::Version
-  version: 13.0.3
+  version: 13.2.0
 platform: ruby
 authors:
 - Pablo Carranza
@@ -235,6 +235,7 @@ 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: http://gitlab.com
@@ -273,5 +274,6 @@ 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