karafka-core 2.5.7 → 2.5.9

data/test/lib/karafka/core/monitoring/statistics_decorator_test.rb

@@ -0,0 +1,284 @@
+# frozen_string_literal: true
+
+describe_current do
+  subject(:decorator) { described_class.new }
+
+  let(:emited_stats1) do
+    {
+      "string" => "value1",
+      "float" => 10.4,
+      "int" => 112,
+      "nested" => {
+        "brokers" => {
+          "localhost:9092/2" => {
+            "txbytes" => 123
+          }
+        }
+      }
+    }
+  end
+
+  let(:emited_stats2) do
+    {
+      "string" => "value2",
+      "float" => 10.8,
+      "int" => 130,
+      "nested" => {
+        "brokers" => {
+          "localhost:9092/2" => {
+            "txbytes" => 153
+          }
+        }
+      }
+    }
+  end
+
+  let(:emited_stats3) do
+    {
+      "string" => "value3",
+      "float" => 11.8,
+      "int" => 10,
+      "nested" => {
+        "brokers" => {
+          "localhost:9092/2" => {
+            "txbytes" => 2
+          }
+        }
+      }
+    }
+  end
+
+  let(:broker_scope) { %w[nested brokers localhost:9092/2] }
+
+  context "when it is a first stats emit" do
+    subject(:decorated) { decorator.call(emited_stats1) }
+
+    it { assert_equal "value1", decorated["string"] }
+    it { refute decorated.key?("string_d") }
+    it { assert_equal 0, decorated["float_d"] }
+    it { assert_equal 0, decorated["int_d"] }
+    it { assert_equal 0, decorated.dig(*broker_scope)["txbytes_d"] }
+    it { assert_predicate decorated, :frozen? }
+  end
+
+  context "when it is a second stats emit" do
+    subject(:decorated) do
+      decorator.call(emited_stats1)
+      decorator.call(emited_stats2)
+    end
+
+    it { assert_equal "value2", decorated["string"] }
+    it { refute decorated.key?("string_d") }
+    it { assert_in_delta(0.4, decorated["float_d"].round(10)) }
+    it { assert_equal 18, decorated["int_d"] }
+    it { assert_equal 30, decorated.dig(*broker_scope)["txbytes_d"] }
+    it { assert_predicate decorated, :frozen? }
+  end
+
+  context "when it is a third stats emit" do
+    subject(:decorated) do
+      decorator.call(emited_stats1)
+      decorator.call(emited_stats2)
+      decorator.call(emited_stats3)
+    end
+
+    it { assert_equal "value3", decorated["string"] }
+    it { refute decorated.key?("string_d") }
+    it { refute decorated.key?("string_fd") }
+    it { assert_in_delta(1.0, decorated["float_d"].round(10)) }
+    it { assert_in_delta 0, decorated["float_fd"], 5 }
+    it { assert_equal(-120, decorated["int_d"]) }
+    it { assert_in_delta 0, decorated["int_fd"], 5 }
+    it { assert_equal(-151, decorated.dig(*broker_scope)["txbytes_d"]) }
+    it { assert_in_delta 0, decorated.dig(*broker_scope)["txbytes_fd"], 5 }
+    it { assert_predicate decorated, :frozen? }
+    it { refute decorated.key?("float_d_d") }
+  end
+
+  context "when a broker is no longer present" do
+    subject(:decorated) do
+      decorator.call(emited_stats1)
+      decorator.call(emited_stats2)
+    end
+
+    before { emited_stats2["nested"] = {} }
+
+    it { assert_equal "value2", decorated["string"] }
+    it { refute decorated.key?("string_d") }
+    it { refute decorated.key?("string_fd") }
+    it { assert_in_delta(0.4, decorated["float_d"].round(10)) }
+    it { assert_in_delta 0, decorated["float_fd"], 5 }
+    it { assert_equal 18, decorated["int_d"] }
+    it { assert_in_delta 0, decorated["int_fd"], 5 }
+    it { assert_equal({}, decorated["nested"]) }
+    it { assert_predicate decorated, :frozen? }
+    it { refute decorated.key?("float_d_d") }
+  end
+
+  context "when broker was introduced later on" do
+    subject(:decorated) do
+      decorator.call(emited_stats1)
+      decorator.call(emited_stats2)
+    end
+
+    before { emited_stats1["nested"] = {} }
+
+    it { assert_equal "value2", decorated["string"] }
+    it { refute decorated.key?("string_d") }
+    it { assert_in_delta(0.4, decorated["float_d"].round(10)) }
+    it { assert_in_delta 0, decorated["float_fd"], 5 }
+    it { assert_equal 18, decorated["int_d"] }
+    it { assert_in_delta 0, decorated["int_fd"], 5 }
+    it { assert_equal 0, decorated.dig(*broker_scope)["txbytes_d"] }
+    it { assert_in_delta 0, decorated.dig(*broker_scope)["txbytes_fd"], 5 }
+    it { assert_predicate decorated, :frozen? }
+    it { refute decorated.key?("float_d_d") }
+  end
+
+  context "when value remains unchanged over time" do
+    subject(:decorated) do
+      # First one will set initial state
+      decorator.call(deep_copy.call)
+      # Second one will build first deltas with freeze duration of zero
+      decorator.call(deep_copy.call)
+      sleep(0.01)
+      # Third one will allow for proper freeze duration computation
+      decorator.call(deep_copy.call)
+    end
+
+    let(:deep_copy) { -> { Marshal.load(Marshal.dump(emited_stats1)) } }
+
+    it { refute decorated.key?("string_d") }
+    it { refute decorated.key?("string_fd") }
+    it { assert_equal 0, decorated["float_d"] }
+    it { assert_in_delta 10, decorated["float_fd"], 5 }
+    it { assert_equal 0, decorated["int_d"] }
+    it { assert_in_delta 10, decorated["int_fd"], 5 }
+    it { assert_predicate decorated, :frozen? }
+    it { refute decorated.key?("float_d_d") }
+  end
+
+  context "when value remains unchanged over multiple occurrences and time" do
+    subject(:decorated) do
+      # First one will set initial state
+      decorator.call(deep_copy.call)
+      # Second one will build first deltas with freeze duration of zero
+      decorator.call(deep_copy.call)
+      sleep(0.01)
+      # Third one will allow for proper freeze duration computation
+      decorator.call(deep_copy.call)
+      sleep(0.01)
+      decorator.call(deep_copy.call)
+    end
+
+    let(:deep_copy) { -> { Marshal.load(Marshal.dump(emited_stats1)) } }
+
+    it { refute decorated.key?("string_d") }
+    it { refute decorated.key?("string_fd") }
+    it { assert_equal 0, decorated["float_d"] }
+    it { assert_in_delta 20, decorated["float_fd"], 5 }
+    it { assert_equal 0, decorated["int_d"] }
+    # On slow CIs this value tends to grow and crash
+    it { assert_in_delta 20, decorated["int_fd"], 15 }
+    it { assert_predicate decorated, :frozen? }
+    it { refute decorated.key?("float_d_d") }
+  end
+
+  context "when a value type changed from non-numeric to numeric between emissions" do
+    subject(:decorated) do
+      decorator.call(emited_stats1)
+      decorator.call(emited_stats2)
+    end
+
+    before do
+      # In the first emission, txbytes is a string (unusual but defensive)
+      emited_stats1["nested"]["brokers"]["localhost:9092/2"]["txbytes"] = "not_a_number"
+    end
+
+    # When previous value was non-numeric but current is numeric, no delta should be computed
+    it { refute decorated.dig(*broker_scope).key?("txbytes_d") }
+    it { refute decorated.dig(*broker_scope).key?("txbytes_fd") }
+    it { assert_equal 153, decorated.dig(*broker_scope)["txbytes"] }
+    it { assert_predicate decorated, :frozen? }
+  end
+
+  context "when excluded_keys are configured" do
+    subject(:decorator) { described_class.new(excluded_keys: %w[nested]) }
+
+    context "when it is a first stats emit" do
+      subject(:decorated) { decorator.call(emited_stats1) }
+
+      it { assert_equal 0, decorated["float_d"] }
+      it { assert_equal 0, decorated["int_d"] }
+      it { assert_predicate decorated, :frozen? }
+
+      it "does not decorate excluded subtrees" do
+        expected = { "brokers" => { "localhost:9092/2" => { "txbytes" => 123 } } }
+
+        assert_equal(expected, decorated["nested"])
+        refute decorated["nested"]["brokers"]["localhost:9092/2"].key?("txbytes_d")
+      end
+    end
+
+    context "when it is a second stats emit" do
+      subject(:decorated) do
+        decorator.call(emited_stats1)
+        decorator.call(emited_stats2)
+      end
+
+      it { assert_in_delta(0.4, decorated["float_d"].round(10)) }
+      it { assert_equal 18, decorated["int_d"] }
+      it { assert_predicate decorated, :frozen? }
+
+      it "does not decorate excluded subtrees" do
+        refute decorated["nested"]["brokers"]["localhost:9092/2"].key?("txbytes_d")
+        refute decorated["nested"]["brokers"]["localhost:9092/2"].key?("txbytes_fd")
+      end
+    end
+  end
+
+  context "when excluded_keys target a numeric key" do
+    let(:decorator) { described_class.new(excluded_keys: %w[int]) }
+
+    subject(:decorated) do
+      decorator.call(emited_stats1)
+      decorator.call(emited_stats2)
+    end
+
+    it { assert_in_delta(0.4, decorated["float_d"].round(10)) }
+    it { assert_equal 130, decorated["int"] }
+    it { refute decorated.key?("int_d") }
+    it { refute decorated.key?("int_fd") }
+    it { assert_predicate decorated, :frozen? }
+  end
+
+  context "when no excluded_keys are configured" do
+    let(:decorator) { described_class.new }
+
+    subject(:decorated) do
+      decorator.call(emited_stats1)
+      decorator.call(emited_stats2)
+    end
+
+    it { assert_equal 18, decorated["int_d"] }
+    it { assert_equal 30, decorated.dig(*broker_scope)["txbytes_d"] }
+  end
+
+  context "when a value type changed from numeric to non-numeric between emissions" do
+    subject(:decorated) do
+      decorator.call(emited_stats1)
+      decorator.call(emited_stats2)
+    end
+
+    before do
+      # In the second emission, txbytes changed to a string
+      emited_stats2["nested"]["brokers"]["localhost:9092/2"]["txbytes"] = "not_a_number"
+    end
+
+    # Non-numeric values are never decorated
+    it { refute decorated.dig(*broker_scope).key?("txbytes_d") }
+    it { refute decorated.dig(*broker_scope).key?("txbytes_fd") }
+    it { assert_equal "not_a_number", decorated.dig(*broker_scope)["txbytes"] }
+    it { assert_predicate decorated, :frozen? }
+  end
+end

