loga 1.0.0

data/lib/loga/event.rb

@@ -0,0 +1,21 @@
+module Loga
+  class Event
+    attr_accessor :data, :exception, :message, :timestamp, :type
+
+    def initialize(opts = {})
+      @data      = opts[:data]
+      @exception = opts[:exception]
+      @message   = safe_encode(opts[:message])
+      @timestamp = opts[:timestamp]
+      @type      = opts[:type]
+    end
+
+    private
+
+    # Guard against Encoding::UndefinedConversionError
+    # http://stackoverflow.com/questions/13003287/encodingundefinedconversionerror
+    def safe_encode(text)
+      text.to_s.encode('UTF-8', invalid: :replace, undef: :replace, replace: '?')
+    end
+  end
+end

data/lib/loga/ext/rails/rack/logger3.rb

@@ -0,0 +1,21 @@
+require 'rails/rack/logger'
+
+module Rails
+  module Rack
+    class Logger
+      protected
+
+      def call_app(_request, env)
+        @app.call(env)
+      ensure
+        ActiveSupport::LogSubscriber.flush_all!
+      end
+
+      private
+
+      def compute_tags(_request)
+        []
+      end
+    end
+  end
+end

data/lib/loga/ext/rails/rack/logger4.rb

@@ -0,0 +1,13 @@
+require 'rails/rack/logger'
+
+module Rails
+  module Rack
+    class Logger
+      private
+
+      def logger
+        ::Logger.new('/dev/null')
+      end
+    end
+  end
+end

data/lib/loga/formatter.rb

@@ -0,0 +1,104 @@
+require 'logger'
+require 'json'
+
+module Loga
+  class Formatter < Logger::Formatter
+    include TaggedLogging::Formatter
+
+    GELF_VERSION = '1.1'.freeze
+    SYSLOG_LEVEL_MAPPING = {
+      'DEBUG'   => 7,
+      'INFO'    => 6,
+      'WARN'    => 4,
+      'ERROR'   => 3,
+      'FATAL'   => 2,
+      'UNKNOWN' => 1,
+    }.freeze
+    DEFAULT_TYPE = 'default'.freeze
+
+    def initialize(opts)
+      @service_name    = opts.fetch(:service_name)
+      @service_version = opts.fetch(:service_version)
+      @host            = opts.fetch(:host)
+    end
+
+    def call(severity, time, _progname, message)
+      event = build_event(time, message)
+      payload = format_additional_fields(event.data)
+
+      payload[:short_message] = event.message
+      payload[:timestamp]     = compute_timestamp(event.timestamp)
+      payload[:host]          = @host
+      payload[:level]         = compute_level(severity)
+      payload[:version]       = GELF_VERSION
+
+      "#{payload.to_json}\n"
+    end
+
+    private
+
+    def build_event(time, message)
+      event = case message
+              when Loga::Event
+                message
+              else
+                Loga::Event.new(message: message)
+              end
+
+      event.timestamp ||= time
+      event.data ||= {}
+      event.data.tap do |hash|
+        hash.merge! compute_exception(event.exception)
+        hash.merge! compute_type(event.type)
+        # Overwrite hash with Loga's additional fields
+        hash.merge! loga_additional_fields
+      end
+      event
+    end
+
+    def compute_timestamp(timestamp)
+      (timestamp.to_f * 1000).floor / 1000.0
+    end
+
+    def compute_level(severity)
+      SYSLOG_LEVEL_MAPPING[severity]
+    end
+
+    def format_additional_fields(fields)
+      fields.each_with_object({}) do |(main_key, values), hash|
+        if values.is_a?(Hash)
+          values.each do |sub_key, sub_values|
+            hash["_#{main_key}.#{sub_key}"] = sub_values
+          end
+        else
+          hash["_#{main_key}"] = values
+        end
+      end
+    end
+
+    def compute_exception(exception)
+      return {} unless exception
+      {
+        exception: {
+          klass:     exception.class.to_s,
+          message:   exception.message,
+          backtrace: exception.backtrace.first(10).join("\n"),
+        },
+      }
+    end
+
+    def compute_type(type)
+      type ? { type: type } : {}
+    end
+
+    def loga_additional_fields
+      {
+        service: {
+          name:    @service_name,
+          version: @service_version,
+        },
+        tags: current_tags,
+      }
+    end
+  end
+end

