grape_logging 1.3.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fe992e3b160e737c3ad0d38a636252db026dbf97
-  data.tar.gz: fbbcd347c5846b25d4a737a964fb2600c4e8ac98
+  metadata.gz: fb1521644b8ec276a0cd7eeb3cadcc75c98d88f5
+  data.tar.gz: 815eaa0bf94e7f282ac99be2f0746ba31abdb4e2
 SHA512:
-  metadata.gz: 35efe1809d92fa3a12d260f71306b8c2aa8f08254607ea2c46c9d3c2dcc38e5a8a009af0b4044f26660feae420b12ef5c0f4d17059d086227253cc2cc9a16000
-  data.tar.gz: a2021c9a92c8b4c4d96cf494b3ef27da4c17bb05c839d7c8e3c35660fbfbae9ba279380f66c173c7e863d110de7c959207367f180292258c3f218f1a72c6272e
+  metadata.gz: 66614c057b039c188ed42a0058d178ffc128e2f3a04fa03e2df2c98558063f5161236f348251ca2aa7b03cabbc35a5894fcde074e2a8257121cbaf627bc92831
+  data.tar.gz: 4af96b697baed8d4cb03d958133a18ad9ed66e7e601397330cd80960a19871c1c295b64de3c4d90b115ca6a23c6b4b3cc4bf7982ee6aa79812ee14a9fdf3f702

data/.gitignore

@@ -7,3 +7,4 @@
 /pkg/
 /spec/reports/
 /tmp/
+.rspec

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 2.3.1
+cache: bundler
+script:
+  - bundle exec rspec

data/README.md

