gitlab-exporter 16.4.0 → 16.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1825ce6b93a9f8c4717470772eee4e887519a735209c2575c1768302fc7390be
-  data.tar.gz: 2ba4a913855b75c73ba9c79a9d2332148835bec68931d5382375d8feef571f47
+  metadata.gz: 741207042e803e24cf2a73e9c622606dc6814a7f335a1e512940977afac6d049
+  data.tar.gz: 27e0ec1192f33b5835e61ddd2a86df4c131673f2c46b11217648c6edc274e64b
 SHA512:
-  metadata.gz: 2e38f6f12cae4a6e1bbda9f567788523e865d2dbd5609b3f37823269352f0c3cc31e12bc16ec79e43c745cd10d3e388bcef71d4f29e2ea41e1b09a3d02023e63
-  data.tar.gz: 2d1ea6f2a7f12249d15de2edddc21a45967daa61cbf44b708b4bdb283d05ae0cc90c71372550a7798d782fab0f61c59bf13e2c7730eaeaf79a2776b082c14968
+  metadata.gz: 9c5f33d6126b18c3da6ae392c5959ee6ca8b361b9af93e24fd5d9f07aa296d4dfd53717bb87fa05496570b3480b4d19ee3512e22ea6a13931a7234e4d1f5f6c6
+  data.tar.gz: 3df0acd00f63f87a674907a70e65b4be172be997c323bfd5c36d3d56fc89cbe7ee72e108c395e674b1075a4618a10befab07ae4b158008c91a102475107d89ce

data/Gemfile.lock

@@ -1,12 +1,12 @@
 PATH
   remote: .
   specs:
-    gitlab-exporter (16.4.0)
+    gitlab-exporter (16.6.0)
       connection_pool (= 2.5.5)
       deep_merge (~> 1.2.2)
       faraday (= 2.14.0)
       pg (= 1.6.3)
-      puma (= 7.1.0)
+      puma (= 7.2.0)
       quantile (= 0.2.1)
       redis (= 4.8.1)
       redis-namespace (= 1.11.0)
@@ -39,8 +39,8 @@ GEM
       ast (~> 2.4.1)
       racc
     pg (1.6.3)
-    prism (1.4.0)
-    puma (7.1.0)
+    prism (1.9.0)
+    puma (7.2.0)
       nio4r (~> 2.0)
     quantile (0.2.1)
     racc (1.8.1)
@@ -66,7 +66,7 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.12.0)
     rspec-support (3.12.0)
-    rubocop (1.82.1)
+    rubocop (1.84.1)
       json (~> 2.3)
       language_server-protocol (~> 3.17.0.2)
       lint_roller (~> 1.1.0)
@@ -74,12 +74,12 @@ GEM
       parser (>= 3.3.0.2)
       rainbow (>= 2.2.2, < 4.0)
       regexp_parser (>= 2.9.3, < 3.0)
-      rubocop-ast (>= 1.48.0, < 2.0)
+      rubocop-ast (>= 1.49.0, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 2.4.0, < 4.0)
-    rubocop-ast (1.48.0)
+    rubocop-ast (1.49.0)
       parser (>= 3.3.7.2)
-      prism (~> 1.4)
+      prism (~> 1.7)
     ruby-progressbar (1.13.0)
     ruby2_keywords (0.0.5)
     sidekiq (6.5.12)

data/gitlab-exporter.gemspec

@@ -26,7 +26,7 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency "deep_merge", "~> 1.2.2"
   s.add_runtime_dependency "faraday", "2.14.0"
   s.add_runtime_dependency "pg", "1.6.3"
-  s.add_runtime_dependency "puma", "7.1.0"
+  s.add_runtime_dependency "puma", "7.2.0"
   s.add_runtime_dependency "quantile", "0.2.1"
   s.add_runtime_dependency "redis", "4.8.1"
   s.add_runtime_dependency "redis-namespace", "1.11.0"

data/lib/gitlab_exporter/database/zoekt.rb

@@ -28,12 +28,11 @@ module GitLab
         SQL
 
         ZOEKT_NODES_QUERY = <<~SQL.freeze
