Initial commit

app/services/log/log.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Log
+  class Log
+    class LogFormatter < Logger::Formatter
+      attr_reader :options
+
+      def initialize(options = {})
+        @options = options
+        super() # superclass does not take parameters
+      end
+
+      def call(severity, timestamp, progname, msg)
+        super(severity, timestamp, progname, "#{log_tags}#{msg}")
+      end
+
+      def log_tags
+        tags = formatted_tags.join ' '
+        tags.blank? ? '' : "[#{tags}] "
+      end
+
+    private
+      def formatted_tags
+        elems = [Thread.current[:name].to_s]
+        elems += (options[:tags] || []).map { |e| e.is_a?(Proc) ? e.call : e }
+        elems.reject(&:blank?)
+      end
+    end
+
+    attr_reader :options # default = {}
+
+    # Options may include:
+    #   tags:   an array of static elements and/or callable Procs to include in log output
+    #   filename:       specifies filename for log in Rails log directory
+    #   stream:         specifies stream for log output (included for test support)
+    def initialize(options = {})
+      @options = options
+    end
+
+    def logger
+      @logger ||= begin
+        new_logger = Logger.new log_destination
+        new_logger.level = numeric_log_level
+        new_logger.formatter = LogFormatter.new options
+        new_logger
+      end
+    end
+
+    def numeric_log_level
+      AppConfig.numeric_log_level
+    end
+
+    # Returns filename for log or stream object if specified in options.
+    def log_destination
+      options[:stream].present? ? options[:stream] : log_filepath
+    end
+
+    def log_filepath
+      @log_filepath ||= log_dir.join log_filename
+    end
+
+    def log_filename
+      options[:filename].present? ? options[:filename].to_s : "#{Rails.env.to_s}.log"
+    end
+
+    def log_dir
+      @log_dir ||= begin
+        dir = Rails.root.join 'log'
+        FileUtils.mkdir_p dir
+        dir
+      end
+    end
+
+    # Same semantics as Log.error except uses current instance of logger.
+    def error(msg, exception = nil, options = {})
+      Log.log_error logger, msg, exception, options
+    end
+
+    # Same semantics as Log.raise_error except uses current instance of logger.
+    def raise_error(msg, exception, options = {})
+      error msg, exception, options
+      raise exception
+    end
+
+    class << self
+      # Logs and re-raises exception.
+      def raise_error (msg, exception, options = {})
+        error msg, exception, options
+        raise exception
+      end
+
+      # Logs error with exception backtrace detail if available.  Always uses Rails.logger.
+      #
+      # Options may include:
+      #   no_backtrace:   true suppresses backtrace
+      #
+      # Returns formatted msg.
+      def error(msg, exception = nil, options = {})
+        log_error Rails.logger, msg, exception, options
+      end
+
+      # Same semantics as Log.error except uses specified logger.
+      def log_error(logger, msg, exception = nil, options = {})
+        message = exception.nil? ? msg : "Exception #{exception.class.name}: #{exception.inspect} #{msg}"
+        logger.error message
+        logger.error exception.backtrace if exception.try(:backtrace) && !options[:no_backtrace]
+        message
+      end
+    end
+  end
+end

app/services/log/loggable.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative 'logging'
+
+module Log
+  module Loggable
+    def logger
+      Logging.instance.logger
+    end
+  end
+end

app/services/log/logging.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'singleton'
+
+module Log
+  class Logging
+    include Singleton
+
+    attr_accessor :logger
+  end
+end