stenotype 0.1.1 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cad5a62bd56d635becd56bf9bae4d6421879d29952473fd507ae60885ea4723e
-  data.tar.gz: 0b2d65ef6e1f9a84bd369d908f4133f3787156fcc5a6b46a194b4193fa735411
+  metadata.gz: 5f58226124306beb915f76259d055c013e197d24dee87513d751764486ce8033
+  data.tar.gz: eee031ad3b4f4b9d5b8ed8645e5d7f676f0490f1f9351cec516ffc72ef5b298a
 SHA512:
-  metadata.gz: c025894e106d650dcfe1bab82cf878b89a561eaae8a7eb23246a8d01a34800460a17734f55da518602d504a554b41648f6039d3174b2747d093dba8fbfbb0f26
-  data.tar.gz: 790e1a50a3fabff8db4c62017a556532b8acf3f1df6a330b91dfafba0e1af1701335f8463688fb8d201b75420542fd6cbba054939d33cd80e400e87b07100ed3
+  metadata.gz: fe129ae49b3b255a02f1cadcc6920820348846d0b10dba93ab554322b545401a63c8bce7becd239502e9ff433b127e738ff612d4b1cc9903a0f32212ce68eda1
+  data.tar.gz: 275de1f70c2c0f4e9d608e79d93e773d75538b18a47c1f2848a7753bb6151b5f96a8ef7c74b36b3a462360de7be196a247d3be3429cfd7f1b00364691ae01a5e

data/.gitignore

@@ -11,3 +11,6 @@
 .rspec_status
 /.rakeTasks
 /.idea
+
+# rbenv
+.ruby-version

data/CHANGELOG.md

@@ -1,6 +1,31 @@
 # Changelog
 
-*Release Date*: 2019/11/21
+*Release Date*: 2020/01/13
+
+### 0.1.7 2020/01/20
+* Adds a config option to allow explicit adapter setup.
+* Adds an `after_initialize` rails hook to setup adapters.
+* Remove topic from the list of Google Cloud adapter arguments.
+
+### 0.1.6 2020/01/17
+* Allow topic to be explicitly set upon Google Cloud adapter initialization
+
+### 0.1.5 2020/01/13
+* In case `graceful_error_handling` is set to off raise a generic `Stenotype::Error` on any exception in order to intercept a single error type in the client code.
+* Adds an `at_exit` hook to flush the async message queue when using the library in async mode.
+
+### 0.1.4 2020/01/10
+* Adds a new configuration option `graceful_error_handling` to suppress errors raised from the gem's internals yet logging the error to specified `config.logger`
+
+### 0.1.3: 2020/01/10
+* Adds a new configuration option `logger` to use during error handling
+* Adds a new config option `Stenotype.config.enabled`. If the option is set to false then event is not going to be published. The option is `true` by default.
+
+### 0.1.2: 2019/12/10
+
+* Changes the interface of how event is emitted. Now you must pass `event_name`, `attributes` and optional `eval_context`. Note that `additional_options` are eliminated
+* Makes StdoutAdapter more informative by adding a special line for every entry in the log.
+* Fixes Rails initializer not working after switching to Configurable from Spicerack.
 
 ### 0.1.1: 2019/11/25
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    stenotype (0.1.1)
+    stenotype (0.1.6)
       activesupport (>= 5.0.0)
       google-cloud-pubsub (~> 1.0.0)
       spicery (>= 0.19.0, < 1.0)
@@ -147,7 +147,7 @@ GEM
       coderay (~> 1.1.0)
       method_source (~> 0.9.0)
     public_suffix (4.0.1)
-    rack (2.0.7)
+    rack (2.0.8)
     rack-test (1.1.0)
       rack (>= 1.0, < 3)
     rails (5.2.4)

data/README.md

