kube_cluster 1.3.1 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 821079f616a7cafa9d2115b32cebda37de37601d9ac116827c7fbcead48de3eb
-  data.tar.gz: bb33e6aec68bc2a83c67272d2a2fa73e38234095aefbb686e6b749bbd4add87c
+  metadata.gz: 1e6e0a31873f5a706d272e0ff37b06a8f3565b0e8d8629b92915f24c572825d1
+  data.tar.gz: '08b20a4bb972d5b52eddd66577c79462a59611c8f84e692d092720c09bced0da'
 SHA512:
-  metadata.gz: 070b4bdf62bbf662bfa99eb55a464335d9666734ef3985f08949b072c78aa548cd51d0527c9cee62d26ca8839df8d2ddafa285b0fb44f0b346268174aab78ec8
-  data.tar.gz: 28f9483b8a10994f19f485c9e55b33e464541742842eff8c5791218ff294435f6ce55f59921aa9eb5c8725bd456d8a63d74be2f39c25d88c46e8601295829f13
+  metadata.gz: 676e83947ff878d10e2ff3e46e9dd880120e856f480e5ed9b26d27046f7d901d07d5d044d0a3358fa99c927768f4c0c54e8af1e13fa5ef96b5806caeefa476d2
+  data.tar.gz: e8ade4344a74dd80bfaf8abec1bb43c5b0531b1130ab0c8584c4a0edb08e0a8d339dead8c35012cf517847d19cf066516717af9937890b70df744611f0809d5a

data/CHANGELOG.md

@@ -5,6 +5,20 @@ All notable changes to this project are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.4.0] - 2026-07-13
+
+### Added
+- `Standard::VictoriaMetrics::VMRule` — a wrapper for the VictoriaMetrics
+  operator's `VMRule` CRD (pinned to `operator.victoriametrics.com/v1beta1`).
+  Rules are built from `VMRule::Group` objects, each exposing `rule`/`alert`
+  helpers that construct `Rule`/`Alert` leaves; the rule expression is the
+  return value of a block, so multi-line PromQL reads as a heredoc.
+- `Standard::VictoriaMetrics::VMAlert` — a wrapper for the VictoriaMetrics
+  operator's `VMAlert` CRD (pinned to `operator.victoriametrics.com/v1beta1`).
+  Wires `datasource`/`remoteWrite`/`remoteRead` and defaults `selectAllByDefault`
+  to true so it evaluates every `VMRule`; `notifier_url` is optional (recording
+  rules need no notifier).
+
 ## [1.3.1] - 2026-07-13
 
 ### Changed

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    kube_cluster (1.3.1)
+    kube_cluster (1.5.0)
       activesupport (~> 8.0)
       kube_kubectl (~> 2.0)
       kube_schema (~> 1.9.2)

data/lib/kube/cluster/standard/victoria_metrics/vl_cluster.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      module VictoriaMetrics
+        # HA/clustered VictoriaLogs: vlstorage + vlselect + vlinsert components
+        # (the horizontally-scalable alternative to VLSingle). Retention lives on
+        # the vlstorage component, so configure the components in the block.
+        class VLCluster < Kube::Cluster["VLCluster"]
+          def initialize(name:, &block)
+            super() {
+              metadata.name = name
+              instance_exec(&block) if block
+            }
+          end
+        end
+      end
+    end
+  end
+end
+
+__END__
+
+describe "VictoriaMetrics::VLCluster" do
+  it "initializes without error" do
+    Kube::Cluster::Standard::VictoriaMetrics::VLCluster
+      .new(name: "vlcluster")
+      .to_yaml
+      .is_a?(String)
+      .should == true
+  end
+end

data/lib/kube/cluster/standard/victoria_metrics/vlogs.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      module VictoriaMetrics
+        # Legacy VictoriaLogs kind (operator.victoriametrics.com/v1beta1). New
+        # deployments should prefer VLSingle (v1); this wrapper exists for
+        # completeness / migrating existing objects. Spec is configured in block.
+        class VLogs < Kube::Cluster["VLogs"]
+          def initialize(name:, &block)
+            super() {
+              metadata.name = name
+              instance_exec(&block) if block
+            }
+          end
+        end
+      end
+    end
+  end
+end
+
+__END__
+
+describe "VictoriaMetrics::VLogs" do
+  it "initializes without error" do
+    Kube::Cluster::Standard::VictoriaMetrics::VLogs
+      .new(name: "vlogs")
+      .to_yaml
+      .is_a?(String)
+      .should == true
+  end
+end

