schema_registry_client 0.0.11.pre.beta1 → 0.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7aa1f66862cabf744233ac1fa0dcc199b7fbaaabb448d50f8e8b3aa0fb98f273
-  data.tar.gz: 642bfb50cd4efa20bdc93fb2740ed0ec6788866b378c7d601d5e7b05e8e6a9cf
+  metadata.gz: '09a16bc0d516a981c823ec6aef2c356cae10f4dca61279870b741741c1f9baa4'
+  data.tar.gz: 7bbcbe0b5b6ffeb494c264983e137fc1864387440bc9ecc41b21f2405d15a361
 SHA512:
-  metadata.gz: 58254805ac900a92e2b7e6418b1e1565dd2d23b257ce6c771d26a1e1dd753193de6836e417c5382c083d322ded4f0a67947898057e8656cf053f1d3b713d31b2
-  data.tar.gz: db29da6cc31f095f9f83d6c26b8b2de06a52d889d2ef1a445ba6861529f34014841dda8068cc26c2945dc016a08f884aebdd7c701ad0650f2feaf9bcb854d67b
+  metadata.gz: 88a82ff70e5fdc2a5b5b783630a218a58b02cdc1f2513470ffd31f14e1d75356eff1f1ccef7e684954ce9d72ce07571e71b50900e61e1cf98de998d3513a5718
+  data.tar.gz: 9c5a98b3299615b052a8eb2f9f4356cc75dea85b283c5cee8e8759b97c373be17350a7df9d3f9232200cf3d6f406dd64ddff80d4292d5be3982807779f9ae4b9

data/.gitignore

@@ -1 +1,2 @@
 coverage
+.claude

data/CHANGELOG.md

@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## UNRELEASED
 
+# 0.0.11 - 2026-02-20
+
+* Fixes for caching working correctly and ensuring we don't recalculate / re-parse Avro schemas
+
 # 0.0.10 - 2026-02-11
 
 * Fix: Do not send `schemaType` or `references` if schema type is `AVRO`, for backwards compatibility with older schema registries.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    schema_registry_client (0.0.11.pre.beta1)
+    schema_registry_client (0.0.11)
       avro
       excon
       google-protobuf

data/lib/schema_registry_client/cached_confluent_schema_registry.rb

@@ -8,6 +8,7 @@ module SchemaRegistry
       @schemas_by_id = {}
       @ids_by_schema = {}
       @versions_by_subject_and_id = {}
+      @mutex = Mutex.new
     end
 
     # Delegate the following methods to the upstream
@@ -20,25 +21,37 @@ module SchemaRegistry
     # @param id [Integer] the schema ID to fetch
     # @return [String] the schema string stored in the registry for the given id
     def fetch(id)
-      @schemas_by_id[id] ||= @upstream.fetch(id)
+      @mutex.synchronize do
+        @schemas_by_id[id] ||= @upstream.fetch(id)
+      end
     end
 
     # @param id [Integer] the schema ID to fetch
     # @param subject [String] the subject to fetch the version for
     # @return [Integer, nil] the version of the schema for the given subject and id, or nil if not found
     def fetch_version(id, subject)
-      key = [subject, id]
-      return @versions_by_subject_and_id[key] if @versions_by_subject_and_id[key]
+      @mutex.synchronize do
+        key = [subject, id]
+        return @versions_by_subject_and_id[key] if @versions_by_subject_and_id[key]
 
-      results = @upstream.schema_subject_versions(id)
-      @versions_by_subject_and_id[key] = results&.find { |r| r["subject"] == subject }&.dig("version")
+        results = @upstream.schema_subject_versions(id)
+        @versions_by_subject_and_id[key] = results&.find { |r| r["subject"] == subject }&.dig("version")
+      end
     end
 
     # @param subject [String] the subject to check
     # @param schema [String] the schema text to check
     # @return [Boolean] true if we know the schema has been registered for that subject.
     def registered?(subject, schema)
-      @ids_by_schema[[subject, schema]] && !@ids_by_schema[[subject, schema]].empty?
+      @mutex.synchronize do
+        @ids_by_schema.key?([subject, schema])
+      end
+    end
+
+    def fetch_id(subject, schema)
+      @mutex.synchronize do
+        @ids_by_schema[[subject, schema]]
+      end
     end
 
     # @param subject [String] the subject to register the schema under
