rack-logjam 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1b41ef65c7eded4ea8dea271c8b87d7efd09a9dd
-  data.tar.gz: 9a9a132674d17a97b9def761ca94b43cc26568c5
+  metadata.gz: 100c480a6bdd47bb50ebbacbde5f69019c7c386c
+  data.tar.gz: 4e737fc841d55db1bdd4c06b2968890e746ca230
 SHA512:
-  metadata.gz: 2200c484906b60998f5ea1f704fa99a9643bc3ca7be94c4e8eded4ed2501ac09263357337554efb72770f79fde9656aa1512f6ac78d7dfd88b97d44522ccb3bb
-  data.tar.gz: 553ef5c793e5d16dfe725c90cf350085d11b377d07f905e47b581f8de8583b05e8b935e0b914ae448cbb117d67115b2c3b78b9a245b5dbceff7f4a784cc7330a
+  metadata.gz: 7d2b976933f0ad9827c1fb5521813b79b0d8b852db8becfb9a03d87d839e8c0cc74406ab1d8263832ec78909d5b5a5ac5109522b4385b594666d071ea182b15e
+  data.tar.gz: d5422d0782d60ea1181119862976e92488244bfdeac02ad3129821e137cf2dd52ff5f1ee5b391c2b966840f15f5bb9d5739ef78112db30589f5be5224c2606ae

data/.ruby-gemset

@@ -0,0 +1 @@
+rack-logjam

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.1.0

data/README.markdown

@@ -2,6 +2,7 @@
 
 Logs helpful HTTP information on Rack requests.
 
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -16,14 +17,148 @@ Or install it yourself as:
 
     $ gem install rack-logjam
 
+
 ## Usage
 