data/lib/loga/parameter_filter.rb

@@ -0,0 +1,65 @@
+module Loga
+  class ParameterFilter
+    FILTERED = '[FILTERED]'.freeze
+
+    attr_accessor :filters
+
+    def initialize(filters)
+      @filters = filters
+    end
+
+    def filter(params)
+      compiled_filters.call(params)
+    end
+
+    private
+
+    def compiled_filters
+      @compiled_filters ||= CompiledFilter.compile(filters)
+    end
+
+    class CompiledFilter
+      def self.compile(filters)
+        ->(params) { params.dup } if filters.empty?
+
+        regexps = []
+        strings = []
+
+        filters.each do |item|
+          if item.is_a?(Regexp)
+            regexps << item
+          else
+            strings << Regexp.escape(item.to_s)
+          end
+        end
+
+        regexps << Regexp.new(strings.join('|'), true) unless strings.empty?
+        new regexps
+      end
+
+      attr_reader :regexps
+
+      def initialize(regexps)
+        @regexps = regexps
+      end
+
+      def call(original_params)
+        filtered_params = {}
+
+        original_params.each do |key, value|
+          if regexps.any? { |r| key =~ r }
+            value = FILTERED
+          elsif value.is_a?(Hash)
+            value = call(value)
+          elsif value.is_a?(Array)
+            value = value.map { |v| v.is_a?(Hash) ? call(v) : v }
+          end
+
+          filtered_params[key] = value
+        end
+
+        filtered_params
+      end
+    end
+  end
+end

data/lib/loga/rack/logger.rb

@@ -0,0 +1,102 @@
+module Loga
+  module Rack
+    class Logger
+      include Utilities
+
+      attr_reader :logger, :taggers
+      def initialize(app, logger = nil, taggers = nil)
+        @app           = app
+        @logger        = logger
+        @taggers       = taggers || []
+      end
+
+      def call(env)
+        request = Loga::Rack::Request.new(env)
+        env['loga.request.original_path'] = request.path
+
+        if logger.respond_to?(:tagged)
+          logger.tagged(compute_tags(request)) { call_app(request, env) }
+        else
+          call_app(request, env)
+        end
+      end
+
+      private
+
+      attr_reader :data, :env, :request, :started_at
+
+      def call_app(request, env)
+        @data       = {}
+        @env        = env
+        @request    = request
+        @started_at = Time.now
+
+        @app.call(env).tap { |status, _headers, _body| data['status'] = status.to_i }
+      ensure
+        set_data
+        send_message
+      end
+
+      def set_data
+        data['method']     = request.request_method
+        data['path']       = request.original_path
+        data['params']     = request.filtered_parameters
+        data['request_id'] = request.uuid
+        data['request_ip'] = request.ip
+        data['user_agent'] = request.user_agent
+        data['duration']   = duration_in_ms(started_at, Time.now)
+      end
+
+      def send_message
+        event = Loga::Event.new(
+          data:       { request: data },
+          exception:  fetch_exception,
+          message:    compute_message,
+          timestamp:  started_at,
+          type:       'request',
+        )
+        logger.public_send(compute_level, event)
+      end
+
+      def compute_message
+        '%{method} %{filtered_full_path} %{status} in %{duration}ms' % {
+          method:             request.request_method,
+          filtered_full_path: request.filtered_full_path,
+          status:             data['status'],
+          duration:           data['duration'],
+        }
+      end
+
+      def compute_level
+        fetch_exception ? :error : :info
+      end
+
+      def fetch_exception
+        framework_exception.tap do |e|
+          return filtered_exceptions.include?(e.class.to_s) ? nil : e
+        end
+      end
+
+      def framework_exception
+        env['loga.exception'] || env['action_dispatch.exception'] || env['sinatra.error']
+      end
+
+      def filtered_exceptions
+        %w(ActionController::RoutingError Sinatra::NotFound)
+      end
+
+      def compute_tags(request)
+        taggers.collect do |tag|
+          case tag
+          when Proc
+            tag.call(request)
+          when Symbol
+            request.send(tag)
+          else
+            tag
+          end
+        end
+      end
+    end
+  end
+end

