event_sourcery 0.13.0

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "event_sourcery"
+require "pry"
+Pry.start

data/bin/setup

@@ -0,0 +1,15 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+echo
+echo "--- Bundling"
+echo
+
+bundle install
+
+echo
+echo "--- Preparing databases"
+echo
+
+createdb event_sourcery_test

data/event_sourcery.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'event_sourcery/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'event_sourcery'
+  spec.version       = EventSourcery::VERSION
+  spec.authors     = ['Steve Hodgkiss', 'Tao Guo', 'Sebastian von Conrad']
+  spec.email       = ['steve@hodgkiss.me', 'tao.guo@envato.com', 'sebastian.von.conrad@envato.com']
+
+  spec.summary       = 'Event Sourcing Library'
+  spec.description   = ''
+  spec.homepage      = 'https://github.com/envato/event_sourcery'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.required_ruby_version = '>= 2.2.0'
+
+  spec.add_development_dependency 'bundler', '~> 1.10'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'benchmark-ips'
+end

data/lib/event_sourcery.rb

@@ -0,0 +1,49 @@
+require 'json'
+require 'securerandom'
+require 'time'
+
+require 'event_sourcery/version'
+require 'event_sourcery/event'
+require 'event_sourcery/event_store/event_sink'
+require 'event_sourcery/event_store/event_source'
+require 'event_sourcery/errors'
+require 'event_sourcery/event_store/each_by_range'
+require 'event_sourcery/event_store/subscription'
+require 'event_sourcery/event_store/poll_waiter'
+require 'event_sourcery/event_store/event_builder'
+require 'event_sourcery/event_store/event_type_serializers/class_name'
+require 'event_sourcery/event_store/event_type_serializers/legacy'
+require 'event_sourcery/event_store/event_type_serializers/underscored'
+require 'event_sourcery/event_store/signal_handling_subscription_master'
+require 'event_sourcery/event_processing/error_handlers/error_handler'
+require 'event_sourcery/event_processing/error_handlers/no_retry'
+require 'event_sourcery/event_processing/error_handlers/constant_retry'
+require 'event_sourcery/event_processing/error_handlers/exponential_backoff_retry'
+require 'event_sourcery/event_processing/esp_process'
+require 'event_sourcery/event_processing/esp_runner'
+require 'event_sourcery/event_processing/event_stream_processor'
+require 'event_sourcery/event_processing/event_stream_processor_registry'
+require 'event_sourcery/config'
+require 'event_sourcery/event_body_serializer'
+require 'event_sourcery/aggregate_root'
+require 'event_sourcery/repository'
+require 'event_sourcery/memory/tracker'
+require 'event_sourcery/memory/event_store'
+
+module EventSourcery
+  def self.configure
+    yield config
+  end
+
+  def self.config
+    @config ||= Config.new
+  end
+
+  def self.logger
+    config.logger
+  end
+
+  def self.event_stream_processor_registry
+    @event_stream_processor_registry ||= EventProcessing::EventStreamProcessorRegistry.new
+  end
+end

data/lib/event_sourcery/aggregate_root.rb

@@ -0,0 +1,68 @@
+module EventSourcery
+  module AggregateRoot
+    UnknownEventError = Class.new(RuntimeError)
+
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.class_eval do
+        @event_handlers = Hash.new { |hash, key| hash[key] = [] }
+      end
+    end
+
+    module ClassMethods
+      attr_reader :event_handlers
+
+      def apply(*event_classes, &block)
+        event_classes.each do |event_class|
+          @event_handlers[event_class.type] << block
+        end
+      end
+    end
+
+    def initialize(id, events, on_unknown_event: EventSourcery.config.on_unknown_event)
+      @id = id.to_str
+      @version = 0
+      @on_unknown_event = on_unknown_event
+      @changes = []
+      load_history(events)
+    end
+
+    attr_reader :changes, :version
+
+    def clear_changes
+      @changes.clear
+    end
+
+    private
+
+    def load_history(events)
+      events.each do |event|
+        mutate_state_from(event)
+      end
+    end
+
+    attr_reader :id
+
+    def apply_event(event_class, options = {})
+      event = event_class.new(**options.merge(aggregate_id: id))
+      mutate_state_from(event)
+      @changes << event
+    end
+
+    def mutate_state_from(event)
+      handlers = self.class.event_handlers[event.type]
+      if handlers.any?
+        handlers.each do |handler|
+          instance_exec(event, &handler)
+        end
+      else
+        @on_unknown_event.call(event, self)
+      end
+      increment_version
+    end
+
+    def increment_version
+      @version += 1
+    end
+  end
+end

