loga 1.4.0 → 2.0.0

data/circle.yml

@@ -1,16 +1,16 @@
 dependencies:
   override:
-    - rvm-exec 2.2.2 bundle install -j 4
-    - rvm-exec 2.2.2 bundle exec appraisal install -j 4
+    - rvm-exec 2.2.5 bundle install -j 4
+    - rvm-exec 2.2.5 bundle exec appraisal install -j 4
     - rvm-exec 2.3.1 bundle install -j 4
     - rvm-exec 2.3.1 bundle exec appraisal install -j 4
 test:
   override:
-    - RACK_ENV=development rvm-exec 2.2.2 bundle exec appraisal rspec
-    - RACK_ENV=production  rvm-exec 2.2.2 bundle exec appraisal rspec
+    - RACK_ENV=development rvm-exec 2.2.5 bundle exec appraisal rspec
+    - RACK_ENV=production  rvm-exec 2.2.5 bundle exec appraisal rspec
     - RACK_ENV=development rvm-exec 2.3.1 bundle exec appraisal rspec
     - RACK_ENV=production  rvm-exec 2.3.1 bundle exec appraisal rspec
-    - rvm-exec 2.2.2 bundle exec rubocop
+    - rvm-exec 2.2.5 bundle exec rubocop
 deployment:
   gemfury:
     tag: /.*/

data/lib/loga.rb

@@ -5,23 +5,27 @@ require 'loga/utilities'
 require 'loga/event'
 require 'loga/formatter'
 require 'loga/parameter_filter'
-require 'loga/revision_strategy'
 require 'loga/rack/logger'
 require 'loga/rack/request'
 require 'loga/rack/request_id'
 require 'loga/railtie' if defined?(Rails)
 
 module Loga
-  def self.configuration
-    @configuration ||= Configuration.new
-  end
+  ConfigurationError = Class.new(StandardError)
 
-  def self.configure
-    yield configuration
+  def self.configuration
+    if @configuration.nil?
+      raise ConfigurationError,
+            'Loga has not been configured. Configure with Loga.configure(options)'
+    end
+    @configuration
   end
 
-  def self.initialize!
-    configuration.initialize!
+  def self.configure(options, framework_options = {})
+    unless @configuration.nil?
+      raise ConfigurationError, 'Loga has already been configured'
+    end
+    @configuration ||= Configuration.new(options, framework_options)
   end
 
   def self.logger

data/lib/loga/configuration.rb

@@ -1,76 +1,127 @@
+require 'active_support/core_ext/object/blank'
+require 'active_support/version'
+require 'loga/service_version_strategies'
 require 'logger'
 require 'socket'
 
 module Loga
   class Configuration
-    attr_accessor :service_name,
-                  :service_version,
-                  :device,
-                  :sync,
-                  :filter_parameters,
-                  :level,
-                  :host,
-                  :enabled,
-                  :silence_rails_rack_logger
-
-    attr_reader :logger
-
-    def initialize
-      @host              = gethostname
-      @device            = nil
-      @sync              = true
-      @level             = :info
-      @filter_parameters = []
-      @service_version   = :git
-
-      # Rails specific configuration
-      @enabled           = true
-      @silence_rails_rack_logger = true
+    DEFAULT_KEYS = %i(
+      device
+      filter_exceptions
+      filter_parameters
+      format
+      host
+      level
+      service_name
+      service_version
+      sync
+      tags
+    ).freeze
+
+    FRAMEWORK_EXCEPTIONS = %w(
+      ActionController::RoutingError
+      ActiveRecord::RecordNotFound
+      Sinatra::NotFound
+    ).freeze
+
+    attr_accessor(*DEFAULT_KEYS)
+    attr_reader :logger, :service_version
+    private_constant :DEFAULT_KEYS
+
+    def initialize(user_options = {}, framework_options = {})
+      options = default_options.merge(framework_options)
+                               .merge(environment_options)
+                               .merge(user_options)
+
+      DEFAULT_KEYS.each do |attribute|
+        public_send("#{attribute}=", options[attribute])
+      end
+
+      raise ConfigurationError, 'Service name cannot be blank' if service_name.blank?
+      raise ConfigurationError, 'Device cannot be blank' if device.blank?
+
+      @service_version = initialize_service_version
+      @logger          = initialize_logger
     end
 