data/lib/loga/rack/request.rb

@@ -0,0 +1,77 @@
+require 'rack/request'
+require 'rack/utils'
+
+module Loga
+  module Rack
+    class Request < ::Rack::Request
+      ACTION_DISPATCH_REQUEST_ID = 'action_dispatch.request_id'.freeze
+
+      def initialize(env)
+        super
+        @uuid = nil
+      end
+
+      def uuid
+        @uuid ||= env[ACTION_DISPATCH_REQUEST_ID]
+      end
+
+      def original_path
+        env['loga.request.original_path']
+      end
+
+      def filtered_full_path
+        @filtered_full_path ||=
+          query_string.empty? ? original_path : "#{original_path}?#{filtered_query_string}"
+      end
+
+      def filtered_parameters
+        @filtered_parameters ||= filtered_query_hash.merge(filtered_form_hash)
+      end
+
+      def filtered_query_hash
+        @filtered_query_hash ||= filter_hash(query_hash)
+      end
+
+      def filtered_form_hash
+        @filter_form_hash ||= filter_hash(form_hash)
+      end
+
+      private
+
+      def query_hash
+        params
+        env['rack.request.query_hash'] || {}
+      end
+
+      def form_hash
+        params
+        env['rack.request.form_hash'] || {}
+      end
+
+      def filter_hash(hash)
+        parameter_filter.filter(hash)
+      end
+
+      KV_RE   = '[^&;=]+'
+      PAIR_RE = /(#{KV_RE})=(#{KV_RE})/
+      def filtered_query_string
+        query_string.gsub(PAIR_RE) do |_|
+          parameter_filter.filter([[$1, $2]]).first.join('=')
+        end
+      end
+
+      def parameter_filter
+        @filter_parameters ||=
+          ParameterFilter.new(loga_filter_parameters | action_dispatch_filter_params)
+      end
+
+      def loga_filter_parameters
+        Loga.configuration.filter_parameters || []
+      end
+
+      def action_dispatch_filter_params
+        env['action_dispatch.parameter_filter'] || []
+      end
+    end
+  end
+end

data/lib/loga/rack/request_id.rb

@@ -0,0 +1,44 @@
+# Shamelessly copied from ActionDispatch::RequestId
+require 'securerandom'
+require 'active_support/core_ext/string/access'
+require 'active_support/core_ext/object/blank'
+
+# rubocop:disable Metrics/LineLength, Lint/AssignmentInCondition, Style/GuardClause
+module Loga
+  module Rack
+    # Makes a unique request id available to the action_dispatch.request_id env variable (which is then accessible through
+    # ActionDispatch::Request#uuid) and sends the same id to the client via the X-Request-Id header.
+    #
+    # The unique request id is either based on the X-Request-Id header in the request, which would typically be generated
+    # by a firewall, load balancer, or the web server, or, if this header is not available, a random uuid. If the
+    # header is accepted from the outside world, we sanitize it to a max of 255 chars and alphanumeric and dashes only.
+    #
+    # The unique request id can be used to trace a request end-to-end and would typically end up being part of log files
+    # from multiple pieces of the stack.
+    class RequestId
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        env['action_dispatch.request_id'] = external_request_id(env) || internal_request_id
+        @app.call(env).tap do |_status, headers, _body|
+          headers['X-Request-Id'] = env['action_dispatch.request_id']
+        end
+      end
+
+      private
+
+      def external_request_id(env)
+        if request_id = env['HTTP_X_REQUEST_ID'].presence
+          request_id.gsub(/[^\w\-]/, '').first(255)
+        end
+      end
+
+      def internal_request_id
+        SecureRandom.uuid
+      end
+    end
+  end
+end
+# rubocop:enable Metrics/LineLength, Lint/AssignmentInCondition, Style/GuardClause