data/lib/event_sourcery/config.rb

@@ -0,0 +1,43 @@
+require 'logger'
+
+module EventSourcery
+  class Config
+    attr_accessor :on_unknown_event,
+                  :on_event_processor_error,
+                  :event_type_serializer,
+                  :error_handler_class
+
+    attr_writer :logger,
+                :event_body_serializer,
+                :event_builder
+
+    def initialize
+      @on_unknown_event = proc { |event, aggregate|
+        raise AggregateRoot::UnknownEventError, "#{event.type} is unknown to #{aggregate.class.name}"
+      }
+      @on_event_processor_error = proc { |exception, processor_name|
+        # app specific custom logic ie. report to rollbar
+      }
+      @event_store = nil
+      @event_type_serializer = EventStore::EventTypeSerializers::Underscored.new
+      @error_handler_class = EventProcessing::ErrorHandlers::ConstantRetry
+    end
+
+    def logger
+      @logger ||= ::Logger.new(STDOUT).tap do |logger|
+        logger.level = Logger::DEBUG
+      end
+    end
+
+    def event_builder
+      @event_builder || EventStore::EventBuilder.new(event_type_serializer: @event_type_serializer)
+    end
+
+    def event_body_serializer
+      @event_body_serializer ||= EventBodySerializer.new
+        .add(Hash, EventBodySerializer::HashSerializer)
+        .add(Array, EventBodySerializer::ArraySerializer)
+        .add(Time, &:iso8601)
+    end
+  end
+end

data/lib/event_sourcery/errors.rb

@@ -0,0 +1,19 @@
+module EventSourcery
+  Error = Class.new(StandardError)
+  UnableToLockProcessorError = Class.new(Error)
+  UnableToProcessEventError = Class.new(Error)
+  ConcurrencyError = Class.new(Error)
+  AtomicWriteToMultipleAggregatesNotSupported = Class.new(Error)
+
+  class EventProcessingError < Error
+    attr_reader :event
+
+    def initialize(event)
+      @event = event
+    end
+
+    def message
+      cause.message if cause
+    end
+  end
+end

data/lib/event_sourcery/event.rb

@@ -0,0 +1,49 @@
+module EventSourcery
+  class Event
+    include Comparable
+
+    def self.type
+      unless self == Event
+        EventSourcery.config.event_type_serializer.serialize(self)
+      end
+    end
+
+    attr_reader :id, :uuid, :aggregate_id, :type, :body, :version, :created_at, :correlation_id, :causation_id
+
+    def initialize(id: nil,
+                   uuid: SecureRandom.uuid,
+                   aggregate_id: nil,
+                   type: nil,
+                   body: nil,
+                   version: nil,
+                   created_at: nil,
+                   correlation_id: nil,
+                   causation_id: nil)
+      @id = id
+      @uuid = uuid && uuid.downcase
+      @aggregate_id = aggregate_id
+      @type = self.class.type || type.to_s
+      @body = body ? EventSourcery::EventBodySerializer.serialize(body) : {}
+      @version = version ? Integer(version) : nil
+      @created_at = created_at
+      @correlation_id = correlation_id
+      @causation_id = causation_id
+    end
+
+    def persisted?
+      !id.nil?
+    end
+
+    def hash
+      [self.class, uuid].hash
+    end
+
+    def eql?(other)
+      instance_of?(other.class) && uuid.eql?(other.uuid)
+    end
+
+    def <=>(other)
+      id <=> other.id if other.is_a? Event
+    end
+  end
+end

data/lib/event_sourcery/event_body_serializer.rb