-          SELECT schema_version, id FROM zoekt_nodes
+          SELECT schema_version, id, metadata ->> 'name' AS node_name FROM zoekt_nodes
         SQL
 
         ZOEKT_NODES_STATUS_QUERY = <<~SQL.freeze
-          SELECT
-            id,
+          SELECT id, metadata ->> 'name' AS node_name,
             CASE
               WHEN last_seen_at < NOW() - INTERVAL '2 minute' THEN 0
               ELSE 1
@@ -63,13 +62,51 @@ module GitLab
           LIMIT 1
         SQL
 
+        ZOEKT_NODE_STORAGE_QUERY = <<~SQL.freeze
+          SELECT
+            id,
+            metadata ->> 'name' AS node_name,
+            unclaimed_storage_bytes,
+            storage_percent_used
+          FROM zoekt_nodes
+        SQL
+
+        ZOEKT_REPOSITORIES_STATE_QUERY = <<~SQL.freeze
+          SELECT state, COUNT(*) FROM zoekt_repositories GROUP BY state
+        SQL
+
+        ZOEKT_INDICES_STATE_QUERY = <<~SQL.freeze
+          SELECT state, COUNT(*) FROM zoekt_indices GROUP BY state
+        SQL
+
+        ZOEKT_INDICES_WATERMARK_QUERY = <<~SQL.freeze
+          SELECT watermark_level, COUNT(*) FROM zoekt_indices GROUP BY watermark_level
+        SQL
+
+        ZOEKT_INDICES_STORAGE_QUERY = <<~SQL.freeze
+          SELECT
+            zoekt_indices.id,
+            zoekt_indices.reserved_storage_bytes,
+            zoekt_indices.used_storage_bytes,
+            zoekt_nodes.metadata ->> 'name' AS node_name
+          FROM
+            zoekt_indices
+          INNER JOIN
+            zoekt_nodes ON zoekt_indices.zoekt_node_id = zoekt_nodes.id
+        SQL
+
         def run
           return {} unless zoekt_indexing_enabled?
 
           {
             task_processing_query_result: execute(ZOEKT_TASKS_PROCESSING_QUERY, [Time.now.utc]),
             repositories_schema_version_query_result: repositories_schema_version_query_result,
-            zoekt_nodes_status_query_result: execute(ZOEKT_NODES_STATUS_QUERY)
+            zoekt_nodes_status_query_result: execute(ZOEKT_NODES_STATUS_QUERY),
+            node_storage_query_result: execute(ZOEKT_NODE_STORAGE_QUERY),
+            repositories_state_query_result: execute(ZOEKT_REPOSITORIES_STATE_QUERY),
+            indices_state_query_result: execute(ZOEKT_INDICES_STATE_QUERY),
+            indices_watermark_query_result: execute(ZOEKT_INDICES_WATERMARK_QUERY),
+            indices_storage_query_result: execute(ZOEKT_INDICES_STORAGE_QUERY)
           }.compact
         end
 
@@ -88,22 +125,25 @@ module GitLab
 
           hash = {}
           zoekt_nodes.each do |row|
-            hash[row["id"]] = row["schema_version"]
+            hash[row["id"]] = [row["schema_version"], row["node_name"]]
           end
           hash
         end
 
         def zoekt_repository_schema_version_result(hash)
           result = Set.new
-          hash.each do |id, schema_version|
-            query_result = execute(ZOEKT_REPOSITORY_SCHEMA_VERSION_QUERY, [id, schema_version])
+          hash.each do |id, schema_version_name_arr|
+            query_result = execute(ZOEKT_REPOSITORY_SCHEMA_VERSION_QUERY, [id, schema_version_name_arr[0]])
             if query_result.nil?
               result = nil
               break
             end
-
-            count = query_result[0]["count"].to_i
-            result.add({ target_schema_version: schema_version, zoekt_node_id: id, unfinished_repository_count: count })
+            result.add(
+              {
+                target_schema_version: schema_version_name_arr[0], zoekt_node_id: id,
+                zoekt_node_name: schema_version_name_arr[1], unfinished_repository_count: query_result[0]["count"].to_i
+              }
+            )
           end
           result
         end
@@ -129,6 +169,7 @@ module GitLab
       end
 
       # The prober which is called when gathering metrics