data/lib/kube/cluster/standard/victoria_metrics/vm_alert.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      module VictoriaMetrics
+        # Evaluates VMRule recording/alerting rules (selecting all by default).
+        # Recording-rule output is written back via remote_write_url; a notifier
+        # is only needed for alerting rules, so it is optional.
+        class VMAlert < Kube::Cluster["VMAlert"]
+          def initialize(name:, datasource_url:, remote_write_url:, remote_read_url: nil,
+                         notifier_url: nil, evaluation_interval: nil, select_all: true, &block)
+            super() {
+              metadata.name           = name
+              spec.selectAllByDefault = select_all
+              spec.datasource         = { url: datasource_url }
+              spec.remoteWrite        = { url: remote_write_url }
+              spec.remoteRead         = { url: remote_read_url }      if remote_read_url
+              spec.notifiers          = [{ url: notifier_url }]       if notifier_url
+              spec.evaluationInterval = evaluation_interval           if evaluation_interval
+              instance_exec(&block) if block
+            }
+          end
+        end
+      end
+    end
+  end
+end
+
+__END__
+
+describe "VictoriaMetrics::VMAlert" do
+  it "wires datasource and remote-write for recording rules" do
+    yaml = Kube::Cluster::Standard::VictoriaMetrics::VMAlert.new(
+      name:             "vmalert",
+      datasource_url:   "http://vmsingle-vmsingle.metrics.svc:8429/prometheus",
+      remote_write_url: "http://vmsingle-vmsingle.metrics.svc:8429/api/v1/write"
+    ).to_yaml
+
+    yaml.include?("operator.victoriametrics.com/v1beta1").should == true
+    yaml.include?("selectAllByDefault").should == true
+    yaml.include?("/api/v1/write").should == true
+  end
+end

data/lib/kube/cluster/standard/victoria_metrics/vm_alertmanager.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      module VictoriaMetrics
+        # Managed Alertmanager instance. Notification routing/receivers can be
+        # supplied inline via spec.configRawYaml or selected from
+        # VMAlertmanagerConfig objects; configure that in the block.
+        class VMAlertmanager < Kube::Cluster["VMAlertmanager"]
+          def initialize(name:, replica_count: 1, &block)
+            super() {
+              metadata.name     = name
+              spec.replicaCount = replica_count
+              instance_exec(&block) if block
+            }
+          end
+        end
+      end
+    end
+  end
+end
+
+__END__
+
+describe "VictoriaMetrics::VMAlertmanager" do
+  it "initializes without error" do
+    Kube::Cluster::Standard::VictoriaMetrics::VMAlertmanager
+      .new(name: "vmalertmanager")
+      .to_yaml
+      .is_a?(String)
+      .should == true
+  end
+end

data/lib/kube/cluster/standard/victoria_metrics/vm_alertmanager_config.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      module VictoriaMetrics
+        # Alertmanager routing tree and receivers, selected by a VMAlertmanager.
+        # Define spec.route and spec.receivers in the block.
+        class VMAlertmanagerConfig < Kube::Cluster["VMAlertmanagerConfig"]
+          def initialize(name:, &block)
+            super() {
+              metadata.name = name
+              instance_exec(&block) if block
+            }
+          end
+        end
+      end
+    end
+  end
+end
+
+__END__
+
+describe "VictoriaMetrics::VMAlertmanagerConfig" do
+  it "initializes without error" do
+    Kube::Cluster::Standard::VictoriaMetrics::VMAlertmanagerConfig
+      .new(name: "vmalertmanagerconfig")
+      .to_yaml
+      .is_a?(String)
+      .should == true
+  end
+end

