deimos-ruby 1.16.2 → 1.16.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 59c0f6801979649cc677cc485cfc1435d1ef235769784a864eabbc3e35e55573
-  data.tar.gz: 85d9adfa94010a7594a94e8770ee15922a893ecb53ccb600e7911ae9615ff574
+  metadata.gz: 6ee238a0bcc822c984f19d5a58d1bea52025407d931654371831b0104fcb5aed
+  data.tar.gz: 5b767073027dae54910c69be504ac2da023d540557ef592417f1f60254f9e3f3
 SHA512:
-  metadata.gz: c663849c130074d566875b278b4e6af667c814e1860a24ac531cc163e819aaac399381578a1d93130b9121402ec1f500108155ee20f37be6999df3d496869376
-  data.tar.gz: 6ba7849db0b98b80684381056be5aeb1f6d206ee65e742c8e33c1cdc9cb0f0f150d8f61f868f18e29837ac2e3279d1b2737c244c79201cbec9038da1c7128264
+  metadata.gz: 904066c010866aaa6ca1173bbdf4e4044c578ac28df8a0ebcf846c25c73cd484fbeb15dea827c3b64935a8f7588f4a62b65d1bdf6f28604d0f1e588cdb8cb15a
+  data.tar.gz: 3cec3d2ae05d855fb9835252646b6cdef16034f600b0c1b7ed169fc8b7969bb0d6a9847fd5b35092e29ca910daa91cad6b3d838425a3b577dc484d7937af1339

data/CHANGELOG.md

@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## UNRELEASED
 
+# 1.16.3 - 2022-09-08
+
+- Add the `tombstone` method to schema classes.
+
 # 1.16.2 - 2022-09-07
 
 - Added support of post_process method in ActiveRecordProducer

data/README.md

@@ -839,6 +839,8 @@ One additional configuration option indicates whether nested records should be g
 
     config.schema.nest_child_schemas = false # Flatten all classes into one directory
 
+You can generate a tombstone message (with only a key and no value) by calling the `YourSchemaClass.tombstone(key)` method. If you're using a `:field` key config, you can pass in just the key scalar value. If using a key schema, you can pass it in as a hash or as another schema class.
+
 ### Consumer
 
 The consumer interface uses the `decode_message` method to turn JSON hash into the Schemas

data/lib/deimos/schema_class/record.rb

@@ -8,10 +8,16 @@ module Deimos
     # Base Class of Record Classes generated from Avro.
     class Record < Base
 
+      attr_accessor :tombstone_key
+
       # Converts the object attributes to a hash which can be used for Kafka
       # @return [Hash] the payload as a hash.
       def to_h
-        self.as_json
+        if self.tombstone_key
+          { payload_key: self.tombstone_key&.as_json }
+        else
+          self.as_json
+        end
       end
 
       # Merge a hash or an identical schema object with this one and return a new object.

data/lib/deimos/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Deimos
-  VERSION = '1.16.2'
+  VERSION = '1.16.3'
 end

data/lib/generators/deimos/schema_class/templates/schema_record.rb.tt

@@ -20,7 +20,7 @@
 <%- if @field_assignments.select{ |h| !h[:is_schema_class] }.any? -%>
     ### Attribute Accessors ###
   <%- @field_assignments.select{ |h| !h[:is_schema_class] }.each do |method_definition| -%>
-    # @param <%= method_definition[:method_argument] %> [<%= method_definition[:deimos_type] %>]
+    # @return [<%= method_definition[:deimos_type] %>]
     attr_accessor :<%= method_definition[:field].name %>
   <%- end -%>
 
@@ -28,14 +28,14 @@
 <%- if @field_assignments.select{ |h| h[:is_schema_class] }.any? -%>
     ### Attribute Writers ###
   <%- @field_assignments.select{ |h| h[:is_schema_class] }.each do |method_definition| -%>
-    # @param <%= method_definition[:method_argument] %> [<%= method_definition[:deimos_type] %>]
+    # @return [<%= method_definition[:deimos_type] %>]
     def <%= method_definition[:field].name %>=(<%= method_definition[:method_argument] %>)
     <%- if method_definition[:field_type] == :array -%>
-      @<%= method_definition[:field].name %> = values.map do |value|
+      @<%= method_definition[:field].name %> = values&.map do |value|
         <%= method_definition[:field_initialization] %>
       end
     <%- elsif method_definition[:field_type] == :map -%>