@@ -0,0 +1,42 @@
+module EventSourcery
+  class EventBodySerializer
+    def self.serialize(event_body,
+                       serializer: EventSourcery.config.event_body_serializer)
+      serializer.serialize(event_body)
+    end
+
+    def initialize
+      @serializers = Hash.new(IdentitySerializer)
+    end
+
+    def add(type, serializer = nil, &block_serializer)
+      @serializers[type] = serializer || block_serializer
+      self
+    end
+
+    def serialize(object)
+      serializer = @serializers[object.class]
+      serializer.call(object, &method(:serialize))
+    end
+
+    module HashSerializer
+      def self.call(hash, &serialize)
+        hash.each_with_object({}) do |(key, value), memo|
+          memo[key.to_s] = serialize.call(value)
+        end
+      end
+    end
+
+    module ArraySerializer
+      def self.call(array, &serialize)
+        array.map(&serialize)
+      end
+    end
+
+    module IdentitySerializer
+      def self.call(object)
+        object
+      end
+    end
+  end
+end

data/lib/event_sourcery/event_processing/error_handlers/constant_retry.rb

@@ -0,0 +1,23 @@
+module EventSourcery
+  module EventProcessing
+    module ErrorHandlers
+      class ConstantRetry
+        include EventSourcery::EventProcessing::ErrorHandlers::ErrorHandler
+        DEFAULT_RETRY_INVERAL = 1
+        def initialize(processor_name:)
+          @processor_name = processor_name
+          @retry_interval = DEFAULT_RETRY_INVERAL
+        end
+
+        def with_error_handling
+          yield
+        rescue => error
+          report_error(error)
+          sleep(@retry_interval)
+
+          retry
+        end
+      end
+    end
+  end
+end

data/lib/event_sourcery/event_processing/error_handlers/error_handler.rb

@@ -0,0 +1,20 @@
+module EventSourcery
+  module EventProcessing
+    module ErrorHandlers
+      module ErrorHandler
+        def with_error_handling
+          raise NotImplementedError, 'Please implement #with_error_handling method'
+        end
+        
+        private
+
+        def report_error(error)
+          error = error.cause if error.instance_of?(EventSourcery::EventProcessingError)
+          EventSourcery.logger.error("Processor #{@processor_name} died with #{error}.\n#{error.backtrace.join("\n")}")
+
+          EventSourcery.config.on_event_processor_error.call(error, @processor_name)
+        end
+      end
+    end
+  end
+end

data/lib/event_sourcery/event_processing/error_handlers/exponential_backoff_retry.rb

@@ -0,0 +1,40 @@
+module EventSourcery
+  module EventProcessing
+    module ErrorHandlers
+      class ExponentialBackoffRetry
+        include EventSourcery::EventProcessing::ErrorHandlers::ErrorHandler
+        DEFAULT_RETRY_INVERAL = 1
+        MAX_RETRY_INVERVAL = 64
+
+        def initialize(processor_name:)
+          @processor_name = processor_name
+          @retry_interval = DEFAULT_RETRY_INVERAL
+        end
+
+        def with_error_handling
+          yield
+        rescue => error
+          report_error(error)
+          update_retry_interval(error)
+          sleep(@retry_interval)
+          retry
+        end
+
+        private
+
+        def update_retry_interval(error)
+          if error.instance_of?(EventSourcery::EventProcessingError)
+            if @error_event_uuid == error.event.uuid
+              @retry_interval *= 2 if @retry_interval < MAX_RETRY_INVERVAL
+            else
+              @error_event_uuid = error.event.uuid
+              @retry_interval = DEFAULT_RETRY_INVERAL
+            end
+          else
+            @retry_interval = DEFAULT_RETRY_INVERAL
+          end
+        end
+      end
+    end
+  end
+end

data/lib/event_sourcery/event_processing/error_handlers/no_retry.rb

@@ -0,0 +1,19 @@
+module EventSourcery
+  module EventProcessing
+    module ErrorHandlers
+      class NoRetry
+        include EventSourcery::EventProcessing::ErrorHandlers::ErrorHandler
+        def initialize(processor_name:)
+          @processor_name = processor_name
+        end
+
+        def with_error_handling
+          yield
+        rescue => error
+          report_error(error)
+          Process.exit(false)
+        end
+      end
+    end
+  end
+end