evt-messaging 0.7.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9395b1e320f5ac8d62251b28f6bb03d24e2c9d76
+  data.tar.gz: 0afc6dd4852ba62cd022e99f4604a9b84eeeeaed
+SHA512:
+  metadata.gz: 2561a6d77b386d0ee6728fd970e767cdc2859e8abd456922a2750d8b19f4897ba95c695e48b7e2745ff71f5a7c46f5fa289f5cbc89ea83d57214ed2b970ea0a1
+  data.tar.gz: 3669488d065b94042d98e4945a6ba0865f76da4ac1739c6bbde29a9a15c86ca18a3ed198c386d264c919fa0bd492489c45267c995bf9781979692b5ee25d1e7e

data/lib/loader.rb

@@ -0,0 +1 @@
+messaging.rb

data/lib/messaging.rb

@@ -0,0 +1,19 @@
+require 'event_source'
+
+require 'messaging/stream_name'
+
+require 'messaging/message'
+require 'messaging/message/metadata'
+require 'messaging/message/copy'
+require 'messaging/message/follow'
+
+require 'messaging/message/transformer'
+require 'messaging/message/import'
+require 'messaging/message/export'
+
+require 'messaging/log'
+require 'messaging/write'
+require 'messaging/write/substitute'
+
+require 'messaging/message_registry'
+require 'messaging/handle'

data/lib/messaging/controls.rb

@@ -0,0 +1,12 @@
+require 'clock/controls'
+require 'event_source/controls'
+
+require 'messaging/controls/time'
+require 'messaging/controls/stream'
+require 'messaging/controls/stream_name'
+require 'messaging/controls/event_data'
+require 'messaging/controls/message'
+require 'messaging/controls/metadata'
+require 'messaging/controls/batch'
+require 'messaging/controls/write'
+require 'messaging/controls/handler'

data/lib/messaging/controls/batch.rb