data/test/lib/karafka/core/monitoring_test.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+# Each component is tested in its own spec file.

data/test/lib/karafka/core/patches/rdkafka/bindings_test.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+describe_current do
+  subject(:producer) do
+    config = { "bootstrap.servers": "localhost:10092" }
+    Rdkafka::Config.new(config).producer
+  end
+
+  describe "#build_error_callback" do
+    let(:errors) { [] }
+    let(:callback) { ->(*args) { errors << args } }
+
+    before { Rdkafka::Config.error_callback.add("test", callback) }
+
+    after { Rdkafka::Config.error_callback.delete("test") }
+
+    it "expect to inject instance name to the error callback" do
+      producer.produce(topic: "test", payload: "1")
+      sleep(0.01) while errors.empty?
+
+      assert_includes errors.first.first, "rdkafka#producer"
+      assert_equal :transport, errors.first.last.code
+    end
+  end
+end

data/test/lib/karafka/core/taggable/tags_test.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+describe_current do
+  subject(:tags) { described_class.new }
+
+  it { assert_empty tags.to_a }
+
+  describe "#add" do
+    context "when few under same name" do
+      before { 3.times { |value| tags.add(:name, value) } }
+
+      it { assert_equal %w[2], tags.to_a }
+    end
+
+    context "when with different names" do
+      before do
+        tags.add(:name1, 1)
+        tags.add(:name2, 2)
+        tags.add(:name3, 3)
+      end
+
+      it { assert_equal %w[1 2 3], tags.to_a }
+    end
+
+    context "when with different names but same value" do
+      before do
+        tags.add(:name1, 1)
+        tags.add(:name2, 1)
+        tags.add(:name3, 1)
+      end
+
+      it { assert_equal %w[1], tags.to_a }
+    end
+  end
+
+  describe "#clear" do
+    before do
+      tags.add(:name, 1)
+      tags.clear
+    end
+
+    it { assert_empty tags.to_a }
+  end
+
+  describe "#delete" do
+    before do
+      tags.add(:name1, 1)
+      tags.delete(:name1)
+      tags.add(:name3, 2)
+    end
+
+    it { assert_equal %w[2], tags.to_a }
+  end
+
+  describe "#to_json" do
+    before { tags.add(:test, "abc") }
+
+    it { assert_equal %w[abc].to_json, tags.to_json }
+  end
+
+  describe "#as_json" do
+    before { tags.add(:test, "abc") }
+
+    it { assert_equal %w[abc], tags.as_json }
+  end
+end