@@ -25,24 +25,48 @@ Or install it yourself as:
 Configuring the library is as simple as:
 ```ruby
 Stenotype.configure do |config|
+  config.enabled = true
   config.targets = [ # Supported targets
     Stenotype::Adapters::StdoutAdapter.new,
     Stenotype::Adapters::GoogleCloud.new
   ]
 
-  config.uuid_generator = SecureRandom
-  config.dispatcher     = Stenotype::Dispatcher.new
-  config.gc_project_id  = "google_cloud_project_id"
-  config.gc_credentials = "path_to_key_json"
-  config.gc_topic       = "google_cloud_topic"
-  config.gc_mode        = :async # either :sync or :async
+  config.uuid_generator               = SecureRandom
+  config.dispatcher                   = Stenotype::Dispatcher.new
+  config.logger                       = Logger.new(STDOUT)
+  config.graceful_error_handling      = true
+  config.auto_adapter_initialization  = true
+
+  config.google_cloud do |gc_config|
+    gc_config.project_id  = "google_cloud_project_id"
+    gc_config.credentials = "path_to_key_json"
+    gc_config.topic       = "google_cloud_topic"
+    gc_config.async       = true # either true or false
+  end
+
+  config.rails do |rails_config|
+    rails_config.enable_action_controller_ext = true
+    rails_config.enable_active_job_ext        = true
+  end
 end
 ```
 
+#### config.enabled
+
+A flag checked upon emission of an event. Will prevent event emission if set to false. An event is emitted if set to true.
+
 #### config.targets
 
 Contain an array of targets for the events to be published to. Targets must implement method `#publish(event_data, **additional_arguments)`.
 
+#### config.logger
+
+Specifies a logger for messages and exceptions to be output to. If not set defaults to `Logger.new(STDOUT)`, otherwise a manually set logger is used.
+
+#### config.graceful_error_handling
+
+This flag if set to `true` is going to suppress all `StandardError`'s raised within a gem. Raises the error to the caller if set to `false`
+
 #### config.uuid_generator
 
 An object that must implement method `#uuid`. Used when an event is emitted to generate a unique id for each event.
@@ -51,21 +75,33 @@ An object that must implement method `#uuid`. Used when an event is emitted to g
 
 Dispatcher used to dispatch the event. A dispatcher must implement method `#publish(even, serializer: Stenotype::EventSerializer)`. By default `Stenotype::EventSerializer` is used, which is responsible for collecting the data from the event and evaluation context.
 
-#### config.gc_project_id
+#### config.google_cloud.project_id
 
 Google cloud project ID. Please refer to Google Cloud management console to get one.
 
-#### config.gc_credentials
+#### config.google_cloud.credentials
 
 Google cloud credentials. Might be obtained from Google Cloud management console.
 
-#### config.gc_topic
+#### config.google_cloud.topic
 
 Google Cloud topic used for publishing the events.
 
-#### config.gc_mode
+#### config.google_cloud.async
+
+Google Cloud publish mode. The mode is either sync or async. When in `sync` mode the event will be published in the same thread (which might influence performance). For `async` mode the event will be put into a pull which is going to be flushed after a threshold is met.
 
-Google Cloud publish mode. Two options are available: `:sync, :async`. When in `sync` mode the event will be published in the same thread (which might influence performance). For `async` mode the event will be put into a pull which is going to be flushed after a threshold is met.
+#### config.rails.enable_action_controller_ext
+
+Allows to enable/disable Rails ActionController extension
+
+#### config.rails.enable_active_job_ext
+
+Allows to enable/disable Rails ActiveJob extension
+
+#### config.rails.auto_adapter_initialization
+
+Controls whether the hook `auto_initialize!` is run for each adapter. If set to true `auto_initialize!` is invoked for every adapter. If false `auto_initialize!` is not run. For example for google cloud adapter this will instantiate `client` and `topic` objects before first publish. If set to false `client` and `topic` are lazy initialized.
 
 #### Configuring context handlers
 