@@ -0,0 +1,29 @@
+module Messaging
+  module Controls
+    module Batch
+      def self.example
+        values = [
+          EventSource::Controls::RandomValue.example,
+          EventSource::Controls::RandomValue.example
+        ]
+
+        batch = Messages.example
+
+        2.times do |i|
+          batch[i].some_attribute = values[i]
+        end
+
+        return batch, values
+      end
+
+      module Messages
+        def self.example
+          [
+            Controls::Message.example,
+            Controls::Message.example
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/messaging/controls/event_data.rb

@@ -0,0 +1,5 @@
+module Messaging
+  module Controls
+    EventData = EventSource::Controls::EventData
+  end
+end

data/lib/messaging/controls/handler.rb

@@ -0,0 +1,47 @@
+module Messaging
+  module Controls
+    module Handler
+      class Example
+        include Messaging::Handle
+        include Controls::Message
+
+        handle SomeMessage do |some_message|
+          some_message.some_attribute = 'some value set by handler'
+        end
+      end
+
+      module HandleMethod
+        class Example
+          include Messaging::Handle
+
+          def handle(event_data)
+            event_data.data = 'some value set by handle method'
+          end
+        end
+      end
+
+      module BlockAndHandleMethod
+        class Example
+          include Messaging::Handle
+          include Controls::Message
+
+          handle SomeMessage do |some_message|
+            some_message.some_attribute = 'some attribute value set by handler'
+          end
+
+          def handle(event_data)
+            event_data.data = 'some data value set by handler'
+          end
+        end
+      end
+
+      module Anomaly
+        module NoHandle
+          class Example
+            include Messaging::Handle
+          end
+        end
+      end
+    end
+  end
+end

data/lib/messaging/controls/message.rb

@@ -0,0 +1,67 @@
+module Messaging
+  module Controls
+    module Message
+      def self.example(some_attribute: nil, metadata: nil)
+        some_attribute ||= attribute
+        metadata ||= Controls::Metadata.example
+
+        message = SomeMessage.new
+        message.some_attribute = some_attribute
+        message.other_attribute = other_attribute
+
+        message.metadata = metadata
+
+        message
+      end
+
+      module New
+        def self.example
+          Message::SomeMessage.new
+        end
+      end
+
+      class SomeMessage
+        include Messaging::Message
+
+        attribute :some_attribute
+        attribute :other_attribute
+      end
+
+      class OtherMessage
+        include Messaging::Message
+
+        attribute :an_attribute
+        attribute :other_attribute
+      end
+
+      class SingleAttribute
+        include Messaging::Message
+
+        attribute :some_attribute
+      end
+
+      def self.message_class
+        SomeMessage
+      end
+
+      def self.type
+        'SomeMessage'
+      end
+
+      def self.attribute
+        'some value'
+      end
+
+      def self.other_attribute
+        'other value'
+      end
+
+      def self.data
+        {
+          some_attribute: attribute,
+          other_attribute: other_attribute
+        }
+      end
+    end
+  end
+end

data/lib/messaging/controls/metadata.rb

@@ -0,0 +1,100 @@
+module Messaging
+  module Controls
+    module Metadata
+      def self.example
+        Messaging::Message::Metadata.build(data)
+      end
+
+      def self.source_event_stream_name
+        'someSource'
+      end
+
+      def self.source_event_position
+        1
+      end
+
+      def self.causation_event_stream_name
+        "someCausation"
+      end
+
+      def self.causation_event_position
+        11
+      end
+
+      def self.correlation_stream_name
+        "someCorrelation"
+      end
+
+      def self.reply_stream_name
+        "someReply"
+      end
+
+      def self.schema_version
+        11
+      end
+
+      def self.source_event_identifier
+        "#{source_event_stream_name}/#{source_event_position}"
+      end
+
+      def self.causation_event_identifier
+        "#{causation_event_stream_name}/#{causation_event_position}"
+      end
+
+      def self.global_position
+        111
+      end
+
+      def self.time
+        Time::Raw.example
+      end
+
+      def self.data
+        {
+          source_event_stream_name: source_event_stream_name,
+          source_event_position: source_event_position,
+
+          causation_event_stream_name: causation_event_stream_name,
+          causation_event_position: causation_event_position,
+
+          correlation_stream_name: correlation_stream_name,
+
+          reply_stream_name: reply_stream_name,
+
+          global_position: global_position,
+          time: time,
+
+          schema_version: schema_version
+        }
+      end
+
+      module New
+        def self.example
+          ::Messaging::Message::Metadata.new
+        end
+      end
+      Empty = New
+
+      module Written
+        def self.example
+          Messaging::Message::Metadata.build(data)
+        end
+
+        def self.data
+          data = Metadata.data
+
+          [
+            :source_event_stream_name,
+            :source_event_position,
+            :global_position,
+            :time
+          ].each do |not_written_attribute|
+            data.delete(not_written_attribute)
+          end
+
+          data
+        end
+      end
+    end
+  end
+end

data/lib/messaging/controls/stream.rb

@@ -0,0 +1,5 @@
+module Messaging
+  module Controls
+    Stream = EventSource::Controls::Stream
+  end
+end

data/lib/messaging/controls/stream_name.rb

@@ -0,0 +1,19 @@
+module Messaging
+  module Controls
+    StreamName = EventSource::Controls::StreamName
+
+    module StreamName
+      module Named
+        def self.example
+          Example.new
+        end
+
+        class Example
+          include Messaging::StreamName
+
+          category :some_category
+        end
+      end
+    end
+  end
+end

data/lib/messaging/controls/time.rb

@@ -0,0 +1,5 @@
+module Messaging
+  module Controls
+    Time = Clock::Controls::Time
+  end
+end

data/lib/messaging/controls/write.rb

@@ -0,0 +1,15 @@
+module Messaging
+  module Controls
+    module Write
+      def self.example
+        Example.build
+      end
+
+      class Example
+        include Messaging::Write
+
+        virtual :configure
+      end
+    end
+  end
+end

data/lib/messaging/handle.rb

@@ -0,0 +1,174 @@
+module Messaging
+  module Handle
+    class Error < RuntimeError; end
+
+    def self.included(cls)
+      cls.class_exec do
+        include Log::Dependency
+
+        cls.extend Build
+        cls.extend Call
+        cls.extend Info
+        cls.extend HandleMacro
+        cls.extend MessageRegistry
+
+        virtual :configure
+
+        attr_writer :strict
+      end
+    end
+
+    def strict
+      @strict ||= false
+    end
+
+    module Build
+      def build(strict: nil)
+        instance = new
+        instance.strict = strict
+        instance.configure
+        instance
+      end
+    end
+
+    module Call
+      def call(message_or_event_data, strict: nil)
+        instance = build(strict: strict)
+        instance.(message_or_event_data)
+      end
+    end
+
+    module Info
+      extend self
+
+      def handler(message_or_event_data)
+        name = handler_name(message_or_event_data)
+
+        if method_defined?(name)
+          return name
+        else
+          return nil
+        end
+      end
+
+      def handles?(message_or_event_data)
+        method_defined? handler_name(message_or_event_data)
+      end
+
+      def handler_name(message_or_event_data)
+        name = nil
+
+        if message_or_event_data.is_a? EventSource::EventData::Read
+          name = Messaging::Message::Info.canonize_name(message_or_event_data.type)
+        else
+          name = message_or_event_data.message_name
+        end
+
+        "handle_#{name}"
+      end
+    end
+
+    module HandleMacro
+      class Error < RuntimeError; end
+
+      def logger
+        @logger ||= Log.get(self)
+      end
+
+      def handle_macro(message_class, &blk)
+        define_handler_method(message_class, &blk)
+        message_registry.register(message_class)
+      end
+      alias :handle :handle_macro
+
+      def define_handler_method(message_class, &blk)
+        handler_method_name = handler_name(message_class)
+
+        if blk.nil?
+          error_msg = "Handler for #{message_class.name} is not correctly defined. It must have a block."
+          logger.error { error_msg }
+          raise Error, error_msg
+        end
+
+        send(:define_method, handler_method_name, &blk)
+
+        handler_method = instance_method(handler_method_name)
+
+        unless handler_method.arity == 1
+          error_msg = "Handler for #{message_class.name} is not correctly defined. It can only have a single parameter."
+          logger.error { error_msg }
+          raise Error, error_msg
+        end
+
+        handler_method_name
+      end
+    end
+
+    module MessageRegistry
+      def message_registry
+        @message_registry ||= Messaging::MessageRegistry.new
+      end
+    end
+
+    def call(message_or_event_data)
+      if message_or_event_data.is_a? Message
+        handle_message(message_or_event_data)
+      else
+        handle_event_data(message_or_event_data)
+      end
+    end
+
+    def handle_message(message)
+      logger.trace(tags: [:handle, :message]) { "Handling message (Message class: #{message.class.name})" }
+      logger.trace(tags: [:data, :message, :handle]) { message.pretty_inspect }
+
+      handler = self.class.handler(message)
+
+      unless handler.nil?
+        public_send(handler, message)
+      else
+        if strict
+          error_msg = "#{self.class.name} does not implement a handler for #{message.message_type}. Cannot handle the message."
+          logger.error { error_msg }
+          raise Error, error_msg
+        end
+      end
+
+      logger.info(tags: [:handle, :message]) { "Handled message (Message class: #{message.class.name})" }
+      logger.trace(tags: [:data, :message, :handle]) { message.pretty_inspect }
+
+      message
+    end
+
+    def handle_event_data(event_data)
+      logger.trace(tags: [:handle, :event_data]) { "Handling event data (Type: #{event_data.type})" }
+      logger.trace(tags: [:data, :event_data, :handle]) { event_data.pretty_inspect }
+
+      res = nil
+
+      handler = self.class.handler(event_data)
+
+      unless handler.nil?
+        message_name = Messaging::Message::Info.canonize_name(event_data.type)
+        message_class = self.class.message_registry.get(message_name)
+        res = Message::Import.(event_data, message_class)
+        public_send(handler, res)
+      else
+        if respond_to?(:handle)
+          res = handle(event_data)
+        else
+          if strict
+            error_msg = "#{self.class.name} does not implement `handle'. Cannot handle event data."
+            logger.error { error_msg }
+            raise Error, error_msg
+          end
+        end
+      end
+
+      logger.info(tags: [:handle, :event_data]) { "Handled event data (Type: #{event_data.type})" }
+      logger.info(tags: [:data, :event_data, :handle]) { event_data.pretty_inspect }
+
+      res
+    end
+  end
+end

data/lib/messaging/log.rb

@@ -0,0 +1,9 @@
+module Messaging
+  class Log < ::Log
+    def tag!(tags)
+      tags << :messaging
+      tags << :library
+      tags << :verbose
+    end
+  end
+end

data/lib/messaging/message.rb

@@ -0,0 +1,82 @@
+module Messaging
+  module Message
+    def self.included(cls)
+      cls.class_exec do
+        include Schema::DataStructure
+      end
+
+      cls.extend Info
+      cls.extend Build
+      cls.extend Copy
+      cls.extend Follow
+      cls.extend Transformer
+    end
+
+    attr_writer :metadata
+    def metadata
+      @metadata ||= Metadata.new
+    end
+
+    def message_type
+      self.class.message_type
+    end
+
+    def message_name
+      self.class.message_name
+    end
+
+    def follows?(other_message)
+      metadata.follows?(other_message.metadata)
+    end
+
+    module Info
+      extend self
+
+      def message_type(msg=self)
+        class_name(msg).split('::').last
+      end
+
+      def message_name(msg=self)
+        Info.canonize_name(message_type(msg))
+      end
+
+      def self.canonize_name(name)
+        name.gsub(/([^\^])([A-Z])/,'\1_\2').downcase
+      end
+
+      def class_name(message)
+        class_name = nil
+        class_name = message if message.instance_of? String
+        class_name ||= message.name if message.instance_of? Class
+        class_name ||= message.class.name
+        class_name
+      end
+    end
+
+    module Build
+      def build(data=nil, metadata=nil)
+        data ||= {}
+        metadata ||= {}
+
+        metadata = build_metadata(metadata)
+
+        new.tap do |instance|
+          set_attributes(instance, data)
+          instance.metadata = metadata
+        end
+      end
+
+      def set_attributes(instance, data)
+        SetAttributes.(instance, data)
+      end
+
+      def build_metadata(metadata)
+        if metadata.nil?
+          Metadata.new
+        else
+          Metadata.build(metadata.to_h)
+        end
+      end
+    end
+  end
+end

data/lib/messaging/message/copy.rb

@@ -0,0 +1,38 @@
+module Messaging
+  module Message
+    module Copy
+      class Error < RuntimeError; end
+
+      extend self
+
+      def self.call(source, receiver=nil, copy: nil, include: nil, exclude: nil, metadata: nil, strict: nil)
+        copy(source, receiver, copy: copy, include: include, exclude: exclude, metadata: metadata, strict: strict)
+      end
+
+      def copy(source, receiver=nil, copy: nil, include: nil, exclude: nil, metadata: nil, strict: nil)
+        metadata ||= false
+        strict = true if strict.nil?
+
+        if receiver.nil?
+          receiver = self
+        end
+
+        if receiver.class == Class
+          receiver = receiver.build
+        end
+
+        begin
+          SetAttributes.(receiver, source, copy: copy, include: include, exclude: exclude, strict: strict)
+        rescue SetAttributes::Attribute::Error => e
+          raise Error, e.message, e.backtrace
+        end
+
+        if metadata
+          SetAttributes.(receiver.metadata, source.metadata)
+        end
+
+        receiver
+      end
+    end
+  end
+end

data/lib/messaging/message/export.rb

@@ -0,0 +1,9 @@
+module Messaging
+  module Message
+    module Export
+      def self.call(event_data)
+        Transform::Write.(event_data, :event_data)
+      end
+    end
+  end
+end

data/lib/messaging/message/follow.rb

@@ -0,0 +1,37 @@
+module Messaging
+  module Message
+    module Follow
+      class Error < RuntimeError; end
+
+      extend self
+
+      def self.call(source, receiver=nil, copy: nil, include: nil, exclude: nil, strict: nil)
+        follow(source, receiver, copy: copy, include: include, exclude: exclude, strict: strict)
+      end
+
+      def follow(source, receiver=nil, copy: nil, include: nil, exclude: nil, strict: nil)
+        if receiver.nil?
+          receiver = self
+        end
+
+        if receiver.class == Class
+          receiver = receiver.build
+        end
+
+        unchanged_source_event_stream_name = receiver.metadata.source_event_stream_name
+        unchanged_source_event_position = receiver.metadata.source_event_position
+        unchanged_schema_version = receiver.metadata.schema_version
+
+        Copy.(source, receiver, copy: copy, include: include, exclude: exclude, strict: strict, metadata: true)
+
+        receiver.metadata.source_event_stream_name = unchanged_source_event_stream_name
+        receiver.metadata.source_event_position = unchanged_source_event_position
+        receiver.metadata.schema_version = unchanged_schema_version
+
+        receiver.metadata.follow(source.metadata)
+
+        receiver
+      end
+    end
+  end
+end

data/lib/messaging/message/import.rb

@@ -0,0 +1,9 @@
+module Messaging
+  module Message
+    module Import
+      def self.call(event_data, message_class)
+        Transform::Read.(event_data, :event_data, message_class)
+      end
+    end
+  end
+end

data/lib/messaging/message/metadata.rb

@@ -0,0 +1,58 @@
+module Messaging
+  module Message
+    class Metadata
+      class Error < RuntimeError; end
+
+      include Schema::DataStructure
+
+      attribute :source_event_stream_name
+      alias :stream_name :source_event_stream_name
+      attribute :source_event_position
+      alias :sequence :source_event_position
+      alias :position :source_event_position
+      alias :position= :source_event_position=
+
+      attribute :causation_event_stream_name
+      attribute :causation_event_position
+
+      attribute :correlation_stream_name
+
+      attribute :reply_stream_name
+
+      attribute :global_position
+      attribute :time
+
+      attribute :schema_version
+
+      def source_event_identifier
+        return nil if source_event_stream_name.nil? || source_event_position.nil?
+        "#{source_event_stream_name}/#{source_event_position}"
+      end
+
+      def causation_event_identifier
+        return nil if causation_event_stream_name.nil? || causation_event_position.nil?
+        "#{causation_event_stream_name}/#{causation_event_position}"
+      end
+
+      def follow(other_metadata)
+        self.causation_event_stream_name = other_metadata.source_event_stream_name
+        self.causation_event_position = other_metadata.source_event_position
+
+        unless follows?(other_metadata)
+          raise Error, "Metadata doesn't have precedence (Metadata: #{self.inspect}, Other Metadata #{other_metadata.inspect})"
+        end
+      end
+
+      def follows?(other_metadata)
+        causation_event_identifier == other_metadata.source_event_identifier &&
+
+          correlation_stream_name == other_metadata.correlation_stream_name &&
+          reply_stream_name == other_metadata.reply_stream_name
+      end
+
+      def clear_reply_stream_name
+        self.reply_stream_name = nil
+      end
+    end
+  end
+end

data/lib/messaging/message/transformer.rb

@@ -0,0 +1,54 @@
+module Messaging
+  module Message
+    module Transformer
+      def self.event_data
+        EventData
+      end
+
+      def self.raw_data(message)
+        message
+      end
+
+      def self.instance(event_data_data, cls)
+        cls.build(event_data_data[:data], event_data_data[:metadata])
+      end
+
+      module EventData
+        def self.write(message)
+          event_data = EventSource::EventData::Write.build
+
+          event_data.type = message.message_type
+
+          event_data.data = message.to_h
+
+          metadata = message.metadata.to_h
+          metadata.delete_if { |k, v| v.nil? || k == :source_event_stream_name || k == :source_event_position}
+
+          event_data.metadata = metadata
+
+          event_data
+        end
+
+        def self.read(event_data)
+          data = event_data.to_h
+
+          unless data[:metadata].nil?
+            data[:metadata] = data[:metadata].clone
+          else
+            data[:metadata] = {}
+          end
+
+          metadata = data[:metadata]
+
+          metadata[:source_event_stream_name] = data[:stream_name]
+          metadata[:source_event_position] = data[:position]
+
+          metadata[:global_position] = data[:global_position]
+          metadata[:time] = data[:time]
+
+          data
+        end
+      end
+    end
+  end
+end

data/lib/messaging/message_registry.rb

@@ -0,0 +1,40 @@
+module Messaging
+  class MessageRegistry
+    class Error < RuntimeError; end
+
+    include Log::Dependency
+
+    def entries
+      @entries ||= []
+    end
+
+    def get(message_name)
+      entries.find do |message_class|
+        message_class.message_name == message_name
+      end
+    end
+
+    def register(message_class)
+      logger.trace { "Registering #{message_class}"}
+      if registered?(message_class)
+        error_msg = "#{message_class} is already registered"
+        logger.error { error_msg }
+        raise Error, error_msg
+      end
+
+      entries << message_class
+
+      logger.debug { "Registered #{message_class}"}
+
+      entries
+    end
+
+    def registered?(message_class)
+      entries.include?(message_class)
+    end
+
+    def length
+      entries.length
+    end
+  end
+end

data/lib/messaging/stream_name.rb

@@ -0,0 +1,58 @@
+module Messaging
+  module StreamName
+    extend self
+
+    include EventSource::StreamName
+
+    def self.included(cls)
+      cls.extend Macro
+    end
+
+    def self.activate
+      target_class ||= Object
+      macro_module = Macro
+      return if target_class.is_a? macro_module
+      target_class.extend(macro_module)
+    end
+
+    module Macro
+      def category_macro(category)
+        category = Casing::Camel.(category, symbol_to_string: true)
+        self.send :define_method, :category do
+          @category || category
+        end
+      end
+      alias :category :category_macro
+    end
+
+    def stream_name(id, category=nil)
+      category ||= self.category
+      EventSource::StreamName.stream_name category, id
+    end
+
+    def command_stream_name(id, category=nil)
+      category ||= self.category
+      EventSource::StreamName.stream_name "#{category}:command", id
+    end
+
+    def category_stream_name(category=nil)
+      category ||= self.category
+      category
+    end
+
+    def command_category_stream_name(category=nil)
+      category ||= self.category
+      category_stream_name = category_stream_name(category)
+
+      "#{category_stream_name}:command"
+    end
+
+    def self.get_category(stream_name)
+      EventSource::StreamName.get_category(stream_name)
+    end
+
+    def self.get_id(stream_name)
+      EventSource::StreamName.get_id stream_name
+    end
+  end
+end

data/lib/messaging/write.rb

@@ -0,0 +1,138 @@
+module Messaging
+  module Write
+    class Error < RuntimeError; end
+
+    def self.included(cls)
+      cls.class_exec do
+        include Log::Dependency
+
+        dependency :event_writer
+        dependency :telemetry, ::Telemetry
+
+        cls.extend Build
+        cls.extend Call
+        cls.extend Configure
+
+        abstract :configure
+      end
+    end
+
+    module Build
+      def build(session: nil)
+        instance = new
+        instance.configure(session: session)
+        ::Telemetry.configure instance
+        instance
+      end
+    end
+
+    module Configure
+      def configure(receiver, session: nil, attr_name: nil)
+        attr_name ||= :write
+        instance = build(session: session)
+        receiver.public_send "#{attr_name}=", instance
+      end
+    end
+
+    module Call
+      def call(message, stream_name, expected_version: nil, reply_stream_name: nil, session: nil)
+        instance = build(session: session)
+        instance.(message, stream_name, expected_version: expected_version, reply_stream_name: reply_stream_name)
+      end
+    end
+
+    def call(message_or_batch, stream_name, expected_version: nil, reply_stream_name: nil)
+      unless message_or_batch.is_a? Array
+        logger.trace { "Writing message (Stream Name: #{stream_name}, Type: #{message_or_batch.class.message_type}, Expected Version: #{expected_version.inspect}, Reply Stream Name: #{reply_stream_name.inspect})" }
+      else
+        logger.trace { "Writing batch (Stream Name: #{stream_name}, Expected Version: #{expected_version.inspect}, Reply Stream Name: #{reply_stream_name.inspect})" }
+      end
+      logger.trace(tags: [:data, :message]) { message_or_batch.pretty_inspect }
+
+      message_batch = Array(message_or_batch)
+
+      event_data_batch = event_data_batch(message_batch, reply_stream_name)
+      last_position = event_writer.(event_data_batch, stream_name, expected_version: expected_version)
+
+      unless message_or_batch.is_a? Array
+        logger.info { "Wrote message (Position: #{last_position}, Stream Name: #{stream_name}, Type: #{message_or_batch.class.message_type}, Expected Version: #{expected_version.inspect}, Reply Stream Name: #{reply_stream_name.inspect})" }
+      else
+        logger.info { "Wrote batch (Position: #{last_position}, Stream Name: #{stream_name}, Expected Version: #{expected_version.inspect}, Reply Stream Name: #{reply_stream_name.inspect})" }
+      end
+      logger.info(tags: [:data, :message]) { event_data_batch.pretty_inspect }
+
+      message_batch.each do |message|
+        telemetry.record :written, Telemetry::Data.new(message, stream_name, expected_version, reply_stream_name)
+      end
+
+      last_position
+    end
+    alias :write :call
+
+    def event_data_batch(message_batch, reply_stream_name=nil)
+      event_data_batch = []
+      message_batch.each do |message|
+        unless reply_stream_name.nil?
+           message.metadata.reply_stream_name = reply_stream_name
+        end
+
+        event_data_batch << Message::Export.(message)
+      end
+
+      event_data_batch
+    end
+
+    def reply(message)
+      if message.is_a? Array
+        error_msg = "Cannot reply with a batch"
+        logger.error { error_msg }
+        raise Error, error_msg
+      end
+
+      metadata = message.metadata
+      reply_stream_name = metadata.reply_stream_name
+
+      logger.trace { "Replying (Message Type: #{message.message_type}, Stream Name: #{reply_stream_name.inspect})" }
+
+      if reply_stream_name.nil?
+        error_msg = "Message has no reply stream name. Cannot reply. (Message Type: #{message.message_type})"
+        logger.error { error_msg }
+        logger.error(tags: [:data, :message]) { message.pretty_inspect }
+        raise Error, error_msg
+      end
+
+      metadata.clear_reply_stream_name
+
+      write(message, reply_stream_name).tap do
+        logger.info { "Replied (Message Type: #{message.message_type}, Stream Name: #{reply_stream_name})" }
+        telemetry.record :replied, Telemetry::Data.new(message, reply_stream_name)
+      end
+    end
+
+    def initial(message, stream_name)
+      write(message, stream_name, expected_version: :no_stream)
+    end
+    alias :write_initial :initial
+
+    def self.register_telemetry_sink(writer)
+      sink = Telemetry.sink
+      writer.telemetry.register sink
+      sink
+    end
+
+    module Telemetry
+      class Sink
+        include ::Telemetry::Sink
+
+        record :written
+        record :replied
+      end
+
+      Data = Struct.new :message, :stream_name, :expected_version, :reply_stream_name
+
+      def self.sink
+        Sink.new
+      end
+    end
+  end
+end

data/lib/messaging/write/substitute.rb

@@ -0,0 +1,64 @@
+module Messaging
+  module Write
+    module Substitute
+      def self.build
+        Substitute::Write.build.tap do |substitute_writer|
+          sink = Messaging::Write.register_telemetry_sink(substitute_writer)
+          substitute_writer.sink = sink
+        end
+      end
+
+      class Write
+        include Messaging::Write
+
+        attr_accessor :sink
+
+        def self.build(session: nil)
+          new.tap do |instance|
+            ::Telemetry.configure instance
+          end
+        end
+
+        def writes(&blk)
+          if blk.nil?
+            return sink.written_records
+          end
+
+          sink.written_records.select do |record|
+            blk.call(record.data.message, record.data.stream_name, record.data.expected_version, record.data.reply_stream_name)
+          end
+        end
+
+        def written?(&blk)
+          if blk.nil?
+            return sink.recorded_written?
+          end
+
+          sink.recorded_written? do |record|
+            blk.call(record.data.message, record.data.stream_name, record.data.expected_version, record.data.reply_stream_name)
+          end
+        end
+
+        def replies(&blk)
+          if blk.nil?
+            return sink.replied_records
+          end
+
+          sink.replied_records.select do |record|
+            blk.call(record.data.message, record.data.stream_name)
+          end
+        end
+
+        def replied?(&blk)
+          if blk.nil?
+            return sink.recorded_replied?
+          end
+
+          sink.recorded_replied? do |record|
+            blk.call(record.data.message, record.data.stream_name)
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: evt-messaging
+version: !ruby/object:Gem::Version
+  version: 0.7.1.0
+platform: ruby
+authors:
+- The Eventide Project
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-12-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: evt-event_source
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ntl-test_bench
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: " "
+email: opensource@eventide-project.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/loader.rb
+- lib/messaging.rb
+- lib/messaging/controls.rb
+- lib/messaging/controls/batch.rb
+- lib/messaging/controls/event_data.rb
+- lib/messaging/controls/handler.rb
+- lib/messaging/controls/message.rb
+- lib/messaging/controls/metadata.rb
+- lib/messaging/controls/stream.rb
+- lib/messaging/controls/stream_name.rb
+- lib/messaging/controls/time.rb
+- lib/messaging/controls/write.rb
+- lib/messaging/handle.rb
+- lib/messaging/log.rb
+- lib/messaging/message.rb
+- lib/messaging/message/copy.rb
+- lib/messaging/message/export.rb
+- lib/messaging/message/follow.rb
+- lib/messaging/message/import.rb
+- lib/messaging/message/metadata.rb
+- lib/messaging/message/transformer.rb
+- lib/messaging/message_registry.rb
+- lib/messaging/stream_name.rb
+- lib/messaging/write.rb
+- lib/messaging/write/substitute.rb
+homepage: https://github.com/eventide-project/messaging
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: Messaging primitives for Eventide
+test_files: []