deimos-ruby 2.4.0.pre.beta13 → 2.4.0.pre.beta14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0f50e61a736a80abdd3ccf4b19023fc4eb98401f35e807024f04e2527eed79bb
-  data.tar.gz: 06d50876e2eddad38af3fc47f2fee14c7561b3844282499d66fde07b411cdb9c
+  metadata.gz: 0e7b5d2bdf8cccca9230dd94d03d806d6049b8e83c79544742a582adf80e8e2a
+  data.tar.gz: 1006fd3b7ede588433731881e3e7cfbb9f8536183922dfb7805972a55151e4f5
 SHA512:
-  metadata.gz: 6ecbc0f494b10201762a0d868db56bc0d7be33453dbfbc2e52cce5256b35ea102381c93f13d5437839c23311f62685cd2a7e134546e0a8d3aaef4f30c59ec7c9
-  data.tar.gz: 4a3ab37d362e785c16ef34739efbba32a66edfb5bb08a59f08b9646ac310849fe755369cf03d0e45aa5a85478ba1d6a4e620bed9887cdd589f87a6e348c0f96d
+  metadata.gz: f3e63d30275bdc6b162f2afbd566c6701d75923e64c9b906b19c8bc8e79fabc7b4121cb75644937a1d127c93fe6c1c9778135ed335d1214fa2ac2a481ee7526c
+  data.tar.gz: 67a0e9fc9981ff1c32cd904b626f3c55c2fbd0aadf1ab6f5d808846a70fc0fe65745c5b8a12b5bf59730aba214b67696a33712684a900a922f6de85feaaf5dfd

data/CHANGELOG.md

@@ -8,6 +8,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## UNRELEASED
 
 - Major change: Switch from using `avro_turf` and `proto_turf` to use `schema_registry_client`, which handles both Avro and Protobuf.
+- Add `registry_url`, `registry_user` and `registry_password` per-topic configuration.
 - Added `have_sent_including` RSpec matcher to allow for Protobuf messages that use default values to be checked.
 
 # 2.3.0 - 2026-01-13

data/docs/CONFIGURATION.md

@@ -117,6 +117,9 @@ The following are additional settings that can be added to the `topic` block in
 | namespace          | nil     | Namespace of the schema to use when finding it locally. Leave blank for protobuf.                                                                                                               |
 | key_config         | nil     | Configuration hash for message keys. See [Kafka Message Keys](../README.md#kafka-message-keys).                                                                                                 |
 | use_schema_classes | nil     | Set to true or false to enable or disable using the producers schema classes. See [Generated Schema Classes](../README.md#generated-schema-classes).                                            |
+| registry_url      | nil     | URL of the schema registry to use for this topic. Overrides the global `schema.registry_url` setting.                                                                                             | 
+| registry_user     | nil     | Basic auth user for the schema registry to use for this topic. Overrides the global `schema.user` setting.                                                                                         |
+| registry_password | nil     | Basic auth password for the schema registry to use for this topic. Overrides the global `schema.password` setting.                                                                                     |
 
 ### Consumer Settings
 

data/lib/deimos/ext/schema_route.rb

@@ -13,6 +13,9 @@ module Deimos
         namespace: nil,
         key_config: { none: true },
         schema_backend: nil,
+        registry_url: nil,
+        registry_user: nil,
+        registry_password: nil,
         use_schema_classes: nil
       }.each do |field, default|
         define_method(field) do |*args|
@@ -25,20 +28,31 @@ module Deimos
           @_deimos_config[:schema][field] || default
         end
       end
-      def _deimos_setup_transcoders # rubocop:disable Metrics/AbcSize
+      def _deimos_setup_transcoders
         use_classes = if use_schema_classes.nil?
                         Deimos.config.schema.use_schema_classes
                       else
                         use_schema_classes
                       end
+        registry_info = if registry_url
+                          Deimos::RegistryInfo.new(registry_url, registry_user, registry_password)
+                        else
+                          nil
+                        end
         payload = Transcoder.new(
           schema: schema,
           namespace: namespace,
           backend: schema_backend,
           use_schema_classes: use_classes,
-          topic: name
+          topic: name,
+          registry_info: registry_info
         )
 
+        deserializers.payload = payload
+        _deimos_setup_key_transcoder(use_classes, registry_info)
+      end
+
+      def _deimos_setup_key_transcoder(use_classes, registry_info)
         key = nil
 
         if key_config[:plain]
@@ -47,7 +61,8 @@ module Deimos
             backend: nil,
             namespace: namespace,
             use_schema_classes: use_classes,
-            topic: name
+            topic: name,
+            registry_info: registry_info
           )
           key.backend_type = :plain
         elsif !key_config[:none]