@@ -76,8 +112,8 @@ Each event is emitted in a context which might be an ActionController instance o
 Emitting an event is as simple as:
 ```ruby
 Stenotype::Event.emit!(
-    data,
-    options: additional_options,
+    "Event Name",
+    { attr1: :value1, attr2: :value2 },
     eval_context: { name_of_registered_context_handler: context_object }
 )
 ```
@@ -172,9 +208,9 @@ Stenotype::ContextHandlers.register CustomHandler
 class PlainRubyClass < BaseClass
   def some_method(data)
     event_data = collect_some_data_as_a_hash
-    emit_event(event_data) # method name will be `some_method`, eval_context: { klass: self }
+    emit_event("event_name", event_data) # method name will be `some_method`, eval_context: { klass: self }
     other_event_data = do_something_else
-    emit_event(other_event_data, method: :custom_method_name, eval_context: { overriden_handler: self })
+    emit_event("other_event_name", other_event_data, method: :custom_method_name, eval_context: { overriden_handler: self })
   end
 end
 ```
@@ -197,6 +233,14 @@ class CustomAdapter < Stenotype::Adapters::Base
   def publish(event_data, **additional_arguments)
     # custom publishing logic
   end
+
+  def flush!
+    # actions to be taken to flush the messages
+  end
+
+  def auto_initialize!
+    # actions to be taken to setup internal adapter state (client, endpoint, whatsoever)
+  end
 end
 ```
 

data/lib/generators/stenotype/initializer/templates/initializer.rb.erb

@@ -1,65 +1,82 @@
 # frozen_string_literal: true
 
 Rails.application.configure do
