avrocadabra 0.0.1

data/ext/avrocadabra/src/schema_state.rs

@@ -0,0 +1,60 @@
+use magnus::{
+    Error, RArray, RHash, RString, Symbol, Value, encoding::EncodingCapable, prelude::*,
+    r_hash::ForEach, rb_sys::AsRawValue,
+};
+
+fn identical(left: Value, right: Value) -> bool {
+    left.as_raw() == right.as_raw()
+}
+
+pub fn unchanged(attributes: RArray, containers: RArray) -> Result<bool, Error> {
+    for index in (0..attributes.len() as isize).step_by(3) {
+        let object: Value = attributes.entry(index)?;
+        let attribute: Symbol = attributes.entry(index + 1)?;
+        let previous: Value = attributes.entry(index + 2)?;
+        if !identical(object.funcall(attribute, ())?, previous) {
+            return Ok(false);
+        }
+    }
+    for index in (0..containers.len() as isize).step_by(2) {
+        let object: Value = containers.entry(index)?;
+        let previous: Value = containers.entry(index + 1)?;
+        if let Some(string) = RString::from_value(object) {
+            let previous = RString::try_convert(previous)?;
+            if string.enc_get() != previous.enc_get()
+                || unsafe { string.as_slice() != previous.as_slice() }
+            {
+                return Ok(false);
+            }
+        } else if let Some(array) = RArray::from_value(object) {
+            let previous = RArray::try_convert(previous)?;
+            if array.len() != previous.len()
+                || !unsafe { array.as_slice().iter().zip(previous.as_slice()) }
+                    .all(|(&left, &right)| identical(left, right))
+            {
+                return Ok(false);
+            }
+        } else if let Some(hash) = RHash::from_value(object) {
+            let previous = RArray::try_convert(previous)?;
+            if hash.len() * 2 != previous.len() {
+                return Ok(false);
+            }
+            let mut index = 0;
+            let mut matches = true;
+            hash.foreach(|key: Value, value: Value| {
+                matches = identical(key, previous.entry(index)?)
+                    && identical(value, previous.entry(index + 1)?);
+                index += 2;
+                Ok(if matches {
+                    ForEach::Continue
+                } else {
+                    ForEach::Stop
+                })
+            })?;
+            if !matches {
+                return Ok(false);
+            }
+        }
+    }
+    Ok(true)
+}

data/ext/avrocadabra/src/validation.rs