data/lib/kube/cluster/standard/victoria_metrics/vm_anomaly.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      module VictoriaMetrics
+        # VictoriaMetrics Anomaly Detection service (vmanomaly). Reads metrics,
+        # fits models, and writes anomaly scores back. Provide the model/reader/
+        # writer configuration via spec.configRawYaml in the block.
+        class VMAnomaly < Kube::Cluster["VMAnomaly"]
+          def initialize(name:, &block)
+            super() {
+              metadata.name = name
+              instance_exec(&block) if block
+            }
+          end
+        end
+      end
+    end
+  end
+end
+
+__END__
+
+describe "VictoriaMetrics::VMAnomaly" do
+  it "initializes without error" do
+    Kube::Cluster::Standard::VictoriaMetrics::VMAnomaly
+      .new(name: "vmanomaly")
+      .to_yaml
+      .is_a?(String)
+      .should == true
+  end
+end

data/lib/kube/cluster/standard/victoria_metrics/vm_anomaly_config.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      module VictoriaMetrics
+        # Reusable configuration object referenced by a VMAnomaly instance.
+        # Define the models/schedulers in the block.
+        class VMAnomalyConfig < Kube::Cluster["VMAnomalyConfig"]
+          def initialize(name:, &block)
+            super() {
+              metadata.name = name
+              instance_exec(&block) if block
+            }
+          end
+        end
+      end
+    end
+  end
+end
+
+__END__
+
+describe "VictoriaMetrics::VMAnomalyConfig" do
+  it "initializes without error" do
+    Kube::Cluster::Standard::VictoriaMetrics::VMAnomalyConfig
+      .new(name: "vmanomalyconfig") { spec.schedulers = {} }
+      .to_yaml
+      .is_a?(String)
+      .should == true
+  end
+end

data/lib/kube/cluster/standard/victoria_metrics/vm_auth.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      module VictoriaMetrics
+        # Auth proxy / router that sits in front of VictoriaMetrics components and
+        # dispatches requests according to the VMUser objects it selects. Configure
+        # user selection and unauthorized-access rules in the block.
+        class VMAuth < Kube::Cluster["VMAuth"]
+          def initialize(name:, &block)
+            super() {
+              metadata.name = name
+              instance_exec(&block) if block
+            }
+          end
+        end
+      end
+    end
+  end
+end
+
+__END__
+
+describe "VictoriaMetrics::VMAuth" do
+  it "initializes without error" do
+    Kube::Cluster::Standard::VictoriaMetrics::VMAuth
+      .new(name: "vmauth")
+      .to_yaml
+      .is_a?(String)
+      .should == true
+  end
+end

data/lib/kube/cluster/standard/victoria_metrics/vm_cluster.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      module VictoriaMetrics
+        # HA/clustered VictoriaMetrics: vmstorage + vmselect + vminsert
+        # components (the horizontally-scalable alternative to VMSingle).
+        # Configure the three components in the block.
+        class VMCluster < Kube::Cluster["VMCluster"]
+          def initialize(name:, retention_period: "30d", &block)
+            super() {
+              metadata.name        = name
+              spec.retentionPeriod = retention_period
+              instance_exec(&block) if block
+            }
+          end
+        end
+      end
+    end
+  end
+end
+
+__END__
+
+describe "VictoriaMetrics::VMCluster" do
+  it "initializes without error" do
+    Kube::Cluster::Standard::VictoriaMetrics::VMCluster
+      .new(name: "vmcluster")
+      .to_yaml
+      .is_a?(String)
+      .should == true
+  end
+end

data/lib/kube/cluster/standard/victoria_metrics/vm_distributed.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      module VictoriaMetrics
+        # Multi-zone/distributed VictoriaMetrics topology. The full shape (zones,
+        # common settings) is configured in the block.
+        class VMDistributed < Kube::Cluster["VMDistributed"]
+          def initialize(name:, &block)
+            super() {
+              metadata.name = name
+              instance_exec(&block) if block
+            }
+          end
+        end
+      end
+    end
+  end
+end
+
+__END__
+
+describe "VictoriaMetrics::VMDistributed" do
+  it "initializes without error" do
+    Kube::Cluster::Standard::VictoriaMetrics::VMDistributed
+      .new(name: "vmdistributed") { spec.retain = true }
+      .to_yaml
+      .is_a?(String)
+      .should == true
+  end
+end