-    def initialize!
-      @service_name = service_name.to_s.strip
-      @service_version = compute_service_version
+    def format=(name)
+      @format = name.to_s.to_sym
+    end
 
-      initialize_logger
+    def service_name=(name)
+      @service_name = name.to_s.strip
     end
 
-    def configure
-      yield self
+    def structured?
+      format == :gelf
     end
 
     private
 
-    def compute_service_version
-      RevisionStrategy.call(service_version)
+    def default_options
+      {
+        device:            STDOUT,
+        filter_exceptions: FRAMEWORK_EXCEPTIONS,
+        filter_parameters: [],
+        format:            :simple,
+        host:              hostname,
+        level:             :info,
+        sync:              true,
+        tags:              [],
+      }
     end
 
-    def initialize_logger
-      device.sync = sync
+    def environment_options
+      { format: ENV['LOGA_FORMAT'].presence }.reject { |_, v| v.nil? }
+    end
+
+    def initialize_service_version
+      service_version || ServiceVersionStrategies.call
+    end
 
+    def initialize_logger
+      device.sync      = sync
       logger           = Logger.new(device)
-      logger.formatter = Formatter.new(
-        service_name:    service_name,
-        service_version: service_version,
-        host:            host,
-      )
+      logger.formatter = assign_formatter
       logger.level     = constantized_log_level
-    rescue
-      logger           = Logger.new(STDERR)
-      logger.level     = Logger::ERROR
-      logger.error 'Loga could not be initialized'
-    ensure
-      @logger          = TaggedLogging.new(logger)
+      TaggedLogging.new(logger)
     end
 
     def constantized_log_level
       Logger.const_get(level.to_s.upcase)
     end
 
-    def gethostname
+    def hostname
       Socket.gethostname
-    rescue Exception
+    rescue SystemCallError
       'unknown.host'
     end
+
+    def assign_formatter
+      if format == :gelf
+        Formatter.new(
+          service_name:    service_name,
+          service_version: service_version,
+          host:            host,
+        )
+      else
+        active_support_simple_formatter
+      end
+    end
+
+    def active_support_simple_formatter
+      case ActiveSupport::VERSION::MAJOR
+      when 3
+        require 'active_support/core_ext/logger'
+        Logger::SimpleFormatter.new
+      when 4..5
+        require 'active_support/logger'
+        ActiveSupport::Logger::SimpleFormatter.new
+      else
+        raise Loga::ConfigurationError,
+              "ActiveSupport #{ActiveSupport::VERSION::MAJOR} is unsupported"
+      end
+    end
   end
 end

data/lib/loga/event.rb

@@ -10,6 +10,17 @@ module Loga
       @type      = opts[:type]
     end
 
+    def to_s
+      output = ["#{timestamp.iso8601(3)} #{message}"]
+      if exception
+        output.push exception.to_s
+        output.push exception.backtrace.join("\n")
+      end
+      output.join("\n")
+    end
+
+    alias inspect to_s
+
     private
 
     # Guard against Encoding::UndefinedConversionError

data/lib/loga/rack/logger.rb

@@ -3,11 +3,8 @@ module Loga
     class Logger
       include Utilities
 
-      attr_reader :logger, :taggers
-      def initialize(app, logger = nil, taggers = nil)
-        @app           = app
-        @logger        = logger
-        @taggers       = taggers || []
+      def initialize(app)
+        @app = app
       end
 
       def call(env)
@@ -37,6 +34,7 @@ module Loga
         send_message
       end
 
+      # rubocop:disable Metrics/LineLength
       def set_data
         data['method']     = request.request_method
         data['path']       = request.original_path
@@ -44,14 +42,15 @@ module Loga
         data['request_id'] = request.uuid
         data['request_ip'] = request.ip
         data['user_agent'] = request.user_agent
-        data['controller'] = request.action_controller if request.action_controller_instance
+        data['controller'] = request.controller_action_name if request.controller_action_name
         data['duration']   = duration_in_ms(started_at, Time.now)
       end