@@ -0,0 +1,174 @@
+use apache_avro::{
+    AvroResult, Schema,
+    error::Details,
+    util,
+    validator::{
+        EnumSymbolNameValidator, RecordFieldNameValidator, SchemaNameValidator,
+        SchemaNamespaceValidator, set_enum_symbol_name_validator, set_record_field_name_validator,
+        set_schema_name_validator, set_schema_namespace_validator,
+    },
+};
+use std::sync::OnceLock;
+
+struct Validator;
+
+const NAME_PATTERN: &str = r"^((?P<namespace>([A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)*)?)\.)?(?P<name>[A-Za-z_][A-Za-z0-9_]*)$";
+const NAMESPACE_PATTERN: &str = r"^([A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)*)?$";
+
+fn identifier(value: &str) -> bool {
+    let mut bytes = value.bytes();
+    bytes
+        .next()
+        .is_some_and(|byte| byte.is_ascii_alphabetic() || byte == b'_')
+        && bytes.all(|byte| byte.is_ascii_alphanumeric() || byte == b'_')
+}
+
+fn namespace(value: &str) -> bool {
+    value.is_empty() || value.split('.').all(identifier)
+}
+
+impl SchemaNameValidator for Validator {
+    fn validate(&self, value: &str) -> AvroResult<usize> {
+        let index = value.rfind('.').map_or(0, |index| index + 1);
+        if identifier(&value[index..]) && (index == 0 || namespace(&value[..index - 1])) {
+            Ok(index)
+        } else {
+            Err(Details::InvalidSchemaName(value.into(), NAME_PATTERN).into())
+        }
+    }
+}
+
+impl SchemaNamespaceValidator for Validator {
+    fn validate(&self, value: &str) -> AvroResult<()> {
+        if namespace(value) {
+            Ok(())
+        } else {
+            Err(Details::InvalidNamespace(value.into(), NAMESPACE_PATTERN).into())
+        }
+    }
+}
+
+impl EnumSymbolNameValidator for Validator {
+    fn validate(&self, value: &str) -> AvroResult<()> {
+        if identifier(value) {
+            Ok(())
+        } else {
+            Err(Details::EnumSymbolName(value.into()).into())
+        }
+    }
+}
+
+impl RecordFieldNameValidator for Validator {
+    fn validate(&self, value: &str) -> AvroResult<()> {
+        if identifier(value) {
+            Ok(())
+        } else {
+            Err(Details::FieldName(value.into()).into())
+        }
+    }
+}
+
+pub(crate) fn initialize() -> Result<(), String> {
+    static INITIALIZED: OnceLock<Result<(), &'static str>> = OnceLock::new();
+    INITIALIZED
+        .get_or_init(|| {
+            // Apache's default regex caches contain mutexes that can remain locked after fork.
+            set_schema_name_validator(Box::new(Validator))
+                .map_err(|_| "Apache schema-name validator was initialized before Avrocadabra")?;
+            set_schema_namespace_validator(Box::new(Validator))
+                .map_err(|_| "Apache namespace validator was initialized before Avrocadabra")?;
+            set_enum_symbol_name_validator(Box::new(Validator))
+                .map_err(|_| "Apache enum validator was initialized before Avrocadabra")?;
+            set_record_field_name_validator(Box::new(Validator))
+                .map_err(|_| "Apache field-name validator was initialized before Avrocadabra")?;
+            util::max_allocation_bytes(util::DEFAULT_MAX_ALLOCATION_BYTES);
+            util::set_serde_human_readable(util::DEFAULT_SERDE_HUMAN_READABLE);
+            let _ = Schema::Null == Schema::Int;
+            Ok(())
+        })
+        .map_err(str::to_owned)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    struct Original;
+    impl SchemaNameValidator for Original {}
+    impl SchemaNamespaceValidator for Original {}
+    impl EnumSymbolNameValidator for Original {}
+    impl RecordFieldNameValidator for Original {}
+
+    #[test]
+    fn ascii_validation_matches_apache_regex_rules() {
+        initialize().unwrap();
+        let alphabet = ['A', 'z', '0', '_', '.', '-', 'é', '\n', ' '];
+        let mut values = vec![String::new()];
+        let mut frontier = vec![String::new()];
+        for _ in 0..4 {
+            frontier = frontier
+                .iter()
+                .flat_map(|prefix| {
+                    alphabet
+                        .iter()
+                        .map(move |character| format!("{prefix}{character}"))
+                })
+                .collect();
+            values.extend(frontier.iter().cloned());
+        }
+        values.extend(
+            [
+                "example.Name",
+                "example.deep.Name",
+                ".Name",
+                "example.",
+                ".example.Name",
+                "__Name9",
+            ]
+            .map(str::to_owned),
+        );
+        for value in values {
+            assert_eq!(
+                SchemaNameValidator::validate(&Validator, &value).ok(),
+                SchemaNameValidator::validate(&Original, &value).ok(),
+                "schema name {value:?}"
+            );
+            assert_eq!(
+                SchemaNamespaceValidator::validate(&Validator, &value).is_ok(),
+                SchemaNamespaceValidator::validate(&Original, &value).is_ok(),
+                "namespace {value:?}"
+            );
+            assert_eq!(
+                EnumSymbolNameValidator::validate(&Validator, &value).is_ok(),
+                EnumSymbolNameValidator::validate(&Original, &value).is_ok(),
+                "enum symbol {value:?}"
+            );
+            assert_eq!(
+                RecordFieldNameValidator::validate(&Validator, &value).is_ok(),
+                RecordFieldNameValidator::validate(&Original, &value).is_ok(),
+                "field name {value:?}"
+            );
+        }
+    }
+
+    #[test]
+    fn initialization_is_idempotent_and_names_keep_enclosing_namespace_rules() {
+        initialize().unwrap();
+        initialize().unwrap();
+        use apache_avro::schema::Name;
+        for (name, enclosing, expected) in [
+            ("Value", None, "Value"),
+            ("Value", Some(""), "Value"),
+            ("Value", Some("outer.ns"), "outer.ns.Value"),
+            ("own.Value", Some("outer.ns"), "own.Value"),
+            (".Value", Some("outer.ns"), "Value"),
+        ] {
+            assert_eq!(
+                Name::new_with_enclosing_namespace(name, enclosing)
+                    .unwrap()
+                    .fullname(None),
+                expected
+            );
+        }
+    }
+}