data/test/lib/karafka/core/taggable_test.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+describe_current do
+  context "when operating on an instance basis" do
+    subject(:tagged) { tagged_class.new }
+
+    let(:other_tagged) { tagged_class.new }
+    let(:tagged_class) do
+      Class.new do
+        include Karafka::Core::Taggable
+      end
+    end
+
+    it { assert_empty tagged.tags.to_a }
+    it { refute_equal other_tagged.tags, tagged.tags }
+  end
+
+  context "when operating on a class basis" do
+    subject(:tagged) { tagged_class }
+
+    let(:other_tagged) { other_tagged_class }
+    let(:tagged_class) do
+      Class.new do
+        extend Karafka::Core::Taggable
+      end
+    end
+    let(:other_tagged_class) do
+      Class.new do
+        extend Karafka::Core::Taggable
+      end
+    end
+
+    it { assert_empty tagged.tags.to_a }
+    it { refute_equal other_tagged.tags, tagged.tags }
+  end
+end

data/test/lib/karafka/core/version_test.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+describe Karafka::Core::VERSION do
+  it { described_class }
+end

data/test/lib/karafka/core_test.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+describe_current do
+  subject(:core) { described_class }
+
+  describe "#gem_root" do
+    context "when we want to get gem root path" do
+      let(:path) { Dir.pwd }
+
+      it { assert_equal path, core.gem_root.to_path }
+    end
+  end
+end