+      # rubocop:disable Metrics/ClassLength
       class ZoektProber
         PrometheusMetrics.describe(
           "search_zoekt_task_processing_queue_size",
@@ -148,6 +189,48 @@ module GitLab
           "gauge"
         )
 
+        PrometheusMetrics.describe(
+          "search_zoekt_node_unclaimed_storage_bytes",
+          "Unclaimed storage bytes for Zoekt node",
+          "gauge"
+        )
+
+        PrometheusMetrics.describe(
+          "search_zoekt_node_storage_percent_used",
+          "Fraction of storage used on Zoekt node (0..1)",
+          "gauge"
+        )
+
+        PrometheusMetrics.describe(
+          "search_zoekt_repositories_states_total",
+          "Number of Zoekt repositories in each state",
+          "gauge"
+        )
+
+        PrometheusMetrics.describe(
+          "search_zoekt_indices_states",
+          "Number of Zoekt indices in each state",
+          "gauge"
+        )
+
+        PrometheusMetrics.describe(
+          "search_zoekt_indices_watermark_levels",
+          "Number of Zoekt indices in each watermark level",
+          "gauge"
+        )
+
+        PrometheusMetrics.describe(
+          "search_zoekt_indices_reserved_storage_bytes",
+          "Reserved storage bytes for each Zoekt index",
+          "gauge"
+        )
+
+        PrometheusMetrics.describe(
+          "search_zoekt_indices_used_storage_bytes",
+          "Used storage bytes for each Zoekt index",
+          "gauge"
+        )
+
         def initialize(metrics: PrometheusMetrics.new, **opts)
           @metrics = metrics
           @collector = opts[:collector] || ZoektCollector.new(**opts)
@@ -155,27 +238,68 @@ module GitLab
 
         def probe_db
           results = @collector.run
-          results[:task_processing_query_result].to_a.each do |row|
-            add_processing_zoekt_tasks_to_metric(row)
-          end
-          results[:repositories_schema_version_query_result]&.each do |row|
-            add_zoekt_repositories_by_schema_version_to_metric(row)
-          end
-          results[:zoekt_nodes_status_query_result]&.each do |row|
-            add_zoekt_nodes_status_to_metric(row)
-          end
-
+          process_results(results)
           self
         rescue PG::ConnectionBad
           self
         end
 
+        private
+
+        def process_results(results)
+          process_task_results(results[:task_processing_query_result])
+          process_repository_results(results[:repositories_schema_version_query_result])
+          process_node_status_results(results[:zoekt_nodes_status_query_result])
+          process_node_storage_results(results[:node_storage_query_result])
+          process_repositories_state_results(results[:repositories_state_query_result])
+          process_indices_state_results(results[:indices_state_query_result])
+          process_indices_watermark_results(results[:indices_watermark_query_result])
+          process_indices_storage_results(results[:indices_storage_query_result])
+        end
+
+        def process_task_results(results)
+          results.to_a.each { |row| add_processing_zoekt_tasks_to_metric(row) }
+        end
+
+        def process_repository_results(results)
+          results&.each { |row| add_zoekt_repositories_by_schema_version_to_metric(row) }
+        end
+
+        def process_node_status_results(results)
+          results&.each { |row| add_zoekt_nodes_status_to_metric(row) }
+        end
+
+        def process_node_storage_results(results)
+          results&.each do |row|
+            add_zoekt_node_unclaimed_storage_to_metric(row)
+            add_zoekt_node_storage_percent_used_to_metric(row)
+          end
+        end
+
+        def process_repositories_state_results(results)
+          results&.each { |row| add_zoekt_repositories_state_to_metric(row) }
+        end
+
+        def process_indices_state_results(results)
+          results&.each { |row| add_zoekt_indices_state_to_metric(row) }
+        end
+
+        def process_indices_watermark_results(results)
+          results&.each { |row| add_zoekt_indices_watermark_to_metric(row) }
+        end
+
+        def process_indices_storage_results(results)
+          results&.each { |row| add_zoekt_indices_storage_to_metric(row) }
+        end
+
         def add_processing_zoekt_tasks_to_metric(row)
           @metrics.add(
             "search_zoekt_task_processing_queue_size",
             row["task_count"].to_i,
-            node_name: row["node_name"],
-            node_id: row["node_id"]
+            **{
+              node_name: row["node_name"],
+              node_id: row["node_id"]
+            }.compact
           )
         end
 