@@ -58,7 +73,8 @@ module Deimos
               namespace: namespace,
               use_schema_classes: use_classes,
               key_field: key_config[:field].to_s,
-              topic: name
+              topic: name,
+              registry_info: registry_info
             )
           elsif key_config[:schema]
             key = Transcoder.new(
@@ -66,13 +82,13 @@ module Deimos
               backend: schema_backend,
               namespace: namespace,
               use_schema_classes: use_classes,
-              topic: self.name
+              topic: self.name,
+              registry_info: registry_info
             )
           else
             raise 'No key config given - if you are not encoding keys, please use `key_config plain: true`'
           end
         end
-        deserializers.payload = payload
         deserializers.key = key if key
       end
     end

data/lib/deimos/schema_backends/avro_base.rb

@@ -11,7 +11,7 @@ module Deimos
       attr_accessor :schema_store
 
       # @override
-      def initialize(schema:, namespace:)
+      def initialize(schema:, namespace:, registry_info: nil)
         super
         @schema_store = SchemaRegistry::AvroSchemaStore.new(path: Deimos.config.schema.path)
       end

data/lib/deimos/schema_backends/avro_schema_registry.rb

@@ -21,10 +21,10 @@ module Deimos
       # @return [SchemaRegistry::Client]
       def schema_registry
         @schema_registry ||= SchemaRegistry::Client.new(
-          registry_url: Deimos.config.schema.registry_url,
+          registry_url: @registry_info&.url || Deimos.config.schema.registry_url,
           logger: Karafka.logger,
-          user: Deimos.config.schema.user,
-          password: Deimos.config.schema.password,
+          user: @registry_info&.user || Deimos.config.schema.user,
+          password: @registry_info&.password || Deimos.config.schema.password,
           schema_type: SchemaRegistry::Schema::Avro.new(schema_store: @schema_store)
         )
         @schema_registry

data/lib/deimos/schema_backends/base.rb

@@ -24,6 +24,24 @@ module Deimos
     end
   end
 
+  class RegistryInfo
+    # @return [String]
+    attr_accessor :url
+    # @return [String]
+    attr_accessor :user
+    # @return [String]
+    attr_accessor :password
+
+    # @param url [String]
+    # @param user [String,nil]
+    # @param password [String,nil]
+    def initialize(url, user, password)
+      @url = url
+      @user = user
+      @password = password
+    end
+  end
+
   module SchemaBackends
     # Base class for encoding / decoding.
     class Base
@@ -33,12 +51,15 @@ module Deimos
       attr_accessor :namespace
       # @return [String]
       attr_accessor :key_schema
+      # @return [RegistryInfo]
+      attr_accessor :registry_info
 
       # @param schema [String,Symbol]
       # @param namespace [String]
-      def initialize(schema:, namespace: nil)
+      def initialize(schema:, namespace: nil, registry_info: nil)
         @schema = schema
         @namespace = namespace
+        @registry_info = registry_info
       end
 
       # @return [String]

data/lib/deimos/schema_backends/proto_schema_registry.rb

@@ -48,9 +48,9 @@ module Deimos
 
       def self.key_schema_registry
         @key_schema_registry ||= SchemaRegistry::Client.new(
-          registry_url: Deimos.config.schema.registry_url,
-          user: Deimos.config.schema.user,
-          password: Deimos.config.schema.password,
+          registry_url: @registry_info&.url || Deimos.config.schema.registry_url,
+          user: @registry_info&.user || Deimos.config.schema.user,
+          password: @registry_info&.password || Deimos.config.schema.password,
           logger: Karafka.logger,
           schema_type: SchemaRegistry::Schema::ProtoJsonSchema.new
         )

data/lib/deimos/transcoder.rb

@@ -13,19 +13,22 @@ module Deimos
     # @param use_schema_classes [Boolean]
     # @param backend [Symbol]
     # @param topic [String]
-    def initialize(schema:, namespace:, key_field: nil, use_schema_classes: nil, topic: nil, backend: nil)
+    def initialize(schema:, namespace:, key_field: nil, use_schema_classes: nil, topic: nil, backend: nil,
+                   registry_info: nil)
       @schema = schema
       @namespace = namespace
       self.key_field = key_field
       @use_schema_classes = use_schema_classes
       @backend_type = backend
       @topic = topic
+      @registry_info = registry_info
     end
 
     # @return [Class<Deimos::SchemaBackends::Base>]
     def backend
       @backend ||= Deimos.schema_backend(schema: @schema,
                                          namespace: @namespace,
+                                         registry_info: @registry_info,
                                          backend: @backend_type)
     end
 

