minato_logger 0.2.15 → 0.2.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 11f2e7e39012b964d05e807bc6e41196166842c527430f8f94f700f7b7dde6c3
-  data.tar.gz: f55d180a17a03bac367ec93f8bf8d5939e47ab09f430b71b244abd3c03b5f1dd
+  metadata.gz: a92bc90dad9351db28e1822889e30507ec655fbbd8af5d8958e0bd71d0543adf
+  data.tar.gz: 116eae9a2b9e93b22227c349bac98bdf939575ab6ffac7c1a381ce34a262f297
 SHA512:
-  metadata.gz: 58a321a141ae059022e2303389d41bd8766a38c9d02e7aab5f2700766d1abd4d31438d831b99a06b85c9cbae5c74200d581e829fef0ec5109af45a4d0b0486d1
-  data.tar.gz: 0ab555ce2babcc1a5787ea59e8fec0661c7681f971ed249696f398c42a44d154335adcaa7a303f2424d5a838ce587ed53284fbd8076f1160f8ed8b86c2d9f00a
+  metadata.gz: fe0647f14553910186ae4bd62937ef60d9768b2c0875aed66a921696c786f3f867057f7016d2551f622d5d43654979225a15a80efe64ef61a8c4fe2e93bb3d01
+  data.tar.gz: 95ff3b9a514096cd59de2f4f48238646beaec3ab8da2cbd712aed8fe26db654ce70506636bef85142c926794c6db1ff327c5e121cdf9f4e2e1fe0bdf5d9d9702

data/lib/minato_logger/configuration.rb

@@ -2,11 +2,16 @@
 
 module MinatoLogger
   class Configuration
-    attr_reader :middleware, :route_blacklist
+    attr_reader :middleware, :route_blacklist, :sensitive_headers
 
     def initialize
       @middleware = MinatoLogger::Middleware.new
       @route_blacklist = %w[/health/alive /health/ready]
+      @sensitive_headers = %w[
+        AUTHORIZATION PROXY_AUTHORIZATION X_CSRF_TOKEN
+        HTTP_AUTHORIZATION HTTP_PROXY_AUTHORIZATION
+        HTTP_X_CSRF_TOKEN COOKIE HTTP_COOKIE
+      ]
 
       yield(self) if block_given?
     end

data/lib/minato_logger/middlewares/request_response_logger.rb

@@ -6,22 +6,18 @@ require 'rails/rack/logger'
 module MinatoLogger
   module Middlewares
     class RequestResponseLogger < Rails::Rack::Logger
-      SENSITIVE_HEADERS = %w[
-        AUTHORIZATION PROXY_AUTHORIZATION X_CSRF_TOKEN
-        HTTP_AUTHORIZATION HTTP_PROXY_AUTHORIZATION
-        HTTP_X_CSRF_TOKEN COOKIE HTTP_COOKIE
-      ].freeze
-
       private
 
       def call_app(request, env)
         should_log = should_log?(request)
-        log_request(request, env) if should_log
+        ctx = { request: { start_time: current_time, headers: extract_request_headers(request),
+                           body: extract_request_body(request) } }
+        log_request(request, env, ctx) if should_log
         handle = dispatch_request_event(request)
-        data = process_request(env)
-        log_response(request, env, data) if should_log
+        ctx[:response] = process_request(env)
+        log_response(request, env, ctx) if should_log
         finish_request_instrumentation(handle, env['rails.rack_logger_tag_count'])
-        [data[:status], data[:headers], [data[:body]]]
+        [ctx.dig(:response, :status), ctx.dig(:response, :headers), [ctx.dig(:response, :body)]]
       end
 
       def compute_tags(request)
@@ -44,11 +40,10 @@ module MinatoLogger
       end
 
       def process_request(env)