@@ -183,8 +307,11 @@ module GitLab
           @metrics.add(
             "search_zoekt_repositories_schema_version_count",
             row[:unfinished_repository_count].to_i,
-            target_schema_version: row[:target_schema_version],
-            zoekt_node_id: row[:zoekt_node_id]
+            **{
+              target_schema_version: row[:target_schema_version],
+              zoekt_node_id: row[:zoekt_node_id],
+              zoekt_node_name: row[:zoekt_node_name]
+            }.compact
           )
         end
 
@@ -192,14 +319,91 @@ module GitLab
           @metrics.add(
             "search_zoekt_nodes_status",
             row["status"].to_i,
-            zoekt_node_id: row["id"]
+            **{
+              zoekt_node_id: row["id"],
+              zoekt_node_name: row["node_name"]
+            }.compact
+          )
+        end
+
+        def add_zoekt_node_unclaimed_storage_to_metric(row)
+          @metrics.add(
+            "search_zoekt_node_unclaimed_storage_bytes",
+            row["unclaimed_storage_bytes"].to_i,
+            **{
+              zoekt_node_id: row["id"],
+              zoekt_node_name: row["node_name"]
+            }.compact
+          )
+        end
+
+        def add_zoekt_node_storage_percent_used_to_metric(row)
+          @metrics.add(
+            "search_zoekt_node_storage_percent_used",
+            row["storage_percent_used"].to_f,
+            **{
+              zoekt_node_id: row["id"],
+              zoekt_node_name: row["node_name"]
+            }.compact
+          )
+        end
+
+        def add_zoekt_repositories_state_to_metric(row)
+          @metrics.add(
+            "search_zoekt_repositories_states_total",
+            row["count"].to_i,
+            **{
+              state: row["state"]
+            }.compact
+          )
+        end
+
+        def add_zoekt_indices_state_to_metric(row)
+          @metrics.add(
+            "search_zoekt_indices_states",
+            row["count"].to_i,
+            **{
+              state: row["state"]
+            }.compact
+          )
+        end
+
+        def add_zoekt_indices_watermark_to_metric(row)
+          @metrics.add(
+            "search_zoekt_indices_watermark_levels",
+            row["count"].to_i,
+            **{
+              watermark_level: row["watermark_level"]
+            }.compact
+          )
+        end
+
+        # rubocop:disable Metrics/MethodLength
+        def add_zoekt_indices_storage_to_metric(row)
+          @metrics.add(
+            "search_zoekt_indices_reserved_storage_bytes",
+            row["reserved_storage_bytes"].to_i,
+            **{
+              zoekt_index_id: row["id"],
+              zoekt_node_name: row["node_name"]
+            }.compact
+          )
+          @metrics.add(
+            "search_zoekt_indices_used_storage_bytes",
+            row["used_storage_bytes"].to_i,
+            **{
+              zoekt_index_id: row["id"],
+              zoekt_node_name: row["node_name"]
+            }.compact
           )
         end
+        # rubocop:enable Metrics/MethodLength
 
         def write_to(target)
           target.write(@metrics.to_s)
         end
       end
+      # rubocop:enable Metrics/ClassLength
     end
   end
 end

data/lib/gitlab_exporter/version.rb

@@ -1,5 +1,5 @@
 module GitLab
   module Exporter
-    VERSION = "16.4.0".freeze
+    VERSION = "16.6.0".freeze
   end
 end

data/spec/database/zoekt_spec.rb

@@ -6,11 +6,36 @@ describe GitLab::Exporter::Database::ZoektCollector do
   let(:connection) { double("connection") }
   let(:zoekt_tasks_processing_query) { described_class::ZOEKT_TASKS_PROCESSING_QUERY }
   let(:zoekt_nodes_query) { described_class::ZOEKT_NODES_QUERY }