data/lib/deimos/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Deimos
-  VERSION = '2.4.0-beta13'
+  VERSION = '2.4.0-beta14'
 end

data/lib/deimos.rb

@@ -76,29 +76,50 @@ module Deimos
     # @return [SchemaBackends::Base]
     def schema_backend_for(topic_name)
       config = Deimos.karafka_config_for(topic: topic_name)
+      registry_info = if config.registry_url
+                        Deimos::RegistryInfo.new(
+                          config.registry_url,
+                          config.registry_user,
+                          config.registry_password
+                        )
+                      else
+                        nil
+                      end
       self.schema_backend(schema: config.schema,
                           namespace: config.namespace,
+                          registry_info: registry_info,
                           backend: config.schema_backend || Deimos.config.schema.backend)
     end
 
     # @param schema [String, Symbol]
     # @param namespace [String]
+    # @param registry_info [Deimos::RegistryInfo]
     # @return [Deimos::SchemaBackends::Base]
-    def schema_backend(schema:, namespace:, backend: Deimos.config.schema.backend)
+    def schema_backend(schema:, namespace:,
+                       registry_info: nil,
+                       backend: Deimos.config.schema.backend)
       if config.schema.use_schema_classes
         # Initialize an instance of the provided schema
         # in the event the schema class is an override, the inherited
         # schema and namespace will be applied
         schema_class = Utils::SchemaClass.klass(schema, namespace)
         if schema_class.nil?
-          schema_backend_class(backend: backend).new(schema: schema, namespace: namespace)
+          schema_backend_class(backend: backend).
+            new(
+              schema: schema,
+              namespace: namespace,
+              registry_info: registry_info
+            )
         else
           schema_instance = schema_class.allocate
           schema_backend_class(backend: backend).
-            new(schema: schema_instance.schema, namespace: schema_instance.namespace)
+            new(schema: schema_instance.schema,
+                namespace: schema_instance.namespace,
+                registry_info: registry_info)
         end
       else
-        schema_backend_class(backend: backend).new(schema: schema, namespace: namespace)
+        schema_backend_class(backend: backend).
+          new(schema: schema, namespace: namespace, registry_info: registry_info)
       end
     end
 

data/spec/deimos_spec.rb

@@ -126,6 +126,42 @@ describe Deimos do
       backend = described_class.schema_backend_for('backend-test-topic-global')
       expect(backend).to be_a(Deimos::SchemaBackends::AvroValidation)
     end
+
+    it 'should use topic-specific registry configuration' do
+      Karafka::App.routes.redraw do
+        topic 'backend-test-topic-registry' do
+          active false
+          schema 'MySchema'
+          namespace 'com.my-namespace'
+          key_config none: true
+          registry_url 'http://topic-specific-registry:8081'
+          registry_user 'topic-user'
+          registry_password 'topic-password'
+        end
+      end
+
+      backend = described_class.schema_backend_for('backend-test-topic-registry')
+      # Backend will be AvroValidation in test mode, but should have registry_info
+      expect(backend.registry_info).not_to be_nil
+      expect(backend.registry_info.url).to eq('http://topic-specific-registry:8081')
+      expect(backend.registry_info.user).to eq('topic-user')
+      expect(backend.registry_info.password).to eq('topic-password')
+    end
+
+    it 'should create backend with nil registry_info when not specified' do
+      Karafka::App.routes.redraw do
+        topic 'backend-test-topic-no-registry' do
+          active false
+          schema 'MySchema'
+          namespace 'com.my-namespace'
+          key_config none: true
+        end
+      end
+
+      backend = described_class.schema_backend_for('backend-test-topic-no-registry')
+      # registry_info should be nil when not specified in topic config
+      expect(backend.registry_info).to be_nil
+    end
   end
 
   describe '#schema_backend_class with mock_backends' do

data/spec/karafka_config/karafka_spec.rb

@@ -76,6 +76,58 @@ RSpec.describe Karafka::Routing::Topic do
       expect('MyTopic').to have_sent({ test_id: 'id1', some_int: 5 }, { test_id: 'id3' })
     end
 