-  #
-  # Stenotype allows you to emit events which are then being published to a list of
-  # targets. Currently two targets are provided by default: Google Cloud Pub Sub and
-  # STDOUT for debug purposes.
-  #
-  # There is also a rails integration module which defines a handy DSL
-  # for triggering events in various Rails components. ActionController and
-  # ActiveJob are supported at the time of writing.
-  #
-  # Both extensions for Rails are enabled by default, but there are config options
-  # to control their presence.
-  # config.stenotype.rails do |rails_modules|
-  #   rails_modules.enable_action_controller_ext = true
-  #   rails_modules.enable_active_job_ext = true
-  # end
-  #
-  #
-  # To make publishing possible one must specify a list of targets. You could use
-  # StdoutAdapter for debug purposes before switching to a production publisher.
-  # By default the list of targets is empty and you'll get an error saying
-  # that no targets are specified.
-  #
-  # A config option is available for setting up the targets:
-  #
-  # config.stenotype.targets = [Stenotype::Adapters::StdoutAdapter.new]
-  #
-  # Or using Google Cloud:
-  #
-  # config.stenotype.targets = [Stenotype::Adapters::GoogleCloud.new]
-  #
-  # Or both:
-  #
-  # config.stenotype.targets = [
-  #   Stenotype::Adapters::StdoutAdapter.new,
-  #   Stenotype::Adapters::GoogleCloud.new
-  # ]
-  #
-  # To be able to use Google Cloud one has to specify Google Cloud credentials:
-  #
-  # config.stenotype.google_cloud do |gc_config|
-  #   gc_config.credentials = "SPECIFY YOUR CREDENTIALS" # path/to/key.json
-  #   gc_config.project_id = "SPECIFY YOUR PROJECT ID"
-  #   gc_config.topic = "SPECIFY YOUR TOPIC"
-  #   gc_config.mode = :async
-  # end
-  #
-  # Each event is shipped with a UUID generated with SecureRandom by default.
-  # This might be changed by using a corresponding config option. Note that
-  # uuid_generator expects method #uuid to be implemented
-  #
-  # config.stenotype.uuid_generator = SecureRandom
-  #
-  # In rare cases you might want to get control over how the event is being dispatched.
-  # Dispatcher must implement instance method #publish.
-  # Which dispatcher to use is controlled by the following config option:
-  #
-  # config.stenotype.dispatcher = Stenotype::Dispatcher
-  #
+  Stenotype.configure do |config|
+    #
+    # Stenotype allows you to emit events which are then being published to a list of
+    # targets. Currently two targets are provided by default: Google Cloud Pub Sub and
+    # STDOUT for debug purposes.
+    #
+    # There is also a rails integration module which defines a handy DSL
+    # for triggering events in various Rails components. ActionController and
+    # ActiveJob are supported at the time of writing.
+    #
+    # Both extensions for Rails are enabled by default, but there are config options
+    # to control their presence.
+    # config.rails do |rails_modules|
+    #   rails_modules.enable_action_controller_ext = true
+    #   rails_modules.enable_active_job_ext = true
+    # end
+    #
+    # To enable or disable the library use the following config option:
+    #
+    # config.enabled = true # or false
+    #
+    # To make publishing possible one must specify a list of targets. You could use
+    # StdoutAdapter for debug purposes before switching to a production publisher.
+    # By default the list of targets is empty and you'll get an error saying
+    # that no targets are specified.
+    #
+    # A config option is available for setting up the targets:
+    #
+    # config.targets = [Stenotype::Adapters::StdoutAdapter.new]
+    #
+    # Or using Google Cloud:
+    #
+    # config.targets = [Stenotype::Adapters::GoogleCloud.new]
+    #
+    # Or both:
+    #
+    # config.targets = [
+    #   Stenotype::Adapters::StdoutAdapter.new,
+    #   Stenotype::Adapters::GoogleCloud.new
+    # ]
+    #
+    # To be able to use Google Cloud one has to specify Google Cloud credentials:
+    #
+    # config.google_cloud do |gc_config|
+    #   gc_config.credentials = "SPECIFY YOUR CREDENTIALS" # path/to/key.json
+    #   gc_config.project_id = "SPECIFY YOUR PROJECT ID"
+    #   gc_config.topic = "SPECIFY YOUR TOPIC"
+    #   gc_config.async = true
+    # end
+    #
+    # Each event is shipped with a UUID generated with SecureRandom by default.
+    # This might be changed by using a corresponding config option. Note that
+    # uuid_generator expects method #uuid to be implemented
+    #
+    # config.uuid_generator = SecureRandom
+    #
+    # In rare cases you might want to get control over how the event is being dispatched.
+    # Dispatcher must implement instance method #publish.
+    # Which dispatcher to use is controlled by the following config option:
+    #
+    # config.dispatcher = Stenotype::Dispatcher
+    #
+    # An option to suppress exception within a gem is available:
+    #
+    # config.graceful_error_handling = true
+    #
+    # To log errors a logger config option is available. Logger.new(STDOUT) is used by default.
+    #
+    # config.logger = Logger.new(STDOUT)
+    #
+    # Add your own context handlers
+    #
+    # Stenotype::ContextHandlers.register Your::Custom::HandlerClass
+    #
+  end
 end
 
 # For more usage instructions please refer to either README.md or yard documentation
-# in gem repository https://github.com/Freshly/stenotype
+# in gem repository https://github.com/Freshly/stenotype

data/lib/stenotype/adapters/base.rb

@@ -35,12 +35,33 @@ module Stenotype
       #
       # This method is expected to be implemented by subclasses
       # @abstract
-      # @raise [NotImplementedError] unless implemented in a subclass
+      # @raise {NotImplementedError} unless implemented in a subclass
       #
-      def publish(_event_data, **_additional_arguments)
+      def publish(_event_data, **_additional_attrs)
         raise NotImplementedError,
               "#{self.class.name} must implement method #publish"
       end
+
+      #
+      # Allows custom setup of the adapter. Noop by default
+      # @abstract
+      #
+      def auto_initialize!
+        # noop by default
+      end
+
+      #
+      # This method is expected to be implemented by subclasses. In case async
+      # publisher is used the process might end before the async queue of
+      # messages is processed, so this method is going to be used in a
+      # `at_exit` hook to flush the queue.
+      # @abstract
+      # @raise {NotImplementedError} unless implemented in a subclass
+      #
+      def flush!
+        raise NotImplementedError,
+              "#{self.class.name} must implement method #flush"
+      end
     end
   end
 end