+      # rubocop:enable Metrics/LineLength
 
       def send_message
         event = Loga::Event.new(
           data:       { request: data },
-          exception:  fetch_exception,
+          exception:  compute_exception,
           message:    compute_message,
           timestamp:  started_at,
           type:       'request',
@@ -59,6 +58,10 @@ module Loga
         logger.public_send(compute_level, event)
       end
 
+      def logger
+        Loga.logger
+      end
+
       def compute_message
         '%{method} %{filtered_full_path} %{status} in %{duration}ms' % {
           method:             request.request_method,
@@ -69,25 +72,23 @@ module Loga
       end
 
       def compute_level
-        fetch_exception ? :error : :info
+        compute_exception ? :error : :info
       end
 
-      def fetch_exception
-        framework_exception.tap do |e|
-          return filtered_exceptions.include?(e.class.to_s) ? nil : e
-        end
+      def compute_exception
+        filter_exceptions.include?(exception.class.to_s) ? nil : exception
       end
 
-      def framework_exception
+      def exception
         env['loga.exception'] || env['action_dispatch.exception'] || env['sinatra.error']
       end
 
-      def filtered_exceptions
-        %w(ActionController::RoutingError Sinatra::NotFound)
+      def filter_exceptions
+        Loga.configuration.filter_exceptions
       end
 
       def compute_tags(request)
-        taggers.collect do |tag|
+        tags.map do |tag|
           case tag
           when Proc
             tag.call(request)
@@ -98,6 +99,10 @@ module Loga
           end
         end
       end
+
+      def tags
+        Loga.configuration.tags
+      end
     end
   end
 end

data/lib/loga/rack/request.rb

@@ -18,22 +18,28 @@ module Loga
 
       alias request_id uuid
 
-      def action_controller
-        "#{action_controller_instance.class}##{action_controller_instance.action_name}"
-      end
-
-      def action_controller_instance
-        @action_controller_instance ||= env[ACTION_CONTROLLER_INSTANCE]
+      # Builds a namespaced controller name and action name string.
+      #
+      # class Admin::UsersController
+      #   def show
+      #   end
+      # end
+      #
+      #  => "Admin::UsersController#show"
+      def controller_action_name
+        aci && "#{aci.class.name}##{aci.action_name}"
       end
 
       def original_path
         env['loga.request.original_path']
       end
 
+      # rubocop:disable Metrics/LineLength
       def filtered_full_path
         @filtered_full_path ||=
           query_string.empty? ? original_path : "#{original_path}?#{filtered_query_string}"
       end
+      # rubocop:enable Metrics/LineLength
 
       def filtered_parameters
         @filtered_parameters ||= filtered_query_hash.merge(filtered_form_hash)
@@ -83,6 +89,12 @@ module Loga
       def action_dispatch_filter_params
         env['action_dispatch.parameter_filter'] || []
       end
+
+      def action_controller_instance
+        @action_controller_instance ||= env[ACTION_CONTROLLER_INSTANCE]
+      end
+
+      alias aci action_controller_instance
     end
   end
 end

data/lib/loga/railtie.rb

@@ -2,41 +2,70 @@ require 'loga'
 
 module Loga
   class Railtie < Rails::Railtie
+    config.loga = {}
+
+    # This service class initializes Loga with user options, framework smart
+    # options and update Rails logger with Loga
     class InitializeLogger
+      def self.call(app)
+        new(app).call
+      end
+
       def initialize(app)
         @app = app
       end
 
       def call
-        loga.tap do |config|
-          config.sync  = sync
-          config.level = app.config.log_level
-        end
-        loga.initialize!
-        app.config.logger = loga.logger
+        validate_user_options
+        Loga.configure(user_options, rails_options)
+        app.config.colorize_logging = false if Loga.configuration.structured?
+        app.config.logger = Loga.logger
       end
 
       private
 
       attr_reader :app
 
-      def loga
+      def rails_options
+        {
+          format: format,
+          level:  app.config.log_level,
+          sync:   sync,
+          tags:   app.config.log_tags || [],
+        }.merge(device_options)
+      end
+
+      def device_options
+        Rails.env.test? ? { device: File.open('log/test.log', 'a') } : {}
+      end
+
+      def user_options
         app.config.loga
       end
 
+      def format
+        Rails.env.production? ? :gelf : :simple
+      end
+
       def sync
         Rails::VERSION::MAJOR > 3 ? app.config.autoflush_log : true
       end
 
-      def constantized_log_level
-        Logger.const_get(app.config.log_level.to_s.upcase)
+      # rubocop:disable Metrics/LineLength
+      def validate_user_options
+        if user_options[:tags].present?
+          raise Loga::ConfigurationError, 'Configure tags with Rails config.log_tags'
+        elsif user_options[:level].present?
+          raise Loga::ConfigurationError, 'Configure level with Rails config.log_level'
+        elsif user_options[:filter_parameters].present?
+          raise Loga::ConfigurationError, 'Configure filter_parameters with Rails config.filter_parameters'
+        end
       end
+      # rubocop:enable Metrics/LineLength
     end
 
-    config.loga = Loga::Configuration.new
-
     initializer :loga_initialize_logger, before: :initialize_logger do |app|
-      InitializeLogger.new(app).call if app.config.loga.enabled
+      InitializeLogger.call(app)
     end
 
     class InitializeMiddleware
@@ -56,15 +85,19 @@ module Loga
         end
       end
 
+      def self.call(app)
+        new(app).call
+      end
+
       def initialize(app)
         @app = app
       end
 
       def call
         insert_loga_rack_logger
-        disable_rails_rack_logger
+        silence_rails_rack_logger
         insert_exceptions_catcher
-        disable_action_dispatch_debug_exceptions
+        silence_action_dispatch_debug_exceptions_logger
       end
 
       private
@@ -81,45 +114,51 @@ module Loga
 
       # Removes start of request log
       # (e.g. Started GET "/users" for 127.0.0.1 at 2015-12-24 23:59:00 +0000)
-      def disable_rails_rack_logger
-        return unless app.config.loga.silence_rails_rack_logger
-
+      def silence_rails_rack_logger
         case Rails::VERSION::MAJOR
-        when 3 then require 'loga/ext/rails/rack/logger3.rb'
+        when 3    then require 'loga/ext/rails/rack/logger3.rb'
+        when 4..5 then require 'loga/ext/rails/rack/logger.rb'
         else
-          require 'loga/ext/rails/rack/logger.rb'
+          raise Loga::ConfigurationError,
+                "Rails #{Rails::VERSION::MAJOR} is unsupported"
         end
       end
 
-      def disable_action_dispatch_debug_exceptions
+      # Removes unstructured exception output. Exceptions are logged with
+      # Loga::Rack::Logger instead
+      def silence_action_dispatch_debug_exceptions_logger
         require 'loga/ext/rails/rack/debug_exceptions.rb'
       end
 
       def insert_loga_rack_logger
-        app.middleware.insert_after Rails::Rack::Logger,
-                                    Loga::Rack::Logger,
-                                    app.config.logger,
-                                    app.config.log_tags
+        app.middleware.insert_after Rails::Rack::Logger, Loga::Rack::Logger
       end
     end
 
     initializer :loga_initialize_middleware do |app|
-      InitializeMiddleware.new(app).call if app.config.loga.enabled
-      app.config.colorize_logging = false
+      InitializeMiddleware.call(app) if Loga.configuration.structured?
     end
 
     class InitializeInstrumentation
+      def self.call
+        new.call
+      end
+
       def call
-        remove_existing_log_subscriptions
+        ensure_subscriptions_attached
+        remove_log_subscriptions
       end
 
       private
 
-      # rubocop:disable Metrics/CyclomaticComplexity
-      def remove_existing_log_subscriptions
+      # Ensure LogSubscribers are attached when available
+      def ensure_subscriptions_attached
         ActionView::Base       if defined?(ActionView::Base)
         ActionController::Base if defined?(ActionController::Base)
+      end
 
+      # rubocop:disable Metrics/LineLength
+      def remove_log_subscriptions
         ActiveSupport::LogSubscriber.log_subscribers.each do |subscriber|
           case subscriber
           when defined?(ActionView::LogSubscriber) && ActionView::LogSubscriber
@@ -129,10 +168,12 @@ module Loga
           end
         end
       end
-      # rubocop:enable Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/LineLength
 
       def unsubscribe(component, subscriber)
-        events = subscriber.public_methods(false).reject { |method| method.to_s == 'call' }
+        events = subscriber
+                 .public_methods(false)
+                 .reject { |method| method.to_s == 'call' }
         events.each do |event|
           ActiveSupport::Notifications
             .notifier
@@ -146,8 +187,8 @@ module Loga
       end
     end
 
-    config.after_initialize do |app|
-      InitializeInstrumentation.new.call if app.config.loga.enabled
+    config.after_initialize do |_|
+      InitializeInstrumentation.call if Loga.configuration.structured?
     end
   end
 end