grape_logging-1.3.0/0000755000004100000410000000000012717476645014372 5ustar www-datawww-datagrape_logging-1.3.0/Rakefile0000644000004100000410000000003512717476645016035 0ustar www-datawww-datarequire 'bundler/gem_tasks' grape_logging-1.3.0/bin/0000755000004100000410000000000012717476645015142 5ustar www-datawww-datagrape_logging-1.3.0/bin/console0000644000004100000410000000052212717476645016526 0ustar www-datawww-data#!/usr/bin/env ruby require 'bundler/setup' require 'grape_logging' # You can add fixtures and/or initialization code here to make experimenting # with your gem easier. You can also use a different console, if you like. # (If you use this, don't forget to add pry to your Gemfile!) # require "pry" # Pry.start require 'irb' IRB.start grape_logging-1.3.0/bin/setup0000644000004100000410000000016312717476645016225 0ustar www-datawww-data#!/bin/bash set -euo pipefail IFS=$'\n\t' bundle install # Do any other automated setup that you need to do here grape_logging-1.3.0/Gemfile0000644000004100000410000000014212717476645015662 0ustar www-datawww-datasource 'https://rubygems.org' # Specify your gem's dependencies in grape_logging.gemspec gemspec grape_logging-1.3.0/grape_logging.gemspec0000644000004100000410000000211312717476645020540 0ustar www-datawww-data# coding: utf-8 lib = File.expand_path('../lib', __FILE__) $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib) require 'grape_logging/version' Gem::Specification.new do |spec| spec.name = 'grape_logging' spec.version = GrapeLogging::VERSION spec.authors = ['aserafin'] spec.email = ['adrian@softmad.pl'] spec.summary = %q{Out of the box request logging for Grape!} spec.description = %q{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!} spec.homepage = 'http://github.com/aserafin/grape_logging' spec.license = 'MIT' spec.files = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) } spec.bindir = "exe" spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) } spec.require_paths = ['lib'] spec.add_dependency 'grape' spec.add_development_dependency 'bundler', '~> 1.8' spec.add_development_dependency 'rake', '~> 10.0' endgrape_logging-1.3.0/LICENSE.txt0000644000004100000410000000206312717476645016216 0ustar www-datawww-dataThe MIT License (MIT) Copyright (c) 2015 aserafin Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. grape_logging-1.3.0/lib/0000755000004100000410000000000012717476645015140 5ustar www-datawww-datagrape_logging-1.3.0/lib/grape_logging.rb0000644000004100000410000000105512717476645020272 0ustar www-datawww-datarequire 'grape_logging/multi_io' require 'grape_logging/version' require 'grape_logging/formatters/default' require 'grape_logging/formatters/json' require 'grape_logging/loggers/base' require 'grape_logging/loggers/response' require 'grape_logging/loggers/filter_parameters' require 'grape_logging/loggers/client_env' require 'grape_logging/loggers/request_headers' require 'grape_logging/reporters/active_support_reporter' require 'grape_logging/reporters/logger_reporter' require 'grape_logging/timings' require 'grape_logging/middleware/request_logger' grape_logging-1.3.0/lib/grape_logging/0000755000004100000410000000000012717476645017744 5ustar www-datawww-datagrape_logging-1.3.0/lib/grape_logging/middleware/0000755000004100000410000000000012717476645022061 5ustar www-datawww-datagrape_logging-1.3.0/lib/grape_logging/middleware/request_logger.rb0000644000004100000410000000474712717476645025451 0ustar www-datawww-datarequire 'grape/middleware/base' module GrapeLogging module Middleware class RequestLogger < Grape::Middleware::Base ActiveSupport::Notifications.subscribe('sql.active_record') do |*args| event = ActiveSupport::Notifications::Event.new(*args) GrapeLogging::Timings.append_db_runtime(event) end if defined?(ActiveRecord) def initialize(app, options = {}) super @included_loggers = @options[:include] || [] @reporter = if options[:instrumentation_key] Reporters::ActiveSupportReporter.new(@options[:instrumentation_key]) else Reporters::LoggerReporter.new(@options[:logger], @options[:formatter]) end end def before reset_db_runtime start_time invoke_included_loggers(:before) end def after stop_time @reporter.perform(collect_parameters) invoke_included_loggers(:after) nil end def call!(env) super end protected def response begin super rescue nil end end def parameters { status: response.nil? ? 'fail' : response.status, time: { total: total_runtime, db: db_runtime, view: view_runtime }, method: request.request_method, path: request.path, params: request.params } end private def request @request ||= ::Rack::Request.new(env) end def total_runtime ((stop_time - start_time) * 1000).round(2) end def view_runtime total_runtime - db_runtime end def db_runtime GrapeLogging::Timings.db_runtime.round(2) end def reset_db_runtime GrapeLogging::Timings.reset_db_runtime end def start_time @start_time ||= Time.now end def stop_time @stop_time ||= Time.now end def collect_parameters parameters.tap do |params| @included_loggers.each do |logger| params.merge! logger.parameters(request, response) do |_, oldval, newval| oldval.respond_to?(:merge) ? oldval.merge(newval) : newval end end end end def invoke_included_loggers(method_name) @included_loggers.each do |logger| logger.send(method_name) if logger.respond_to?(method_name) end end end end end grape_logging-1.3.0/lib/grape_logging/loggers/0000755000004100000410000000000012717476645021406 5ustar www-datawww-datagrape_logging-1.3.0/lib/grape_logging/loggers/response.rb0000644000004100000410000000115312717476645023571 0ustar www-datawww-datamodule GrapeLogging module Loggers class Response < GrapeLogging::Loggers::Base def parameters(_, response) response ? { response: serialized_response_body(response) } : {} end private # In some cases, response.body is not parseable by JSON. # For example, if you POST on a PUT endpoint, response.body is egal to """". # It's strange but it's the Grape behavior... def serialized_response_body(response) begin response.body.map{ |body| JSON.parse(body.to_s) } rescue => e response.body end end end end end grape_logging-1.3.0/lib/grape_logging/loggers/request_headers.rb0000644000004100000410000000066712717476645025127 0ustar www-datawww-datamodule GrapeLogging module Loggers class RequestHeaders < GrapeLogging::Loggers::Base HTTP_PREFIX = 'HTTP_'.freeze def parameters(request, _) headers = {} request.env.each_pair do |k, v| next unless k.to_s.start_with? HTTP_PREFIX k = k[5..-1].split('_').each(&:capitalize!).join('-') headers[k] = v end { headers: headers } end end end end grape_logging-1.3.0/lib/grape_logging/loggers/filter_parameters.rb0000644000004100000410000000134212717476645025443 0ustar www-datawww-datamodule GrapeLogging module Loggers class FilterParameters < GrapeLogging::Loggers::Base def initialize(filter_parameters = nil, replacement = '[FILTERED]') @filter_parameters = filter_parameters || (defined?(Rails.application) ? Rails.application.config.filter_parameters : []) @replacement = replacement end def parameters(request, _) { params: replace_parameters(request.params.clone) } 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 end parameters end end end end grape_logging-1.3.0/lib/grape_logging/loggers/client_env.rb0000644000004100000410000000041212717476645024056 0ustar www-datawww-datamodule GrapeLogging module Loggers class ClientEnv < GrapeLogging::Loggers::Base def parameters(request, _) { ip: request.env["HTTP_X_FORWARDED_FOR"] || request.env["REMOTE_ADDR"], ua: request.env["HTTP_USER_AGENT"] } end end end end grape_logging-1.3.0/lib/grape_logging/loggers/base.rb0000644000004100000410000000020312717476645022640 0ustar www-datawww-datamodule GrapeLogging module Loggers class Base def parameters(request, response) {} end end end end grape_logging-1.3.0/lib/grape_logging/timings.rb0000644000004100000410000000055212717476645021745 0ustar www-datawww-datamodule GrapeLogging module Timings extend self def db_runtime=(value) Thread.current[:grape_db_runtime] = value end def db_runtime Thread.current[:grape_db_runtime] ||= 0 end def reset_db_runtime self.db_runtime = 0 end def append_db_runtime(event) self.db_runtime += event.duration end end endgrape_logging-1.3.0/lib/grape_logging/reporters/0000755000004100000410000000000012717476645021771 5ustar www-datawww-datagrape_logging-1.3.0/lib/grape_logging/reporters/active_support_reporter.rb0000644000004100000410000000040512717476645027306 0ustar www-datawww-datamodule Reporters class ActiveSupportReporter def initialize(instrumentation_key) @instrumentation_key = instrumentation_key end def perform(params) ActiveSupport::Notifications.instrument @instrumentation_key, params end end endgrape_logging-1.3.0/lib/grape_logging/reporters/logger_reporter.rb0000644000004100000410000000047012717476645025520 0ustar www-datawww-datamodule Reporters class LoggerReporter def initialize(logger, formatter) @logger = logger || Logger.new(STDOUT) @logger.formatter = formatter || GrapeLogging::Formatters::Default.new if @logger.respond_to?(:formatter=) end def perform(params) @logger.info params end end endgrape_logging-1.3.0/lib/grape_logging/version.rb0000644000004100000410000000005412717476645021755 0ustar www-datawww-datamodule GrapeLogging VERSION = '1.3.0' end grape_logging-1.3.0/lib/grape_logging/formatters/0000755000004100000410000000000012717476645022132 5ustar www-datawww-datagrape_logging-1.3.0/lib/grape_logging/formatters/default.rb0000644000004100000410000000155012717476645024104 0ustar www-datawww-datamodule GrapeLogging module Formatters class Default def call(severity, datetime, _, data) "[#{datetime}] #{severity} -- #{format(data)}\n" end def format(data) if data.is_a?(String) data elsif data.is_a?(Exception) format_exception(data) elsif data.is_a?(Hash) "#{data.delete(:status)} -- #{format_hash(data.delete(:time))} -- #{data.delete(:method)} #{data.delete(:path)} #{format_hash(data)}" else data.inspect end end private def format_hash(hash) hash.keys.sort.map { |key| "#{key}=#{hash[key]}" }.join(' ') end def format_exception(exception) backtrace_array = (exception.backtrace || []).map { |line| "\t#{line}" } "#{exception.message}\n#{backtrace_array.join("\n")}" end end end end grape_logging-1.3.0/lib/grape_logging/formatters/json.rb0000644000004100000410000000114612717476645023432 0ustar www-datawww-datamodule GrapeLogging module Formatters class Json def call(severity, datetime, _, data) { date: datetime, severity: severity, data: format(data) }.to_json end private def format(data) if data.is_a?(String) || data.is_a?(Hash) data elsif data.is_a?(Exception) format_exception(data) else data.inspect end end def format_exception(exception) { exception: { message: exception.message } } end end end end grape_logging-1.3.0/lib/grape_logging/multi_io.rb0000644000004100000410000000034612717476645022115 0ustar www-datawww-datamodule GrapeLogging class MultiIO def initialize(*targets) @targets = targets end def write(*args) @targets.each {|t| t.write(*args)} end def close @targets.each(&:close) end end endgrape_logging-1.3.0/.gitignore0000644000004100000410000000012712717476645016362 0ustar www-datawww-data/.bundle/ /.yardoc /Gemfile.lock /_yardoc/ /coverage/ /doc/ /pkg/ /spec/reports/ /tmp/ grape_logging-1.3.0/README.md0000644000004100000410000001035312717476645015653 0ustar www-datawww-data# grape_logging [![Code Climate](https://codeclimate.com/github/aserafin/grape_logging/badges/gpa.svg)](https://codeclimate.com/github/aserafin/grape_logging) ## Installation Add this line to your application's Gemfile: gem 'grape_logging' And then execute: $ bundle install Or install it yourself as: $ gem install grape_logging ## Basic Usage In your api file (somewhere on the top) 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 ## Features ### Log Format With the default configuration you will get nice log message [2015-04-16 12:52:12 +0200] INFO -- 200 -- total=2.06 db=0.36 -- PATCH /your_app/endpoint params={"some_param"=>{"value_1"=>"123", "value_2"=>"456"}} 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 ### 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 #### 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. #### ClientEnv The `ClientEnv` logger will add `ip` and user agent `ua` in your log. #### RequestHeaders 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) ### 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 and then add an initializer in your Rails project: # 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 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 ## 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. To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org). ## Contributing 1. Fork it ( https://github.com/aserafin/grape_logging/fork ) 2. Create your feature branch (`git checkout -b my-new-feature`) 3. Commit your changes (`git commit -am 'Add some feature'`) 4. Push to the branch (`git push origin my-new-feature`) 5. Create a new Pull Request