rack-traffic-logger 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6a455d4887387282d5194961bad8442b7f05d1cd
-  data.tar.gz: 6bfc39d711eebf00a9c93f6e2035f70ea524babe
+  metadata.gz: f50ccbadf767b049731815d271ce316d986d916a
+  data.tar.gz: a6a970b4368ff2ed2a88a3ab66384dc32e046220
 SHA512:
-  metadata.gz: 489b81dcb76375c24c0bdc8d9e933494c7134d4264aa3ef83e6176176ae6d32768b7f1ff226323404198dfe51a0612b52d3aa0cf6e951bf35f059dcb48e7d1ff
-  data.tar.gz: c51a533ccbc5868fc9a7f44cb0f7f6355d362eb51aa9cc1badd70011871adcd9ab328ef6b09a840676dfeb53c1a944983e64e6ae5f7d02f07ce6f0d3e51f4302
+  metadata.gz: 29df161ebf86d8f6735f92f8d85314450c53534ef9e6fbcc0c67edc0f306b014bea4cd5920a41e520e9f86698feb85d5b1bf5d948764cb8bd64e4c73d00b3a11
+  data.tar.gz: 8331c0187a9d47ecbda6972f18724801dc6b3b806f32f5c1a95af3f220320eb71d79db85c9fbfb7047652ee2f1d0345d73ebc3762816e609d483d17bc822de24

data/README.md

@@ -17,9 +17,119 @@ require 'rack/traffic_logger'
 Then, in your `config.ru` or wherever you set up your middleware stack:
 
 ```ruby
-use Rack::TrafficLogger, 'path/to/file.log', response_bodies: false, colors: true
+use Rack::TrafficLogger, 'path/to/file.log'
 ```
 