@@ -46,12 +59,14 @@ module SchemaRegistry
     # @param references [Array<Hash>] optional references to other schemas
     # @param schema_type [String]
     def register(subject, schema, references: [], schema_type: "PROTOBUF")
-      key = [subject, schema]
+      @mutex.synchronize do
+        key = [subject, schema]
 
-      @ids_by_schema[key] ||= @upstream.register(subject,
-        schema,
-        references: references,
-        schema_type: schema_type)
+        @ids_by_schema[key] ||= @upstream.register(subject,
+          schema,
+          references: references,
+          schema_type: schema_type)
+      end
     end
   end
 end

data/lib/schema_registry_client/confluent_schema_registry.rb

@@ -24,9 +24,6 @@ module SchemaRegistry
       resolv_resolver: nil,
       retry_limit: nil
     )
-      if SchemaRegistry.debug
-        logger.info("Creating Confluent Schema Registry client with url: #{url}, schema_context: #{schema_context}, user: #{user}, path_prefix: #{path_prefix}")
-      end
       @path_prefix = path_prefix
       @schema_context_prefix = schema_context.nil? ? "" : ":.#{schema_context}:"
       @schema_context_options = schema_context.nil? ? {} : {query: {subject: @schema_context_prefix}}
@@ -76,7 +73,6 @@ module SchemaRegistry
     # @param references [Array<Hash>] optional references to other schemas
     # @return [Integer] the ID of the registered schema
     def register(subject, schema, references: [], schema_type: "PROTOBUF")
-      puts("schema_type #{schema_type}")
       body = {schema: schema.to_s}
       # Not all schema registry versions support schemaType
       if schema_type != "AVRO"

data/lib/schema_registry_client/schema/avro.rb

@@ -22,7 +22,10 @@ module SchemaRegistry
         @schema_store ||= SchemaRegistry::AvroSchemaStore.new(
           path: SchemaRegistry.avro_schema_path || DEFAULT_SCHEMAS_PATH
         )
-        @schema_store.load_schemas!
+        unless @schemas_loaded
+          @schema_store.load_schemas!
+          @schemas_loaded = true
+        end
         @schema_store
       end
 
@@ -44,10 +47,10 @@ module SchemaRegistry
       end
 
       def decode(stream, schema_text)
-        # Parse the schema text from the registry into an Avro schema object
-        JSON.parse(schema_text)
-        writers_schema = ::Avro::Schema.parse(schema_text)
-
+        # Cache parsed writer schemas to avoid re-parsing on every decode
+        @parsed_writers_schemas ||= {}
+        @parsed_writers_schemas[schema_text] ||= ::Avro::Schema.parse(schema_text)
+        writers_schema = @parsed_writers_schemas[schema_text]
         decoder = ::Avro::IO::BinaryDecoder.new(stream)
 
         # Try to find the reader schema locally, fall back to writer schema

data/lib/schema_registry_client/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SchemaRegistry
-  VERSION = "0.0.11-beta1"
+  VERSION = "0.0.11"
 end

data/lib/schema_registry_client.rb

@@ -14,8 +14,6 @@ module SchemaRegistry
 
   class << self
     attr_accessor :avro_schema_path
-
-    attr_accessor :debug
   end
 
   class Client
@@ -136,7 +134,12 @@ module SchemaRegistry
 
     def register_schema(message, subject, schema_text: nil, schema_name: nil)
       schema_text ||= @schema.schema_text(message, schema_name: schema_name)
-      return if @registry.registered?(schema_text, subject)
+
+      # Fast path: if already registered, return the cached ID without
+      # resolving dependencies again.
+      if @registry.registered?(subject, schema_text)
+        return @registry.fetch_id(subject, schema_text)
+      end
 
       # register dependencies first
       dependencies = @schema.dependencies(message)

data/spec/decoding_spec.rb

@@ -60,18 +60,19 @@ RSpec.describe "decoding" do
   end
 
   describe "with Avro" do
-    let(:schema_registry_client) do
+    around(:each) do |ex|
       SchemaRegistry.avro_schema_path = "#{__dir__}/schemas"
+      ex.run
+      SchemaRegistry.avro_schema_path = nil
+    end
+
+    let(:schema_registry_client) do
       SchemaRegistry::Client.new(
         registry_url: "http://localhost:8081",
         schema_type: SchemaRegistry::Schema::Avro.new
       )
     end
 