-        data = { body: '', status: 500, start_time: current_time, headers: {} }
-
-        data[:status], data[:headers], response = @app.call(env)
-        data[:body] = extract_body_safely(response || [])
-        data
+        res = { body: '', status: 500, headers: {} }
+        res[:status], res[:headers], response = @app.call(env)
+        res[:body] = extract_body_safely(response || [])
+        res
       end
 
       def dispatch_request_event(request)
@@ -58,41 +53,36 @@ module MinatoLogger
         handle
       end
 
-      def log_request(request, env)
-        payload = default_log_data(request, env).merge({
-                                                         type: 'REQUEST',
-                                                         message: "Receiving request #{request.method} #{request.fullpath}"
-                                                       })
-        payload[:request].merge!({ headers: extract_request_headers(request), body: extract_request_body(request) })
+      def log_request(request, env, ctx)
+        payload = { type: 'REQUEST', message: "Receiving request #{request.method} #{request.fullpath}" }
+        payload.merge!(default_log_data(request, env, ctx))
         log(payload)
       end
 
-      def log_response(request, env, data)
-        data[:duration] = ((current_time - data[:start_time]) * 1000).round(2)
-        payload = build_response_payload(request, env, data)
-        log_level = data[:status] >= 500 ? :error : :info
+      def log_response(request, env, ctx)
+        ctx[:response][:duration] = ((current_time - ctx.dig(:request, :start_time)) * 1000).round(2)
+        payload = build_response_payload(request, env, ctx)
+        log_level = ctx.dig(:response, :status) >= 500 ? :error : :info
         log(payload, log_level)
       end
 
-      def default_log_data(request, env)
+      def default_log_data(request, env, ctx)
         route = env['action_dispatch.route_uri_pattern'] || request.path
         request = { id: request.request_id, method: request.method,
                     time: Time.zone.now.iso8601, remote_ip: request.remote_ip, route: route, ip: request.ip,
-                    path: request.fullpath, params: filter_params(request) }
+                    path: request.fullpath, params: filter_params(request), headers: ctx.dig(:request, :headers),
+                    body: ctx.dig(:request, :body) }
         { rails_version: Rails.version, request: request }
       end
 
-      def build_response_payload(request, env, data)
-        payload = default_log_data(request, env).merge({
-                                                         type: 'RESPONSE', duration: data[:duration], status: data[:status],
-                                                         message: "Responding #{request.method} #{request.fullpath} " \
-                                                                  "- #{data[:status]} (#{data[:duration]}ms)"
-                                                       })
-        payload[:response] = {
-          body: safe_parse_json(data[:body]), headers: filter_sensitive_headers(data[:headers]),
-          status: data[:status], duration: data[:duration]
-        }
-        payload
+      def build_response_payload(request, env, ctx)
+        response = { body: safe_parse_json(ctx.dig(:response, :body)),
+                     headers: filter_sensitive_headers(ctx.dig(:response, :headers)),
+                     status: ctx.dig(:response, :status), duration: ctx.dig(:response, :duration) }
+        payload = { type: 'RESPONSE',  response: response,
+                    message: "Responding #{request.method} #{request.fullpath} " \
+                             "- #{ctx.dig(:response, :status)} (#{ctx.dig(:response, :duration)}ms)" }
+        default_log_data(request, env, ctx).merge(payload)
       end
 
       def log(payload, level = :info)
@@ -154,7 +144,7 @@ module MinatoLogger
 
         headers.reject do |k, _|
           key = k.to_s.upcase.tr('-', '_')
-          SENSITIVE_HEADERS.any? { |sensitive| key.include?(sensitive) }
+          Rails.application.config.minato_logger.sensitive_headers.any? { |sensitive| key.include?(sensitive) }
         end
       end
     end

data/lib/minato_logger/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MinatoLogger
-  VERSION = '0.2.15'
+  VERSION = '0.2.16'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: minato_logger
 version: !ruby/object:Gem::Version
-  version: 0.2.15
+  version: 0.2.16
 platform: ruby
 authors:
 - Ferreri