data/lib/kube/cluster/standard/victoria_metrics/vm_pod_scrape.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      module VictoriaMetrics
+        # Declares how to scrape the pods selected by the app.kubernetes.io/name
+        # label (the pod-selector analogue of VMServiceScrape), relabelling the
+        # metrics onto a job.
+        class VMPodScrape < Kube::Cluster["VMPodScrape"]
+          def initialize(name:, job:, match_name:, port:, &block)
+            super() {
+              metadata.name           = name
+              spec.selector           = { matchLabels: { "app.kubernetes.io/name" => match_name } }
+              spec.podMetricsEndpoints = [{ port: port, relabelConfigs: [{ targetLabel: "job", replacement: job }] }]
+              instance_exec(&block) if block
+            }
+          end
+        end
+      end
+    end
+  end
+end
+
+__END__
+
+describe "VictoriaMetrics::VMPodScrape" do
+  it "initializes without error" do
+    Kube::Cluster::Standard::VictoriaMetrics::VMPodScrape
+      .new(name: "opencost", job: "opencost", match_name: "opencost", port: "http")
+      .to_yaml
+      .is_a?(String)
+      .should == true
+  end
+end

data/lib/kube/cluster/standard/victoria_metrics/vm_probe.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      module VictoriaMetrics
+        # Blackbox/probe scraping: points a prober (e.g. blackbox_exporter) at a
+        # set of targets. Pass the prober URL here and the targets/module in the
+        # block via spec.targets and spec.module.
+        class VMProbe < Kube::Cluster["VMProbe"]
+          def initialize(name:, prober_url:, &block)
+            super() {
+              metadata.name    = name
+              spec.vmProberSpec = { url: prober_url }
+              instance_exec(&block) if block
+            }
+          end
+        end
+      end
+    end
+  end
+end
+
+__END__
+
+describe "VictoriaMetrics::VMProbe" do
+  it "initializes without error" do
+    Kube::Cluster::Standard::VictoriaMetrics::VMProbe
+      .new(name: "blackbox", prober_url: "http://blackbox-exporter.metrics.svc:9115")
+      .to_yaml
+      .is_a?(String)
+      .should == true
+  end
+end