data/lib/stenotype/adapters/google_cloud.rb

@@ -48,22 +48,42 @@ module Stenotype
       #   # publishes to default CustomGCClient
       #   google_cloud_adapter.publish({ event: :data }, { additional: :data })
       #
-      def publish(event_data, **additional_arguments)
+      def publish(event_data, **additional_attrs)
         if config.async
-          publish_async(event_data, **additional_arguments)
+          publish_async(event_data, **additional_attrs)
         else
-          publish_sync(event_data, **additional_arguments)
+          publish_sync(event_data, **additional_attrs)
         end
       end
 
+      #
+      # Flushes the topic's async queue
+      #
+      def flush!
+        # a publisher might be uninitialized until the first event is published
+        return unless topic.async_publisher
+
+        topic.async_publisher.stop.wait!
+      end
+
+      #
+      # If not called both client and topic are lazy initialized on first call (if not
+      # passed to #initialize). #auto_initialize! is going to explicitly initialize
+      # both client and topic.
+      #
+      def auto_initialize!
+        client
+        topic
+      end
+
       private
 
-      def publish_sync(event_data, **additional_arguments)
-        topic.publish(event_data, additional_arguments)
+      def publish_sync(event_data, **additional_attrs)
+        topic.publish(event_data, additional_attrs)
       end
 
-      def publish_async(event_data, **additional_arguments)
-        topic.publish_async(event_data, additional_arguments) do |result|
+      def publish_async(event_data, **additional_attrs)
+        topic.publish_async(event_data, additional_attrs) do |result|
           raise Stenotype::MessageNotPublishedError unless result.succeeded?
         end
       end

data/lib/stenotype/adapters/stdout_adapter.rb

@@ -31,8 +31,20 @@ module Stenotype
       #  adapter = Stenotype::Adapters::StdoutAdapter.new(client: STDERR)
       #  adapter.publish({ event: :data }, { additional: :data })
       #
-      def publish(event_data, **additional_arguments)
-        client.info(**event_data, **additional_arguments)
+      def publish(event_data, **additional_attrs)
+        client.info("[Stenotype::Event] emitted with the following attributes") do
+          {
+            **event_data,
+            **additional_attrs,
+          }
+        end
+      end
+
+      #
+      # Does nothing
+      #
+      def flush!
+        # noop
       end
 
       private

data/lib/stenotype/at_exit.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# :nocov:
+require "stenotype"
+
+at_exit do
+  targets = Stenotype.config.targets
+  targets.each(&:flush!)
+end
+# :nocov:

data/lib/stenotype/configuration.rb

@@ -6,6 +6,7 @@ module Stenotype
   #
   # @example Configuring the library
   #   Stenotype.configure do |config|
+  #     config.enabled = true
   #     config.targets = [Target1.new, Target2.new]
   #     config.uuid_generator = SecureRandom
   #
@@ -25,6 +26,18 @@ module Stenotype
   module Configuration
     extend Spicerack::Configurable
 
+    # @!attribute graceful_error_handling
+    # @return {true, false} a flag for suppressing error raised withing the gem
+
+    # @!attribute logger
+    # @return {Logger} a logger with default severity methods to output gem level messages
+
+    # @!attribute enabled
+    # @return {true, false} a flag indicating whether event emission is enabled
+
+    # @!attribute auto_adapter_initialization
+    # @return {true, false} enables/disables lazy initialization of adapters' clients
+
     # @!attribute targets
     # @return {Array<#publish>} a list of targets responding to method [#publish]
 
@@ -49,7 +62,6 @@ module Stenotype
     # @!attribute [rw] google_cloud.async
     # @return [true, false] GC publish mode, either async if true, sync if false
 