-  let(:zoekt_nodes_query_results) { [{ "id" => "1", "schema_version" => "2302" }] }
+  let(:zoekt_nodes_query_results) { [{ "id" => "1", "schema_version" => "2302", "node_name" => "foo" }] }
   let(:zoekt_enabled_query) { described_class::ZOEKT_ENABLED_QUERY }
   let(:zoekt_repository_schema_version_query) { described_class::ZOEKT_REPOSITORY_SCHEMA_VERSION_QUERY }
   let(:zoekt_nodes_status_query) { described_class::ZOEKT_NODES_STATUS_QUERY }
-  let(:zoekt_nodes_status_query_results) { [{ "id" => "1", "status" => "1" }] }
+  let(:zoekt_nodes_status_query_results) { [{ "id" => "1", "name" => "foo", "status" => "1" }] }
+  let(:zoekt_node_storage_query) { described_class::ZOEKT_NODE_STORAGE_QUERY }
+  let(:zoekt_node_storage_query_results) do
+    [{ "id" => "1", "node_name" => "foo", "unclaimed_storage_bytes" => "1000000", "storage_percent_used" => "0.75" }]
+  end
+  let(:zoekt_repositories_state_query) { described_class::ZOEKT_REPOSITORIES_STATE_QUERY }
+  let(:zoekt_repositories_state_query_results) do
+    [{ "state" => "0", "count" => "5" }, { "state" => "10", "count" => "15" }]
+  end
+  let(:zoekt_indices_state_query) { described_class::ZOEKT_INDICES_STATE_QUERY }
+  let(:zoekt_indices_state_query_results) do
+    [{ "state" => "0", "count" => "3" }, { "state" => "1", "count" => "7" }]
+  end
+  let(:zoekt_indices_watermark_query) { described_class::ZOEKT_INDICES_WATERMARK_QUERY }
+  let(:zoekt_indices_watermark_query_results) do
+    [{ "watermark_level" => "healthy", "count" => "8" }, { "watermark_level" => "warning", "count" => "2" }]
+  end
+  let(:zoekt_indices_storage_query) { described_class::ZOEKT_INDICES_STORAGE_QUERY }
+  let(:zoekt_indices_storage_query_results) do
+    [
+      { "id" => "1", "reserved_storage_bytes" => "1000000", "used_storage_bytes" => "500000",
+        "node_name" => "zoekt-1" },
+      { "id" => "2", "reserved_storage_bytes" => "2000000", "used_storage_bytes" => "1500000",
+        "node_name" => "zoekt-2" }
+    ]
+  end
 
   let(:zoekt_repository_schema_version_query_results) { [{ "count" => "1" }] }
 
@@ -41,14 +66,21 @@ describe GitLab::Exporter::Database::ZoektCollector do
     end
 
     let(:zoekt_repositories_schema_version_query_results) do
-      Set.new([{ target_schema_version: "2302", zoekt_node_id: "1", unfinished_repository_count: 1 }])
+      Set.new(
+        [{ target_schema_version: "2302", zoekt_node_id: "1", zoekt_node_name: "foo", unfinished_repository_count: 1 }]
+      )
     end
 
     let(:result) do
       {
         repositories_schema_version_query_result: zoekt_repositories_schema_version_query_results,
         task_processing_query_result: zoekt_tasks_processing_query_results,
-        zoekt_nodes_status_query_result: zoekt_nodes_status_query_results
+        zoekt_nodes_status_query_result: zoekt_nodes_status_query_results,
+        node_storage_query_result: zoekt_node_storage_query_results,
+        repositories_state_query_result: zoekt_repositories_state_query_results,
+        indices_state_query_result: zoekt_indices_state_query_results,
+        indices_watermark_query_result: zoekt_indices_watermark_query_results,
+        indices_storage_query_result: zoekt_indices_storage_query_results
       }
     end
 
@@ -80,6 +112,16 @@ describe GitLab::Exporter::Database::ZoektCollector do
                                                    .and_return(zoekt_repository_schema_version_query_results)
         expect(connection).to receive(:exec_params).with(zoekt_nodes_status_query, [])
                                                    .and_return(zoekt_nodes_status_query_results)