data/lib/kube/cluster/standard/victoria_metrics/vm_rule.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      module VictoriaMetrics
+        # A recording rule. The block returns the PromQL expression, so
+        # multi-line queries read as a heredoc at the call site.
+        class Rule
+          def initialize(name, labels: nil, &block)
+            @name   = name
+            @labels = labels
+            @expr   = block.call.to_s if block
+          end
+
+          def to_h
+            h = { record: @name, expr: @expr }
+            h[:labels] = @labels if @labels
+            h
+          end
+        end
+
+        # An alerting rule. The block returns the PromQL expression.
+        class Alert
+          def initialize(name, for_: nil, keep_firing_for: nil, labels: nil, annotations: nil, &block)
+            @name            = name
+            @for             = for_
+            @keep_firing_for = keep_firing_for
+            @labels          = labels
+            @annotations     = annotations
+            @expr            = block.call.to_s if block
+          end
+
+          def to_h
+            h = { alert: @name, expr: @expr }
+            h[:for]             = @for             if @for
+            h[:keep_firing_for] = @keep_firing_for if @keep_firing_for
+            h[:labels]          = @labels          if @labels
+            h[:annotations]     = @annotations     if @annotations
+            h
+          end
+        end
+
+        # A named group of rules. `rule`/`alert` build and collect the leaves;
+        # the block is instance_eval'd so those helpers read like keywords.
+        #
+        #   Group.new("node.rules") {
+        #     rule "node:node_num_cpu:sum" do
+        #       <<~PROMQL
+        #         count by (cluster, node) (...)
+        #       PROMQL
+        #     end
+        #   }
+        class Group
+          def initialize(name, &block)
+            @name  = name
+            @rules = []
+            instance_eval(&block) if block
+          end
+
+          def rule(name, **opts, &block)  = @rules << Rule.new(name, **opts, &block)
+          def alert(name, **opts, &block) = @rules << Alert.new(name, **opts, &block)
+
+          def to_h = { name: @name, rules: @rules.map(&:to_h) }
+        end
+
+        # A VMRule CR: a set of rule Groups evaluated by VictoriaMetrics.
+        #
+        #   VMRule.new(name: "node", groups: [
+        #     Group.new("node.rules") { ... },
+        #   ])
+        class VMRule < Kube::Cluster["VMRule"]
+          def initialize(name:, groups:, &block)
+            super() {
+              metadata.name = name
+              spec.groups   = groups.map(&:to_h)
+              instance_exec(&block) if block
+            }
+          end
+        end
+      end
+    end
+  end
+end
+
+__END__
+
+describe "VictoriaMetrics::VMRule" do
+  vmrule = Kube::Cluster::Standard::VictoriaMetrics::VMRule
+  group  = Kube::Cluster::Standard::VictoriaMetrics::Group
+
+  it "emits a recording rule with the resolved v1beta1 apiVersion" do
+    yaml = vmrule.new(
+      name:   "node",
+      groups: [
+        group.new("node.rules") {
+          rule "node:node_num_cpu:sum" do
+            "count by (cluster, node) (node_cpu_seconds_total)"
+          end
+        },
+      ]
+    ).to_yaml
+
+    yaml.include?("operator.victoriametrics.com/v1beta1").should == true
+    yaml.include?("record: node:node_num_cpu:sum").should == true
+  end
+
+  it "carries labels on records" do
+    group.new("g") {
+      rule "r", labels: { quantile: "0.99" } do
+        "histogram_quantile(0.99, x)"
+      end
+    }.to_h.should == {
+      name:  "g",
+      rules: [{ record: "r", expr: "histogram_quantile(0.99, x)", labels: { quantile: "0.99" } }],
+    }
+  end
+
+  it "builds alerts with for/labels/annotations" do
+    group.new("g") {
+      alert "Down", for_: "5m", labels: { severity: "warning" }, annotations: { summary: "down" } do
+        "up == 0"
+      end
+    }.to_h.should == {
+      name:  "g",
+      rules: [{
+        alert:       "Down",
+        expr:        "up == 0",
+        for:         "5m",
+        labels:      { severity: "warning" },
+        annotations: { summary: "down" },
+      }],
+    }
+  end
+end

data/lib/kube/cluster/standard/victoria_metrics/vm_scrape_config.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      module VictoriaMetrics
+        # Generic scrape configuration supporting the full range of service-
+        # discovery mechanisms (static, kubernetes, http, ec2, consul, …). Declare
+        # the discovery configs and relabelling in the block.
+        class VMScrapeConfig < Kube::Cluster["VMScrapeConfig"]
+          def initialize(name:, &block)
+            super() {
+              metadata.name = name
+              instance_exec(&block) if block
+            }
+          end
+        end
+      end
+    end
+  end
+end
+
+__END__
+
+describe "VictoriaMetrics::VMScrapeConfig" do
+  it "initializes without error" do
+    Kube::Cluster::Standard::VictoriaMetrics::VMScrapeConfig
+      .new(name: "vmscrapeconfig")
+      .to_yaml
+      .is_a?(String)
+      .should == true
+  end
+end

data/lib/kube/cluster/standard/victoria_metrics/vm_static_scrape.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      module VictoriaMetrics
+        # Scrapes a fixed set of static targets (host:port) under a named job —
+        # for endpoints that have no Service/Pod to select. Extra per-endpoint
+        # settings (path, scheme, labels) can be added in the block.
+        class VMStaticScrape < Kube::Cluster["VMStaticScrape"]
+          def initialize(name:, job:, targets:, &block)
+            super() {
+              metadata.name       = name
+              spec.jobName        = job
+              spec.targetEndpoints = [{ targets: Array(targets) }]
+              instance_exec(&block) if block
+            }
+          end
+        end
+      end
+    end
+  end
+end
+
+__END__
+
+describe "VictoriaMetrics::VMStaticScrape" do
+  it "initializes without error" do
+    Kube::Cluster::Standard::VictoriaMetrics::VMStaticScrape
+      .new(name: "external", job: "external", targets: ["10.0.0.1:9100"])
+      .to_yaml
+      .is_a?(String)
+      .should == true
+  end
+end