data/test/lib/karafka-core_test.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+# Each component is tested in its own spec file.

data/test/support/class_builder.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# Class builder helps creating anonymous classes that we can use to spec our code
+# We need co create new class instances to have an "empty" and "clear" class for each spec
+# This module acts as an interface to create classes
+module ClassBuilder
+  class << self
+    # Creates an empty class without any predefined methods
+    # @return [Class] created anonymous class
+    def build(&)
+      klass = Class.new
+
+      klass.class_eval(&) if block_given?
+      klass
+    end
+
+    # This method allows us to create a class that inherits from any other
+    # @param klass [Class] any class from which we want to inherit in our anonymous class
+    # @return [Class] new anonymous class
+    def inherit(klass, &)
+      Class.new(klass, &)
+    end
+  end
+end

data/test/support/describe_current_helper.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+# Port of Karafka::Core::Helpers::RSpecLocator for minitest/spec
+# Provides `describe_current` that auto-discovers the class under test from file path,
+# `described_class` and `subject` DSL methods.
+
+TESTS_ROOT_DIR = File.expand_path("..", __dir__)
+
+# Top-level method: auto-discovers the class from the caller file path and opens a describe block
+def describe_current(&block)
+  klass = caller(1..1)
+    .first
+    .split(":")
+    .first
+    .gsub(TESTS_ROOT_DIR, "")
+    .gsub("_test.rb", "")
+    .split("/")
+    .delete_if(&:empty?)
+    .itself[1..]
+    .join("/")
+    .then { |path| custom_camelize(path) }
+    .then { |class_name| custom_constantize(class_name) }
+
+  describe(klass, &block)
+end
+
+# Custom implementation of camelize without ActiveSupport
+def custom_camelize(string)
+  string = string.gsub("/", "::")
+
+  string.gsub(/(?:^|_|::)([a-z])/) do |match|
+    if match.include?("::")
+      "::#{match[-1].upcase}"
+    else
+      match[-1].upcase
+    end
+  end
+end
+
+# Custom implementation of constantize without ActiveSupport
+def custom_constantize(string)
+  names = string.split("::")
+  constant = Object
+  regexp = /^[A-Z][a-zA-Z0-9_]*$/
+
+  names.each do |name|
+    raise NameError, "#{name} is not a valid constant name!" unless name.match?(regexp)
+
+    constant = constant.const_get(name)
+  end
+
+  constant
+rescue NameError => e
+  raise NameError, "Uninitialized constant #{string}: #{e.message}"
+end
+
+# Provide `described_class` for minitest/spec — walks the desc hierarchy to find a Class/Module
+module MinitestDescribedClass
+  def described_class
+    # Walk up the describe hierarchy to find the Class/Module
+    klass = self.class
+    while klass
+      return klass.desc if klass.respond_to?(:desc) && klass.desc.is_a?(Module)
+
+      klass = klass.superclass
+    end
+    nil
+  end
+end
+
+Minitest::Spec.include MinitestDescribedClass
+
+# Provide `subject` DSL for minitest/spec
+module MinitestSubjectDSL
+  def subject(name = nil, &block)
+    if name
+      let(name, &block)
+      define_method(:subject) { send(name) }
+    else
+      let(:subject, &block)
+    end
+  end
+end
+
+Minitest::Spec.extend MinitestSubjectDSL