-TODO: Write usage instructions here
+### Including the Middleware
+
+#### Grape
+
+Include the middleware in your API classes with the `use` statement
+
+    module AwesomeApp
+      class ApiV1 < Grape::API
+        use Rack::Logjam::Grape::Middleware
+      end
+    end
+
+
+#### Rails
+
+Require the middleware in `config/application.rb`
+
+    config.middleware.use( 'Rack::Logjam::Middleware' )
+
+### Configuration
+
+At a minimum one must specify the logger that rack-logjam will use.
+
+    Rack::Logjam.configure |c|
+      c.logger = Rails.logger
+    end
+
+#### Formatters
+
+Rack::Logjam includes several default formatters that are registered by default: `Array, FormUrlencoded, Json, TextPlain, and Xml`.  Formatters 
+are registered and selected by mime-types.  If a the mime-type of a response does not have a regostered formatter, it will output a message to
+the log in place of the body specifying the lack of formatter and mime-type.
+
+Additionally, you can configure custom mime-types with formatters in the configuration file.
+
+    Rack::Logjam.configure |c|
+      # register custom mime-types with inlcuded formatters
+      c.register_formatter 'application/vnd.awesome-app-v1+x-www-form-urlencoded', :FormUrlencoded
+      c.register_formatter 'application/vnd.awesome-app-v1+json', :Json                        
+      c.register_formatter 'application/vnd.awesome-app-v1+text', :TextPlain                        
+      c.register_formatter 'application/vnd.awesome-app-v1+xml', :Xml
+
+      # register custom mime-type with custom formatter
+      c.register_formatter 'application/vnd.awesome-app-v1+csv', AwesomeApp::LogFormatter::Csv 
+    end
+
+#### Filters
+
+Filters can fully fully redact or truncate data within data structures.  Filters are registered and selected by mime-types.  No filters are 
+registered by default.  However, Rack::Logjam includes a `Json` filter.  The Json filter uses [JsonPath](https://github.com/joshbuddy/jsonpath)
+to specify which attributes are filtered.
+
+Additionally, you can configure custom mime-types with filters in the configuration file.
+
+    Rack::Logjam.configure |c|
+      # configure a mime-type with the built in Json filter
+      #   this filter will truncate all image_as_base64 attributes 
+      #   at any level of nesting and redact the subject/date_of_birth
+      c.register_filter 'application/vnd.ncite-vetting-v1+json', :Json, [
+        ['$..image_as_base64', :truncate, 10],
+        ['$.subject_attributes.date_of_birth', :redact]
+      ]
+    end
+
+#### Custom Formatters and Filters
+
+##### Writing a Custom Formatter
+
+A formatter is a simply a class that accepts content in an initializer and implements a #render method with no parameters.  Folowing
+is an implementation of a CSV formatter.
+
+    module AwesomeApp
+      module Formatter
+        class Csv
+          def initialize( content )
+            @content = content
+          end
+
+          def render
+            content
+          end
+
+        protected
+
+          attr_reader :content
+        end
+      end
+    end
+
+The formatter must also be registered with a mime-type.
+
+    c.register_formatter 'application/vnd.awesome-app-v1+csv', AwesomeApp::Formatter::Csv
+
+##### Writing a Custom Filter
+
+A filter is a simply a class that accepts content and filters in an initializer and implements a #render method with no parameters.  Folowing
+is a naive implementation of a CSV filter.
+
+    require 'csv' 
+
+    module AwesomeApp
+      module Filters
+        class Csv
+          def initialize( content, filters )
+            @content = content
+            @filters = filters
+          end
+
+          def render
+            CSV.parse("some long bit of text",data,123-45-6789,data") do |row|
+              filters.each do |column, action, length| 
+                row[column] = send( action, row[column], length )
+              end
+            end
+          end
+
+        protected
+
+          def redact( val, *args )
+            (val.nil? || val.empty?) ?
+              val :
+              "[REDACTED]"
+          end
+
+          def truncate( val, length )
+            (val.nil? || val.empty?) ?
+              val :
+              "#{val[0..length]}...[TRUNCATED]..."
+          end
+
+          attr_reader :content,
+                      :filters
+        end
+      end
+    end
 
-## Contributing
+The filter must also be registered with a mime-type.
 
-1. Fork it ( http://github.com/ninja-loss/rack-logjam/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 new Pull Request
+    c.register_filter 'application/vnd.awesome-app-v1+xml', AwesomeApp::Filters::Csv, [
+      [0, :truncate, 10],
+      [2, :redact]
+    ]

data/lib/rack/logjam/ansi.rb

@@ -1,7 +1,5 @@
 module Rack
-
   module Logjam
-
     class ANSI
 
       def self.resolve_text( color, &block )
@@ -38,7 +36,5 @@ module Rack
       end
 
     end
-
   end
-
 end

data/lib/rack/logjam/configuration.rb

@@ -0,0 +1,19 @@
+module Rack
+  module Logjam
+    class Configuration
+
+      def logger=( logger )
+        Rack::Logjam::logger = logger
+      end
+
+      def register_filter( mime_type, filter_symbol_or_constant, filters )
+        Rack::Logjam::Filters.register( mime_type, filter_symbol_or_constant, filters )
+      end
+
+      def register_formatter( mime_type, formatter_symbol_or_constant )
+        Rack::Logjam::Formatters.register( mime_type, formatter_symbol_or_constant )
+      end
+
+    end
+  end
+end

data/lib/rack/logjam/filters/base.rb

@@ -0,0 +1,23 @@
+module Rack
+  module Logjam
+    module Filters
+      class Base
+
+        def initialize( content, filters )
+          @content = content
+          @filters = filters
+        end
+
+        def render
+          raise NotImplementedError
+        end
+
+      protected
+
+        attr_reader :content,
+                    :filters
+
+      end
+    end
+  end
+end

data/lib/rack/logjam/filters/json.rb

@@ -0,0 +1,55 @@
+require 'jsonpath'
+
+module Rack
+  module Logjam
+    module Filters
+      class Json < Rack::Logjam::Filters::Base
+
+        def render
+          apply_filters
+          json_path.to_json
+        end
+
+      protected
+
+        def apply_filters
+          filters.each do |j_path, action, length|
+            json_path.gsub!( j_path ) do |val|
+              method_name = "#{action}_#{val.class.name.downcase}"
+              if respond_to?( method_name, true )
+                send( method_name, val, length )
+              else
+                "[#{action.upcase}ED: #{val.class.name}]"
+              end
+            end
+          end
+        end
+
+        def redact_nilclass( val, *args )
+          nil
+        end
+
+        def truncate_nilclass( val, length )
+          nil
+        end
+
+        def redact_string( val, *args )
+          (val.nil? || val.empty?) ?
+            val :
+            "[REDACTED]"
+        end
+
+        def truncate_string( val, length )
+          (val.nil? || val.empty?) ?
+            val :
+            "#{val[0..length]}...[TRUNCATED]..."
+        end
+
+        def json_path
+          @json_path ||= ::JsonPath.for( content )
+        end
+
+      end
+    end
+  end
+end

data/lib/rack/logjam/filters/nil.rb

@@ -0,0 +1,13 @@
+module Rack
+  module Logjam
+    module Filters
+      class Nil < Rack::Logjam::Filters::Base
+
+        def render
+          content
+        end
+
+      end
+    end
+  end
+end

data/lib/rack/logjam/filters.rb

@@ -0,0 +1,26 @@
+module Rack
+  module Logjam
+    module Filters
+
+      autoload :Base, 'rack/logjam/filters/base'
+      autoload :Json, 'rack/logjam/filters/json'
+      autoload :Nil,  'rack/logjam/filters/nil'
+
+      @registry = {}
+
+      def self.registry
+        @registry
+      end
+
+      def self.register( mime_type, formatter_klass_name, filters )
+        registry.merge!( mime_type => [formatter_klass_name, filters] )
+      end
+
+      def self.get( mime_type )
+        const_name, filters = registry.fetch( mime_type, [:Nil, []] )
+        return self::const_get( const_name ), filters
+      end
+
+    end
+  end
+end

data/lib/rack/logjam/formatters/array.rb

@@ -0,0 +1,13 @@
+module Rack
+  module Logjam
+    module Formatters
+      class Array < ::Rack::Logjam::Formatters::Base
+
+        def render
+          Json.new( content, format ).render
+        end
+
+      end
+    end
+  end
+end

data/lib/rack/logjam/formatters/base.rb

@@ -0,0 +1,23 @@
+module Rack
+  module Logjam
+    module Formatters
+      class Base
+
+        def initialize( content, format=nil )
+          @content = content
+          @format  = format
+        end
+
+        def render
+          "You must implement #{self.class.name}#render in order to render a #{format} response"
+        end
+
+      protected
+
+        attr_reader :content,
+                    :format
+
+      end
+    end
+  end
+end

data/lib/rack/logjam/formatters/empty.rb

@@ -0,0 +1,13 @@
+module Rack
+  module Logjam
+    module Formatters
+      class Empty < ::Rack::Logjam::Formatters::Base
+
+        def render
+          "[EMPTY]"
+        end
+
+      end
+    end
+  end
+end

data/lib/rack/logjam/formatters/form_urlencoded.rb

@@ -0,0 +1,13 @@
+module Rack
+  module Logjam
+    module Formatters
+      class FormUrlencoded < ::Rack::Logjam::Formatters::Base
+
+        def render
+          URI.unescape( content )
+        end
+
+      end
+    end
+  end
+end

data/lib/rack/logjam/formatters/json.rb

@@ -0,0 +1,16 @@
+require 'multi_json'
+
+module Rack
+  module Logjam
+    module Formatters
+      class Json < ::Rack::Logjam::Formatters::Base
+
+        def render
+          hash = MultiJson.load( content )
+          MultiJson.dump( hash, pretty: true )
+        end
+
+      end
+    end
+  end
+end

data/lib/rack/logjam/formatters/nil.rb

@@ -0,0 +1,13 @@
+module Rack
+  module Logjam
+    module Formatters
+      class Nil < ::Rack::Logjam::Formatters::Base
+
+        def render
+          "No formatter defined for mime-type #{format}"
+        end
+
+      end
+    end
+  end
+end

data/lib/rack/logjam/formatters/text_plain.rb

@@ -0,0 +1,13 @@
+module Rack
+  module Logjam
+    module Formatters
+      class TextPlain < ::Rack::Logjam::Formatters::Base
+
+        def render
+          content
+        end
+
+      end
+    end
+  end
+end

data/lib/rack/logjam/formatters/xml.rb

@@ -0,0 +1,17 @@
+require 'nokogiri'
+
+module Rack
+  module Logjam
+    module Formatters
+      class Xml < ::Rack::Logjam::Formatters::Base
+
+        def render
+          ::Nokogiri.XML( content ) do |config|
+            config.default_xml.noblanks
+          end.to_xml( indent: 2 )
+        end
+
+      end
+    end
+  end
+end

data/lib/rack/logjam/formatters.rb

@@ -0,0 +1,33 @@
+module Rack
+  module Logjam
+    module Formatters
+
+      autoload :Array,          'rack/logjam/formatters/array'
+      autoload :Base,           'rack/logjam/formatters/base'
+      autoload :Empty,          'rack/logjam/formatters/empty'
+      autoload :FormUrlencoded, 'rack/logjam/formatters/form_urlencoded'
+      autoload :Json,           'rack/logjam/formatters/json'
+      autoload :Nil,            'rack/logjam/formatters/nil'
+      autoload :TextPlain,      'rack/logjam/formatters/text_plain'
+      autoload :Xml,            'rack/logjam/formatters/xml'
+
+      @registry = {}
+
+      def self.registry
+        @registry
+      end
+
+      def self.register( mime_type, formatter_klass_name )
+        registry.merge!( mime_type => formatter_klass_name )
+      end
+
+      def self.get( mime_type )
+        const_name = registry.fetch( mime_type, :Nil )
+        const_name.is_a?( Class ) ?
+          const_name :
+          self::const_get( const_name )
+      end
+
+    end
+  end
+end

data/lib/rack/logjam/grape/middleware.rb

@@ -0,0 +1,88 @@
+#require 'json'
+require 'grape/middleware/base'
+
+module Rack
+  module Logjam
+    module Grape
+      class Middleware < ::Grape::Middleware::Base
+
+        def before
+          return unless api_request?( env )
+
+          logger.log_request( env )
+        end
+
+        def after
+          return unless api_request?( env )
+
+          status = @app_response.first
+          headers = @app_response[1]
+          body = @app_response.last.body.last
+
+          #logger.log_response( env, status, headers, response )
+          logger.log_response( env, status, headers, body )
+
+          @app_response
+        end
+
+      protected
+
+        def api_request?( env )
+          true
+          #path_info( env ) =~ /^\/api\//
+        end
+
+        def path_info( env )
+          env['PATH_INFO']
+        end
+
+        def logger
+          Rack::Logjam::Logger.new
+        end
+
+        def request_log_data
+          request_data = {
+            auth_token:     env['HTTP_X_NCITE_AUTH_TOKEN'],
+            content_type:   content_type,
+            content_length: env['CONTENT_LENGTH'],
+            accept:         env['HTTP_ACCEPT'],
+            accept_version: env['HTTP_ACCEPT_VERSION'],
+            method:         env['REQUEST_METHOD'],
+            path:           env['PATH_INFO'],
+            query:          env['QUERY_STRING']
+          }
+          #request_data[:user_id] = current_user.id if current_user
+          request_data
+        end
+
+        def response_log_data
+          {
+            description: env['api.endpoint'].options[:route_options][:description],
+            source_file: env['api.endpoint'].block.source_location[0][(::Rails.root.to_s.length+1)..-1],
+            source_line: env['api.endpoint'].block.source_location[1]
+          }
+        end
+
+        def content_type
+          env['CONTENT_TYPE']
+        end
+
+        def formatted_request_body
+          body = env['rack.input'].read
+          return ANSI.yellow { 'EMPTY' } if body.blank?
+
+          if content_type == Mime::JSON.to_s
+            return ANSI.cyan { JSON.pretty_generate( JSON.parse( body )) }
+          end
+
+          nil
+        end
+
+        def formatted_response_body
+          ANSI.cyan { JSON.pretty_generate(JSON.parse( @app_response.last.body.last )) }
+        end
+
+      end
+    end
+  end
+end

data/lib/rack/logjam/grape.rb

@@ -0,0 +1,9 @@
+module Rack
+  module Logjam
+    module Grape
+
+      autoload :Middleware, 'rack/logjam/grape/middleware'
+
+    end
+  end
+end

data/lib/rack/logjam/logger.rb

@@ -0,0 +1,94 @@
+require 'jsonpath'
+require 'mime/types'
+
+module Rack
+  module Logjam
+    class Logger
+
+      def log_request( env )
+        _logger.info <<-end_info
+[#{ANSI.green { 'api' }}] #{ANSI.cyan { '--- Request Env ---' }}
+#{ANSI.magenta { JSON.pretty_generate( request_log_data( env )) }}
+[#{ANSI.green { 'api' }}] #{ANSI.cyan { '--- Request Body ---' }}
+#{ANSI.cyan { formatted_request_body( env ) }}
+end_info
+      end
+
+      def log_response( env, status, headers, response )
+        _logger.info <<-end_info
+[#{ANSI.green { 'api' }}] #{ANSI.cyan { '--- Response ---' }}
+Status: #{status}
+Headers: #{headers.inspect}
+Body:
+#{ANSI.cyan { format_body( (response.body rescue response), accept( env ), env ) }}
+        end_info
+      end
+
+    protected
+
+      def request_log_data( env )
+        request_data = {
+          content_type:   content_type( env ),
+          content_length: env['CONTENT_LENGTH'],
+          accept:         accept( env ),
+          accept_version: env['HTTP_ACCEPT_VERSION'],
+          method:         env['REQUEST_METHOD'],
+          path:           path_info( env ),
+          query:          query( env )
+        }
+        #request_data[:user_id] = current_user.id if current_user
+        request_data
+      end
+
+      def content_type( env )
+        env['CONTENT_TYPE']
+      end
+
+      def accept( env )
+        env['HTTP_ACCEPT']
+      end
+
+      def path_info( env )
+        env['PATH_INFO']
+      end
+
+      def query( env )
+        URI.unescape( env['QUERY_STRING'] )
+      end
+
+      def formatted_request_body( env )
+        format_body( rack_input_content( env ), content_type( env ), env )
+      end
+
+      def format_body( body, format, env )
+        filter = fetch_filter( format, body )
+        filtered = filter.render
+
+        formatter = fetch_formatter( format, body ).new( filtered, format )
+        formatter.render
+      end
+
+      def fetch_filter( format, body )
+        klass, filters = Rack::Logjam::Filters.get( format )
+        klass.new( body, filters )
+      end
+
+      def fetch_formatter( format, body )
+        return Rack::Logjam::Array if body.is_a?( Array )
+        return Rack::Logjam::Empty if body.strip.nil? || body.strip.empty?
+        Rack::Logjam::Formatters.get( format )
+      end
+
+      def rack_input_content( env )
+        ( rack_input = env['rack.input'] ).read.tap do |content|
+          rack_input.rewind
+        end
+      end
+
+      def _logger
+        ::Rack::Logjam::logger
+      end
+
+    end
+  end
+end

data/lib/rack/logjam/rails/middleware.rb

@@ -0,0 +1,52 @@
+require 'action_dispatch/http/mime_type'
+require 'jsonpath'
+
+module Rack
+  module Logjam
+    module Rails
+      class Middleware
+
+        def initialize( app )
+          @app = app
+        end
+
+        def call( env )
+          before env
+
+          app.call( env ).tap do |rack_response|
+            after env, *rack_response
+          end
+        end
+
+      protected
+
+        attr_reader :app
+
+        def before( env )
+          return unless api_request?( env )
+
+          logger.log_request( env )
+        end
+
+        def after( env, status, headers, response )
+          return unless api_request?( env )
+
+          logger.log_response( env, status, headers, response )
+        end
+
+        def api_request?( env )
+          path_info( env ) =~ /^\/api\//
+        end
+
+        def path_info( env )
+          env['PATH_INFO']
+        end
+
+        def logger
+          Rack::Logjam::Logger.new
+        end
+
+      end
+    end
+  end
+end

data/lib/rack/logjam/rails.rb

@@ -0,0 +1,9 @@
+module Rack
+  module Logjam
+    module Rails
+
+      autoload :Middleware, 'rack/logjam/rails/middleware'
+
+    end
+  end
+end

data/lib/rack/logjam/version.rb

@@ -2,7 +2,7 @@ module Rack
 
   module Logjam
 
-    VERSION = '0.1.0'
+    VERSION = '0.2.0'
 
   end
 

data/lib/rack/logjam.rb

@@ -1,11 +1,35 @@
 module Rack
-
   module Logjam
 
-    autoload :VERSION,    'rack/logjam/version'
-    autoload :ANSI,       'rack/logjam/ansi'
-    autoload :Middleware, 'rack/logjam/middleware'
+    autoload :ANSI,          'rack/logjam/ansi'
+    autoload :Configuration, 'rack/logjam/configuration'
+    autoload :Filters,       'rack/logjam/filters'
+    autoload :Formatters,    'rack/logjam/formatters'
+    autoload :Grape,         'rack/logjam/grape'
+    autoload :Logger,        'rack/logjam/logger'
+    autoload :Rails,         'rack/logjam/rails'
+    autoload :VERSION,       'rack/logjam/version'
 
-  end
+    def self.configuration
+      @configuration ||= Configuration.new
+    end
+
+    def self.configuration=( configuration )
+      @configuration = configuration
+    end
+
+    def self.configure
+      yield( configuration ) if block_given?
+    end
 
+    class << self
+      attr_accessor :logger
+    end
+
+  end
 end
+
+Rack::Logjam::Formatters.register 'application/x-www-form-urlencoded', :FormUrlencoded
+Rack::Logjam::Formatters.register 'application/json', :Json
+Rack::Logjam::Formatters.register 'text/plain', :TextPlain
+Rack::Logjam::Formatters.register 'application/xml', :Xml

data/rack-logjam.gemspec

@@ -20,9 +20,9 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'actionpack', '~> 3.2'
-  spec.add_dependency 'jsonpath',   '~> 0.5'
-  spec.add_dependency 'nokogiri',   '~> 1.6'
+  spec.add_dependency 'jsonpath', '~> 0.5'
+  spec.add_dependency 'multi_json'
+  spec.add_dependency 'nokogiri'
 
   spec.add_development_dependency 'bundler', '~> 1.5'
   spec.add_development_dependency 'rake'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rack-logjam
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Jason Harrelson
@@ -9,50 +9,50 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-06 00:00:00.000000000 Z
+date: 2014-10-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: actionpack
+  name: jsonpath
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '0.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '0.5'
 - !ruby/object:Gem::Dependency
-  name: jsonpath
+  name: multi_json
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.5'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.5'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: nokogiri
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -89,6 +89,8 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".ruby-gemset"
+- ".ruby-version"
 - Gemfile
 - License.markdown
 - README.markdown
@@ -96,7 +98,25 @@ files:
 - lib/rack-logjam.rb
 - lib/rack/logjam.rb
 - lib/rack/logjam/ansi.rb
-- lib/rack/logjam/middleware.rb
+- lib/rack/logjam/configuration.rb
+- lib/rack/logjam/filters.rb
+- lib/rack/logjam/filters/base.rb
+- lib/rack/logjam/filters/json.rb
+- lib/rack/logjam/filters/nil.rb
+- lib/rack/logjam/formatters.rb
+- lib/rack/logjam/formatters/array.rb
+- lib/rack/logjam/formatters/base.rb
+- lib/rack/logjam/formatters/empty.rb
+- lib/rack/logjam/formatters/form_urlencoded.rb
+- lib/rack/logjam/formatters/json.rb
+- lib/rack/logjam/formatters/nil.rb
+- lib/rack/logjam/formatters/text_plain.rb
+- lib/rack/logjam/formatters/xml.rb
+- lib/rack/logjam/grape.rb
+- lib/rack/logjam/grape/middleware.rb
+- lib/rack/logjam/logger.rb
+- lib/rack/logjam/rails.rb
+- lib/rack/logjam/rails/middleware.rb
 - lib/rack/logjam/version.rb
 - rack-logjam.gemspec
 homepage: ''

data/lib/rack/logjam/middleware.rb

@@ -1,149 +0,0 @@
-require 'action_dispatch/http/mime_type'
-require 'jsonpath'
-
-module Rack
-
-  module Logjam
-
-    class Middleware
-
-      def initialize( app )
-        @app = app
-      end
-
-      def call( env )
-        before env
-        app.call( env ).tap do |rack_response|
-          after env, *rack_response
-        end
-      end
-
-    protected
-
-      attr_reader :app
-
-      def before( env )
-        return unless api_request?( env )
-
-        Rails.logger.info <<-end_info
-[#{ANSI.green { 'api' }}] #{ANSI.cyan { '--- Request Env ---' }}
-#{ANSI.magenta { JSON.pretty_generate( request_log_data( env )) }}
-[#{ANSI.green { 'api' }}] #{ANSI.cyan { '--- Request Body ---' }}
-#{ANSI.cyan { formatted_request_body( env ) }}
-        end_info
-      end
-
-      def after( env, status, headers, response )
-        return unless api_request?( env )
-
-        Rails.logger.info <<-end_info
-[#{ANSI.green { 'api' }}] #{ANSI.cyan { '--- Response ---' }}
-Status: #{status}
-Headers: #{headers.inspect}
-Body:
-#{ANSI.cyan { format_body( (response.body rescue response), accept( env ), env ) }}
-        end_info
-      end
-
-      def request_log_data( env )
-        request_data = {
-          auth_token:     env['HTTP_X_NCITE_AUTH_TOKEN'],
-          content_type:   content_type( env ),
-          content_length: env['CONTENT_LENGTH'],
-          accept:         accept( env ),
-          accept_version: env['HTTP_ACCEPT_VERSION'],
-          method:         env['REQUEST_METHOD'],
-          path:           path_info( env ),
-          query:          query( env )
-        }
-        #request_data[:user_id] = current_user.id if current_user
-        request_data
-      end
-
-      def api_request?( env )
-        path_info( env ) =~ /^\/api\//
-      end
-
-      def content_type( env )
-        env['CONTENT_TYPE']
-      end
-
-      def accept( env )
-        env['HTTP_ACCEPT']
-      end
-
-      def path_info( env )
-        env['PATH_INFO']
-      end
-
-      def query( env )
-        URI.unescape( env['QUERY_STRING'] )
-      end
-
-      def formatted_request_body( env )
-        format_body( rack_input_content( env ), content_type( env ), env )
-      end
-
-      def format_body( body, format, env )
-        return body.inspect if body.is_a?( Array )
-        return body if body.strip.nil? || body.strip.empty?
-
-        if format == ::Mime::JSON.to_s
-          hash = truncate_json_attributes( body )
-          return ::JSON.pretty_generate( hash )
-        elsif format == ::Mime::XML.to_s
-          return ::Nokogiri.XML( body ) do |config|
-            config.default_xml.noblanks
-          end.to_xml( indent: 2 )
-        elsif format == ::Mime::URL_ENCODED_FORM.to_s
-          return URI.unescape( body )
-        elsif format == ::Mime::OCTET_STREAM.to_s
-          return "no body b/c content type is #{::Mime::OCTET_STREAM}"
-        end
-
-        body
-      end
-
-      def rack_input_content( env )
-        ( rack_input = env['rack.input'] ).read.tap do |content|
-          rack_input.rewind
-        end
-      end
-
-      # Can currently use the following xpath expressions that will translate to json_path:
-      # /some/path -> $.some.path (search from root)
-      # some/path -> some.path (search for any sub-path that matches this, not bound to root)
-      # //path -> $..path (recursive search)
-      #
-      def truncated_attributes_as_xpath
-        %w(
-          //image_as_base64
-          //fingerprint_image_as_base64
-        )
-      end
-
-      def truncate_json_attributes( json )
-        json_path = ::JsonPath.for( json )
-        truncated_attributes_as_json_paths.each do |j_path|
-          json_path.gsub!( j_path ) { |val| (val.nil? || val.empty?) ? val : "#{val[0..25]} ... [TRUNCATED] ..." }
-        end
-        json_path.to_hash
-      end
-
-      def truncated_attributes_as_json_paths
-        truncated_attributes_as_xpath.map do |xpath|
-          if xpath.start_with?( '//' )
-            xpath.gsub( '//', '$..' )
-          else
-            parts = xpath.split( '/' )
-            parts[0] = '$' if parts[0] == ''
-            parts.join( '.' )
-          end
-        end
-      end
-
-    end
-
-  end
-
-end