@@ -1,6 +1,7 @@
 # grape_logging
 
 [![Code Climate](https://codeclimate.com/github/aserafin/grape_logging/badges/gpa.svg)](https://codeclimate.com/github/aserafin/grape_logging)
+[![Build Status](https://travis-ci.org/aserafin/grape_logging.svg?branch=master)](https://travis-ci.org/aserafin/grape_logging)
 
 ## Installation
 
@@ -20,9 +21,11 @@ Or install it yourself as:
 
 In your api file (somewhere on the top)
 
-    require 'grape_logging'
-    logger.formatter = GrapeLogging::Formatters::Default.new
-    use GrapeLogging::Middleware::RequestLogger, { logger: logger }
+```ruby
+require 'grape_logging'
+logger.formatter = GrapeLogging::Formatters::Default.new
+use GrapeLogging::Middleware::RequestLogger, { logger: logger }
+```
 
 **ProTip:** If your logger doesn't support setting formatter you can remove this line - it's optional
 
@@ -37,23 +40,25 @@ With the default configuration you will get nice log message
 If you prefer some other format I strongly encourage you to do pull request with new formatter class ;)
 
 You can change the formatter like so
-
-    class MyAPI < Grape::API
-      use GrapeLogging::Middleware::RequestLogger, logger: logger, format: MyFormatter.new
-    end
+```ruby
+class MyAPI < Grape::API
+  use GrapeLogging::Middleware::RequestLogger, logger: logger, formatter: MyFormatter.new
+end
+```
 
 ### Customising What Is Logged
 
 You can include logging of other parts of the request / response cycle by including subclasses of `GrapeLogging::Loggers::Base`
-
-    class MyAPI < Grape::API
-      use GrapeLogging::Middleware::RequestLogger,
-        logger: logger,
-        include: [ GrapeLogging::Loggers::Response.new,
-                   GrapeLogging::Loggers::FilterParameters.new,
-                   GrapeLogging::Loggers::ClientEnv.new,
-                   GrapeLogging::Loggers::RequestHeaders.new ]
-    end
+```ruby
+class MyAPI < Grape::API
+  use GrapeLogging::Middleware::RequestLogger,
+    logger: logger,
+    include: [ GrapeLogging::Loggers::Response.new,
+               GrapeLogging::Loggers::FilterParameters.new,
+               GrapeLogging::Loggers::ClientEnv.new,
+               GrapeLogging::Loggers::RequestHeaders.new ]
+end
+```
 
 #### FilterParameters
 The `FilterParameters` logger will filter out sensitive parameters from your logs. If mounted inside rails, will use the `Rails.application.config.filter_parameters` by default. Otherwise, you must specify a list of keys to filter out.
@@ -67,45 +72,48 @@ The `RequestHeaders` logger will add `request headers` in your log.
 ### Logging to file and STDOUT
 
 You can log to file and STDOUT at the same time, you just need to assign new logger
-
-    log_file = File.open('path/to/your/logfile.log', 'a')
-    log_file.sync = true
-    logger Logger.new GrapeLogging::MultiIO.new(STDOUT, log_file)
+```ruby
+log_file = File.open('path/to/your/logfile.log', 'a')
+log_file.sync = true
+logger Logger.new GrapeLogging::MultiIO.new(STDOUT, log_file)
+```
 
 ### Logging via Rails instrumentation
 
 You can choose to not pass the logger to ```grape_logging``` but instead send logs to Rails instrumentation in order to let Rails and its configured Logger do the log job, for example.
 First, config ```grape_logging```, like that:
-
-    class MyAPI < Grape::API
-      use GrapeLogging::Middleware::RequestLogger,
-        instrumentation_key: 'grape_key',
-        include: [ GrapeLogging::Loggers::Response.new,
-                   GrapeLogging::Loggers::FilterParameters.new ]
-    end
+```ruby
+class MyAPI < Grape::API
+  use GrapeLogging::Middleware::RequestLogger,
+    instrumentation_key: 'grape_key',
+    include: [ GrapeLogging::Loggers::Response.new,
+               GrapeLogging::Loggers::FilterParameters.new ]
+end
+```
 
 and then add an initializer in your Rails project:
+```ruby
+# config/initializers/instrumentation.rb
 
-    # config/initializers/instrumentation.rb
-
-    # Subscribe to grape request and log with Rails.logger
-    ActiveSupport::Notifications.subscribe('grape_key') do |name, starts, ends, notification_id, payload|
-      Rails.logger.info payload
-    end
+# Subscribe to grape request and log with Rails.logger
+ActiveSupport::Notifications.subscribe('grape_key') do |name, starts, ends, notification_id, payload|
+  Rails.logger.info payload
+end
+```
 
 The idea come from here: https://gist.github.com/teamon/e8ae16ffb0cb447e5b49
 
 ### Logging exceptions
 
 If you want to log exceptions you can do it like this
-
-    class MyAPI < Grape::API
-      rescue_from :all do |e|
-        MyAPI.logger.error e
-        #do here whatever you originally planned to do :)
-      end
-    end
-
+```ruby
+class MyAPI < Grape::API
+  rescue_from :all do |e|
+    MyAPI.logger.error e
+    #do here whatever you originally planned to do :)
+  end
+end
+```
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.

data/grape_logging.gemspec

@@ -23,4 +23,6 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency 'bundler', '~> 1.8'
   spec.add_development_dependency 'rake', '~> 10.0'
-end
+  spec.add_development_dependency 'rspec', '~> 3.5'
+  spec.add_development_dependency 'pry-byebug', '~> 3.4.2'
+end

data/lib/grape_logging.rb

@@ -2,6 +2,7 @@ require 'grape_logging/multi_io'
 require 'grape_logging/version'
 require 'grape_logging/formatters/default'
 require 'grape_logging/formatters/json'
+require 'grape_logging/formatters/logstash'
 require 'grape_logging/loggers/base'
 require 'grape_logging/loggers/response'
 require 'grape_logging/loggers/filter_parameters'
@@ -11,3 +12,4 @@ require 'grape_logging/reporters/active_support_reporter'
 require 'grape_logging/reporters/logger_reporter'
 require 'grape_logging/timings'
 require 'grape_logging/middleware/request_logger'
+require 'grape_logging/util/parameter_filter'

data/lib/grape_logging/formatters/logstash.rb

@@ -0,0 +1,35 @@
+module GrapeLogging
+  module Formatters
+    class Logstash
+      def call(severity, datetime, _, data)
+        {
+          :'@timestamp' => datetime.iso8601,
+          :'@version' => '1',
+          :severity => severity
+        }.merge!(format(data)).to_json
+      end
+
+      private
+
+      def format(data)
+        if data.is_a?(Hash)
+          data
+        elsif data.is_a?(String)
+          { message: data }
+        elsif data.is_a?(Exception)
+          format_exception(data)
+        else
+          { message: data.inspect }
+        end
+      end
+
+      def format_exception(exception)
+        {
+          exception: {
+            message: exception.message
+          }
+        }
+      end
+    end
+  end
+end

data/lib/grape_logging/loggers/filter_parameters.rb

@@ -1,23 +1,35 @@
 module GrapeLogging
   module Loggers
     class FilterParameters < GrapeLogging::Loggers::Base
-      def initialize(filter_parameters = nil, replacement = '[FILTERED]')
+      AD_PARAMS = 'action_dispatch.request.parameters'.freeze
+
+      def initialize(filter_parameters = nil, replacement = nil, exceptions = %w(controller action format))
         @filter_parameters = filter_parameters || (defined?(Rails.application) ? Rails.application.config.filter_parameters : [])
-        @replacement = replacement
+        @replacement = replacement || '[FILTERED]'
+        @exceptions = exceptions
       end
 
       def parameters(request, _)
-        { params: replace_parameters(request.params.clone) }
+        { params: safe_parameters(request) }
       end
 
       private
-      def replace_parameters(parameters)
-        @filter_parameters.each do |parameter_name|
-          if parameters.key?(parameter_name.to_s)
-            parameters[parameter_name.to_s] = @replacement
-          end
+
+      def parameter_filter
+        @parameter_filter ||= ParameterFilter.new(@replacement, @filter_parameters)
+      end
+
+      def safe_parameters(request)
+        # Now this logger can work also over Rails requests
+        if request.params.empty?
+          clean_parameters(request.env[AD_PARAMS] || {})
+        else
+          clean_parameters(request.params)
         end
-        parameters
+      end
+
+      def clean_parameters(parameters)
+        parameter_filter.filter(parameters).reject{ |key, _value| @exceptions.include?(key) }
       end
     end
   end

data/lib/grape_logging/middleware/request_logger.rb

@@ -58,7 +58,8 @@ module GrapeLogging
           },
           method: request.request_method,
           path: request.path,
-          params: request.params
+          params: request.params,
+          host: request.host
         }
       end
 

data/lib/grape_logging/reporters/logger_reporter.rb

@@ -2,7 +2,9 @@ module Reporters
   class LoggerReporter
     def initialize(logger, formatter)
       @logger = logger || Logger.new(STDOUT)
-      @logger.formatter = formatter || GrapeLogging::Formatters::Default.new if @logger.respond_to?(:formatter=)
+      if @logger.respond_to?(:formatter=)
+        @logger.formatter = formatter || @logger.formatter || GrapeLogging::Formatters::Default.new
+      end
     end
 
     def perform(params)

data/lib/grape_logging/util/parameter_filter.rb

@@ -0,0 +1,90 @@
+if defined?(Rails.application)
+  class ParameterFilter < ActionDispatch::Http::ParameterFilter
+    def initialize(_replacement, filter_parameters)
+      super(filter_parameters)
+    end
+  end
+else
+  #
+  # lifted from https://github.com/rails/rails/blob/master/actionpack/lib/action_dispatch/http/parameter_filter.rb
+  # we could depend on Rails specifically, but that would us way to hefty!
+  #
+  class ParameterFilter
+    def initialize(replacement, filters = [])
+      @replacement = replacement
+      @filters = filters
+    end
+
+    def filter(params)
+      compiled_filter.call(params)
+    end
+
+    private
+
+    def compiled_filter
+      @compiled_filter ||= CompiledFilter.compile(@replacement, @filters)
+    end
+
+    class CompiledFilter # :nodoc:
+      def self.compile(replacement, filters)
+        return lambda { |params| params.dup } if filters.empty?
+
+        strings, regexps, blocks = [], [], []
+
+        filters.each do |item|
+          case item
+          when Proc
+            blocks << item
+          when Regexp
+            regexps << item
+          else
+            strings << Regexp.escape(item.to_s)
+          end
+        end
+
+        deep_regexps, regexps = regexps.partition { |r| r.to_s.include?("\\.".freeze) }
+        deep_strings, strings = strings.partition { |s| s.include?("\\.".freeze) }
+
+        regexps << Regexp.new(strings.join('|'.freeze), true) unless strings.empty?
+        deep_regexps << Regexp.new(deep_strings.join('|'.freeze), true) unless deep_strings.empty?
+
+        new replacement, regexps, deep_regexps, blocks
+      end
+
+      attr_reader :regexps, :deep_regexps, :blocks
+
+      def initialize(replacement, regexps, deep_regexps, blocks)
+        @replacement = replacement
+        @regexps = regexps
+        @deep_regexps = deep_regexps.any? ? deep_regexps : nil
+        @blocks  = blocks
+      end
+
+      def call(original_params, parents = [])
+        filtered_params = {}
+
+        original_params.each do |key, value|
+          parents.push(key) if deep_regexps
+          if regexps.any? { |r| key =~ r }
+            value = @replacement
+          elsif deep_regexps && (joined = parents.join('.')) && deep_regexps.any? { |r| joined =~ r }
+            value = @replacement
+          elsif value.is_a?(Hash)
+            value = call(value, parents)
+          elsif value.is_a?(Array)
+            value = value.map { |v| v.is_a?(Hash) ? call(v, parents) : v }
+          elsif blocks.any?
+            key = key.dup if key.duplicable?
+            value = value.dup if value.duplicable?
+            blocks.each { |b| b.call(key, value) }
+          end
+          parents.pop if deep_regexps
+
+          filtered_params[key] = value
+        end
+
+        filtered_params
+      end
+    end
+  end
+end

data/lib/grape_logging/version.rb

@@ -1,3 +1,3 @@
 module GrapeLogging
-  VERSION = '1.3.0'
+  VERSION = '1.4.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: grape_logging
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.4.0
 platform: ruby
 authors:
 - aserafin
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-05-18 00:00:00.000000000 Z
+date: 2017-03-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: grape
@@ -52,6 +52,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.4.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.4.2
 description: This gem provides simple request logging for Grape with just few lines
   of code you have to put in your project! In return you will get response codes,
   paths, parameters and more!
@@ -62,6 +90,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -72,6 +101,7 @@ files:
 - lib/grape_logging.rb
 - lib/grape_logging/formatters/default.rb
 - lib/grape_logging/formatters/json.rb
+- lib/grape_logging/formatters/logstash.rb
 - lib/grape_logging/loggers/base.rb
 - lib/grape_logging/loggers/client_env.rb
 - lib/grape_logging/loggers/filter_parameters.rb
@@ -82,6 +112,7 @@ files:
 - lib/grape_logging/reporters/active_support_reporter.rb
 - lib/grape_logging/reporters/logger_reporter.rb
 - lib/grape_logging/timings.rb
+- lib/grape_logging/util/parameter_filter.rb
 - lib/grape_logging/version.rb
 homepage: http://github.com/aserafin/grape_logging
 licenses:
@@ -103,7 +134,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Out of the box request logging for Grape!