data/lib/kube/cluster/standard/victoria_metrics/vm_user.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      module VictoriaMetrics
+        # A user/route definition consumed by VMAuth: maps credentials to a set of
+        # upstream target refs. Pass the routing in the block via spec.targetRefs.
+        class VMUser < Kube::Cluster["VMUser"]
+          def initialize(name:, username: nil, &block)
+            super() {
+              metadata.name = name
+              spec.username = username if username
+              instance_exec(&block) if block
+            }
+          end
+        end
+      end
+    end
+  end
+end
+
+__END__
+
+describe "VictoriaMetrics::VMUser" do
+  it "initializes without error" do
+    Kube::Cluster::Standard::VictoriaMetrics::VMUser
+      .new(name: "vmuser", username: "reader") {
+        spec.targetRefs = [{ crd: { kind: "VMSingle", name: "vmsingle", namespace: "metrics" }, paths: ["/"] }]
+      }
+      .to_yaml
+      .is_a?(String)
+      .should == true
+  end
+end

data/lib/kube/cluster/standard/victoria_metrics/vt_cluster.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      module VictoriaMetrics
+        # HA/clustered VictoriaTraces: storage + select + insert components
+        # (the horizontally-scalable alternative to VTSingle). Retention lives on
+        # the storage component, so configure the components in the block.
+        class VTCluster < Kube::Cluster["VTCluster"]
+          def initialize(name:, &block)
+            super() {
+              metadata.name = name
+              instance_exec(&block) if block
+            }
+          end
+        end
+      end
+    end
+  end
+end
+
+__END__
+
+describe "VictoriaMetrics::VTCluster" do
+  it "initializes without error" do
+    Kube::Cluster::Standard::VictoriaMetrics::VTCluster
+      .new(name: "vtcluster")
+      .to_yaml
+      .is_a?(String)
+      .should == true
+  end
+end

data/lib/kube/cluster/standard/victoria_metrics/vt_single.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      module VictoriaMetrics
+        # Single-node VictoriaTraces store.
+        class VTSingle < Kube::Cluster["VTSingle"]
+          def initialize(name:, retention_period: "30d", &block)
+            super() {
+              metadata.name        = name
+              spec.retentionPeriod = retention_period
+              instance_exec(&block) if block
+            }
+          end
+        end
+      end
+    end
+  end
+end
+
+__END__
+
+describe "VictoriaMetrics::VTSingle" do
+  it "initializes without error" do
+    Kube::Cluster::Standard::VictoriaMetrics::VTSingle
+      .new(name: "vtsingle")
+      .to_yaml
+      .is_a?(String)
+      .should == true
+  end
+end

data/lib/kube/cluster/version.rb

@@ -2,6 +2,6 @@
 
 module Kube
   module Cluster
-    VERSION = "1.3.1"
+    VERSION = "1.5.0"
   end
 end

data/lib/kube/cluster.rb

@@ -126,11 +126,29 @@ Kube::Cluster.config do
 
   # VictoriaMetrics operator.
   resolve "VLAgent",                  to: "operator.victoriametrics.com/v1/VLAgent"
+  resolve "VLCluster",                to: "operator.victoriametrics.com/v1/VLCluster"
+  resolve "VLogs",                    to: "operator.victoriametrics.com/v1beta1/VLogs"
   resolve "VLSingle",                 to: "operator.victoriametrics.com/v1/VLSingle"
   resolve "VMAgent",                  to: "operator.victoriametrics.com/v1beta1/VMAgent"
+  resolve "VMAlert",                  to: "operator.victoriametrics.com/v1beta1/VMAlert"
+  resolve "VMAlertmanager",           to: "operator.victoriametrics.com/v1beta1/VMAlertmanager"
+  resolve "VMAlertmanagerConfig",     to: "operator.victoriametrics.com/v1beta1/VMAlertmanagerConfig"
+  resolve "VMAnomaly",                to: "operator.victoriametrics.com/v1/VMAnomaly"
+  resolve "VMAnomalyConfig",          to: "operator.victoriametrics.com/v1/VMAnomalyConfig"
+  resolve "VMAuth",                   to: "operator.victoriametrics.com/v1beta1/VMAuth"
+  resolve "VMCluster",                to: "operator.victoriametrics.com/v1beta1/VMCluster"
+  resolve "VMDistributed",            to: "operator.victoriametrics.com/v1alpha1/VMDistributed"
   resolve "VMNodeScrape",             to: "operator.victoriametrics.com/v1beta1/VMNodeScrape"