+        expect(connection).to receive(:exec_params).with(zoekt_node_storage_query, [])
+                                                   .and_return(zoekt_node_storage_query_results)
+        expect(connection).to receive(:exec_params).with(zoekt_repositories_state_query, [])
+                                                   .and_return(zoekt_repositories_state_query_results)
+        expect(connection).to receive(:exec_params).with(zoekt_indices_state_query, [])
+                                                   .and_return(zoekt_indices_state_query_results)
+        expect(connection).to receive(:exec_params).with(zoekt_indices_watermark_query, [])
+                                                   .and_return(zoekt_indices_watermark_query_results)
+        expect(connection).to receive(:exec_params).with(zoekt_indices_storage_query, [])
+                                                   .and_return(zoekt_indices_storage_query_results)
 
         expect(collector.run).to eq(result)
       end
@@ -92,6 +134,16 @@ describe GitLab::Exporter::Database::ZoektCollector do
                                                     .and_raise(PG::UndefinedTable)
           allow(connection).to receive(:exec_params).with(zoekt_nodes_status_query, [])
                                                     .and_raise(PG::UndefinedTable)
+          allow(connection).to receive(:exec_params).with(zoekt_node_storage_query, [])
+                                                    .and_raise(PG::UndefinedTable)
+          allow(connection).to receive(:exec_params).with(zoekt_repositories_state_query, [])
+                                                    .and_raise(PG::UndefinedTable)
+          allow(connection).to receive(:exec_params).with(zoekt_indices_state_query, [])
+                                                    .and_raise(PG::UndefinedTable)
+          allow(connection).to receive(:exec_params).with(zoekt_indices_watermark_query, [])
+                                                    .and_raise(PG::UndefinedTable)
+          allow(connection).to receive(:exec_params).with(zoekt_indices_storage_query, [])
+                                                    .and_raise(PG::UndefinedTable)
 
           expect(collector.run).to eq({})
         end
@@ -106,6 +158,15 @@ describe GitLab::Exporter::Database::ZoektCollector do
           expect(connection).to receive(:exec_params).with(zoekt_repository_schema_version_query, %w[1 2302])
                                                      .and_raise(PG::UndefinedTable)
           expect(connection).to receive(:exec_params).with(zoekt_nodes_status_query, []).and_raise(PG::UndefinedTable)
+          expect(connection).to receive(:exec_params).with(zoekt_node_storage_query, []).and_raise(PG::UndefinedColumn)
+          expect(connection).to receive(:exec_params).with(zoekt_repositories_state_query, [])
+                                                     .and_raise(PG::UndefinedColumn)
+          expect(connection).to receive(:exec_params).with(zoekt_indices_state_query, [])
+                                                     .and_raise(PG::UndefinedColumn)
+          expect(connection).to receive(:exec_params).with(zoekt_indices_watermark_query, [])
+                                                     .and_raise(PG::UndefinedColumn)
+          expect(connection).to receive(:exec_params).with(zoekt_indices_storage_query, [])
+                                                     .and_raise(PG::UndefinedColumn)
 
           expect(collector.run).to eq({ task_processing_query_result: zoekt_tasks_processing_query_results })
         end
@@ -136,11 +197,39 @@ describe GitLab::Exporter::Database::ZoektProber do
   let(:data) do
     {
       repositories_schema_version_query_result: Set.new(
-        [{ target_schema_version: "2302", zoekt_node_id: "1", unfinished_repository_count: 1 }]
+        [{ target_schema_version: "2302", zoekt_node_id: "1", unfinished_repository_count: 1, zoekt_node_name: "foo" }]
       ),
       task_processing_query_result: [
         { "node_id" => "1", "node_name" => "zoekt-1", "task_count" => "5" },
         { "node_id" => "2", "node_name" => "zoekt-2", "task_count" => "10" }
+      ],
+      node_storage_query_result: [
+        {
+          "id" => "1", "node_name" => "zoekt-1", "unclaimed_storage_bytes" => "1000000",
+          "storage_percent_used" => "0.75"
+        },
+        {
+          "id" => "2", "node_name" => "zoekt-2", "unclaimed_storage_bytes" => "2000000",
+          "storage_percent_used" => "0.50"
+        }
+      ],
+      repositories_state_query_result: [
+        { "state" => "0", "count" => "5" },
+        { "state" => "10", "count" => "15" }
+      ],
+      indices_state_query_result: [
+        { "state" => "0", "count" => "3" },
+        { "state" => "1", "count" => "7" }
+      ],
+      indices_watermark_query_result: [
+        { "watermark_level" => "healthy", "count" => "8" },
+        { "watermark_level" => "warning", "count" => "2" }
+      ],
+      indices_storage_query_result: [
+        { "id" => "1", "reserved_storage_bytes" => "1000000", "used_storage_bytes" => "500000",
+          "node_name" => "zoekt-1" },
+        { "id" => "2", "reserved_storage_bytes" => "2000000", "used_storage_bytes" => "1500000",
+          "node_name" => "zoekt-2" }
       ]
     }
   end