data/ext/avrocadabra/src/wire.rs

@@ -0,0 +1,269 @@
+use apache_avro::{
+    Schema,
+    schema::{InnerDecimalSchema, NamesRef, RecordField, RecordSchema, UnionSchema, UuidSchema},
+    types::Value,
+};
+use serde::{
+    Deserialize, Deserializer, Serialize, Serializer,
+    de::{MapAccess, SeqAccess, Visitor},
+    ser::{Error, SerializeMap, SerializeSeq, SerializeStruct},
+};
+use std::fmt;
+
+// Serde retains map order. A named one-field record represents each enum's wire index
+// because Serde's enum serializer requires static symbol names.
+pub fn schema(schema: &Schema) -> Result<Schema, String> {
+    Ok(match schema {
+        Schema::Enum(value) => Schema::Record(
+            RecordSchema::builder()
+                .name(value.name.clone())
+                .aliases(value.aliases.clone())
+                .fields(vec![
+                    RecordField::builder()
+                        .name("index")
+                        .schema(Schema::Int)
+                        .build(),
+                ])
+                .build(),
+        ),
+        Schema::Record(value) => {
+            let mut value = value.clone();
+            for field in &mut value.fields {
+                field.schema = self::schema(&field.schema)?;
+                field.default = None;
+            }
+            Schema::Record(value)
+        }
+        Schema::Array(value) => {
+            let mut value = value.clone();
+            value.items = Box::new(self::schema(&value.items)?);
+            Schema::Array(value)
+        }
+        Schema::Map(value) => {
+            let mut value = value.clone();
+            value.types = Box::new(self::schema(&value.types)?);
+            Schema::Map(value)
+        }
+        Schema::Union(value) => Schema::Union(
+            UnionSchema::new(
+                value
+                    .variants()
+                    .iter()
+                    .map(self::schema)
+                    .collect::<Result<_, _>>()?,
+            )
+            .map_err(|error| error.to_string())?,
+        ),
+        Schema::Decimal(value) => match &value.inner {
+            InnerDecimalSchema::Bytes => Schema::Bytes,
+            InnerDecimalSchema::Fixed(value) => Schema::Fixed(value.clone()),
+        },
+        Schema::BigDecimal | Schema::Uuid(UuidSchema::Bytes) => Schema::Bytes,
+        Schema::Uuid(UuidSchema::String) => Schema::String,
+        Schema::Duration(value) | Schema::Uuid(UuidSchema::Fixed(value)) => {
+            Schema::Fixed(value.clone())
+        }
+        Schema::Date | Schema::TimeMillis => Schema::Int,
+        Schema::TimeMicros
+        | Schema::TimestampMillis
+        | Schema::TimestampMicros
+        | Schema::TimestampNanos
+        | Schema::LocalTimestampMillis
+        | Schema::LocalTimestampMicros
+        | Schema::LocalTimestampNanos => Schema::Long,
+        value => value.clone(),
+    })
+}
+
+pub struct Datum(pub Value);
+
+struct DatumRef<'a>(&'a Value);
+
+impl Serialize for Datum {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        DatumRef(&self.0).serialize(serializer)
+    }
+}
+
+impl Serialize for DatumRef<'_> {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        match self.0 {
+            Value::Null => serializer.serialize_unit(),
+            Value::Boolean(value) => serializer.serialize_bool(*value),
+            Value::Int(value) | Value::Date(value) | Value::TimeMillis(value) => {
+                serializer.serialize_i32(*value)
+            }
+            Value::Long(value)
+            | Value::TimeMicros(value)
+            | Value::TimestampMillis(value)
+            | Value::TimestampMicros(value)
+            | Value::TimestampNanos(value)
+            | Value::LocalTimestampMillis(value)
+            | Value::LocalTimestampMicros(value)
+            | Value::LocalTimestampNanos(value) => serializer.serialize_i64(*value),
+            Value::Float(value) => serializer.serialize_f32(*value),
+            Value::Double(value) => serializer.serialize_f64(*value),
+            Value::String(value) => serializer.serialize_str(value),
+            Value::Bytes(value) | Value::Fixed(_, value) => serializer.serialize_bytes(value),
+            Value::Enum(index, _) => {
+                let mut record = serializer.serialize_struct("", 1)?;
+                record.serialize_field("index", &(*index as i32))?;
+                record.end()
+            }
+            Value::Union(index, value) => {
+                serializer.serialize_newtype_variant("", *index, "", &DatumRef(value))
+            }
+            Value::Array(values) => {
+                let mut seq = serializer.serialize_seq(Some(values.len()))?;
+                for value in values {
+                    seq.serialize_element(&DatumRef(value))?;
+                }
+                seq.end()
+            }
+            Value::Record(values) => {
+                let mut map = serializer.serialize_map(Some(values.len()))?;
+                for (key, value) in values {
+                    map.serialize_entry(key, &DatumRef(value))?;
+                }
+                map.end()
+            }
+            Value::Decimal(value) => value.serialize(serializer),
+            Value::BigDecimal(value) => serializer
+                .serialize_bytes(&crate::big_decimal::encode(value).map_err(S::Error::custom)?),
+            Value::Duration(value) => serializer.serialize_bytes(&<[u8; 12]>::from(*value)),
+            Value::Map(_) | Value::Uuid(_) => {
+                Err(S::Error::custom("unordered or unconverted datum"))
+            }
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for Datum {
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        deserializer.deserialize_any(DatumVisitor)
+    }
+}
+
+struct DatumVisitor;
+
+struct Key(String);
+
+impl<'de> Deserialize<'de> for Key {
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        match deserializer.deserialize_identifier(DatumVisitor)? {
+            Datum(Value::String(key)) => Ok(Self(key)),
+            _ => Err(serde::de::Error::custom("expected string key")),
+        }
+    }
+}
+
+impl<'de> Visitor<'de> for DatumVisitor {
+    type Value = Datum;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter.write_str("an Avro datum")
+    }
+
+    fn visit_unit<E>(self) -> Result<Datum, E> {
+        Ok(Datum(Value::Null))
+    }
+    fn visit_bool<E>(self, value: bool) -> Result<Datum, E> {
+        Ok(Datum(Value::Boolean(value)))
+    }
+    fn visit_i32<E>(self, value: i32) -> Result<Datum, E> {
+        Ok(Datum(Value::Int(value)))
+    }
+    fn visit_i64<E>(self, value: i64) -> Result<Datum, E> {
+        Ok(Datum(Value::Long(value)))
+    }
+    fn visit_f32<E>(self, value: f32) -> Result<Datum, E> {
+        Ok(Datum(Value::Float(value)))
+    }
+    fn visit_f64<E>(self, value: f64) -> Result<Datum, E> {
+        Ok(Datum(Value::Double(value)))
+    }
+    fn visit_string<E>(self, value: String) -> Result<Datum, E> {
+        Ok(Datum(Value::String(value)))
+    }
+    fn visit_str<E>(self, value: &str) -> Result<Datum, E> {
+        Ok(Datum(Value::String(value.to_owned())))
+    }
+    fn visit_byte_buf<E>(self, value: Vec<u8>) -> Result<Datum, E> {
+        Ok(Datum(Value::Bytes(value)))
+    }
+    fn visit_bytes<E>(self, value: &[u8]) -> Result<Datum, E> {
+        Ok(Datum(Value::Bytes(value.to_owned())))
+    }
+
+    fn visit_seq<A: SeqAccess<'de>>(self, mut seq: A) -> Result<Datum, A::Error> {
+        let mut values = Vec::new();
+        while let Some(Datum(value)) = seq.next_element()? {
+            values.push(value);
+        }
+        Ok(Datum(Value::Array(values)))
+    }
+
+    fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Datum, A::Error> {
+        let mut values = Vec::new();
+        while let Some((Key(key), Datum(value))) = map.next_entry()? {
+            values.push((key, value));
+        }
+        Ok(Datum(Value::Record(values)))
+    }
+}
+
+pub fn materialize(
+    value: Value,
+    schema: &Schema,
+    names: &NamesRef<'_>,
+    unions: &mut impl Iterator<Item = u32>,
+) -> Result<Value, String> {
+    match (schema, value) {
+        (Schema::Ref { name }, value) => materialize(
+            value,
+            names.get(name).ok_or("unresolved wire schema")?,
+            names,
+            unions,
+        ),
+        (Schema::Union(union), value) => {
+            let index = unions.next().ok_or("missing union index")?;
+            let branch = union
+                .variants()
+                .get(index as usize)
+                .ok_or("invalid union index")?;
+            Ok(Value::Union(
+                index,
+                Box::new(materialize(value, branch, names, unions)?),
+            ))
+        }
+        (Schema::Record(record), Value::Record(values)) => values
+            .into_iter()
+            .zip(&record.fields)
+            .map(|((key, value), field)| {
+                Ok((key, materialize(value, &field.schema, names, unions)?))
+            })
+            .collect::<Result<_, _>>()
+            .map(Value::Record),
+        (Schema::Map(map), Value::Record(values)) => values
+            .into_iter()
+            .map(|(key, value)| Ok((key, materialize(value, &map.types, names, unions)?)))
+            .collect::<Result<_, _>>()
+            .map(Value::Record),
+        (Schema::Array(array), Value::Array(values)) => values
+            .into_iter()
+            .map(|value| materialize(value, &array.items, names, unions))
+            .collect::<Result<_, _>>()
+            .map(Value::Array),
+        (Schema::Enum(enumeration), Value::Record(mut values)) => {
+            let Some((_, Value::Int(index))) = values.pop() else {
+                return Err("invalid enum index".into());
+            };
+            let symbol = enumeration
+                .symbols
+                .get(index as usize)
+                .ok_or("invalid enum index")?;
+            Ok(Value::Enum(index as u32, symbol.clone()))
+        }
+        (schema, value) => crate::resolution::logical_value(value, schema),
+    }
+}