+  resolve "VMPodScrape",              to: "operator.victoriametrics.com/v1beta1/VMPodScrape"
+  resolve "VMProbe",                  to: "operator.victoriametrics.com/v1beta1/VMProbe"
+  resolve "VMRule",                   to: "operator.victoriametrics.com/v1beta1/VMRule"
+  resolve "VMScrapeConfig",           to: "operator.victoriametrics.com/v1beta1/VMScrapeConfig"
   resolve "VMServiceScrape",          to: "operator.victoriametrics.com/v1beta1/VMServiceScrape"
   resolve "VMSingle",                 to: "operator.victoriametrics.com/v1beta1/VMSingle"
+  resolve "VMStaticScrape",           to: "operator.victoriametrics.com/v1beta1/VMStaticScrape"
+  resolve "VMUser",                   to: "operator.victoriametrics.com/v1beta1/VMUser"
+  resolve "VTCluster",                to: "operator.victoriametrics.com/v1/VTCluster"
+  resolve "VTSingle",                 to: "operator.victoriametrics.com/v1/VTSingle"
 
   # Gateway API — pin to the stable v1 group/version.
   resolve "GatewayClass",             to: "gateway.networking.k8s.io/v1/GatewayClass"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kube_cluster
 version: !ruby/object:Gem::Version
-  version: 1.3.1
+  version: 1.5.0
 platform: ruby
 authors:
 - Nathan K
@@ -244,11 +244,29 @@ files:
 - lib/kube/cluster/standard/service_account.rb
 - lib/kube/cluster/standard/service_account_with_role.rb
 - lib/kube/cluster/standard/victoria_metrics/vl_agent.rb
+- lib/kube/cluster/standard/victoria_metrics/vl_cluster.rb
 - lib/kube/cluster/standard/victoria_metrics/vl_single.rb
+- lib/kube/cluster/standard/victoria_metrics/vlogs.rb
 - lib/kube/cluster/standard/victoria_metrics/vm_agent.rb
+- lib/kube/cluster/standard/victoria_metrics/vm_alert.rb
+- lib/kube/cluster/standard/victoria_metrics/vm_alertmanager.rb
+- lib/kube/cluster/standard/victoria_metrics/vm_alertmanager_config.rb
+- lib/kube/cluster/standard/victoria_metrics/vm_anomaly.rb
+- lib/kube/cluster/standard/victoria_metrics/vm_anomaly_config.rb
+- lib/kube/cluster/standard/victoria_metrics/vm_auth.rb
+- lib/kube/cluster/standard/victoria_metrics/vm_cluster.rb
+- lib/kube/cluster/standard/victoria_metrics/vm_distributed.rb
 - lib/kube/cluster/standard/victoria_metrics/vm_node_scrape.rb
+- lib/kube/cluster/standard/victoria_metrics/vm_pod_scrape.rb
+- lib/kube/cluster/standard/victoria_metrics/vm_probe.rb
+- lib/kube/cluster/standard/victoria_metrics/vm_rule.rb
+- lib/kube/cluster/standard/victoria_metrics/vm_scrape_config.rb
 - lib/kube/cluster/standard/victoria_metrics/vm_service_scrape.rb
 - lib/kube/cluster/standard/victoria_metrics/vm_single.rb
+- lib/kube/cluster/standard/victoria_metrics/vm_static_scrape.rb
+- lib/kube/cluster/standard/victoria_metrics/vm_user.rb
+- lib/kube/cluster/standard/victoria_metrics/vt_cluster.rb
+- lib/kube/cluster/standard/victoria_metrics/vt_single.rb
 - lib/kube/cluster/standard/volume_processing.rb
 - lib/kube/cluster/version.rb
 - lib/kube/cluster/version.rb.erb