@@ -165,10 +254,12 @@ describe GitLab::Exporter::Database::ZoektProber do
 
       data[:task_processing_query_result].each do |node_data|
         expect(metrics).to receive(:add)
-          .with("search_zoekt_task_processing_queue_size",
-                node_data["task_count"].to_i,
-                node_name: node_data["node_name"],
-                node_id: node_data["node_id"])
+          .with(
+            "search_zoekt_task_processing_queue_size",
+            node_data["task_count"].to_i,
+            node_name: node_data["node_name"],
+            node_id: node_data["node_id"]
+          )
       end
 
       data[:repositories_schema_version_query_result].each do |node_data|
@@ -177,7 +268,69 @@ describe GitLab::Exporter::Database::ZoektProber do
             "search_zoekt_repositories_schema_version_count",
             node_data[:unfinished_repository_count].to_i,
             target_schema_version: node_data[:target_schema_version],
-            zoekt_node_id: node_data[:zoekt_node_id]
+            zoekt_node_id: node_data[:zoekt_node_id],
+            zoekt_node_name: node_data[:zoekt_node_name]
+          )
+      end
+
+      data[:node_storage_query_result].each do |node_data|
+        expect(metrics).to receive(:add)
+          .with(
+            "search_zoekt_node_unclaimed_storage_bytes",
+            node_data["unclaimed_storage_bytes"].to_i,
+            zoekt_node_id: node_data["id"],
+            zoekt_node_name: node_data["node_name"]
+          )
+        expect(metrics).to receive(:add)
+          .with(
+            "search_zoekt_node_storage_percent_used",
+            node_data["storage_percent_used"].to_f,
+            zoekt_node_id: node_data["id"],
+            zoekt_node_name: node_data["node_name"]
+          )
+      end
+
+      data[:repositories_state_query_result].each do |state_data|
+        expect(metrics).to receive(:add)
+          .with(
+            "search_zoekt_repositories_states_total",
+            state_data["count"].to_i,
+            state: state_data["state"]
+          )
+      end
+
+      data[:indices_state_query_result].each do |state_data|
+        expect(metrics).to receive(:add)
+          .with(
+            "search_zoekt_indices_states",
+            state_data["count"].to_i,
+            state: state_data["state"]
+          )
+      end
+
+      data[:indices_watermark_query_result].each do |watermark_data|
+        expect(metrics).to receive(:add)
+          .with(
+            "search_zoekt_indices_watermark_levels",
+            watermark_data["count"].to_i,
+            watermark_level: watermark_data["watermark_level"]
+          )
+      end
+
+      data[:indices_storage_query_result].each do |storage_data|
+        expect(metrics).to receive(:add)
+          .with(
+            "search_zoekt_indices_reserved_storage_bytes",
+            storage_data["reserved_storage_bytes"].to_i,
+            zoekt_index_id: storage_data["id"],
+            zoekt_node_name: storage_data["node_name"]
+          )
+        expect(metrics).to receive(:add)
+          .with(
+            "search_zoekt_indices_used_storage_bytes",
+            storage_data["used_storage_bytes"].to_i,
+            zoekt_index_id: storage_data["id"],
+            zoekt_node_name: storage_data["node_name"]
           )
       end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gitlab-exporter
 version: !ruby/object:Gem::Version
-  version: 16.4.0
+  version: 16.6.0
 platform: ruby
 authors:
 - Pablo Carranza
@@ -72,14 +72,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 7.1.0
+        version: 7.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 7.1.0
+        version: 7.2.0
 - !ruby/object:Gem::Dependency
   name: quantile
   requirement: !ruby/object:Gem::Requirement