event_logger_rails 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 110cf01af709d86d2e848b9d11363ca58a0ab433eb444c05b9e9044d22ed35a3
-  data.tar.gz: 4b338f9e6f937e16195fc6f184bbad7e376409dcf44e545c50c3cec101b58123
+  metadata.gz: 31f83610ba9d1fbd9edb2f165dd19927cfffce11f39f8fdb17c48743fe76eb27
+  data.tar.gz: 6a59e89dc85c6a82cada24710a84e8b2fb4b0aebac1babfe6ed7e47c54fbc805
 SHA512:
-  metadata.gz: 46be7cf18342e29d39b60f7cc4858858b5b880f16f049d65d89f69dccc0f0add12053be5020d6856a8db059f75f7f7b86f05e7733a55cadda3b3ed83dfe1e9c5
-  data.tar.gz: e69a33c9979e4bea40ec4ed0c723821c574586ab6a6ac29cea0f8e181fc0c545acf763b985d69b98899c5b2336262add45055479c3411673fc87ce20f760bc6f
+  metadata.gz: 8a91d59e2d7b19433d7405beb536b8a911cf17bc61a596ecd040110be5602340e0cc07179ceec627f7e4f0c4e1294015424adff2035b072f79c5e872c650683a
+  data.tar.gz: ec168b78dbcf93a860ecbcc42883a0401c743951a0434b42f22ed988d723b50a89dc3e1d916a50e0e4f5f486cb90dfcd6214b9fa458830ac0d7e136682e0cf1d

data/README.md

@@ -327,6 +327,14 @@ Rails.application.configure do |config|
 end
 ```
 
+You can configure a custom formatter. Reference `EventLoggerRails::Formatters::JSON` for an example.
+
+```ruby
+Rails.application.configure do |config|
+  config.event_logger_rails.formatter = 'MyCustomFormatterClass'
+end
+```
+
 By default, `EventLoggerRails` outputs to a separate log file (`log/event_logger_rails.#{Rails.env}.log`) from normal Rails log output, allowing
 you to ingest these logs independently. If you wish to set an alternative log device to capture output, you can configure it in `config/application.rb`:
 
