action_pubsub 0.1.1 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 84b10ab5fca7e4529071e72418eaf0848f2b76c5
-  data.tar.gz: 97a02cce5b9147716c7a80a497c2262227bc99c5
+  metadata.gz: add736363fea3bee32c27d452e27658e6c15ecca
+  data.tar.gz: 343e314ddd56701f6d8b50c68c45a648507f54cf
 SHA512:
-  metadata.gz: 2098f79665ee6c3d0b067ab86a2f586613610a60c09e05b8b1b5c5dea6d289d16bbef56b2a1b887c1c408c0031a540fcc9b0e9c208106489776192827e130110
-  data.tar.gz: 17bd202a32d8393e5d62c34c5e5cf0a93b1760ddb0164721a1477edfb48ff35abb11e96e36c52dc789ffa7cc0e23a3066f88e5975ffff654395fd3f747e50f5d
+  metadata.gz: 1d66f335d116c6fe845f82eab144b09499142fd60a7e9ef1bdec5aad16dd76a2f651556a8cdc478d9bec6d7c5dbe593018c0956f9070f914031e7a5c99c9006b
+  data.tar.gz: ffc57559d5a8513fc6d372ed00ade3bc9ddd2250c30cf53ccb19eaa637e12fd324b8c2c8e51bc52fd2ec67bb99bed1a5d1a13b59a5af1da0978295f13f57474d

data/Gemfile

@@ -2,4 +2,5 @@ source 'https://rubygems.org'
 
 # gem "concurrent-ruby", :path => "~/gems/ruby-concurrency"
 # Specify your gem's dependencies in action_pubsub.gemspec
+gem "concurrent-ruby", :github => "ruby-concurrency/concurrent-ruby", :branch => "zero-nine-two"
 gemspec

data/README.md

@@ -2,7 +2,7 @@
 
 In process, concurrent observers, loosely modeled after rabbitmq
 
-## Example
+## Active Record Example
 
 Lets say we have a blog app, and our posts have comments enabled on a case by case basis.
 When someone leaves a new comment, we want to blast out an email to everyone who