-      @<%= method_definition[:field].name %> = values.transform_values do |value|
+      @<%= method_definition[:field].name %> = values&.transform_values do |value|
         <%= method_definition[:field_initialization] %>
       end
     <%- else -%>
@@ -62,7 +62,15 @@
     def namespace
       '<%= @current_schema.namespace %>'
     end
-
+<%- if @tombstone_assignment %>
+    def self.tombstone(key)
+      record = self.new
+<%- if @tombstone_assignment.present? -%>
+      <%= @tombstone_assignment %>
+<%- end -%>
+      record
+    end
+<%- end %>
     # @override
     def as_json(_opts={})
       {

data/lib/generators/deimos/schema_class_generator.rb

@@ -41,16 +41,16 @@ module Deimos
         # Deimos Consumer or Producer Configuration object
         # @param schema_name [String]
         # @param namespace [String]
-        # @param key_schema_name [String,nil]
-        def generate_classes(schema_name, namespace, key_schema_name)
+        # @param key_config [Hash,nil]
+        def generate_classes(schema_name, namespace, key_config)
           schema_base = Deimos.schema_backend(schema: schema_name, namespace: namespace)
           schema_base.load_schema
-          if key_schema_name.present?
-            key_schema_base = Deimos.schema_backend(schema: key_schema_name, namespace: namespace)
+          if key_config&.dig(:schema)
+            key_schema_base = Deimos.schema_backend(schema: key_config[:schema], namespace: namespace)
             key_schema_base.load_schema
-            generate_class_from_schema_base(key_schema_base)
+            generate_class_from_schema_base(key_schema_base, key_config: nil)
           end
-          generate_class_from_schema_base(schema_base, key_schema_base: key_schema_base)
+          generate_class_from_schema_base(schema_base, key_config: key_config)
         end
 
         # @param schema [Avro::Schema::NamedSchema]
@@ -83,8 +83,8 @@ module Deimos
         end
 
         # @param schema_base [Deimos::SchemaBackends::Base]
-        # @param key_schema_base[Avro::Schema::NamedSchema]
-        def generate_class_from_schema_base(schema_base, key_schema_base: nil)
+        # @param key_config [Hash,nil]
+        def generate_class_from_schema_base(schema_base, key_config: nil)
           @discovered_schemas = Set.new
           @sub_schema_templates = []
           schemas = collect_all_schemas(schema_base.schema_store.schemas.values)
@@ -93,11 +93,11 @@ module Deimos
           sub_schemas = schemas.reject { |s| s.name == schema_base.schema }.sort_by(&:name)
           if Deimos.config.schema.nest_child_schemas
             @sub_schema_templates = sub_schemas.map do |schema|
-              _generate_class_template_from_schema(schema)
+              _generate_class_template_from_schema(schema, nil)
             end
-            write_file(main_schema, key_schema_base)
+            write_file(main_schema, key_config)
           else
-            write_file(main_schema, key_schema_base)
+            write_file(main_schema, key_config)
             sub_schemas.each do |schema|
               write_file(schema, nil)
             end
@@ -105,9 +105,9 @@ module Deimos
         end
 
         # @param schema [Avro::Schema::NamedSchema]
-        # @param key_schema_base [Avro::Schema::NamedSchema, nil]
-        def write_file(schema, key_schema_base)
-          class_template = _generate_class_template_from_schema(schema, key_schema_base)
+        # @param key_schema_base [Hash]
+        def write_file(schema, key_config)
+          class_template = _generate_class_template_from_schema(schema, key_config)
           @modules = Utils::SchemaClass.modules_for(schema.namespace)
           @main_class_definition = class_template
 
@@ -154,7 +154,7 @@ module Deimos
           key_schema_name = config.key_config[:schema]
           found_schemas.add("#{namespace}.#{schema_name}")
           found_schemas.add("#{namespace}.#{key_schema_name}") if key_schema_name
-          generate_classes(schema_name, namespace, key_schema_name)
+          generate_classes(schema_name, namespace, config.key_config)
         end
 
         Deimos.config.consumer_objects.each do |config|
@@ -163,7 +163,7 @@ module Deimos
           key_schema_name = config.key_config[:schema]
           found_schemas.add("#{namespace}.#{schema_name}")
           found_schemas.add("#{namespace}.#{key_schema_name}") if key_schema_name
-          generate_classes(schema_name, namespace, key_schema_name)
+          generate_classes(schema_name, namespace, config.key_config)
         end
 
         generate_from_schema_files(found_schemas)
@@ -191,10 +191,10 @@ module Deimos
       end
 
       # @param schema[Avro::Schema::NamedSchema]
-      # @param key_schema_base[Avro::Schema::NamedSchema]
+      # @param key_config[Hash,nil]
       # @return [String]
-      def _generate_class_template_from_schema(schema, key_schema_base=nil)
-        _set_instance_variables(schema, key_schema_base)
+      def _generate_class_template_from_schema(schema, key_config)
+        _set_instance_variables(schema, key_config)
 
         temp = schema.is_a?(Avro::Schema::RecordSchema) ? _record_class_template : _enum_class_template
         res = ERB.new(temp, nil, '-')
@@ -202,20 +202,38 @@ module Deimos
       end
 
       # @param schema[Avro::Schema::NamedSchema]
-      # @param key_schema_base[Avro::Schema::NamedSchema]
-      def _set_instance_variables(schema, key_schema_base=nil)
+      # @param key_config [Hash,nil]
+      def _set_instance_variables(schema, key_config)
         schema_is_record = schema.is_a?(Avro::Schema::RecordSchema)
         @current_schema = schema
         return unless schema_is_record
 
         @fields = fields(schema)
-        if key_schema_base.present?
+        key_schema = nil
+        if key_config&.dig(:schema)
+          key_schema_base = Deimos.schema_backend(schema: key_config[:schema], namespace: schema.namespace)
           key_schema_base.load_schema
           key_schema = key_schema_base.schema_store.schemas.values.first
           @fields << Deimos::SchemaField.new('payload_key', key_schema, [], nil)
         end
         @initialization_definition = _initialization_definition
         @field_assignments = _field_assignments
+        @tombstone_assignment = _tombstone_assignment(key_config, key_schema)
+      end
+
+      def _tombstone_assignment(key_config, key_schema)
+        return nil unless key_config
+
+        if key_config[:plain]
+          "record.tombstone_key = key"
+        elsif key_config[:field]
+          "record.tombstone_key = key\n      record.#{key_config[:field]} = key"
+        elsif key_schema
+          field_base_type = _field_type(key_schema)
+          "record.tombstone_key = #{field_base_type}.initialize_from_value(key)\n      record.payload_key = key"
+        else
+          ''
+        end
       end
 
       # Defines the initialization method for Schema Records with one keyword argument per line

data/regenerate_test_schema_classes.rb

@@ -0,0 +1,68 @@
+#! /usr/bin/env ruby
+require 'action_controller/railtie'
+require 'deimos'
+require 'deimos/metrics/mock'
+require 'deimos/tracing/mock'
+# not sure why "require deimos/utils/schema_class" doesn't work
+require_relative 'lib/deimos/utils/schema_class'
+
+class DeimosApp < Rails::Application
+end
+DeimosApp.initialize!
+
+class MyConsumer < Deimos::Consumer
+  def consume(payload, metadata); end
+end
+
+require_relative "./lib/generators/deimos/schema_class_generator"
+
+Deimos.configure do |deimos_config|
+  deimos_config.schema.nest_child_schemas = true
+  deimos_config.schema.path = "spec/schemas"
+  deimos_config.schema.backend = :avro_validation
+  deimos_config.schema.generated_class_path = './spec/schemas'
+  deimos_config.schema.generate_namespace_folders = true
+  deimos_config.schema.nest_child_schemas = true
+
+  consumer do
+    class_name 'MyConsumer'
+    topic 'MyTopic'
+    schema 'Generated'
+    namespace 'com.my-namespace'
+    key_config field: :a_string
+  end
+
+  consumer do
+    class_name 'MyConsumer'
+    topic 'MyTopic'
+    schema 'MySchemaWithComplexTypes'
+    namespace 'com.my-namespace'
+    key_config field: :test_id
+  end
+
+  consumer do
+    class_name 'MyConsumer'
+    topic 'MyTopic'
+    schema 'MySchemaWithCircularReference'
+    namespace 'com.my-namespace'
+    key_config none: true
+  end
+
+  consumer do
+    class_name 'MyConsumer'
+    topic 'MyTopic'
+    schema 'MyNestedSchema'
+    namespace 'com.my-namespace'
+    key_config field: :test_id
+  end
+
+  producer do
+    class_name 'MyConsumer'
+    topic 'MyTopic'
+    schema 'MySchema'
+    namespace 'com.my-namespace'
+    key_config schema: 'MySchema_key'
+  end
+end
+
+Deimos::Generators::SchemaClassGenerator.new.generate

data/spec/generators/schema_class/my_schema_spec.rb

@@ -0,0 +1,16 @@
+RSpec.describe Schemas::MyNamespace::MySchema do
+  let(:key) { Schemas::MyNamespace::MySchemaKey.new(test_id: 123) }
+
+  it 'should produce a tombstone with a hash' do
+    result = described_class.tombstone({test_id: 123})
+    expect(result.payload_key).to eq(key)
+    expect(result.to_h).to eq({ payload_key: { 'test_id' => 123}})
+  end
+
+  it 'should work with a record' do
+    key = Schemas::MyNamespace::MySchemaKey.new(test_id: 123)
+    result = described_class.tombstone(key)
+    expect(result.payload_key).to eq(key)
+    expect(result.to_h).to eq({ payload_key: { 'test_id' => 123}})
+  end
+end

data/spec/generators/schema_class/my_schema_with_circular_reference_spec.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # For testing the generated class.
-RSpec.describe Schemas::MySchemaWithCircularReference do
+RSpec.describe Schemas::MyNamespace::MySchemaWithCircularReference do
   let(:payload_hash) do
     {
       properties: {

data/spec/generators/schema_class/my_schema_with_complex_types_spec.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # For testing the generated class.
-RSpec.describe Schemas::MySchemaWithComplexType do
+RSpec.describe Schemas::MyNamespace::MySchemaWithComplexType do
   let(:payload_hash) do
     {
       test_id: 'test id',
@@ -9,16 +9,16 @@ RSpec.describe Schemas::MySchemaWithComplexType do
       test_string_array: %w(abc def),
       test_int_array: [123, 456],
       some_integer_map: { 'int_1' => 1, 'int_2' => 2 },
-      some_record: Schemas::MySchemaWithComplexType::ARecord.new(a_record_field: 'field 1'),
-      some_optional_record: Schemas::MySchemaWithComplexType::ARecord.new(a_record_field: 'field 2'),
-      some_record_array: [Schemas::MySchemaWithComplexType::ARecord.new(a_record_field: 'field 3'),
-                          Schemas::MySchemaWithComplexType::ARecord.new(a_record_field: 'field 4')],
+      some_record: described_class::ARecord.new(a_record_field: 'field 1'),
+      some_optional_record: described_class::ARecord.new(a_record_field: 'field 2'),
+      some_record_array: [described_class::ARecord.new(a_record_field: 'field 3'),
+                          described_class::ARecord.new(a_record_field: 'field 4')],
       some_record_map: {
-        'record_1' => Schemas::MySchemaWithComplexType::ARecord.new(a_record_field: 'field 5'),
-        'record_2' => Schemas::MySchemaWithComplexType::ARecord.new(a_record_field: 'field 6')
+        'record_1' => described_class::ARecord.new(a_record_field: 'field 5'),
+        'record_2' => described_class::ARecord.new(a_record_field: 'field 6')
       },
-      some_enum_array: [Schemas::MySchemaWithComplexType::AnEnum.new('sym1'),
-                        Schemas::MySchemaWithComplexType::AnEnum.new('sym2')]
+      some_enum_array: [described_class::AnEnum.new('sym1'),
+                        described_class::AnEnum.new('sym2')]
     }
   end
 
@@ -51,6 +51,14 @@ RSpec.describe Schemas::MySchemaWithComplexType do
 
   end
 
+  describe '.tombstone' do
+    it 'should return a tombstone' do
+      record = described_class.tombstone('foo')
+      expect(record.tombstone_key).to eq('foo')
+      expect(record.to_h).to eq({payload_key: 'foo'})
+    end
+  end
+
   describe 'base class methods' do
     let(:klass) do
       described_class.new(**payload_hash)
@@ -116,7 +124,7 @@ RSpec.describe Schemas::MySchemaWithComplexType do
       payload_hash.delete(:some_record)
       klass = described_class.new(**payload_hash)
       expect(klass.some_record).
-        to eq(Schemas::MySchemaWithComplexType::ARecord.new(a_record_field: 'Test String'))
+        to eq(described_class::ARecord.new(a_record_field: 'Test String'))
     end
 
     it 'should set some_record to nil' do
@@ -139,26 +147,26 @@ RSpec.describe Schemas::MySchemaWithComplexType do
 
       it 'should get the value of some_record_array' do
         some_record_array = klass.some_record_array
-        expect(some_record_array.first).to be_instance_of(Schemas::MySchemaWithComplexType::ARecord)
+        expect(some_record_array.first).to be_instance_of(described_class::ARecord)
         expect(some_record_array.first.a_record_field).to eq('field 3')
       end
 
       it 'should get the value of some_record_map' do
         some_record_map = klass.some_record_map
         expect(some_record_map['record_1']).
-          to be_instance_of(Schemas::MySchemaWithComplexType::ARecord)
+          to be_instance_of(described_class::ARecord)
         expect(some_record_map['record_1'].a_record_field).to eq('field 5')
       end
 
       it 'should get the value of some_enum_array' do
         some_enum_array = klass.some_enum_array
-        expect(some_enum_array.first).to be_instance_of(Schemas::MySchemaWithComplexType::AnEnum)
+        expect(some_enum_array.first).to be_instance_of(described_class::AnEnum)
         expect(some_enum_array.first.value).to eq('sym1')
       end
 
       it 'should get the value of some_record' do
         record = klass.some_record
-        expect(record).to be_instance_of(Schemas::MySchemaWithComplexType::ARecord)
+        expect(record).to be_instance_of(described_class::ARecord)
         expect(record.a_record_field).to eq('field 1')
         expect(record.to_h).to eq({ 'a_record_field' => 'field 1' })
       end
@@ -180,40 +188,40 @@ RSpec.describe Schemas::MySchemaWithComplexType do
 
       it 'should modify the value of some_optional_record' do
         expect(klass.some_optional_record).
-          to eq(Schemas::MySchemaWithComplexType::ARecord.new(a_record_field: 'field 2'))
-        klass.some_optional_record = Schemas::MySchemaWithComplexType::ARecord.
+          to eq(described_class::ARecord.new(a_record_field: 'field 2'))
+        klass.some_optional_record = described_class::ARecord.
           new(a_record_field: 'new field')
 
-        expect(klass.some_optional_record).to eq(Schemas::MySchemaWithComplexType::ARecord.
+        expect(klass.some_optional_record).to eq(described_class::ARecord.
           new(a_record_field: 'new field'))
         expect(klass.some_optional_record.as_json).to eq({ 'a_record_field' => 'new field' })
       end
 
       it 'should accept a hash object inner records' do
         klass.some_optional_record = { a_record_field: 'new field' }
-        expect(klass.some_optional_record).to eq(Schemas::MySchemaWithComplexType::ARecord.
-          new(a_record_field: 'new field'))
+        expect(klass.some_optional_record).
+          to eq(described_class::ARecord.new(a_record_field: 'new field'))
         expect(klass.some_optional_record.as_json).to eq({ 'a_record_field' => 'new field' })
       end
 
       it 'should modify the value of some_enum_array' do
         klass.some_enum_array.first.value = 'new_sym'
         expect(klass.some_enum_array.first).
-          to eq(Schemas::MySchemaWithComplexType::AnEnum.new('new_sym'))
+          to eq(described_class::AnEnum.new('new_sym'))
 
-        klass.some_enum_array.second.an_enum = Schemas::MySchemaWithComplexType::AnEnum.
+        klass.some_enum_array.second.an_enum = described_class::AnEnum.
           new('other_sym')
         expect(klass.some_enum_array.second.an_enum).to eq('other_sym')
       end
 
       it 'should modify the value of some_record_map' do
         klass.some_record_map['record_1'].a_record_field = 'new field'
-        expect(klass.some_record_map['record_1']).to eq(Schemas::MySchemaWithComplexType::ARecord.
+        expect(klass.some_record_map['record_1']).to eq(described_class::ARecord.
           new(a_record_field: 'new field'))
 
-        klass.some_record_map['record_2'] = Schemas::MySchemaWithComplexType::ARecord.
+        klass.some_record_map['record_2'] = described_class::ARecord.
           new(a_record_field: 'other field')
-        expect(klass.some_record_map['record_2']).to eq(Schemas::MySchemaWithComplexType::ARecord.
+        expect(klass.some_record_map['record_2']).to eq(described_class::ARecord.
           new(a_record_field: 'other field'))
       end
     end

data/spec/producer_spec.rb

@@ -397,7 +397,7 @@ module ProducerTest
         end
         expect(MyProducer.encoder).to receive(:validate).and_raise('OH NOES')
         expect {
-          MyProducer.publish(Schemas::MySchema.new(test_id: 'foo', some_int: 'invalid'))
+          MyProducer.publish(Schemas::MyNamespace::MySchema.new(test_id: 'foo', some_int: 'invalid'))
         }.to raise_error('OH NOES')
         Deimos.unsubscribe(subscriber)
       end
@@ -420,8 +420,8 @@ module ProducerTest
         ).and_call_original
 
         MyProducer.publish_list(
-          [Schemas::MySchema.new(test_id: 'foo', some_int: 123),
-           Schemas::MySchema.new(test_id: 'bar', some_int: 124)]
+          [Schemas::MyNamespace::MySchema.new(test_id: 'foo', some_int: 123),
+           Schemas::MyNamespace::MySchema.new(test_id: 'bar', some_int: 124)]
         )
         expect('my-topic').to have_sent('test_id' => 'foo', 'some_int' => 123)
         expect('your-topic').not_to have_sent('test_id' => 'foo', 'some_int' => 123)
@@ -432,8 +432,8 @@ module ProducerTest
         expect(described_class).not_to receive(:produce_batch)
         Deimos.configure { |c| c.producers.disabled = true }
         MyProducer.publish_list(
-          [Schemas::MySchema.new(test_id: 'foo', some_int: 123),
-           Schemas::MySchema.new(test_id: 'bar', some_int: 124)]
+          [Schemas::MyNamespace::MySchema.new(test_id: 'foo', some_int: 123),
+           Schemas::MyNamespace::MySchema.new(test_id: 'bar', some_int: 124)]
         )
         expect(MyProducer.topic).not_to have_sent(anything)
       end
@@ -452,8 +452,8 @@ module ProducerTest
                                                             }, { topic: 'my-topic-value' })
 
         MyProducer.publish_list(
-          [Schemas::MySchema.new(test_id: 'foo', some_int: 123),
-           Schemas::MySchema.new(test_id: 'bar', some_int: 124)]
+          [Schemas::MyNamespace::MySchema.new(test_id: 'foo', some_int: 123),
+           Schemas::MyNamespace::MySchema.new(test_id: 'bar', some_int: 124)]
         )
       end
 
@@ -464,19 +464,19 @@ module ProducerTest
                                                                       { topic: 'my-topic2-key' })
 
         MySchemaProducer.publish_list(
-          [Schemas::MySchema.new(test_id: 'foo', some_int: 123, payload_key: { 'test_id' => 'foo_key' }),
-           Schemas::MySchema.new(test_id: 'bar', some_int: 124, payload_key: { 'test_id' => 'bar_key' })]
+          [Schemas::MyNamespace::MySchema.new(test_id: 'foo', some_int: 123, payload_key: { 'test_id' => 'foo_key' }),
+           Schemas::MyNamespace::MySchema.new(test_id: 'bar', some_int: 124, payload_key: { 'test_id' => 'bar_key' })]
         )
       end
 
       it 'should properly encode and coerce values with a nested record' do
         expect(MyNestedSchemaProducer.encoder).to receive(:encode_key).with('test_id', 'foo', topic: 'my-topic-key')
         MyNestedSchemaProducer.publish(
-          Schemas::MyNestedSchema.new(
+          Schemas::MyNamespace::MyNestedSchema.new(
             test_id: 'foo',
             test_float: BigDecimal('123.456'),
             test_array: ['1'],
-            some_nested_record: Schemas::MyNestedSchema::MyNestedRecord.new(
+            some_nested_record: Schemas::MyNamespace::MyNestedSchema::MyNestedRecord.new(
               some_int: 123,
               some_float: BigDecimal('456.789'),
               some_string: '123',