+    it 'should work with custom registry configuration' do
+      KarafkaApp.routes.draw do
+        topic 'MyTopic' do
+          producer_class MyProducer
+          schema 'MySchema'
+          namespace 'com.my-namespace'
+          key_config(none: true)
+          registry_url 'http://custom-registry:8081'
+          registry_user 'custom-user'
+          registry_password 'custom-password'
+        end
+      end
+
+      # Verify the topic configuration has the registry settings
+      topic_config = Deimos.karafka_config_for(topic: 'MyTopic')
+      expect(topic_config.registry_url).to eq('http://custom-registry:8081')
+      expect(topic_config.registry_user).to eq('custom-user')
+      expect(topic_config.registry_password).to eq('custom-password')
+
+      # Verify schema_backend_for uses the custom registry settings
+      backend = Deimos.schema_backend_for('MyTopic')
+      expect(backend.registry_info).not_to be_nil
+      expect(backend.registry_info.url).to eq('http://custom-registry:8081')
+      expect(backend.registry_info.user).to eq('custom-user')
+      expect(backend.registry_info.password).to eq('custom-password')
+    end
+
+    it 'should work with partial registry configuration' do
+      KarafkaApp.routes.draw do
+        topic 'MyTopic' do
+          producer_class MyProducer
+          schema 'MySchema'
+          namespace 'com.my-namespace'
+          key_config(none: true)
+          registry_url 'http://custom-registry:8081'
+          # No user or password specified
+        end
+      end
+
+      topic_config = Deimos.karafka_config_for(topic: 'MyTopic')
+      expect(topic_config.registry_url).to eq('http://custom-registry:8081')
+      expect(topic_config.registry_user).to be_nil
+      expect(topic_config.registry_password).to be_nil
+
+      # Verify schema_backend_for creates registry_info with nil user/password
+      backend = Deimos.schema_backend_for('MyTopic')
+      expect(backend.registry_info).not_to be_nil
+      expect(backend.registry_info.url).to eq('http://custom-registry:8081')
+      expect(backend.registry_info.user).to be_nil
+      expect(backend.registry_info.password).to be_nil
+    end
+
   end
 
   it 'should be able to pick up a consumer' do

data/spec/registry_info_spec.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+RSpec.describe Deimos::RegistryInfo do
+  describe '#initialize' do
+    it 'should initialize with url, user, and password' do
+      registry_info = described_class.new('http://localhost:8081', 'user1', 'pass1')
+      expect(registry_info.url).to eq('http://localhost:8081')
+      expect(registry_info.user).to eq('user1')
+      expect(registry_info.password).to eq('pass1')
+    end
+
+    it 'should allow nil user and password' do
+      registry_info = described_class.new('http://localhost:8081', nil, nil)
+      expect(registry_info.url).to eq('http://localhost:8081')
+      expect(registry_info.user).to be_nil
+      expect(registry_info.password).to be_nil
+    end
+
+    it 'should allow setting attributes' do
+      registry_info = described_class.new('http://localhost:8081', 'user1', 'pass1')
+      registry_info.url = 'http://newhost:8081'
+      registry_info.user = 'user2'
+      registry_info.password = 'pass2'
+
+      expect(registry_info.url).to eq('http://newhost:8081')
+      expect(registry_info.user).to eq('user2')
+      expect(registry_info.password).to eq('pass2')
+    end
+  end
+end

data/spec/schema_backends/avro_schema_registry_spec.rb

@@ -28,4 +28,26 @@ RSpec.describe Deimos::SchemaBackends::AvroSchemaRegistry do
       with('encoded-payload')
   end
 
+  describe 'with registry_info' do
+    let(:registry_info) do
+      Deimos::RegistryInfo.new('http://custom-registry:8081', 'custom-user', 'custom-password')
+    end
+    let(:backend_with_registry) do
+      described_class.new(schema: 'MySchema', namespace: 'com.my-namespace', registry_info: registry_info)
+    end
+
+    it 'should store registry_info when provided' do
+      expect(backend_with_registry.registry_info).to eq(registry_info)
+      expect(backend_with_registry.registry_info.url).to eq('http://custom-registry:8081')
+      expect(backend_with_registry.registry_info.user).to eq('custom-user')
+      expect(backend_with_registry.registry_info.password).to eq('custom-password')
+    end
+
+    it 'should have nil registry_info when not provided' do
+      backend_without_registry = described_class.new(schema: 'MySchema', namespace: 'com.my-namespace',
+                                                     registry_info: nil)
+      expect(backend_without_registry.registry_info).to be_nil
+    end
+  end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: deimos-ruby
 version: !ruby/object:Gem::Version
-  version: 2.4.0.pre.beta13
+  version: 2.4.0.pre.beta14
 platform: ruby
 authors:
 - Daniel Orner
@@ -597,6 +597,7 @@ files:
 - spec/protos/sample/v1/sample.proto
 - spec/protos/sample/v1/sample_key.proto
 - spec/rake_spec.rb
+- spec/registry_info_spec.rb
 - spec/schema_backends/avro_base_shared.rb
 - spec/schema_backends/avro_local_spec.rb
 - spec/schema_backends/avro_schema_registry_spec.rb