@@ -41,6 +41,101 @@ module Blogger
 end
 ```
 
+## Non Active Record Subscribers
+
+As of 0.2.0, we can make anything subscribable, and publish to specific non "exchange" queues.
+
+``` ruby
+module Blogger
+  class Comment < ::ActiveRecord::Base
+    after_create :publish_after_create, :publish_after_save
+
+    def publish_after_create
+      ::ActionPubsub.publish('blogger/comment/created')
+    end
+
+    def publish_after_save
+      ::ActionPubsub.publish('blogger/comment/saved')
+    end    
+  end
+end
+```
+
+``` ruby
+class CommentSentimentAnalyzer
+  include ::ActionPubsub::HasSubscriptions
+  include ::ActionPubsub::ActiveRecord::WithConnection
+
+  class_attribute :sentiment_scores
+  self.sentiment_scores = []
+
+  on 'blogger/comment/created' do |record|
+    result = perform_sentiment_analysis(record)
+
+    if(result.is_beligerent?)
+      record.status = :hidden
+      record.sentiment_score = result.value
+    else
+      record.sentiment_score = result.value
+    end
+
+    self.class.sentiment_scores << record.sentiment_score
+
+    record.save
+  end
+
+  def perform_sentiment_analysis(record)
+    ##hit some 3rd party sentiment analysis api
+    return record
+  end
+
+  def average_sentiment
+    sentiment_scores.calculate_average
+  end
+end
+```
+
+Notes:
+1. The cool thing about the above, is not only is it a really lean, loosely coupled subscription, but its subscribes *asynchronously*, so we can call the 3rd party sentiment analysis api
+directly from our subscriber without worrying about blocking the main thread.
+
+2. the use of
+``` ruby
+include ::ActionPubsub::ActiveRecord::WithConnection
+```
+
+This ensures that the active record connection gets checked out and checked back into the pool, else youll run out of connections quickly. If you are not doing anything with active record, dont include it. If you are doing ANYTHING with active record (running a query or anything), make sure to include it, or wrap every on action in a connection checkout block, i.e.
+
+``` ruby
+::ActiveRecord::Base.connection_pool.with_connection
+```
+
+### Alternative Methods of Publish/Subscription
+
+``` ruby
+::ActionPubsub.publish('blogger/comment/created', {:my => :comment})
+
+#accessing and publishing to the channel directly
+::ActionPubsub['blogger/comment/created'] << {:my => :comment}
+
+#subscribing to channel directly
+::ActionPubsub.on('blogger/comment/created') do |comment|
+  puts comment.inspect
+end
+
+#multiple subscriptions per channel are allowed as well
+::ActionPubsub.on('blogger/comment/created') do |comment|
+  puts "do something else with comment #{comment}"
+end
+
+#as well as unique keyed subscriptions by name, i.e.
+::ActionPubsub.on('blogger/comment/created', :as => '/user/1/blogger/comment/created') do |comment|
+  puts "do something specific to user 1 with comment"
+end
+
+#will ensure that the existing subscription does not get duplicated.
+```
+
 ### What is the advantage of this pattern?
 
 The advantage is it makes your app incredibly reactive. Rather than have to fatten
@@ -52,12 +147,10 @@ application, and do nothing but react to the events occurring within the system.
 
 ### Callbacks
 
-Sure, we could use callbacks, but do we care about any of that if the record has
-not been commited to the database? (No we should not). Unless you use
-after_commit :on => :create, then your callbacks will attempt to run even if record hasn't been committed,
-unless at some point an error or false was returned.
-
-So as a best practice, we only broadcast the creation after it's been commited.
+The ActiveRecord callbacks from the ActionPubsub::ActiveRecord module, are only fired after_commit.
+If for some reason that's a problem, you probably don't want a subscriber to begin with,
+and should stick with standard callbacks. Meaning, subscribers are primarily intended to perform duties
+relevant to the model, but that do not change the model itself.
 
 This also allows for complex chains of events to occur, with no knowledge of each other,
 but that do their one job, and do it well. If that subscriber happens to create a new record,

data/action_pubsub.gemspec

@@ -24,8 +24,7 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "active_attr"
   spec.add_dependency "activesupport"
-  spec.add_dependency "concurrent-ruby"
-  spec.add_dependency "trax_core"
+  spec.add_dependency "concurrent-ruby", "~> 0.9.1"
   spec.add_development_dependency "bundler", "~> 1.10"
   spec.add_development_dependency 'guard', '~> 2'
   spec.add_development_dependency 'guard-rspec', '~> 4'

data/lib/action_pubsub.rb

@@ -5,22 +5,27 @@ require "active_attr"
 require "concurrent/lazy_register"
 require "concurrent/actor"
 require "concurrent/agent"
-require "trax_core"
 
 module ActionPubsub
   extend ::ActiveSupport::Autoload
 
   autoload :ActiveRecord
+  autoload :Actors
+  autoload :Balancer
   autoload :Config
+  autoload :Channel
+  autoload :Channels
+  autoload :Errors
   autoload :Event
-  autoload :Exchange
-  autoload :ExchangeRegistry
+  autoload :Exchanges
+  autoload :HasSubscriptions
   autoload :Publish
   autoload :Publishable
   autoload :Logging
   autoload :Subscriber
+  autoload :Subscriptions
+  autoload :Registry
   autoload :Queue
-  autoload :Types
 
   @configuration ||= ::ActionPubsub::Config.new
 
@@ -28,12 +33,29 @@ module ActionPubsub
     block.call(config)
   end
 
+  def self.channels
+    @channels ||= ::ActionPubsub::Channels.new
+  end
+
+  def self.channel?(channel_path)
+    channels.key?(channel_path)
+  end
+
+  def self.disable_all!
+    configure do |config|
+      config.disabled = true
+    end
+
+    subscriptions.all.map{ |_subscription| _subscription << :terminate! }
+    self
+  end
+
   def self.event_count
     @event_count ||= ::Concurrent::Agent.new(0)
   end
 
-  def self.exchange_registry
-    @exchange_registry ||= ::ActionPubsub::ExchangeRegistry.new
+  def self.exchanges
+    @exchanges ||= ::ActionPubsub::Exchanges.new
   end
 
   def self.destination_tuple_from_path(path_string)
@@ -50,18 +72,33 @@ module ActionPubsub
     [segs.join("/"), action]
   end
 
+  def self.on(*paths, as:nil, &block)
+    paths.map do |path|
+      target_channel = ::ActionPubsub.channels[path]
+      subscription_path = "#{path}:#{as || SecureRandom.uuid}"
+
+      ::ActionPubsub.subscriptions[subscription_path] ||= ::Concurrent::Actor::Utils::AdHoc.spawn(subscription_path) do
+        target_channel << :subscribe
+        -> message {
+          block.call(message)
+        }
+      end
+    end
+  end
+
   def self.symbolize_routing_key(routing_key)
     :"#{routing_key.split('.').join('_')}"
   end
 
+  def self.publish(path, message)
+    self[path] << message
+  end
+
   def self.publish_event(routing_key, event)
     #need to loop through exchanges and publish to them
     #maybe there is a better way to do this?
-    exchange_hash = ::ActionPubsub.exchanges[routing_key].instance_variable_get("@data").value
-    queue_names = exchange_hash.keys
-
-    queue_names.each do |queue_name|
-      exchange_registry[routing_key][queue_name] << serialize_event(event)
+    exchanges[routing_key].keys.each do |queue_name|
+      exchanges[routing_key][queue_name] << serialize_event(event)
     end
   end
 
@@ -69,6 +106,18 @@ module ActionPubsub
     event
   end
 
+  def self.subscriptions
+    @subscriptions ||= ::ActionPubsub::Subscriptions.new
+  end
+
+  def self.silent_dead_letter_handler
+    @silent_dead_letter_handler ||= ::ActionPubsub::Actors::SilentDeadLetterHandler.spawn('action_pubsub/silent_dead_letter_handler')
+  end
+
+  def self.subscription?(path)
+    subscriptions.key?(path)
+  end
+
   def self.deserialize_event(event)
     event
   end
@@ -76,10 +125,10 @@ module ActionPubsub
   class << self
     attr_accessor :configuration
     alias_method :config, :configuration
-    alias_method :exchanges, :exchange_registry
 
-    delegate :register_queue, :to => :exchange_registry
-    delegate :register_channel, :to => :exchange_registry
-    delegate :register_exchange, :to => :exchange_registry
+    delegate :[], :to => :channels
+    delegate :register_queue, :to => :exchanges
+    delegate :register_channel, :to => :exchanges
+    delegate :register_exchange, :to => :exchanges
   end
 end

data/lib/action_pubsub/active_record.rb

@@ -7,5 +7,6 @@ module ActionPubsub
     autoload :Publishable
     autoload :Subscriber
     autoload :Subscription
+    autoload :WithConnection
   end
 end

data/lib/action_pubsub/active_record/subscriber.rb

@@ -30,6 +30,9 @@ module ActionPubsub
         subklass.event_processed_count = ::Concurrent::AtomicFixnum.new(0)
       end
 
+      def self.disable_all!
+      end
+
       def self.on(event_name, **options, &block)
         reactions[event_name] = {}.tap do |hash|
           hash[:block] = block
@@ -69,11 +72,11 @@ module ActionPubsub
           target_exchange = [exchange_prefix, event_name].join("/")
           subscriber_key = name.underscore
           queue_key = [target_exchange, subscriber_key].join("/")
-
           ::ActionPubsub.register_queue(target_exchange, subscriber_key)
 
           self.concurrency.times do |i|
-            self.subscription.spawn("#{queue_key}/#{i}") do
+            queue_address = "#{queue_key}/#{i}"
+            ::ActionPubsub.subscriptions[queue_address] ||= self.subscription.spawn(queue_address) do
               self.subscription.bind_subscription(target_exchange, subscriber_key)
             end
           end

data/lib/action_pubsub/active_record/subscription.rb

@@ -4,7 +4,7 @@ module ActionPubsub
       class_attribute :subscriber
 
       def self.bind_subscription(target_exchange, subscriber_key)
-        ::ActionPubsub.exchange_registry[target_exchange][subscriber_key] << :subscribe
+        ::ActionPubsub.exchanges[target_exchange][subscriber_key] << :subscribe
         -> message {
           ::ActiveRecord::Base.connection_pool.with_connection do
             begin
@@ -21,10 +21,10 @@ module ActionPubsub
               self.class.bind_subscription(target_exchange, subscriber_key)
             rescue => e
               #ensure we rebind subscription regardless
-              self.class.bind_subscription(target_exchange, subscriber_key)
+              self.class.bind_subscription(target_exchange, subscriber_key) unless message.is_a?(Symbol)
               message = ::ActionPubsub.deserialize_event(message)
 
-              failure_message = ::ActionPubsub::Types::SubscriptionReactionError.new(
+              failure_message = ::ActionPubsub::Errors::SubscriptionReactionErrorMessage.new(
                 :target_exchange => target_exchange,
                 :subscriber_key => subscriber_key,
                 :error => e,

data/lib/action_pubsub/active_record/with_connection.rb

@@ -0,0 +1,19 @@
+module ActionPubsub
+  module ActiveRecord
+    module WithConnection
+      extend ::ActiveSupport::Concern
+
+      module ClassMethods
+        def on(*paths, as:nil, &block)
+          wrapped_block = lambda{ |message|
+            ::ActiveRecord::Base.connection_pool.with_connection { block.call(message) }
+          }
+
+          _subscriptions = ::ActionPubsub.on(*paths, as:(as || _as), &wrapped_block)
+          _subscriptions.each { |_subscription| subscriptions << _subscription }
+          subscriptions
+        end
+      end
+    end
+  end
+end

data/lib/action_pubsub/actors.rb

@@ -0,0 +1,8 @@
+module ActionPubsub
+  module Actors
+    extend ::ActiveSupport::Autoload
+
+    autoload :SilenceDeadLetters
+    autoload :SilentDeadLetterHandler
+  end
+end

data/lib/action_pubsub/actors/silent_dead_letter_handler.rb

@@ -0,0 +1,12 @@
+#dead letter routing not working ATM
+module ActionPubsub
+  module Actors
+    class SilentDeadLetterHandler < ::Concurrent::Actor::RestartingContext
+      def on_messaage(dead_letter)
+        puts "SILENCE DEAD LETTER HANDLER GOT MESSAGE"
+        puts dead_letter.inspect
+        super(dead_letter)
+      end
+    end
+  end
+end

data/lib/action_pubsub/balancer.rb

@@ -0,0 +1,37 @@
+module ActionPubsub
+  class Balancer < ::Concurrent::Actor::Utils::Balancer
+
+    def initialize
+      @receivers = []
+      @buffer    = []
+    end
+
+    def on_message(message)
+      case message
+      when :subscribe
+        @receivers << envelope.sender
+        distribute
+        true
+      when :unsubscribe
+        @receivers.delete envelope.sender
+        true
+      when :subscribed?
+        @receivers.include? envelope.sender
+      else
+        @buffer << envelope
+        distribute
+        ::Concurrent::Actor::Behaviour::MESSAGE_PROCESSED
+      end
+    end
+
+    def distribute
+      while !@receivers.empty? && !@buffer.empty?
+        redirect @receivers.shift, @buffer.shift
+      end
+    end
+
+    def dead_letter_routing
+      ::ActionPubsub.silent_dead_letter_handler
+    end
+  end
+end

data/lib/action_pubsub/channel.rb

@@ -0,0 +1,4 @@
+module ActionPubsub
+  class Channel < Concurrent::Actor::Utils::Broadcast
+  end
+end

data/lib/action_pubsub/channels.rb

@@ -0,0 +1,10 @@
+module ActionPubsub
+  class Channels < ::ActionPubsub::Registry
+    def [](val)
+      return super(val) if key?(val)
+
+      add(val){ ::ActionPubsub::Channel.spawn(val) }
+      super(val)
+    end
+  end
+end

data/lib/action_pubsub/config.rb

@@ -6,6 +6,7 @@ module ActionPubsub
       super(*args)
 
       self[:debug] = false
+      self[:disabled] = false
       self[:serializer] = nil
       self[:_on_error_block] = nil
     end
@@ -14,6 +15,10 @@ module ActionPubsub
       ::Concurrent.use_stdlib_logger(Logger::DEBUG) if val
     end
 
+    def disabled?
+      self[:disabled]
+    end
+
     def serializer=(val)
       if val && val.ancestors.include?(::ActiveSupport::Concern)
         ::ActionPubsub.include(val)

data/lib/action_pubsub/errors.rb

@@ -0,0 +1,16 @@
+require 'active_model'
+
+module ActionPubsub
+  module Errors
+    class SubscriptionReactionErrorMessage
+      attr_accessor :message, :error, :target_exchange, :subscriber_key
+
+      def initialize(*args, message:, error:, target_exchange:nil, subscriber_key:nil, **options)
+        @message = message
+        @error = error
+        @target_exchange = target_exchange
+        @subscriber_key = subscriber_key
+      end
+    end
+  end
+end

data/lib/action_pubsub/exchanges.rb

@@ -0,0 +1,21 @@
+module ActionPubsub
+  class Exchanges < ::ActionPubsub::Registry
+    def register_queue(exchange_name, subscriber_name)
+      queue_name = [exchange_name, subscriber_name].join("/")
+      queue_exists = self[exchange_name].all.any?{ |queue| queue.name == queue_name }
+      self[exchange_name].add(subscriber_name) { ::ActionPubsub::Queue.spawn(queue_name) } unless queue_exists
+    end
+
+    def register_exchange(exchange_name)
+      add(exchange_name) { ::ActionPubsub::Exchanges.new }
+      self[exchange_name]
+    end
+
+    def [](val)
+      return super(val) if key?(val)
+
+      add(val){ ::ActionPubsub::Exchanges.new  }
+      super(val)
+    end
+  end
+end

data/lib/action_pubsub/has_subscriptions.rb

@@ -0,0 +1,23 @@
+module ActionPubsub
+  module HasSubscriptions
+    extend ::ActiveSupport::Concern
+
+    included do
+      class_attribute :_as
+      class_attribute :subscriptions
+      self.subscriptions = []
+    end
+
+    module ClassMethods
+      def as(val)
+        self._as = val
+      end
+
+      def on(*paths, as:nil, &block)
+        _subscriptions = ::ActionPubsub.on(*paths, as:(as || _as), &block)
+        _subscriptions.each { |_subscription| subscriptions << _subscription }
+        subscriptions
+      end
+    end
+  end
+end

data/lib/action_pubsub/queue.rb

@@ -1,4 +1,4 @@
 module ActionPubsub
-  class Queue < ::Concurrent::Actor::Utils::Balancer
+  class Queue < ::ActionPubsub::Balancer
   end
 end

data/lib/action_pubsub/registry.rb

@@ -0,0 +1,17 @@
+module ActionPubsub
+  class Registry < ::Concurrent::LazyRegister
+    def all
+      keys.map do |k|
+        self[k]
+      end
+    end
+
+    def []=(key, val)
+      register(key) { val }
+    end
+
+    def keys
+      @data.value.keys
+    end
+  end
+end

data/lib/action_pubsub/subscriber.rb

@@ -1,39 +1,5 @@
-### NOTE: Don't use this. Only the active record subscriber is working ATM.
 module ActionPubsub
-  class Subscriber < ::Concurrent::Actor::Utils::AdHoc
-    class_attribute :concurrency, :queue, :exchange_prefix, :watches
-    self.concurrency = 1
-
-    def self.inherited(subklass)
-      subklass.watches = {}
-    end
-
-    def self.register_event_watcher(event_name)
-      target_exchange = [exchange_prefix, event_name].join("/")
-      subscriber_key = name.underscore
-      queue_key = [target_exchange, subscriber_key].join("/")
-
-      ::ActionPubsub.register_queue(target_exchange, subscriber_key)
-
-      self.concurrency.times do |i|
-        spawn("#{queue_key}/#{i}") do
-          bind_subscription(target_exchange, subscriber_key)
-        end
-      end
-    end
-
-    def self.on(event_name, &block)
-      watches[event_name] = block
-      register_event_watcher(event_name)
-    end
-
-    def self.bind_subscription(target_exchange, subscriber_key)
-      ::ActionPubsub.exchange_registry[target_exchange][subscriber_key] << :subscribe
-      -> message {
-        self.class.watches[message["action"]].call(message["record"])
-
-        self.class.bind_subscription(target_exchange, subscriber_key)
-      }
-    end
+  class Subscriber
+    include ::ActionPubsub::HasSubscriptions
   end
 end

data/lib/action_pubsub/subscriptions.rb

@@ -0,0 +1,4 @@
+module ActionPubsub
+  class Subscriptions < ::ActionPubsub::Registry
+  end
+end

data/lib/action_pubsub/version.rb

@@ -1,3 +1,3 @@
 module ActionPubsub
-  VERSION = "0.1.1"
+  VERSION = "0.2.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: action_pubsub
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.1
 platform: ruby
 authors:
 - Jason Ayre
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-11-03 00:00:00.000000000 Z
+date: 2016-01-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: active_attr
@@ -42,30 +42,16 @@ dependencies:
   name: concurrent-ruby
   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: trax_core
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.9.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.9.1
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -290,14 +276,23 @@ files:
 - lib/action_pubsub/active_record/publishable.rb
 - lib/action_pubsub/active_record/subscriber.rb
 - lib/action_pubsub/active_record/subscription.rb
+- lib/action_pubsub/active_record/with_connection.rb
+- lib/action_pubsub/actors.rb
+- lib/action_pubsub/actors/silent_dead_letter_handler.rb
+- lib/action_pubsub/balancer.rb
+- lib/action_pubsub/channel.rb
+- lib/action_pubsub/channels.rb
 - lib/action_pubsub/config.rb
+- lib/action_pubsub/errors.rb
 - lib/action_pubsub/event.rb
-- lib/action_pubsub/exchange_registry.rb
+- lib/action_pubsub/exchanges.rb
+- lib/action_pubsub/has_subscriptions.rb
 - lib/action_pubsub/queue.rb
+- lib/action_pubsub/registry.rb
 - lib/action_pubsub/serialization.rb
 - lib/action_pubsub/serialization/marshal.rb
 - lib/action_pubsub/subscriber.rb
-- lib/action_pubsub/types.rb
+- lib/action_pubsub/subscriptions.rb
 - lib/action_pubsub/version.rb
 homepage: http://github.com/jasonayre/action_pubsub
 licenses:

data/lib/action_pubsub/exchange_registry.rb

@@ -1,15 +0,0 @@
-module ActionPubsub
-  class ExchangeRegistry < ::Concurrent::LazyRegister
-    def register_queue(exchange_name, subscriber_name)
-      register_exchange(exchange_name) unless key?(exchange_name)
-      exchange_hash = self[exchange_name].instance_variable_get("@data").value
-      exchange_keys = exchange_hash.keys
-      queue_name = [exchange_name, subscriber_name].join("/")
-      self[exchange_name].add(subscriber_name) { ::ActionPubsub::Queue.spawn(queue_name) }
-    end
-
-    def register_exchange(exchange_name)
-      add(exchange_name) { ::Concurrent::LazyRegister.new }
-    end
-  end
-end

data/lib/action_pubsub/types.rb

@@ -1,19 +0,0 @@
-require 'trax_core'
-
-module ActionPubsub
-  class Types < ::Trax::Core::Blueprint
-    class SubscriptionReactionError < ::Trax::Core::Types::Struct
-      string :target_exchange
-      string :subscriber_key
-
-      attr_accessor :message, :error
-
-      def initialize(*args, message:, error:, **options)
-        super(*args, **options)
-
-        @message = message
-        @error = error
-      end
-    end
-  end
-end