-    after do
-      SchemaRegistry.avro_schema_path = nil
-    end
-
     it "should decode a simple message" do
       schema = File.read("#{__dir__}/schemas/simple/v1/SimpleMessage.avsc")
       stub = stub_request(:get, "http://localhost:8081/schemas/ids/15")
@@ -180,4 +181,121 @@ RSpec.describe "decoding" do
       end.to raise_error(/Schema|not found/i)
     end
   end
+
+  describe "caching" do
+    it "should not fetch the same schema ID twice (Protobuf)" do
+      schema = File.read("#{__dir__}/schemas/simple/simple.proto")
+      stub = stub_request(:get, "http://localhost:8081/schemas/ids/15")
+        .to_return_json(body: {schema: schema})
+      msg = Simple::V1::SimpleMessage.new(name: "my name")
+      encoded = "\u0000\u0000\u0000\u0000\u000F\u0000#{msg.to_proto}"
+
+      3.times { schema_registry_client.decode(encoded) }
+
+      expect(stub).to have_been_requested.once
+    end
+
+    it "should fetch different schema IDs independently" do
+      simple_schema = File.read("#{__dir__}/schemas/simple/simple.proto")
+      stub_15 = stub_request(:get, "http://localhost:8081/schemas/ids/15")
+        .to_return_json(body: {schema: simple_schema})
+
+      ref_schema = File.read("#{__dir__}/schemas/referenced/referer.proto")
+      stub_20 = stub_request(:get, "http://localhost:8081/schemas/ids/20")
+        .to_return_json(body: {schema: ref_schema})
+
+      msg1 = Simple::V1::SimpleMessage.new(name: "my name")
+      encoded1 = "\u0000\u0000\u0000\u0000\u000F\u0000#{msg1.to_proto}"
+
+      msg2 = Referenced::V1::MessageB::MessageBA.new(
+        simple: Simple::V1::SimpleMessage.new(name: "my name")
+      )
+      encoded2 = "\u0000\u0000\u0000\u0000\u0014\u0004\u0002\u0000#{msg2.to_proto}"
+
+      # Decode both messages
+      schema_registry_client.decode(encoded1)
+      schema_registry_client.decode(encoded2)
+
+      # Each schema fetched exactly once
+      expect(stub_15).to have_been_requested.once
+      expect(stub_20).to have_been_requested.once
+
+      # Decode again - no new requests
+      schema_registry_client.decode(encoded1)
+      schema_registry_client.decode(encoded2)
+
+      expect(stub_15).to have_been_requested.once
+      expect(stub_20).to have_been_requested.once
+    end
+
+    it "should not share cache between different client instances" do
+      schema = File.read("#{__dir__}/schemas/simple/simple.proto")
+      stub = stub_request(:get, "http://localhost:8081/schemas/ids/15")
+        .to_return_json(body: {schema: schema})
+      msg = Simple::V1::SimpleMessage.new(name: "my name")
+      encoded = "\u0000\u0000\u0000\u0000\u000F\u0000#{msg.to_proto}"
+
+      schema_registry_client.decode(encoded)
+
+      # A second client should make its own request
+      client2 = SchemaRegistry::Client.new(registry_url: "http://localhost:8081")
+      client2.decode(encoded)
+
+      expect(stub).to have_been_requested.twice
+    end
+
+    describe "with Avro" do
+      around(:each) do |ex|
+        SchemaRegistry.avro_schema_path = "#{__dir__}/schemas"
+        ex.run
+        SchemaRegistry.avro_schema_path = nil
+      end
+
+      let(:schema_registry_client) do
+        SchemaRegistry::Client.new(
+          registry_url: "http://localhost:8081",
+          schema_type: SchemaRegistry::Schema::Avro.new
+        )
+      end
+
+      it "should not fetch the same schema ID twice" do
+        schema = File.read("#{__dir__}/schemas/simple/v1/SimpleMessage.avsc")
+        stub = stub_request(:get, "http://localhost:8081/schemas/ids/15")
+          .to_return_json(body: {schema: schema})
+
+        encoded = "\u0000\u0000\u0000\u0000\u000F\u000Emy name"
+
+        3.times { schema_registry_client.decode(encoded) }
+
+        expect(stub).to have_been_requested.once
+      end
+
+      it "should fetch different schema IDs independently" do
+        simple_schema = File.read("#{__dir__}/schemas/simple/v1/SimpleMessage.avsc")
+        stub_15 = stub_request(:get, "http://localhost:8081/schemas/ids/15")
+          .to_return_json(body: {schema: simple_schema})
+
+        nested_schema = File.read("#{__dir__}/schemas/referenced/v1/MessageBA.avsc")
+        stub_20 = stub_request(:get, "http://localhost:8081/schemas/ids/20")
+          .to_return_json(body: {schema: nested_schema})
+
+        encoded1 = "\u0000\u0000\u0000\u0000\u000F\u000Emy name"
+        encoded2 = "\u0000\u0000\u0000\u0000\u0014\u000Emy name"
+
+        # Decode both messages
+        schema_registry_client.decode(encoded1)
+        schema_registry_client.decode(encoded2)
+
+        expect(stub_15).to have_been_requested.once
+        expect(stub_20).to have_been_requested.once
+
+        # Decode again - no new requests
+        schema_registry_client.decode(encoded1)
+        schema_registry_client.decode(encoded2)
+
+        expect(stub_15).to have_been_requested.once
+        expect(stub_20).to have_been_requested.once
+      end
+    end
+  end
 end