-
     # @!attribute [rw] rails
     # @return [NestedConfiguration] Rails configuration.
 
@@ -60,9 +72,12 @@ module Stenotype
     # @return [true, false] A flag of whether ActiveJob ext is enabled
 
     configuration_options do
+      option :graceful_error_handling, default: true
+      option :enabled, default: true
       option :targets, default: []
       option :dispatcher, default: Stenotype::Dispatcher
       option :uuid_generator, default: SecureRandom
+      option :logger
 
       nested :google_cloud do
         option :credentials, default: nil
@@ -74,11 +89,34 @@ module Stenotype
       nested :rails do
         option :enable_action_controller_ext, default: true
         option :enable_active_job_ext, default: true
+        option :auto_adapter_initialization, default: true
       end
     end
 
     module_function
 
+    #
+    # @example With default logger
+    #   Stenotype.configure do |config|
+    #     # config.logger = nil # logger not set manually
+    #   end
+    #   Stenotype.config.logger #=> `Logger.new(STDOUT)` instance
+    #
+    # @example With custom logger
+    #   Stenotype.configure do |config|
+    #     config.logger = custom_logger_instance
+    #   end
+    #   Stenotype.config.logger #=> custom_logger_instance
+    #
+    # @return [{Logger, CustomLogger}] a logger object. Logger.new(STDOUT) by
+    #   default if another is not set during configuration
+    #
+    def logger
+      return config.logger if config.logger
+
+      config.logger || Logger.new(STDOUT)
+    end
+
     #
     # @example When at least one target is present
     #   Stenotype.configure do |config|
@@ -93,6 +131,8 @@ module Stenotype
     # @raise {Stenotype::NoTargetsSpecifiedError} in case no targets are configured
     # @return {Array<#publish>} An array of targets implementing method [#publish]
     #
+    # @todo THIS NEVER GETS CALLED, needs a fix
+    #
     def targets
       return config.targets unless config.targets.empty?
 

data/lib/stenotype/emitter.rb

@@ -33,11 +33,12 @@ module Stenotype
     end
 
     #
-    # @!method emit_event(data = {}, method: caller_locations.first.label, eval_context: nil)
+    # @!method emit_event(name, attributes = {}, method: caller_locations.first.label, eval_context: nil)
     #   A method injected into target class to manually track events
     #   @!scope instance
-    #   @param data {Hash} Data to be sent to the targets
-    #   @param method {String} An optional method name
+    #   @param name {[String, Symbol]} Event name.
+    #   @param attributes {Hash} Data to be sent to the targets.
+    #   @param method {String} An optional method name.
     #   @param eval_context {Hash} A hash linking object to context handler
     #   @return {Stenotype::Event} An instance of emitted event
     #   @example Usage of emit_event
@@ -91,15 +92,14 @@ module Stenotype
     #
     def self.build_instance_methods(instance_mod)
       instance_mod.module_eval <<-RUBY, __FILE__, __LINE__ + 1
-        def emit_event(data = {}, method: caller_locations.first.label, eval_context: nil)
+        def emit_event(event_name, attributes = {}, method: caller_locations.first.label, eval_context: nil)
           Stenotype::Event.emit!(
+            event_name,
             {
-              type: "class_instance",
-              **data,
-            },
-            options: {
+              type: "instance_method",
               class: self.class.name,
-              method: method.to_sym
+              method: method.to_sym,
+              **attributes,
             },
             eval_context: (eval_context || { klass: self })
           )