data/lib/avrocadabra/avro_turf/cache.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Avrocadabra
+  module AvroTurf
+    class Cache
+      LIMIT = 128
+
+      def initialize
+        @entries = {}.compare_by_identity
+        @mutex = Mutex.new
+      end
+
+      def fetch(schema)
+        codec = @mutex.synchronize { @entries[schema] }
+        return codec if codec&.current?
+
+        @mutex.synchronize do
+          codec = @entries[schema]
+          return codec if codec&.current?
+
+          codec = Codec.new(schema)
+          @entries.shift if !@entries.key?(schema) && @entries.size >= LIMIT
+          @entries[schema] = codec
+        end
+      end
+    end
+  end
+end

data/lib/avrocadabra/avro_turf/codec.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Avrocadabra
+  module AvroTurf
+    class Codec
+      attr_reader :source
+
+      def initialize(source)
+        @source = source
+        @state = SchemaState.new(source)
+        @mapping = Mapping.new(source, @state.schemas)
+        document = source.to_avro
+        prepare_document(source, document)
+        @native = Schema.new(JSON.generate(document)).__send__(:native)
+      rescue SchemaError => e
+        raise ::Avro::SchemaParseError, e.message
+      end
+
+      def encode(datum)
+        @native.encode(datum, false, @mapping.native)
+      rescue EncodeError => e
+        raise ::Avro::IO::AvroTypeError.new(@source, datum), cause: e
+      end
+
+      def current?
+        @state.current?
+      end
+
+      def read(decoder, reader)
+        @native.decode(decoder.reader, reader.native, false, false, reader.mapping.native)
+      rescue ResolutionError => e
+        if e.message.include?("reader field is absent from writer schema and has no default")
+          raise ::Avro::AvroError, e.message
+        end
+
+        raise ::Avro::IO::SchemaMatchException.new(source, reader.source), cause: e
+      rescue DecodeError => e
+        raise EOFError, e.message if e.message.include?("truncated")
+
+        raise ::Avro::AvroError, e.message
+      end
+
+      private
+
+      def prepare_document(source, document)
+        document.delete("logicalType") if document.is_a?(Hash)
+        case source.type_sym
+        when :record, :error
+          return if document.is_a?(String)
+
+          source.fields.zip(document.fetch("fields")) do |field, entry|
+            entry["aliases"] = field.aliases if field.aliases
+            prepare_document(field.type, entry.fetch("type"))
+          end
+        when :array
+          prepare_document(source.items, document.fetch("items"))
+        when :map
+          prepare_document(source.values, document.fetch("values"))
+        when :union
+          source.schemas.zip(document) { |branch, entry| prepare_document(branch, entry) }
+        end
+      end
+
+      protected
+
+      attr_reader :mapping, :native
+    end
+  end
+end