data/spec/encoding_spec.rb

@@ -102,18 +102,19 @@ RSpec.describe "encoding" do
   end
 
   describe "with Avro" do
-    let(:schema_registry_client) do
+    around(:each) do |ex|
       SchemaRegistry.avro_schema_path = "#{__dir__}/schemas"
+      ex.run
+      SchemaRegistry.avro_schema_path = nil
+    end
+
+    let(:schema_registry_client) do
       SchemaRegistry::Client.new(
         registry_url: "http://localhost:8081",
         schema_type: SchemaRegistry::Schema::Avro.new
       )
     end
 
-    after do
-      SchemaRegistry.avro_schema_path = nil
-    end
-
     it "should encode a simple message" do
       schema = File.read("#{__dir__}/schemas/simple/v1/SimpleMessage.avsc")
       stub = stub_request(:post, "http://localhost:8081/subjects/simple/versions")
@@ -196,4 +197,143 @@ RSpec.describe "encoding" do
       end.to raise_error(Avro::SchemaValidator::ValidationError)
     end
   end
+
+  describe "caching" do
+    it "should not register the same schema twice (Protobuf)" do
+      schema = File.read("#{__dir__}/schemas/simple/simple.proto")
+      stub = stub_request(:post, "http://localhost:8081/subjects/simple/versions")
+        .with(body: {"schemaType" => "PROTOBUF",
+                     "references" => [],
+                     "schema" => schema}).to_return_json(body: {id: 15})
+      msg = Simple::V1::SimpleMessage.new(name: "my name")
+
+      3.times { schema_registry_client.encode(msg, subject: "simple") }
+
+      expect(stub).to have_been_requested.once
+    end
+
+    it "should register schemas for different subjects separately" do
+      schema = File.read("#{__dir__}/schemas/simple/simple.proto")
+      stub_a = stub_request(:post, "http://localhost:8081/subjects/subject-a/versions")
+        .with(body: {"schemaType" => "PROTOBUF",
+                     "references" => [],
+                     "schema" => schema}).to_return_json(body: {id: 15})
+      stub_b = stub_request(:post, "http://localhost:8081/subjects/subject-b/versions")
+        .with(body: {"schemaType" => "PROTOBUF",
+                     "references" => [],
+                     "schema" => schema}).to_return_json(body: {id: 16})
+
+      msg = Simple::V1::SimpleMessage.new(name: "my name")
+
+      schema_registry_client.encode(msg, subject: "subject-a")
+      schema_registry_client.encode(msg, subject: "subject-b")
+
+      # Both subjects should get their own registration
+      expect(stub_a).to have_been_requested.once
+      expect(stub_b).to have_been_requested.once
+
+      # Encoding again for either subject should not re-register
+      schema_registry_client.encode(msg, subject: "subject-a")
+      schema_registry_client.encode(msg, subject: "subject-b")
+
+      expect(stub_a).to have_been_requested.once
+      expect(stub_b).to have_been_requested.once
+    end
+
+    it "should not re-register dependencies on subsequent encodes (Protobuf)" do
+      schema = File.read("#{__dir__}/schemas/referenced/referer.proto")
+      dep_schema = File.read("#{__dir__}/schemas/simple/simple.proto")
+      dep_stub = stub_request(:post, "http://localhost:8081/subjects/simple%2Fsimple.proto/versions")
+        .with(body: {"schemaType" => "PROTOBUF",
+                     "references" => [],
+                     "schema" => dep_schema}).to_return_json(body: {id: 15})
+      version_stub = stub_request(:get, "http://localhost:8081/schemas/ids/15/versions")
+        .to_return_json(body: [{version: 1, subject: "simple/simple.proto"}])
+      stub = stub_request(:post, "http://localhost:8081/subjects/referenced/versions")
+        .with(body: {"schemaType" => "PROTOBUF",
+                     "references" => [
+                       {
+                         name: "simple/simple.proto",
+                         subject: "simple/simple.proto",
+                         version: 1
+                       }
+                     ],
+                     "schema" => schema}).to_return_json(body: {id: 20})
+      msg = Referenced::V1::MessageB::MessageBA.new(
+        simple: Simple::V1::SimpleMessage.new(name: "my name")
+      )
+
+      3.times { schema_registry_client.encode(msg, subject: "referenced") }
+
+      expect(stub).to have_been_requested.once
+      expect(dep_stub).to have_been_requested.once
+      expect(version_stub).to have_been_requested.once
+    end
+
+    it "should not share cache between different client instances" do
+      schema = File.read("#{__dir__}/schemas/simple/simple.proto")
+      stub = stub_request(:post, "http://localhost:8081/subjects/simple/versions")
+        .with(body: {"schemaType" => "PROTOBUF",
+                     "references" => [],
+                     "schema" => schema}).to_return_json(body: {id: 15})
+      msg = Simple::V1::SimpleMessage.new(name: "my name")
+
+      schema_registry_client.encode(msg, subject: "simple")
+
+      # A second client should make its own registration request
+      client2 = SchemaRegistry::Client.new(registry_url: "http://localhost:8081")
+      client2.encode(msg, subject: "simple")
+
+      expect(stub).to have_been_requested.twice
+    end
+
+    describe "with Avro" do
+      around(:each) do |ex|
+        SchemaRegistry.avro_schema_path = "#{__dir__}/schemas"
+        ex.run
+        SchemaRegistry.avro_schema_path = nil
+      end
+
+      let(:schema_registry_client) do
+        SchemaRegistry::Client.new(
+          registry_url: "http://localhost:8081",
+          schema_type: SchemaRegistry::Schema::Avro.new
+        )
+      end
+
+      it "should not register the same schema twice" do
+        schema = File.read("#{__dir__}/schemas/simple/v1/SimpleMessage.avsc")
+        stub = stub_request(:post, "http://localhost:8081/subjects/simple/versions")
+          .with(body: {"schema" => schema}).to_return_json(body: {id: 15})
+        msg = {"name" => "my name"}
+
+        3.times { schema_registry_client.encode(msg, subject: "simple", schema_name: "simple.v1.SimpleMessage") }
+
+        expect(stub).to have_been_requested.once
+      end
+
+      it "should register schemas for different subjects separately" do
+        schema = File.read("#{__dir__}/schemas/simple/v1/SimpleMessage.avsc")
+        stub_a = stub_request(:post, "http://localhost:8081/subjects/subject-a/versions")
+          .with(body: {"schema" => schema}).to_return_json(body: {id: 15})
+        stub_b = stub_request(:post, "http://localhost:8081/subjects/subject-b/versions")
+          .with(body: {"schema" => schema}).to_return_json(body: {id: 16})
+
+        msg = {"name" => "my name"}
+
+        schema_registry_client.encode(msg, subject: "subject-a", schema_name: "simple.v1.SimpleMessage")
+        schema_registry_client.encode(msg, subject: "subject-b", schema_name: "simple.v1.SimpleMessage")
+
+        expect(stub_a).to have_been_requested.once
+        expect(stub_b).to have_been_requested.once
+
+        # Encoding again should not re-register
+        schema_registry_client.encode(msg, subject: "subject-a", schema_name: "simple.v1.SimpleMessage")
+        schema_registry_client.encode(msg, subject: "subject-b", schema_name: "simple.v1.SimpleMessage")
+
+        expect(stub_a).to have_been_requested.once
+        expect(stub_b).to have_been_requested.once
+      end
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: schema_registry_client
 version: !ruby/object:Gem::Version
-  version: 0.0.11.pre.beta1
+  version: 0.0.11
 platform: ruby
 authors:
 - Daniel Orner