data/test/test_helper.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+Warning[:performance] = true if RUBY_VERSION >= "3.3"
+Warning[:deprecated] = true
+$VERBOSE = true
+
+require "warning"
+
+Warning.process do |warning|
+  next unless warning.include?(Dir.pwd)
+
+  raise "Warning in your code: #{warning}"
+end
+
+ENV["KARAFKA_ENV"] = "test"
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+
+%w[
+  byebug
+  simplecov
+  tempfile
+  securerandom
+].each do |lib|
+  require lib
+end
+
+# Don't include unnecessary stuff into rcov
+SimpleCov.start do
+  add_filter "/vendor/"
+  add_filter "/gems/"
+  add_filter "/.bundle/"
+  add_filter "/doc/"
+  add_filter "/test/"
+  add_filter "/config/"
+  add_filter "/patches/"
+  merge_timeout 600
+end
+
+SimpleCov.minimum_coverage(98.8)
+
+require "minitest/autorun"
+require "minitest/spec"
+
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"]
+  .each { |f| require f }
+
+require "karafka-core"
+
+# Allow `context` as an alias for `describe` in minitest/spec
+Minitest::Spec.class_eval do
+  class << self
+    alias_method :context, :describe
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: karafka-core
 version: !ruby/object:Gem::Version
-  version: 2.5.7
+  version: 2.5.9
 platform: ruby
 authors:
 - Maciej Mensfeld
@@ -44,9 +44,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".coditsu/ci.yml"
 - ".console_irbrc"
-- ".diffend.yml"
 - ".github/CODEOWNERS"
 - ".github/FUNDING.yml"
 - ".github/ISSUE_TEMPLATE/bug_report.md"
@@ -56,12 +54,15 @@ files:
 - ".github/workflows/trigger-wiki-refresh.yml"
 - ".github/workflows/verify-action-pins.yml"
 - ".gitignore"
-- ".rspec"
+- ".rubocop.yml"
 - ".ruby-gemset"
 - ".ruby-version"
+- ".yard-lint.yml"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
+- Gemfile.lint
+- Gemfile.lint.lock
 - Gemfile.lock
 - MIT-LICENSE
 - README.md
@@ -91,7 +92,33 @@ files:
 - lib/karafka/core/taggable/tags.rb
 - lib/karafka/core/version.rb
 - log/.gitkeep
+- package-lock.json
+- package.json
 - renovate.json
+- test/lib/karafka-core_test.rb
+- test/lib/karafka/core/configurable/leaf_test.rb
+- test/lib/karafka/core/configurable/node_test.rb
+- test/lib/karafka/core/configurable_test.rb
+- test/lib/karafka/core/contractable/contract_test.rb
+- test/lib/karafka/core/contractable/result_test.rb
+- test/lib/karafka/core/contractable/rule_test.rb
+- test/lib/karafka/core/contractable_test.rb
+- test/lib/karafka/core/helpers/time_test.rb
+- test/lib/karafka/core/instrumentation/callbacks_manager_test.rb
+- test/lib/karafka/core/instrumentation_test.rb
+- test/lib/karafka/core/monitoring/event_test.rb
+- test/lib/karafka/core/monitoring/monitor_test.rb
+- test/lib/karafka/core/monitoring/notifications_test.rb
+- test/lib/karafka/core/monitoring/statistics_decorator_test.rb
+- test/lib/karafka/core/monitoring_test.rb
+- test/lib/karafka/core/patches/rdkafka/bindings_test.rb
+- test/lib/karafka/core/taggable/tags_test.rb
+- test/lib/karafka/core/taggable_test.rb
+- test/lib/karafka/core/version_test.rb
+- test/lib/karafka/core_test.rb
+- test/support/class_builder.rb
+- test/support/describe_current_helper.rb
+- test/test_helper.rb
 homepage: https://karafka.io
 licenses:
 - MIT
@@ -116,7 +143,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Karafka ecosystem core modules
 test_files: []

data/.coditsu/ci.yml

@@ -1,3 +0,0 @@
-repository_id: 'd3cd0fec-757e-47be-87ca-7829dff0c5f4'
-api_key: <%= ENV['CODITSU_API_KEY'] %>
-api_secret: <%= ENV['CODITSU_API_SECRET'] %>

data/.diffend.yml

@@ -1,3 +0,0 @@
-project_id: '199f1b30-ba87-49e1-96d8-f4ea86732443'
-shareable_id: '6a6f2b22-021c-40cd-885c-82838f84f2f9'
-shareable_key: '9c7e0a66-7bff-4b90-9528-69d8d4c0bba4'