@@ -344,6 +352,25 @@ Rails.application.configure do |config|
 end
 ```
 
+You can configure a custom logger. Reference `EventLoggerRails::EventLogger` for an example.
+
+```ruby
+Rails.application.configure do |config|
+  config.event_logger_rails.logger_class = 'MyCustomLoggerClass'
+end
+```
+
+You can also configure the Rails logger to use `EventLoggerRails::EventLogger` to render structured logs in JSON format with the additional app and request data.
+
+```ruby
+Rails.application.configure do
+  config.colorize_logging = false
+  config.log_level = ENV.fetch('RAILS_LOG_LEVEL', :info)
+  logger = EventLoggerRails::EventLogger.new($stdout)
+  config.logger = ActiveSupport::TaggedLogging.new(logger)
+end
+```
+
 ## Contributing
 
 Your inputs echo in this realm. Venture forth and materialize your thoughts through a PR.

data/app/controllers/concerns/event_logger_rails/loggable_controller.rb

@@ -7,13 +7,16 @@ module EventLoggerRails
     extend ActiveSupport::Concern
     include EventLoggerRails::Extensions::Loggable
 
-    def optional_data
+    # Includes the controller name and action in the log output.
+    #
+    # @return [Hash] The data to include in log output.
+    def optional_event_logger_data
       {
         action: action_name,
         controller: controller_name.camelcase
       }
     end
 
-    private :optional_data
+    private :optional_event_logger_data
   end
 end

data/app/models/concerns/event_logger_rails/loggable_model.rb

@@ -7,13 +7,16 @@ module EventLoggerRails
     extend ActiveSupport::Concern
     include EventLoggerRails::Extensions::Loggable
 
-    def optional_data
+    # Includes the model name and instance ID in the log output.
+    #
+    # @return [Hash] The data to include in log output.
+    def optional_event_logger_data
       {
         model: self.class.name,
         instance_id: id
       }
     end
 
-    private :optional_data
+    private :optional_event_logger_data
   end
 end

data/lib/event_logger_rails/current_request.rb

@@ -1,9 +1,21 @@
 # frozen_string_literal: true
 
 module EventLoggerRails
-  ##
   # Provides global state with request details
   class CurrentRequest < ActiveSupport::CurrentAttributes
+    # @note Defines the attributes for the current request object.
+    # @!attribute [rw] id
+    #   @return [String] The ID of the request.
+    # @!attribute [rw] format
+    #   @return [Symbol] The format of the request.
+    # @!attribute [rw] method
+    #   @return [String] The HTTP method of the request.
+    # @!attribute [rw] parameters
+    #   @return [Hash] The parameters of the request.
+    # @!attribute [rw] path
+    #   @return [String] The path of the request.
+    # @!attribute [rw] remote_ip
+    #   @return [String] The remote IP of the request.
     attribute :id, :format, :method, :parameters, :path, :remote_ip
   end
 end

data/lib/event_logger_rails/emitter.rb

@@ -1,13 +1,27 @@
 # frozen_string_literal: true
 
 module EventLoggerRails
-  ##
   # Processes events, sending data to logger.
   class Emitter
-    def initialize(logdev:)
-      @logger = JsonLogger.new(logdev)
+    # Initializes the emitter.
+    # It references the configured log device for log output.
+    # It references the configured logger class for logging, falling back to EventLogger.
+    def initialize
+      logdev = EventLoggerRails.logdev
+      @logger = EventLoggerRails.logger_class.constantize.new(logdev) || EventLoggerRails::EventLogger.new(logdev)
     end
 
+    # Validates and logs an event with the given level and data.
+    # If an error is raised, it recursively calls itself with the error's event.
+    #
+    # @note Prefer to use the public API provided by `EventLoggerRails.log()`.
+    # @param event [EventLoggerRails::Event, String] The event to log. Can be a string or an Event object.
+    # @param level [Symbol] The level of the event.
+    # @param data [Hash] Additional data to log.
+    # @return [Integer] The number of bytes written to the log.
+    # @example
+    #   emitter = EventLoggerRails::Emitter.new
+    #   emitter.log('foo.bar.baz', level: :info, data: { foo: 'bar' })
     def log(event, level:, data: {})
       Event.new(event).validate! do |validated_event|
         message = Message.new(event: validated_event, data:)
@@ -20,8 +34,16 @@ module EventLoggerRails
 
     private
 
+    # @!attribute [r] logger
+    #   @return [JsonLogger] The logger instance used for log output.
     attr_reader :logger
 
+    # Logs a message with the given level.
+    #
+    # @param message [String] The message to log.
+    # @param level [Symbol] The level of the message.
+    # @return [Integer] The number of bytes written to the log.
+    # @raise [EventLoggerRails::Exceptions::InvalidLoggerLevel] If the level is invalid.
     def log_message(message, level)
       logger.send(level) { message }
     rescue NoMethodError

data/lib/event_logger_rails/engine.rb

@@ -1,28 +1,43 @@
 # frozen_string_literal: true
 
 module EventLoggerRails
-  ##
-  # Engine for plugging into Rails
+  # Engine for plugging into Rails.
   class Engine < ::Rails::Engine
+    # Use the EventLoggerRails namespace.
     isolate_namespace EventLoggerRails
 
+    # Use the rspec test framework.
     config.generators do |generator|
       generator.test_framework :rspec
     end
 
+    # Initialize the EventLoggerRails configuration.
     config.event_logger_rails = ActiveSupport::OrderedOptions.new
+    config.event_logger_rails.formatter = 'EventLoggerRails::Formatters::JSON'
     config.event_logger_rails.logdev = "log/event_logger_rails.#{Rails.env}.log"
+    config.event_logger_rails.logger_class = 'EventLoggerRails::EventLogger'
     config.event_logger_rails.default_level = :warn
 
+    # Add the EventLoggerRails middleware.
     initializer 'event_logger_rails.add_middleware' do |app|
+      # Use middleware to capture the request details.
       app.middleware.use Middleware::CaptureRequestDetails
     end
 
+    # Configure EventLoggerRails
     config.after_initialize do |app|
       EventLoggerRails.setup do |engine|
+        # Set the default logging level from the registration.
         engine.default_level = app.config.event_logger_rails.default_level
+        # Set the formatter.
+        engine.formatter = app.config.event_logger_rails.formatter
+        # Set the log device.
         engine.logdev = app.config.event_logger_rails.logdev
+        # Set the logger class.
+        engine.logger_class = app.config.event_logger_rails.logger_class
+        # Set the registered events from the registration.
         engine.registered_events = Rails.application.config_for(:event_logger_rails)
+        # Set the sensitive fields.
         engine.sensitive_fields = app.config.filter_parameters
       end
     end

data/lib/event_logger_rails/event.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 module EventLoggerRails
-  ##
   # Models an event for logging.
   class Event
+    # Contains the default event registration.
     DEFAULT_EVENTS = {
       'event_logger_rails.logger_level.invalid' => {
         description: 'Indicates provided level was invalid.',
@@ -20,32 +20,89 @@ module EventLoggerRails
     }.freeze
     private_constant :DEFAULT_EVENTS
 
-    attr_reader :identifier, :description, :level
+    # @!attribute [r] identifier
+    #   @return [String] The identifier of the event.
+    attr_reader :identifier
 
+    # @!attribute [r] description
+    #   @return [String] The description of the event.
+    attr_reader :description
+
+    # @!attribute [r] level
+    #   @return [Symbol] The configured logging level of the event.
+    attr_reader :level
+
+    # Initializes the event using the provided identifier to determine its properties from
+    # either the default registration (for default events) or the user-defined registry.
+    #
+    # @param provided_identifier [EventLoggerRails::Event, String] The event or its identifier.
     def initialize(provided_identifier)
       @provided_identifier = provided_identifier.to_s
 
+      # Attempt to find default registration for event
       if (default_event = DEFAULT_EVENTS[@provided_identifier])
         default_registration = [@provided_identifier, *default_event&.values]
       end
 
+      # Fallback to user-defined registration if default not found.
+      # Deconstruct registration to set identifier, description, and level attributes.
       @identifier, @description, @level = default_registration || config_registration
     end
 
+    # Converts the event into a hash and merges the given hash into it.
+    #
+    # @param kwargs [Hash] The hash to merge into the event.
+    # @return [Hash] The merged hash.
+    # @example
+    #   event = EventLoggerRails::Event.new('event_logger_rails.event.testing')
+    #   event.merge(foo: 'bar')
+    #   # {
+    #   #   event_identifier: 'event_logger_rails.event.testing',
+    #   #   event_description: 'Event reserved for testing',
+    #   #   foo: 'bar'
+    #   # }
     def merge(...)
       to_hash.merge(...)
     end
 
+    # Determines if the event is valid.
+    #
+    # @return [Boolean] true if the event is valid, false otherwise.
+    # @example
+    #   valid_event = EventLoggerRails::Event.new('event_logger_rails.event.testing')
+    #   valid_event.valid? # => true
+    #   invalid_event = EventLoggerRails::Event.new('foo.bar.baz')
+    #   invalid_event.valid? # => false
     def valid?
       identifier.present?
     end
 
+    # Validates the event and yields it to the given block.
+    #
+    # @note This only validates the event registration. Logger level is validated at the time of logging.
+    # @yield [self] Yields the event to the given block.
+    # @raise [EventLoggerRails::Exceptions::UnregisteredEvent] If the event is not registered.
+    # @example
+    #   event = EventLoggerRails::Event.new('event_logger_rails.event.testing')
+    #   event.validate! do |validated_event|
+    #     puts "Event: #{validated_event}"
+    #   end
     def validate!
       raise Exceptions::UnregisteredEvent.new(unregistered_event: self) unless valid?
 
       yield(self)
     end
 
+    # Returns a hash representation of the event.
+    #
+    # @return [Hash] The event as a hash.
+    # @example
+    #   event = EventLoggerRails::Event.new('event_logger_rails.event.testing')
+    #   event.to_hash
+    #   # {
+    #   #   event_identifier: 'event_logger_rails.event.testing',
+    #   #   event_description: 'Event reserved for testing'
+    #   # }
     def to_hash
       {
         event_identifier: identifier,
@@ -53,18 +110,38 @@ module EventLoggerRails
       }
     end
 
+    # Returns a string representation of the event.
+    # The provided identifier is returned if the event is not registered.
+    #
+    # @return [String] The event as a string.
+    # @example
+    #   event = EventLoggerRails::Event.new('event_logger_rails.event.testing')
+    #   event.to_s # => 'event_logger_rails.event.testing'
     def to_s
       identifier&.to_s || provided_identifier.to_s
     end
 
+    # Determines if the event is equivalent to the given object through string comparison.
+    #
+    # @param other [EventLoggerRails::Event] The event to compare.
+    # @return [Boolean] true if the event is equal to the given object, false otherwise.
+    # @example
+    #   event = EventLoggerRails::Event.new('event_logger_rails.event.testing')
+    #   event == 'event_logger_rails.event.testing' # => true
     def ==(other)
       to_s == other.to_s
     end
 
     private
 
+    # @!attribute [r] provided_identifier
+    #   @return [String] The identifier provided when the event was initialized.
     attr_reader :provided_identifier
 
+    # Parses the event identifier and looks up the details from the user-defined registry.
+    #
+    # @return [Array<String, String, Symbol>] The identifier, description, and level of the event.
+    #   If the event is not registered, each array element will be nil.
     def config_registration
       parsed_event = provided_identifier.split('.').map(&:to_sym)
       config = EventLoggerRails.registered_events.dig(*parsed_event)

data/lib/event_logger_rails/event_logger.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module EventLoggerRails
+  # Writes log entries in configured format.
+  class EventLogger < ::Logger
+    include ActiveSupport::LoggerSilence
+
+    # Initializes the logger with a JSON formatter.
+    #
+    # @param logdev [IO, #write] The log device for log output.
+    def initialize(...)
+      super(...)
+      @formatter = EventLoggerRails.formatter.constantize.new || EventLoggerRails::Formatters::JSON.new
+    end
+  end
+end

data/lib/event_logger_rails/exceptions/invalid_logger_level.rb

@@ -2,17 +2,22 @@
 
 module EventLoggerRails
   module Exceptions
-    ##
     # Indicates invalid log level provided.
     class InvalidLoggerLevel < StandardError
+      # @!attribute [r] event
+      #   @return [EventLoggerRails::Event] The default invalid logging level event.
       attr_reader :event
 
+      # Initializes the exception with the given logger level.
       def initialize(logger_level:)
         super
         @event = Event.new('event_logger_rails.logger_level.invalid')
         @logger_level = logger_level
       end
 
+      # Provides an informative error message.
+      #
+      # @return [String] The error message.
       def message
         "Invalid logger level provided: '#{logger_level.to_sym}'. " \
           'Valid levels: :debug, :info, :warn, :error, :unknown.'
@@ -20,6 +25,8 @@ module EventLoggerRails
 
       private
 
+      # @!attribute [r] logger_level
+      #   @return [Symbol] The invalid logger level.
       attr_reader :logger_level
     end
   end

data/lib/event_logger_rails/exceptions/unregistered_event.rb

@@ -2,23 +2,32 @@
 
 module EventLoggerRails
   module Exceptions
-    ##
     # Indicates event provided not registered.
     class UnregisteredEvent < StandardError
+      # @!attribute [r] event
+      #   @return [EventLoggerRails::Event] The default event for unregistered events.
       attr_reader :event
 
+      # Initializes the exception with the given unregistered event.
+      #
+      # @param unregistered_event [EventLoggerRails::Event] The unregistered event.
       def initialize(unregistered_event:)
         super()
         @event = Event.new('event_logger_rails.event.unregistered')
         @unregistered_event = unregistered_event
       end
 
+      # Provides an informative error message.
+      #
+      # @return [String] The error message.
       def message
         "Event provided not registered: #{unregistered_event}"
       end
 
       private
 
+      # @!attribute [r] unregistered_event
+      #   @return [EventLoggerRails::Event] The unregistered event.
       attr_reader :unregistered_event
     end
   end

data/lib/event_logger_rails/extensions/loggable.rb

@@ -2,20 +2,28 @@
 
 module EventLoggerRails
   module Extensions
-    ##
-    # Provides event logging with relevant model data.
+    # Provides event logging with optional data.
     module Loggable
+      # Logs an event with the given level and data.
+      #
+      # @param event [EventLoggerRails::Event] The event to log.
+      # @option kwargs [Symbol] :level The level of the event.
+      # @option kwargs [Hash] :data The data of the event.
       def log_event(event, **kwargs)
         EventLoggerRails.log(
           event,
           level: kwargs[:level] || nil,
-          data: (kwargs[:data] || {}).merge(optional_data)
+          data: (kwargs[:data] || {}).merge(optional_event_logger_data)
         )
       end
 
       private
 
-      def optional_data
+      # Optional data to include in log output.
+      #
+      # @return [Hash] The data to include in log output.
+      # @note This method can be overridden by classes that implement Loggable.
+      def optional_event_logger_data
         {}
       end
     end

data/lib/event_logger_rails/formatters/json.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module EventLoggerRails
+  module Formatters
+    # Writes log entries in JSON format
+    class JSON < ActiveSupport::Logger::SimpleFormatter
+      # Returns the formatted output for logging.
+      #
+      # @param level [Symbol] The level of the event.
+      # @param timestamp [Time] The timestamp of the event.
+      # @param progname [String] The name of the logger.
+      # @param message [EventLoggerRails::Message, Hash, String] The message containing the data for logging.
+      # @return [String] The formatted output for logging.
+      def call(level, timestamp, _progname, message)
+        output = Output.new(level:, timestamp:, message:)
+        "#{output.to_json}\n"
+      end
+    end
+  end
+end

data/lib/event_logger_rails/message.rb

@@ -1,20 +1,32 @@
 # frozen_string_literal: true
 
 module EventLoggerRails
-  ##
   # Models a message sent to the logger containing event and optional data
   class Message
+    # Initializes the message with the given event and data.
+    #
+    # @param event [EventLoggerRails::Event] The event to log.
+    # @param data [Hash] Additional data to log.
     def initialize(event:, data: {})
       @event = event
       @data = data
     end
 
+    # Converts the message to a hash containing the event and data details.
+    #
+    # @return [Hash] The hash representation of the message.
     def to_hash
       event.merge(data)
     end
 
     private
 
-    attr_reader :event, :data
+    # @!attribute [r] event
+    #   @return [EventLoggerRails::Event] The event to log.
+    attr_reader :event
+
+    # @!attribute [r] data
+    #   @return [Hash] Additional data to log.
+    attr_reader :data
   end
 end

data/lib/event_logger_rails/middleware/capture_request_details.rb

@@ -4,14 +4,21 @@ require_relative '../current_request'
 
 module EventLoggerRails
   module Middleware
-    ##
     # Middleware to capture request details and store in global state
     class CaptureRequestDetails
+      # Initializes the middleware with the given app.
+      #
+      # @param app [Proc] The Rack app.
       def initialize(app)
         @app = app
       end
 
       # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+
+      # Captures request details and stores in global state
+      #
+      # @param env [Hash] The Rack environment.
+      # @note The CurrentRequest is reset at the end of the request.
       def call(env)
         begin
           request = ActionDispatch::Request.new(env)

data/lib/event_logger_rails/output.rb

@@ -1,9 +1,13 @@
 # frozen_string_literal: true
 
 module EventLoggerRails
-  ##
   # Merges data from application, request, and logger message for structured output
   class Output
+    # Initializes the output with the given level, timestamp, and message.
+    #
+    # @param level [Symbol] The level of the event.
+    # @param timestamp [Time] The timestamp of the event.
+    # @param message [EventLoggerRails::Message] The message of the event.
     def initialize(level:, timestamp:, message:)
       @current_request = EventLoggerRails::CurrentRequest
       @level = level
@@ -11,22 +15,48 @@ module EventLoggerRails
       @message = message.respond_to?(:to_hash) ? sanitizer.filter(**message) : { message: }
     end
 
+    # Converts the output to a JSON string.
+    #
+    # @return [String] The JSON representation of the output.
     def to_json(*args)
       JSON.generate(to_hash, *args)
     end
 
+    # Converts the output to a hash containing the application, request, and logger details.
+    #
+    # @return [Hash] The hash representation of the output.
     def to_hash
       application_data.merge(**current_request_data, **logger_data)
     end
 
     private
 
-    attr_reader :level, :timestamp, :message, :current_request
+    # @!attribute [r] level
+    #   @return [Symbol] The level of the event.
+    attr_reader :level
 
+    # @!attribute [r] timestamp
+    #   @return [Time] The timestamp of the event.
+    attr_reader :timestamp
+
+    # @!attribute [r] message
+    #   @return [EventLoggerRails::Message] The message to log.
+    attr_reader :message
+
+    # @!attribute [r] current_request
+    #   @return [EventLoggerRails::CurrentRequest] The object storing the current request data.
+    attr_reader :current_request
+
+    # Finds or initializes a parameter filter for sensitive data.
+    #
+    # @return [ActiveSupport::ParameterFilter] The parameter filter for sensitive data.
     def sanitizer
       @sanitizer ||= ActiveSupport::ParameterFilter.new(EventLoggerRails.sensitive_fields)
     end
 
+    # Structures the application data to include in the output.
+    #
+    # @return [Hash] The application data to include in the output.
     def application_data
       {
         environment: Rails.env,
@@ -36,6 +66,10 @@ module EventLoggerRails
     end
 
     # rubocop:disable Metrics/AbcSize
+
+    # Structures the request data to include in the output.
+    #
+    # @return [Hash] The request data to include in the output.
     def current_request_data
       return {} if CurrentRequest.instance.attributes.blank?
 
@@ -50,6 +84,10 @@ module EventLoggerRails
     end
     # rubocop:enable Metrics/AbcSize
 
+    # Structures the logger data to include in the output.
+    #
+    # @return [Hash] The logger data to include in the output.
+    # @note The logger data includes the level, timestamp, and message.
     def logger_data
       {
         level:,

data/lib/event_logger_rails/version.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
 module EventLoggerRails
-  VERSION = '0.3.0'
+  # The version of the gem.
+  #
+  # @return [String] The version of the gem.
+  VERSION = '0.4.0'
 end

data/lib/event_logger_rails.rb

@@ -2,39 +2,79 @@
 
 require 'rails'
 require 'active_support/dependencies'
-require 'event_logger_rails/engine'
 require 'event_logger_rails/current_request'
-require 'event_logger_rails/event'
+require 'event_logger_rails/engine'
 require 'event_logger_rails/emitter'
+require 'event_logger_rails/event'
+require 'event_logger_rails/event_logger'
 require 'event_logger_rails/exceptions/invalid_logger_level'
 require 'event_logger_rails/exceptions/unregistered_event'
 require 'event_logger_rails/extensions/loggable'
-require 'event_logger_rails/json_logger'
+require 'event_logger_rails/formatters/json'
 require 'event_logger_rails/message'
 require 'event_logger_rails/middleware/capture_request_details'
 require 'event_logger_rails/output'
 require 'event_logger_rails/version'
 
-##
-# Namespace for EventLoggerRails gem
+# Provides configurable state and public API for EventLoggerRails.
+# Also serves as the namespace for the gem.
 module EventLoggerRails
+  # @!attribute [r] default_level
+  #   @return [Symbol] The default level of the events logged by EventLoggerRails.
   mattr_accessor :default_level
+
+  # @!attribute [r] formatter
+  #   @return [Class] The formatter to use for logging.
+  mattr_accessor :formatter
+
+  # @!attribute [r] logdev
+  #   @return [IO, #write] The log device used by EventLoggerRails.
   mattr_accessor :logdev
+
+  # @!attribute [r] logger_class
+  #   @return [Class] The logger class used by EventLoggerRails.
+  mattr_accessor :logger_class
+
+  # @!attribute [r] registered_events
+  #   @return [Array<Hash>] The events registry defined in the config/event_logger_rails.yml file.
   mattr_accessor :registered_events
+
+  # @!attribute [r] sensitive_fields
+  #   @return [Array<Symbol>] The fields which may contain sensitive data that EventLoggerRails should filter.
   mattr_accessor :sensitive_fields
 
+  # Provides a method for configuring EventLoggerRails.
+  #
+  # @yield [self] Gives the class itself to the block for configuration.
+  # @example
+  #   EventLoggerRails.setup do |config|
+  #     config.default_level = :info
+  #   end
+  # @return [void]
   def self.setup
     yield self
   end
 
+  # Returns or initializes the Emitter instance for EventLoggerRails.
+  #
+  # @return [Emitter] The Emitter instance used for logging events.
   def self.emitter
-    @emitter ||= Emitter.new(logdev:)
+    @emitter ||= Emitter.new
   end
 
+  # Forwards the arguments to the Emitter's log method.
+  #
+  # @example
+  #   EventLoggerRails.log('foo.bar.baz', level: :info, data: { foo: 'bar' })
+  # @param (see Emitter#log)
+  # @return (see Emitter#log)
   def self.log(...)
     emitter.log(...)
   end
 
+  # Resets the Emitter instance.
+  #
+  # @return [void]
   def self.reset
     @emitter = nil
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: event_logger_rails
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Dick Davis
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-10-06 00:00:00.000000000 Z
+date: 2024-08-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -43,10 +43,11 @@ files:
 - lib/event_logger_rails/emitter.rb
 - lib/event_logger_rails/engine.rb
 - lib/event_logger_rails/event.rb
+- lib/event_logger_rails/event_logger.rb
 - lib/event_logger_rails/exceptions/invalid_logger_level.rb
 - lib/event_logger_rails/exceptions/unregistered_event.rb
 - lib/event_logger_rails/extensions/loggable.rb
-- lib/event_logger_rails/json_logger.rb
+- lib/event_logger_rails/formatters/json.rb
 - lib/event_logger_rails/message.rb
 - lib/event_logger_rails/middleware/capture_request_details.rb
 - lib/event_logger_rails/output.rb

data/lib/event_logger_rails/json_logger.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module EventLoggerRails
-  ##
-  # Writes log entries in JSON format
-  class JsonLogger < ::Logger
-    def initialize(...)
-      super(...)
-      @formatter = proc do |level, timestamp, _progname, message|
-        output = Output.new(level:, timestamp:, message:)
-        "#{output.to_json}\n"
-      end
-    end
-  end
-end