data/lib/avrocadabra/avro_turf/datum_reader.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Avrocadabra
+  module AvroTurf
+    module DatumReader
+      def read(decoder)
+        cache = Thread.current[:avrocadabra_codecs]
+        return super unless cache && decoder.instance_of?(::Avro::IO::BinaryDecoder) && decoder.reader.is_a?(StringIO)
+
+        self.readers_schema = writers_schema unless readers_schema
+        writer = cache.fetch(writers_schema)
+        reader = readers_schema.equal?(writers_schema) ? writer : cache.fetch(readers_schema)
+        writer.read(decoder, reader)
+      end
+    end
+  end
+end

data/lib/avrocadabra/avro_turf/datum_writer.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Avrocadabra
+  module AvroTurf
+    module DatumWriter
+      def write(datum, encoder)
+        cache = Thread.current[:avrocadabra_codecs]
+        return super unless cache && encoder.instance_of?(::Avro::IO::BinaryEncoder)
+
+        encoder.write(cache.fetch(writers_schema).encode(datum))
+      end
+    end
+  end
+end

data/lib/avrocadabra/avro_turf/mapping.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Avrocadabra
+  module AvroTurf
+    class Mapping
+      attr_reader :native
+
+      def initialize(source, schemas)
+        nodes = {}.compare_by_identity
+        schemas.each do |schema|
+          adapter = schema.type_adapter
+          nodes[schema] = [schema, adapter == ::Avro::LogicalTypes::Identity ? nil : adapter]
+        end
+        nodes.each do |schema, node|
+          node.push(children(schema).map { nodes.fetch(it) }.freeze).freeze
+        end
+        @native = [self, nodes.fetch(source)].freeze
+        @reader = ::Avro::IO::DatumReader.new
+      end
+
+      def union_index(schema, value, budget)
+        schema.schemas.index { ::Avro::Schema.validate(it, value, avrocadabra_budget: budget) } ||
+          raise(encoding_error(schema, value))
+      end
+
+      def default_value(schema, name)
+        field = schema.fields_hash.fetch(name)
+        @reader.read_default_value(field.type, field.default)
+      end
+
+      def encoding_error(schema, value)
+        ::Avro::IO::AvroTypeError.new(schema, value)
+      end
+
+      private
+
+      def children(schema)
+        case schema.type_sym
+        when :record, :error then schema.fields.map(&:type)
+        when :array then [schema.items]
+        when :map then [schema.values]
+        when :union then schema.schemas
+        else []
+        end
+      end
+    end
+  end
+end

data/lib/avrocadabra/avro_turf/messaging.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Avrocadabra
+  module AvroTurf
+    class Messaging < ::AvroTurf::Messaging
+      def initialize(...)
+        @avrocadabra_codecs = Cache.new
+        super
+      end
+    end
+  end
+end