@@ -120,12 +120,14 @@ module Stenotype
             proxy.module_eval do
               define_method(method) do |*args, **rest_args, &block|
                 Stenotype::Event.emit!(
-                  { type: "class_instance" },
-                  options: {
+                  # @todo How do we name such events?
+                  "instance_method",
+                  {
+                    type: "instance_method",
                     class: self.class.name,
-                    method: __method__
+                    method: __method__,
                   },
-                  eval_context: { klass: self }
+                  eval_context: { klass: self },
                 )
                 super(*args, **rest_args, &block)
               end
@@ -142,12 +144,14 @@ module Stenotype
             proxy.module_eval do
               define_method(method) do |*args, **rest_args, &block|
                 Stenotype::Event.emit!(
-                  { type: "class" },
-                  options: {
+                  # @todo How do we name such events?
+                  "class_method",
+                  {
+                    type: "class_method",
                     class: self.name,
-                    method: __method__
+                    method: __method__,
                   },
-                  eval_context: { klass: self }
+                  eval_context: { klass: self },
                 )
                 super(*args, **rest_args, &block)
               end

data/lib/stenotype/event.rb

@@ -11,19 +11,31 @@ module Stenotype
     # @example Emit an event using class method
     #   Stenotype::Event.emit!(data, options, eval_context)
     #
-    # @param data {Hash} Data to be published to the targets.
-    # @param options {Hash} A hash of additional options to be tracked.
-    # @param eval_context {Hash} A context having handler defined in {Stenotype::ContextHandlers}.
-    # @param dispatcher {#publish} A dispatcher object responding to [#publish]
+    # @param {[String, Symbol]} name Event name.
+    # @param {Hash} attributes Data to be published to the targets.
+    # @param {Hash} eval_context A context having handler defined in {Stenotype::ContextHandlers}.
+    # @param dispatcher {#publish} A dispatcher object responding to [#publish].
     # @return {Stenotype::Event} An instance of {Stenotype::Event}
     #
-    def self.emit!(data, options: {}, eval_context: {}, dispatcher: Stenotype.config.dispatcher)
-      event = new(data, options: options, eval_context: eval_context, dispatcher: dispatcher)
-      event.emit!
-      event
+    def self.emit!(name, attributes = {}, eval_context: {}, dispatcher: Stenotype.config.dispatcher)
+      return unless Stenotype.config.enabled
+
+      begin
+        event = new(name, attributes, eval_context: eval_context, dispatcher: dispatcher)
+        event.emit!
+        event
+      rescue StandardError => exception
+        #
+        # @todo This is a temporary solution to enable conditional logger fetching
+        #   needs a fix to use default Spicerack::Configuration functionality
+        #
+        Stenotype::Configuration.logger.error(exception)
+
+        raise Stenotype::Error unless Stenotype.config.graceful_error_handling
+      end
     end
 
-    attr_reader :data, :options, :eval_context, :dispatcher
+    attr_reader :name, :attributes, :eval_context, :dispatcher
 
     #
     # @example Create an event
@@ -31,15 +43,15 @@ module Stenotype
     # @example Create an event with custom dispatcher
     #   event = Stenotype::Event.new(data, options, eval_context, dispatcher: MyDispatcher.new)
     #
-    # @param {Hash} data Data to be published to the targets.
-    # @param {Hash} options A hash of additional options to be tracked.
+    # @param {[String, Symbol]} name Event name.
+    # @param {Hash} attributes Data to be published to the targets.
     # @param {Hash} eval_context A context having handler defined in {Stenotype::ContextHandlers}.
     # @param dispatcher {#publish} A dispatcher object responding to [#publish].
     # @return {Stenotype::Event} An instance of event
     #
-    def initialize(data, options: {}, eval_context: {}, dispatcher: Stenotype.config.dispatcher)
-      @data = data
-      @options = options
+    def initialize(name, attributes = {}, eval_context: {}, dispatcher: Stenotype.config.dispatcher)
+      @name = name
+      @attributes = attributes
       @eval_context = eval_context
       @dispatcher = dispatcher.new
     end
@@ -48,11 +60,23 @@ module Stenotype
     # Emits a {Stenotype::Event}.
     #
     # @example Emit an instance of event
-    #   event = Stenotype::Event.new(data, options, eval_context)
+    #   event = Stenotype::Event.new('events_name', { key: :value }, eval_context: { controller: ctrl })
     #   event.emit! #=> Publishes the event to targets
     #
     def emit!
-      dispatcher.publish(self)
+      return unless Stenotype.config.enabled
+
+      begin
+        dispatcher.publish(self)
+      rescue StandardError => exception
+        #
+        # @todo This is a temporary solution to enable conditional logger fetching
+        #   needs a fix to use default Spicerack::Configuration functionality
+        #
+        Stenotype::Configuration.logger.error(exception)
+
+        raise Stenotype::Error unless Stenotype.config.graceful_error_handling
+      end
     end
   end
 end

data/lib/stenotype/event_serializer.rb

@@ -42,8 +42,8 @@ module Stenotype
     #
     def serialize
       {
-        **event_data,
-        **event_options,
+        name: event_name,
+        **event_attributes,
         **default_options,
         **eval_context_options,
       }
@@ -51,12 +51,12 @@ module Stenotype
 
     private
 
-    def event_data
-      event.data
+    def event_name
+      event.name
     end
 
-    def event_options
-      event.options
+    def event_attributes
+      event.attributes
     end
 
     def eval_context

data/lib/stenotype/frameworks/rails/action_controller.rb

@@ -20,10 +20,11 @@ module Stenotype
 
         #
         # Emits and event with given data
-        # @param data {Hash} Data to be sent to targets
+        # @param name {[String, Symbol]} Event name
+        # @todo What is really the name here?
         #
-        def _record_freshly_event(data)
-          Stenotype::Event.emit!(data, options: {}, eval_context: { controller: self })
+        def _record_freshly_event(name)
+          Stenotype::Event.emit!(name, { type: "controller_action" }, { eval_context: { controller: self }})
         end
 
         #
@@ -72,7 +73,7 @@ module Stenotype
             return if delta.empty?
 
             before_action only: delta do
-              _record_freshly_event(type: "view")
+              _record_freshly_event("view")
             end
 
             _tracked_actions.merge(delta)
@@ -110,7 +111,7 @@ module Stenotype
             return if delta.empty?
 
             before_action only: delta.to_a do
-              _record_freshly_event(type: "view")
+              _record_freshly_event("view")
             end
 
             # merge is a mutating op

data/lib/stenotype/frameworks/rails/active_job.rb

@@ -35,9 +35,9 @@ module Stenotype
           proxy.module_eval do
             define_method(:perform) do |*args, **rest_args, &block|
               Stenotype::Event.emit!(
+                "active_job_#{self.class.name}",
                 { type: "active_job" },
-                { options: {},
-                  eval_context: { active_job: self }},
+                { eval_context: { active_job: self }},
               )
               super(*args, **rest_args, &block)
             end

data/lib/stenotype/railtie.rb

@@ -18,6 +18,8 @@ module Stenotype
 
     config.stenotype = Stenotype.config
 
+    config.after_initialize { config.stenotype.targets.each(&:auto_initialize!) } if config.stenotype.rails.auto_adapter_initialization
+
     if config.stenotype.rails.enable_action_controller_ext
       ActiveSupport.on_load(:action_controller) do
         Stenotype::ContextHandlers.register Stenotype::ContextHandlers::Rails::Controller

data/lib/stenotype/version.rb

@@ -2,6 +2,6 @@
 
 module Stenotype
   # :nodoc:
-  VERSION = "0.1.1"
+  VERSION = "0.1.7"
   # :nodoc:
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: stenotype
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.7
 platform: ruby
 authors:
 - Roman Kapitonov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-12-09 00:00:00.000000000 Z
+date: 2020-01-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -267,6 +267,7 @@ files:
 - lib/stenotype/adapters/base.rb
 - lib/stenotype/adapters/google_cloud.rb
 - lib/stenotype/adapters/stdout_adapter.rb
+- lib/stenotype/at_exit.rb
 - lib/stenotype/configuration.rb
 - lib/stenotype/context_handlers.rb
 - lib/stenotype/context_handlers/base.rb