-- If you don't provide a log, everything will go to `STDOUT`.
-- You can supply either the path to a log file, an open file handle, or an instance of `Logger`.
-- See [this file](https://github.com/hx/rack-traffic-logger/blob/develop/lib/rack/traffic_logger.rb) for a list of other options that can affect logging style/filtering.
+By default, simple stream-like output will be written:
+
+```
+@ Wed 12 Nov '14 15:19:48.0 #48f8ed62
+GET /home HTTP/1.1
+
+@ Wed 12 Nov '14 15:19:48.0 #48f8ed62
+HTTP/1.1 200 OK
+```
+
+The part after the `#` is the **request log ID**, which is unique to each request. It lets you match up a response with its request, in case you have multiple listeners.
+
+You can add some colour, and JSON request/response body pretty-printing, by specifying a formatter:
+
+```ruby
+use Rack::TrafficLogger, 'file.log', Rack::TrafficLogger::Formatter::Stream.new(color: true, pretty_print: true)
+```
+
+You can also output JSON (great for sending to log analyzers like Splunk):
+
+```ruby
+use Rack::TrafficLogger, 'file.log', Rack::TrafficLogger::Formatter::JSON.new
+```
+
+### Filtering
+
+By default, only basic request/response details are logged:
+
+```json
+{
+  "timestamp": "2014-11-12 15:30:20 +1100",
+  "request_log_id": "d67e5591",
+  "event": "request",
+  "SERVER_NAME": "localhost",
+  "REQUEST_METHOD": "GET",
+  "PATH_INFO": "/home",
+  "HTTP_VERSION": "HTTP/1.1",
+  "SERVER_PORT": "80",
+  "QUERY_STRING": "",
+  "REMOTE_ADDR": "127.0.0.1"
+}
+{
+  "timestamp": "2014-11-12 15:30:20 +1100",
+  "request_log_id": "d67e5591",
+  "event": "response",
+  "http_version": "HTTP/1.1",
+  "status_code": 200,
+  "status_name": "OK"
+}
+```
+
+You can specify other parts of requests/responses to be logged:
+
+```ruby
+use Rack::TrafficLogger, 'file.log', :request_headers, :response_bodies
+```
+
+Optional sections include `request_headers`, `request_bodies`, `response_headers`, and `response_bodies`. You can also specify `headers` for both request and response headers, and `bodies` for both request and response bodies. Or, specify `all` if you want the lot. Combine tokens to get the output you need:
+
+```ruby
+use Rack::TrafficLogger, 'file.log', :headers, :response_bodies # Everything except request bodies!
+# Or:
+use Rack::TrafficLogger, 'file.log', :all # Everything
+```
+
+If you want to use a custom formatter, make sure you include it before any filtering arguments:
+
+```ruby
+use Rack::TrafficLogger, 'file.log', Rack::TrafficLogger::Formatter::JSON.new, :headers
+```
+
+You can specify that you want different parts logged based on the kind of request that was made:
+
+```ruby
+use Rack::TrafficLogger, 'file.log', :headers, post: :request_bodies # Log headers for all requests, and also request bodies for POST requests
+```
+
+You can also exclude other request verbs entirely:
+
+```ruby
+use Rack::TrafficLogger, 'file.log', only: {post: [:headers, :request_bodies]} # Log only POST requests, and include all headers, and request bodies
+```
+
+This can be shortened to:
+
+```ruby
+use Rack::TrafficLogger, 'file.log', :post, :headers, :request_bodies
+```
+
+Or if you only want the basics of POST requests, without headers/bodies:
+
+```ruby
+use Rack::TrafficLogger, 'file.log', :post
+```
+
+You can apply the same filtration based on response status codes:
+
+```ruby
+use Rack::TrafficLogger, 'file.log', 404 # Only log requests that are not-found
+```
+
+Include as many as you like, and even use ranges:
+
+```ruby
+use Rack::TrafficLogger, 'file.log', 301, 302, 400...600 # Log redirects and errors
+```
+
+If you need to, you can get pretty fancy:
+
+```ruby
+use Rack::TrafficLogger, 'file.log', :request_headers, 401 => false, 500...600 => :all, 200...300 => {post: :request_bodies, delete: false}
+use Rack::TrafficLogger, 'file.log', [:get, :head] => 200..204, post: {only: {201 => :request_bodies}}, [:put, :patch] => :all
+```

data/lib/rack/traffic_logger/echo.rb

@@ -5,25 +5,23 @@ module Rack
   class TrafficLogger
     class Echo
       def call(env)
+        body = env['rack.input'].tap(&:rewind).read
+        headers = {}
         begin
-          body = JSON.parse(env['rack.input'].tap(&:rewind).read).to_json
-          headers = {'Content-Type' => 'application/json'}
-          if env['HTTP_ACCEPT_ENCODING'] =~ /\bgzip\b/
-            zipped = StringIO.new('w')
-            writer = Zlib::GzipWriter.new(zipped)
-            writer.write body
-            writer.close
-            body = zipped.string
-            headers['Content-Encoding'] = 'gzip'
-          end
-          [200, headers, [body]]
-        rescue JSON::ParserError => error
-          [
-              500,
-              {'Content-Type' => 'text/plain;charset=UTF-8'},
-              [error.message]
-          ]
+          body = JSON.parse(body).to_json
+          headers['Content-Type'] = 'application/json'
+        rescue JSON::ParserError
+          # ignored
         end
+        if env['HTTP_ACCEPT_ENCODING'] =~ /\bgzip\b/
+          zipped = StringIO.new('w')
+          writer = Zlib::GzipWriter.new(zipped)
+          writer.write body
+          writer.close
+          body = zipped.string
+          headers['Content-Encoding'] = 'gzip'
+        end
+        [200, headers, [body]]
       end
     end
   end

data/lib/rack/traffic_logger/formatter/json.rb

@@ -0,0 +1,18 @@
+require 'json'
+
+module Rack
+  class TrafficLogger
+    class Formatter
+      class JSON < self
+
+        def initialize(pretty_print: false)
+          formatter = pretty_print ?
+              -> hash { ::JSON.pretty_generate(hash) << "\n" } :
+              -> hash { ::JSON.generate(hash) << "\n" }
+          define_singleton_method :format, formatter
+        end
+
+      end
+    end
+  end
+end

data/lib/rack/traffic_logger/formatter/stream.rb

@@ -0,0 +1,19 @@
+module Rack
+  class TrafficLogger
+    class Formatter
+      class Stream < self
+
+        def initialize(**options)
+          @simulator = StreamSimulator.new(**options)
+        end
+
+        def format(hash)
+          time = hash[:timestamp]
+          id = hash[:request_log_id]
+          "@ #{time.strftime '%a %d %b \'%y %T'}.#{'%d' % (time.usec / 1e4)} ##{id}\n#{@simulator.format(hash)}\n\n"
+        end
+
+      end
+    end
+  end
+end

data/lib/rack/traffic_logger/formatter.rb

@@ -0,0 +1,14 @@
+require_relative 'formatter/stream'
+require_relative 'formatter/json'
+
+module Rack
+  class TrafficLogger
+    class Formatter
+
+      def format(hash)
+        raise NotImplementedError
+      end
+
+    end
+  end
+end

data/lib/rack/traffic_logger/option_interpreter.rb

@@ -0,0 +1,149 @@
+module Rack
+  class TrafficLogger
+    class OptionInterpreter
+      
+      VERBS = %i[get post put patch delete head options trace]
+      TYPES = %i[request_headers response_headers request_bodies response_bodies]
+
+      def initialize(*options)
+        @tests = {}
+        add_rules options
+      end
+
+      class Rule
+        attr_reader :arg, :filter
+        def initialize(arg, filter = {})
+          @arg = arg
+          @filter = filter
+        end
+        def inspect
+          "<#{filter} #{self.class.name[/[^:]+$/]}: #{arg}>"
+        end
+        def applies?(verb, code)
+          return false if filter[:verb] && verb != filter[:verb]
+          !filter[:code] || filter[:code] === code
+        end
+      end
+
+      class OnlyVerb < Rule; end
+      class OnlyCode < Rule; end
+      class Include < Rule; end
+      class Exclude < Rule; end
+
+      TYPES.each do |type|
+        define_method(:"#{type}?") { |verb, code| test verb, code, type }
+      end
+
+      class OptionProxy
+        def initialize(interpreter, verb, code)
+          @interpreter = interpreter
+          @verb = verb
+          @code = code
+        end
+        (TYPES + [:basic]).each do |type|
+          method = :"#{type}?"
+          define_method(method) { @interpreter.__send__ method, @verb, @code }
+        end
+      end
+
+      def for(verb, code)
+        OptionProxy.new self, verb, code
+      end
+
+      def add_rules(input, **filter)
+        input = [input] unless Array === input
+        verb = filter[:verb]
+        code = filter[:code]
+        input.each do |token|
+          case token
+            when *VERBS
+              raise "Verb on verb (#{token} on #{verb})" if verb
+              rules << OnlyVerb.new(token, filter)
+            when Fixnum, Range
+              raise "Code on code (#{token} on #{code})" if code
+              rules << OnlyCode.new(token, filter)
+            when *TYPES
+              rules << Include.new(token, filter)
+            when FalseClass
+              rules << Exclude.new(nil, filter)
+            when :headers then add_rules [:request_headers, :response_headers], **filter
+            when :bodies then add_rules [:request_bodies, :response_bodies], **filter
+            when :all then add_rules [:headers, :bodies], **filter
+            when Hash
+              if token.keys == [:only]
+                inner_hash = token.values.first
+                raise 'You can only use :only => {} with a Hash' unless Hash === inner_hash
+                add_rules inner_hash.keys, **filter
+                add_rule_hash inner_hash, **filter
+              else
+                add_rule_hash token, **filter
+              end
+            else raise "Invalid token of type #{token.class.name} : #{token}"
+          end
+        end
+      end
+
+      def add_rule_hash(hash, **filter)
+        hash.each { |k, v| add_rule_pair k, v, **filter }
+      end
+
+      def add_rule_pair(name, value, **filter)
+        case name
+          when *VERBS then add_rules value, **filter.merge(verb: name)
+          when Fixnum, Range then add_rules value, **filter.merge(code: name)
+          when Array then name.each { |n| add_rule_pair n, value, **filter }
+          else raise "Invalid token of type #{name.class.name} : #{name}"
+        end
+      end
+
+      # Test whether a given verb, status code, and log type should be logged
+      # @param verb [Symbol] One of the {self::VERBS} symbols
+      # @param code [Fixnum] The HTTP status code
+      # @param type [Symbol|NilClass] One of the {self::TYPES} symbols, or `nil` for basic request/response details
+      # @return [TrueClass|FalseClass] Whether the type should be logged
+      def test(*args)
+        if @tests.key? args
+          @tests[args]
+        else
+          @tests[args] = _test *args
+        end
+      end
+
+      alias :basic? :test
+
+      private
+
+      def _test(verb, code, type = nil)
+
+        # To start, only allow if not a header/body
+        type_result = type == nil
+
+        # Exclusivity filters
+        only_code = nil
+        only_verb = nil
+
+        # Loop through rules that apply to this verb and code
+        rules.select { |r| r.applies? verb, code }.each do |rule|
+          case rule
+            when Include then type_result ||= rule.arg == type
+            when OnlyVerb then only_verb ||= rule.arg == verb
+            when OnlyCode then only_code ||= rule.arg === code
+            when Exclude
+              only_verb ||= false if rule.filter[:verb]
+              only_code ||= false if rule.filter[:code]
+            else nil
+          end
+        end
+
+        # Pass if the type was accepted, and exclusivity filters passed
+        type_result && ![only_verb, only_code].include?(false)
+
+      end
+
+      def rules
+        @rules ||= []
+      end
+
+    end
+  end
+end

data/lib/rack/traffic_logger/stream_simulator.rb

@@ -0,0 +1,87 @@
+module Rack
+  class TrafficLogger
+    class StreamSimulator
+
+      def initialize(color: false, pretty_print: false)
+        @color = color
+        @pretty_print = pretty_print
+      end
+
+      def format(input)
+        case input[:event]
+          when 'request' then format_request input
+          when 'response' then format_response input
+          else nil
+        end
+      end
+
+      private
+
+      REQUEST_TEMPLATES = {
+          true => "\e[35m:verb \e[36m:path:qs\e[0m :http",
+          false => ':verb :path:qs :http'
+      }
+
+      RESPONSE_TEMPLATES = {
+          true => ":http \e[:color:code \e[36m:status\e[0m",
+          false => ':http :code :status'
+      }
+
+      HEADER_TEMPLATES = {
+          true => "\n\e[4m:key\e[0m: :val\e[34m:extra\e[0m",
+          false => "\n:key: :val:extra"
+      }
+
+      BASIC_AUTH_PATTERN = /^basic ([a-z\d+\/]+={0,2})$/i
+
+      def format_request(input)
+        result = render REQUEST_TEMPLATES[@color],
+                        verb: input['REQUEST_METHOD'],
+                        path: input['PATH_INFO'],
+                        qs: (q = input['QUERY_STRING']).empty? ? '' : "?#{q}",
+                        http: input['HTTP_VERSION'] || 'HTTP/1.1'
+        result << format_headers(env_request_headers input)
+        result << format_body(input, input['CONTENT_TYPE'] || input['HTTP_CONTENT_TYPE'])
+      end
+
+      def format_response(input)
+        result = render RESPONSE_TEMPLATES[@color],
+                        http: input['http_version'] || 'HTTP/1.1',
+                        code: input['status_code'],
+                        status: input['status_name']
+        headers = input['headers']
+        result << format_headers(headers) if headers
+        result << format_body(input, headers && headers['Content-Type'])
+      end
+
+      def render(template, data)
+        template.gsub(/:(\w+)/) { data[$1.to_sym] }
+      end
+
+      def format_headers(headers)
+        headers = HeaderHash.new(headers) unless HeaderHash === headers
+        headers.map do |k, v|
+          data = {key: k, val: v}
+          data[:extra] = " #{$1.unpack('m').first}" if k == 'Authorization' && v =~ BASIC_AUTH_PATTERN
+          render HEADER_TEMPLATES[@color], data
+        end.join
+      end
+
+      def format_body(input, content_type)
+        body = input['body_base64'] ? input['body_base64'].unpack('m').first : input['body']
+        return '' unless body
+        body = JSON.pretty_generate(JSON.parse body) rescue body if @pretty_print && content_type =~ %r{^application/json(;|$)}
+        if body =~ /[^[:print:]\r\n\t]/
+          length = body.bytes.length
+          body = "<BINARY (#{length} byte#{length == 1 ? '' : 's'})>"
+        end
+        "\n\n#{body}"
+      end
+
+      def env_request_headers(env)
+        env.select { |k, _| k =~ /^(CONTENT|HTTP)_(?!VERSION)/ }.map { |(k, v)| [k.sub(/^HTTP_/, ''), v] }.to_h
+      end
+
+    end
+  end
+end

data/lib/rack/traffic_logger/version.rb

@@ -1,5 +1,5 @@
 module Rack
   class TrafficLogger
-    VERSION = '0.1.4'
+    VERSION = '0.2.0'
   end
 end

data/lib/rack/traffic_logger.rb

@@ -1,151 +1,154 @@
 require_relative 'traffic_logger/version'
-require_relative 'traffic_logger/logger'
 require_relative 'traffic_logger/header_hash'
+require_relative 'traffic_logger/option_interpreter'
+require_relative 'traffic_logger/stream_simulator'
+require_relative 'traffic_logger/formatter'
 
-require 'forwardable'
-require 'rack/nulllogger'
 require 'json'
+require 'securerandom'
 
 module Rack
   class TrafficLogger
-    extend Forwardable
-
-    PUBLIC_ATTRIBUTES = {
-        request_headers:  {type: [TrueClass, FalseClass], default: true},
-        request_bodies:   {type: [TrueClass, FalseClass], default: true},
-        response_headers: {type: [TrueClass, FalseClass], default: true},
-        response_bodies:  {type: [TrueClass, FalseClass], default: true},
-        colors: {type: [TrueClass, FalseClass], default: false},
-        prevent_compression: {type: [TrueClass, FalseClass], default: false},
-        pretty_print: {type: [TrueClass, FalseClass], default: false}
-    }
-
-    PUBLIC_ATTRIBUTES.each do |attr, props|
-      type = props[:type]
-      type = [type] unless Array === type
-      define_method(attr) { @options[attr] }
-      define_method :"#{attr}=" do |value|
-        raise "Expected one of [#{type.map(&:name).join ' | '}], got #{value.class.name}" unless type.find { |t| t === value }
-        @options[attr] = value
-      end
-    end
-
-    delegate %i(info debug warn error fatal) => :@logger
 
-    def initialize(app, logger = nil, options = {})
-      Raise "Expected a Hash, but got #{options.class.name}" unless Hash === options
+    # These environment properties will always be logged as part of request logs
+    BASIC_ENV_PROPERTIES = %w[
+        REQUEST_METHOD
+        HTTPS
+        SERVER_NAME
+        SERVER_PORT
+        PATH_INFO
+        QUERY_STRING
+        HTTP_VERSION
+        REMOTE_HOST
+        REMOTE_ADDR
+      ]
+
+    attr_reader :app, :options
+
+    def initialize(app, log_path, *options)
       @app = app
-      case logger
-        when nil, false then logger = Logger.new(STDOUT)
-        when String, IO then logger = Logger.new(logger)
-        else logger = Rack::NullLogger.new(nil) unless logger.respond_to? :debug
-      end
-      @logger = logger
-      @options = self.class.default_options.merge(options)
+      @log_path = log_path
+      @formatter = options.first.respond_to?(:format) ? options.shift : Formatter::Stream.new
+      @options = OptionInterpreter.new(*options)
     end
 
     def call(env)
-      env.delete 'HTTP_ACCEPT_ENCODING' if prevent_compression
-      safely('logging request') { log_request! env }
-      @app.call(env).tap { |response| safely('logging response') { log_response! env, response } }
+      Request.new(self).call env
     end
 
-    private
-
-    def safely(action)
-      yield rescue error "Error #{action}: #{$!}"
+    def log(hash)
+      write @formatter.format hash
     end
 
-    def self.default_options
-      @default_options ||= PUBLIC_ATTRIBUTES.map { |k, v| [k, v[:default]] }.to_h
+    def write(data)
+      if @log_path.respond_to? :write
+        @log_path.write data
+      else
+        File.write @log_path, data, mode: 'a', encoding: data.encoding
+      end
     end
 
-    def render(template, data)
-      template.gsub(/:(\w+)/) { data[$1.to_sym] }
-    end
+    private
 
-    REQUEST_TEMPLATES = {
-        true => "\e[35m:verb \e[36m:path:qs\e[0m :http",
-        false => ':verb :path:qs :http'
-    }
-
-    def log_request!(env)
-      debug render REQUEST_TEMPLATES[colors],
-                   verb: env['REQUEST_METHOD'],
-                   path: env['PATH_INFO'],
-                   qs: (q = env['QUERY_STRING']).empty? ? '' : "?#{q}",
-                   http: env['HTTP_VERSION'] || 'HTTP/1.1'
-      if request_headers || request_bodies
-        headers = HeaderHash.new(env_request_headers env)
-        log_headers! headers if request_headers
-        input = env['rack.input']
-        if request_bodies && input
-          log_body! input.read,
-                    type: headers['Content-Type'],
-                    encoding: headers['Content-Encoding']
-          input.rewind
+    class Request
+
+      def initialize(logger)
+        @logger = logger
+        @id = SecureRandom.hex 4
+        @started_at = Time.now
+      end
+
+      def call(env)
+        @verb = env['REQUEST_METHOD']
+        @env = env
+        begin
+          response = @logger.app.call(env)
+        ensure
+          @code = Array === response ? response.first.to_i : 0
+          @options = @logger.options.for(@verb, @code)
+          if @options.basic?
+            log_request env
+            log_response env, response if @code > 0
+          end
         end
       end
-    end
 
-    RESPONSE_TEMPLATES = {
-        true => ":http \e[:color:code \e[36m:status\e[0m",
-        false => ':http :code :status'
-    }
+      private
 
-    def status_color(status)
-      case (status.to_i / 100).to_i
-        when 2 then '32m'
-        when 4, 5 then '31m'
-        else '33m'
-      end
-    end
+      BASIC_AUTH_PATTERN = /^basic ([a-z\d+\/]+={0,2})$/i
 
-    def log_response!(env, response)
-      debug render RESPONSE_TEMPLATES[colors],
-                   http: env['HTTP_VERSION'] || 'HTTP/1.1',
-                   code: code = response[0],
-                   status: Rack::Utils::HTTP_STATUS_CODES[code],
-                   color: status_color(code)
-      if response_headers || response_bodies
-        headers = HeaderHash.new(response[1])
-        log_headers! headers if response_headers
-        if response_bodies
-          body = response[2]
-          body = ::File.open(body.path, 'rb') { |f| f.read } if body.respond_to? :path
-          if body.respond_to? :read
-            stream = body
-            body = stream.tap(&:rewind).read
-            stream.rewind
+      def log_request(env)
+        log 'request' do |hash|
+          if @options.request_headers?
+            hash.merge! env.reject { |_, v| v.respond_to? :read }
+          else
+            hash.merge! env.select { |k, _| BASIC_ENV_PROPERTIES.include? k }
+          end
+
+          hash['BASIC_AUTH_USERINFO'] = $1.unpack('m').first.split(':', 2) if hash['HTTP_AUTHORIZATION'] =~ BASIC_AUTH_PATTERN
+
+          input = env['rack.input']
+          if input && @options.request_bodies?
+            add_body_to_hash input.tap(&:rewind).read, env['CONTENT_ENCODING'] || env['HTTP_CONTENT_ENCODING'], hash
+            input.rewind
           end
-          body = body.join if body.respond_to? :join
-          body = body.body while Rack::BodyProxy === body
-          log_body! body,
-                    type: headers['Content-Type'],
-                    encoding: headers['Content-Encoding']
         end
       end
-    end
 
-    def log_body!(body, type: nil, encoding: nil)
-      return unless body
-      body = Zlib::GzipReader.new(StringIO.new body).read if encoding == 'gzip'
-      body = JSON.pretty_generate(JSON.parse body) if type[/[^;]+/] == 'application/json' && pretty_print
-      body = "<#BINARY #{body.bytes.length} bytes>" if body =~ /[^[:print:]\r\n\t]/
-      info body
-    end
+      def log_response(env, response)
+        code, headers, body = response
+        code = code.to_i
+        headers = HeaderHash.new(headers) if @options.response_headers? || @options.response_bodies?
+        log 'response' do |hash|
+          hash['http_version'] = env['HTTP_VERSION'] || 'HTTP/1.1'
+          hash['status_code'] = code
+          hash['status_name'] = Utils::HTTP_STATUS_CODES[code]
+          hash['headers'] = headers if @options.response_headers?
+          add_body_to_hash get_real_body(body), headers['Content-Encoding'], hash if @options.response_bodies?
+        end
+      end
 
-    HEADER_TEMPLATES = {
-        true => "\e[4m:key\e[0m: :val\n",
-        false => ":key: :val\n"
-    }
+      # Rack allows response bodies to be a few different things. This method
+      # ensures we get a string back.
+      def get_real_body(body)
 
-    def log_headers!(headers)
-      info headers.map { |k, v| render HEADER_TEMPLATES[colors], key: k, val: v }.join
-    end
+        # For bodies representing temporary files
+        body = File.open(body.path, 'rb') { |f| f.read } if body.respond_to? :path
+
+        # For bodies representing streams
+        body = body.read.tap { body.rewind } if body.respond_to? :read
+
+        # When body is an array (the common scenario)
+        body = body.join if body.respond_to? :join
+
+        # When body is a proxy
+        body = body.body while Rack::BodyProxy === body
+
+        # It should be a string now. Just in case it's not...
+        body.to_s
+
+      end
+
+      def add_body_to_hash(body, encoding, hash)
+        body = Zlib::GzipReader.new(StringIO.new body).read if encoding == 'gzip'
+        body.force_encoding 'UTF-8'
+        if body.valid_encoding?
+          hash['body'] = body
+        else
+          hash['body_base64'] = [body].pack 'm0'
+        end
+      end
+
+      def log(event)
+        hash = {
+            timestamp: Time.now,
+            request_log_id: @id,
+            event: event
+        }
+        yield hash rescue hash.merge! error: $!
+        @logger.log hash
+      end
 
-    def env_request_headers(env)
-      env.select { |k, _| k =~ /^(CONTENT|HTTP)_(?!VERSION)/ }.map { |(k, v)| [k.sub(/^HTTP_/, ''), v] }.to_h
     end
 
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rack-traffic-logger
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors:
 - Neil E. Pearson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-01 00:00:00.000000000 Z
+date: 2014-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -35,8 +35,12 @@ files:
 - README.md
 - lib/rack/traffic_logger.rb
 - lib/rack/traffic_logger/echo.rb
+- lib/rack/traffic_logger/formatter.rb
+- lib/rack/traffic_logger/formatter/json.rb
+- lib/rack/traffic_logger/formatter/stream.rb
 - lib/rack/traffic_logger/header_hash.rb
-- lib/rack/traffic_logger/logger.rb
+- lib/rack/traffic_logger/option_interpreter.rb
+- lib/rack/traffic_logger/stream_simulator.rb
 - lib/rack/traffic_logger/version.rb
 homepage: https://github.com/hx/rack-traffic-logger
 licenses:

data/lib/rack/traffic_logger/logger.rb

@@ -1,25 +0,0 @@
-require 'logger'
-
-module Rack
-  class TrafficLogger
-    class Logger < ::Logger
-
-      def initialize(*args)
-        super *args
-        @default_formatter = Formatter.new
-      end
-
-      class Formatter
-
-        def call(severity, time, progname, msg)
-          if severity == 'INFO'
-            "#{msg}\n"
-          else
-            "@ #{time.strftime '%a %d %b \'%y %T'}.#{'%d' % (time.usec / 1e4)}\n#{msg}\n"
-          end
-        end
-
-      end
-    end
-  end
-end