timber-rack 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 842b8f0648df453c036c272d6a4c6acb14b5871f93d510e5c0ff13d695099558
+  data.tar.gz: ac7015817b3f3cd58e2fbb2ae06439af33ad958c44beb9fa6bed381a68b44f9d
+SHA512:
+  metadata.gz: f90f921a1ef9f09dccdd32d3ab0d00439b35726de39713d1d69fad28be6dde80c9815d088111beae17d3cc1b0c71d1752fa80c4475036a18401fa0bf705f8a2f
+  data.tar.gz: ef5185ce6ce4e908c2521effd3a3a4790ec949e11fcfa1eb03d8ce863e216fd770f8308e1e226862c8cb2515235ed0333c972832d246f0d3985935d72e7402b3

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+
+# Ignore gemset
+/.gem

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.5.1
+before_install: gem install bundler -v 1.17.3

data/Gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+# TODO: REMOVE ME
+gem 'timber', git: 'https://github.com/timberio/timber-ruby.git', branch: '3.0'
+
+# Specify your gem's dependencies in timber-ruby-rack.gemspec
+gemspec

data/LICENSE.md

@@ -0,0 +1,16 @@
+# License
+
+Copyright (c) 2016, Timber Technologies, Inc.
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.
+

data/README.md

@@ -0,0 +1,12 @@
+# 🌲 Timber Integration For Rack
+
+[![ISC License](https://img.shields.io/badge/license-ISC-ff69b4.svg)](LICENSE.md)
+[![Yard Docs](http://img.shields.io/badge/yard-docs-blue.svg)](http://www.rubydoc.info/github/timberio/timber-ruby-rack)
+[![Build Status](https://travis-ci.org/timberio/timber-ruby-rack.svg?branch=master)](https://travis-ci.org/timberio/timber-ruby-rack)
+[![Code Climate](https://codeclimate.com/github/timberio/timber-ruby-rack/badges/gpa.svg)](https://codeclimate.com/github/timberio/timber-ruby-rack)
+
+This library integrates the [`timber` Ruby library](https://github.com/timberio/timber-ruby) with the [Rack](https://github.com/rack/rack) framework,
+turning your Rack logs into rich structured events.
+
+* **Sign-up: [https://app.timber.io](https://app.timber.io)**
+* **Documentation: [https://docs.timber.io/setup/languages/ruby/integrations/rack](https://docs.timber.io/setup/languages/ruby/integrations/rack)**

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "timber-rack"
+
+# 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(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/timber-rack.rb

@@ -0,0 +1,16 @@
+require "rack"
+require "timber"
+require "timber-rack/config"
+require "timber-rack/error_event"
+require "timber-rack/http_context"
+require "timber-rack/http_events"
+require "timber-rack/session_context"
+require "timber-rack/user_context"
+
+module Timber
+  module Integrations
+    module Rack
+    end
+  end
+end
+

data/lib/timber-rack/config.rb

@@ -0,0 +1,85 @@
+require "timber"
+
+Timber::Config.instance.define_singleton_method(:logrageify!) do
+  integrations.rack.http_events.collapse_into_single_event = true
+end
+
+module Timber
+  class Config
+    module Integrations
+      extend self
+      # Convenience module for accessing the various `Timber::Integrations::Rack::*` classes
+      # through the {Timber::Config} object. Timber couples configuration with the class
+      # responsibls for implementing it. This provides for a tighter design, but also
+      # requires the user to understand and access the various classes. This module aims
+      # to provide a simple ruby-like configuration interface for internal Timber classes.
+      #
+      # For example:
+      #
+      #     config = Timber::Config.instance
+      #     config.integrations.rack.http_events.enabled = false
+      def rack
+        Rack
+      end
+
+      module Rack
+        extend self
+
+        # Convenience method for accessing the {Timber::Integrations::Rack::ErrorEvent}
+        # middleware class specific configuration. See {Timber::Integrations::Rack::ExceptionEvent}
+        # for a list of methods available.
+        #
+        # @example
+        #   config = Timber::Config.instance
+        #   config.integrations.rack.error_event.enabled = false
+        def error_event
+          Timber::Integrations::Rack::ErrorEvent
+        end
+
+        # Convenience method for accessing the {Timber::Integrations::Rack::HTTPContext}
+        # middleware class specific configuration. See {Timber::Integrations::Rack::HTTPContext}
+        # for a list of methods available.
+        #
+        # @example
+        #   config = Timber::Config.instance
+        #   config.integrations.rack.http_context.enabled = false
+        def http_context
+          Timber::Integrations::Rack::HTTPContext
+        end
+
+        # Convenience method for accessing the {Timber::Integrations::Rack::HTTPEvents}
+        # middleware class specific configuration. See {Timber::Integrations::Rack::HTTPEvents}
+        # for a list of methods available.
+        #
+        # @example
+        #   config = Timber::Config.instance
+        #   config.integrations.rack.http_events.enabled = false
+        def http_events
+          Timber::Integrations::Rack::HTTPEvents
+        end
+
+        # Convenience method for accessing the {Timber::Integrations::Rack::SessionContext}
+        # middleware class specific configuration. See {Timber::Integrations::Rack::SessionContext}
+        # for a list of methods available.
+        #
+        # @example
+        #   config = Timber::Config.instance
+        #   config.integrations.rack.session_context.enabled = false
+        def session_context
+          Timber::Integrations::Rack::SessionContext
+        end
+
+        # Convenience method for accessing the {Timber::Integrations::Rack::UserContext}
+        # middleware class specific configuration. See {Timber::Integrations::Rack::UserContext}
+        # for a list of methods available.
+        #
+        # @example
+        #   config = Timber::Config.instance
+        #   config.integrations.rack.user_context.enabled = false
+        def user_context
+          Timber::Integrations::Rack::UserContext
+        end
+      end
+    end
+  end
+end

data/lib/timber-rack/error_event.rb

@@ -0,0 +1,28 @@
+require "timber/config"
+require "timber/events/error"
+require "timber-rack/middleware"
+
+module Timber
+  module Integrations
+    module Rack
+      # A Rack middleware that is reponsible for capturing exception and error events
+      class ErrorEvent < Middleware
+        def call(env)
+          begin
+            status, headers, body = @app.call(env)
+          rescue Exception => exception
+            Config.instance.logger.fatal do
+              Events::Error.new(
+                name: exception.class.name,
+                error_message: exception.message,
+                backtrace: exception.backtrace
+              )
+            end
+
+            raise exception
+          end
+        end
+      end
+    end
+  end
+end

data/lib/timber-rack/http_context.rb

@@ -0,0 +1,27 @@
+require "timber/contexts/http"
+require "timber/current_context"
+require "timber-rack/middleware"
+require "timber-rack/util/request"
+
+module Timber
+  module Integrations
+    module Rack
+      # A Rack middleware that is reponsible for adding the HTTP context {Timber::Contexts::HTTP}.
+      class HTTPContext < Middleware
+        def call(env)
+          request = Util::Request.new(env)
+          context = Contexts::HTTP.new(
+            host: request.host,
+            method: request.request_method,
+            path: request.path,
+            remote_addr: request.ip,
+            request_id: request.request_id
+          )
+          CurrentContext.with(context) do
+            @app.call(env)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/timber-rack/http_events.rb

@@ -0,0 +1,278 @@
+require "set"
+
+require "timber/config"
+require "timber/contexts/http"
+require "timber/current_context"
+require "timber-rack/http_request"
+require "timber-rack/http_response"
+require "timber-rack/middleware"
+
+module Timber
+  module Integrations
+    module Rack
+      # A Rack middleware that is reponsible for capturing and logging HTTP server requests and
+      # response events. The {Events::HTTPRequest} and {Events::HTTPResponse} events
+      # respectively.
+      class HTTPEvents < Middleware
+        class << self
+          # Allows you to capture the HTTP request body, default is off (false).
+          #
+          # Capturing HTTP bodies can be extremely helpful when debugging issues,
+          # but please proceed with caution:
+          #
+          # 1. Capturing HTTP bodies can use quite a bit of data (this can be mitigated, see below)
+          #
+          # If you opt to capture bodies, you can also truncate the size to reduce the data
+          # captured. See {Events::HTTPRequest}.
+          #
+          # @example
+          #   Timber::Integrations::Rack::HTTPEvents.capture_request_body = true
+          def capture_request_body=(value)
+            @capture_request_body = value
+          end
+
+          # Accessor method for {#capture_request_body=}
+          def capture_request_body?
+            @capture_request_body == true
+          end
+
+          # Just like {#capture_request_body=} but for the {Events::HTTPResponse} event.
+          # Please see {#capture_request_body=} for more details. The documentation there also
+          # applies here.
+          def capture_response_body=(value)
+            @capture_response_body = value
+          end
+
+          # Accessor method for {#capture_response_body=}
+          def capture_response_body?
+            @capture_response_body == true
+          end
+
+          # Collapse both the HTTP request and response events into a single log line event.
+          # While we don't recommend this, it can help to reduce log volume if desired.
+          # The reason we don't recommend this, is because the logging service you use should
+          # not be so expensive that you need to strip out useful logs. It should also provide
+          # the tools necessary to properly search your logs and reduce noise. Such as viewing
+          # logs for a specific request.
+          #
+          # To provide an example. This setting turns this:
+          #
+          #   Started GET "/" for 127.0.0.1 at 2012-03-10 14:28:14 +0100
+          #   Completed 200 OK in 79ms (Views: 78.8ms | ActiveRecord: 0.0ms)
+          #
+          # Into this:
+          #
+          #   Get "/" sent 200 OK in 79ms
+          #
+          # The single event is still a {Timber::Events::HTTPResponse} event. Because
+          # we capture HTTP context, you still get the HTTP details, but you will not get
+          # all of the request details that the {Timber::Events::HTTPRequest} event would
+          # provide.
+          #
+          # @example
+          #   Timber::Integrations::Rack::HTTPEvents.collapse_into_single_event = true
+          def collapse_into_single_event=(value)
+            @collapse_into_single_event = value
+          end
+
+          # Accessor method for {#collapse_into_single_event=}.
+          def collapse_into_single_event?
+            @collapse_into_single_event == true
+          end
+
+          # This setting allows you to silence requests based on any conditions you desire.
+          # We require a block because it gives you complete control over how you want to
+          # silence requests. The first parameter being the traditional Rack env hash, the
+          # second being a [Rack Request](http://www.rubydoc.info/gems/rack/Rack/Request) object.
+          #
+          # @example
+          #   Integrations::Rack::HTTPEvents.silence_request = lambda do |rack_env, rack_request|
+          #     rack_request.path == "/_health"
+          #   end
+          def silence_request=(proc)
+            if proc && !proc.is_a?(Proc)
+              raise ArgumentError.new("The value passed to #silence_request must be a Proc")
+            end
+
+            @silence_request = proc
+          end
+
+          # Accessor method for {#silence_request=}
+          def silence_request
+            @silence_request
+          end
+
+          def http_body_limit=(value)
+            @http_body_limit = value
+          end
+
+          # Accessor method for {#http_body_limit=}
+          def http_body_limit
+            @http_body_limit
+          end
+
+          def http_header_filters=(value)
+            @http_header_filters = value
+          end
+
+          # Accessor method for {#http_header_filters=}
+          def http_header_filters
+            @http_header_filters
+          end
+        end
+
+        CONTENT_LENGTH_KEY = 'Content-Length'.freeze
+
+        def call(env)
+          request = Util::Request.new(env)
+
+          if silenced?(env, request)
+            if Config.instance.logger.respond_to?(:silence)
+              Config.instance.logger.silence do
+                @app.call(env)
+              end
+            else
+              @app.call(env)
+            end
+
+          elsif collapse_into_single_event?
+            start = Time.now
+
+            status, headers, body = @app.call(env)
+
+            Config.instance.logger.info do
+              http_context_key = Contexts::HTTP.keyspace
+              http_context = CurrentContext.fetch(http_context_key)
+              content_length = headers[CONTENT_LENGTH_KEY]
+              duration_ms = (Time.now - start) * 1000.0
+
+              http_response = HTTPResponse.new(
+                content_length: content_length,
+                headers: headers,
+                http_context: http_context,
+                request_id: request.request_id,
+                status: status,
+                duration_ms: duration_ms,
+                body_limit: self.class.http_body_limit,
+                headers_to_sanitize: self.class.http_header_filters,
+              )
+
+              {
+                message: http_response.message,
+                event: {
+                  http_response_sent: {
+                    body: http_response.body,
+                    content_length: http_response.content_length,
+                    headers_json: http_response.headers_json,
+                    request_id: http_response.request_id,
+                    service_name: http_response.service_name,
+                    status: http_response.status,
+                    duration_ms: http_response.duration_ms,
+                  }
+                }
+              }
+            end
+
+            [status, headers, body]
+          else
+            start = Time.now
+
+            Config.instance.logger.info do
+              event_body = capture_request_body? ? request.body_content : nil
+              http_request = HTTPRequest.new(
+                body: event_body,
+                content_length: request.content_length,
+                headers: request.headers,
+                host: request.host,
+                method: request.request_method,
+                path: request.path,
+                port: request.port,
+                query_string: request.query_string,
+                request_id: request.request_id,
+                scheme: request.scheme,
+                body_limit: self.class.http_body_limit,
+                headers_to_sanitize: self.class.http_header_filters,
+              )
+
+              {
+                message: http_request.message,
+                event: {
+                  http_request_received: {
+                    body: http_request.body,
+                    content_length: http_request.content_length,
+                    headers_json: http_request.headers_json,
+                    host: http_request.host,
+                    method: http_request.method,
+                    path: http_request.path,
+                    port: http_request.port,
+                    query_string: http_request.query_string,
+                    request_id: http_request.request_id,
+                    scheme: http_request.scheme,
+                    service_name: http_request.service_name,
+                  }
+                }
+              }
+            end
+
+            status, headers, body = @app.call(env)
+
+            Config.instance.logger.info do
+              event_body = capture_response_body? ? body : nil
+              content_length = headers[CONTENT_LENGTH_KEY]
+              duration_ms = (Time.now - start) * 1000.0
+
+              http_response = HTTPResponse.new(
+                body: event_body,
+                content_length: content_length,
+                headers: headers,
+                request_id: request.request_id,
+                status: status,
+                duration_ms: duration_ms,
+                body_limit: self.class.http_body_limit,
+                headers_to_sanitize: self.class.http_header_filters,
+              )
+
+              {
+                message: http_response.message,
+                event: {
+                  http_response_sent: {
+                    body: http_response.body,
+                    content_length: http_response.content_length,
+                    headers_json: http_response.headers_json,
+                    request_id: http_response.request_id,
+                    service_name: http_response.service_name,
+                    status: http_response.status,
+                    duration_ms: http_response.duration_ms,
+                  }
+                }
+              }
+            end
+
+            [status, headers, body]
+          end
+        end
+
+        private
+          def capture_request_body?
+            self.class.capture_request_body?
+          end
+
+          def capture_response_body?
+            self.class.capture_response_body?
+          end
+
+          def collapse_into_single_event?
+            self.class.collapse_into_single_event?
+          end
+
+          def silenced?(env, request)
+            if !self.class.silence_request.nil?
+              self.class.silence_request.call(env, request)
+            else
+              false
+            end
+          end
+      end
+    end
+  end
+end

data/lib/timber-rack/http_request.rb

@@ -0,0 +1,51 @@
+require "timber/util"
+
+module Timber
+  module Integrations
+    module Rack
+      # The HTTP server request event tracks incoming HTTP requests to your HTTP server.
+      # Such as unicorn, webrick, puma, etc.
+      #
+      # @note This event should be installed automatically through integrations,
+      #   such as the {Integrations::ActionController::LogSubscriber} integration.
+      class HTTPRequest
+        BODY_MAX_BYTES = 8192.freeze
+        HEADERS_JSON_MAX_BYTES = 8192.freeze
+        HEADERS_TO_SANITIZE = ['authorization', 'x-amz-security-token'].freeze
+        HOST_MAX_BYTES = 256.freeze
+        METHOD_MAX_BYTES = 20.freeze
+        PATH_MAX_BYTES = 2048.freeze
+        QUERY_STRING_MAX_BYTES = 2048.freeze
+        REQUEST_ID_MAX_BYTES = 256.freeze
+        SCHEME_MAX_BYTES = 20.freeze
+        SERVICE_NAME_MAX_BYTES = 256.freeze
+
+        attr_reader :body, :content_length, :headers, :headers_json, :host, :method, :path, :port,
+          :query_string, :request_id, :scheme, :service_name
+
+        def initialize(attributes)
+          normalizer = Util::AttributeNormalizer.new(attributes)
+          body_limit = attributes.delete(:body_limit) || BODY_MAX_BYTES
+          headers_to_sanitize = HEADERS_TO_SANITIZE + (attributes.delete(:headers_to_sanitize) || [])
+
+          @body = normalizer.fetch(:body, :string, :limit => body_limit)
+          @content_length = normalizer.fetch(:content_length, :integer)
+          @headers= normalizer.fetch(:headers, :hash, :sanitize => headers_to_sanitize)
+          @headers_json = @headers.to_json.byteslice(0, HEADERS_JSON_MAX_BYTES)
+          @host = normalizer.fetch(:host, :string, :limit => HOST_MAX_BYTES)
+          @method = normalizer.fetch!(:method, :string, :upcase => true, :limit => METHOD_MAX_BYTES)
+          @path = normalizer.fetch(:path, :string, :limit => PATH_MAX_BYTES)
+          @port = normalizer.fetch(:port, :integer)
+          @query_string = normalizer.fetch(:query_string, :string, :limit => QUERY_STRING_MAX_BYTES)
+          @scheme = normalizer.fetch(:scheme, :string, :limit => SCHEME_MAX_BYTES)
+          @request_id = normalizer.fetch(:request_id, :string, :limit => REQUEST_ID_MAX_BYTES)
+          @service_name = normalizer.fetch(:service_name, :string, :limit => SERVICE_NAME_MAX_BYTES)
+        end
+
+        def message
+          'Started %s "%s"' % [method, path]
+        end
+      end
+    end
+  end
+end

data/lib/timber-rack/http_response.rb

@@ -0,0 +1,63 @@
+require "timber/util"
+
+module Timber
+  module Integrations
+    module Rack
+      # The HTTP server response event tracks outgoing HTTP responses that you send
+      # to clients.
+
+      class HTTPResponse
+        BODY_MAX_BYTES = 8192.freeze
+        HEADERS_JSON_MAX_BYTES = 256.freeze
+        HEADERS_TO_SANITIZE = ['authorization', 'x-amz-security-token'].freeze
+        REQUEST_ID_MAX_BYTES = 256.freeze
+        SERVICE_NAME_MAX_BYTES = 256.freeze
+
+        attr_reader :body, :content_length, :headers, :headers_json, :http_context, :request_id, :service_name,
+          :status, :duration_ms
+
+        def initialize(attributes)
+          normalizer = Util::AttributeNormalizer.new(attributes)
+          body_limit = attributes.delete(:body_limit) || BODY_MAX_BYTES
+          headers_to_sanitize = HEADERS_TO_SANITIZE + (attributes.delete(:headers_to_sanitize) || [])
+
+          @body = normalizer.fetch(:body, :string, :limit => body_limit)
+          @content_length = normalizer.fetch(:content_length, :integer)
+          @headers = normalizer.fetch(:headers, :hash, :sanitize => headers_to_sanitize)
+          @headers_json = @headers.to_json.byteslice(0, HEADERS_JSON_MAX_BYTES)
+          @http_context = attributes[:http_context]
+          @request_id = normalizer.fetch(:request_id, :string, :limit => REQUEST_ID_MAX_BYTES)
+          @service_name = normalizer.fetch(:service_name, :string, :limit => SERVICE_NAME_MAX_BYTES)
+          @status = normalizer.fetch!(:status, :integer)
+          @duration_ms = normalizer.fetch!(:duration_ms, :float, :precision => 6)
+        end
+
+        # Returns the human readable log message for this event.
+        def message
+          if http_context
+            message = "#{http_context[:method]} #{http_context[:path]} completed with " \
+              "#{status} #{status_description} "
+
+            if content_length
+              message << ", #{content_length} bytes, "
+            end
+
+            message << "in #{duration_ms}ms"
+          else
+            message = "Completed #{status} #{status_description} "
+
+            if content_length
+              message << ", #{content_length} bytes, "
+            end
+
+            message << "in #{duration_ms}ms"
+          end
+        end
+
+        def status_description
+          ::Rack::Utils::HTTP_STATUS_CODES[status]
+        end
+      end
+    end
+  end
+end

data/lib/timber-rack/middleware.rb

@@ -0,0 +1,28 @@
+module Timber
+  module Integrations
+    module Rack
+      # Base class that all Timber Rack middlewares extend. See the class level methods for
+      # configuration options.
+      class Middleware
+        class << self
+          # Easily enable / disable specific middlewares.
+          #
+          # @example
+          #   Timber::Integrations::Rack::UserContext.enabled = false
+          def enabled=(value)
+            @enabled = value
+          end
+
+          # Accessor method for {#enabled=}.
+          def enabled?
+            @enabled != false
+          end
+        end
+
+        def initialize(app)
+          @app = app
+        end
+      end
+    end
+  end
+end

data/lib/timber-rack/session_context.rb

@@ -0,0 +1,47 @@
+require "timber/config"
+require "timber/contexts/session"
+require "timber-rack/middleware"
+
+module Timber
+  module Integrations
+    module Rack
+      # A Rack middleware that is responsible for adding the Session context
+      # {Timber::Contexts::Session}.
+      class SessionContext < Middleware
+        def call(env)
+          id = get_session_id(env)
+          if id
+            context = Contexts::Session.new(id: id)
+            CurrentContext.with(context) do
+              @app.call(env)
+            end
+          else
+            @app.call(env)
+          end
+        end
+
+        private
+          def get_session_id(env)
+            if session = env['rack.session']
+              if session.respond_to?(:id)
+                Timber::Config.instance.debug { "Rack env session detected, using id attribute" }
+                session.id
+              elsif session.respond_to?(:[])
+                Timber::Config.instance.debug { "Rack env session detected, using the session_id key" }
+                session["session_id"]
+              else
+                Timber::Config.instance.debug { "Rack env session detected but could not extract id" }
+                nil
+              end
+            else
+              Timber::Config.instance.debug { "No session data could be detected, skipping" }
+
+              nil
+            end
+          rescue Exception => e
+            nil
+          end
+      end
+    end
+  end
+end

data/lib/timber-rack/user_context.rb

@@ -0,0 +1,135 @@
+require "timber/config"
+require "timber/contexts/user"
+require "timber-rack/middleware"
+
+module Timber
+  module Integrations
+    module Rack
+      # This is a Rack middleware responsible for setting the user context.
+      # See {Timber::Contexts::User} for more information on the user context.
+      #
+      # ## Why a Rack middleware?
+      #
+      # We use a Rack middleware because we want to set the user context as early as
+      # possible, and before the initial incoming request log line:
+      #
+      #   Started GET /welcome
+      #
+      # The above log line is logged in a request middleware, before it reaches
+      # the controller.
+      #
+      # If, for example, we set the user context in a controller, the log line above
+      # will not have the user context attached. This is because it is logged before
+      # the controller is executed. This is not ideal, and it's why we take a middleware
+      # approach here. If for some reason you cannot identify the user at the middleware
+      # level then setting it in the controller is perfectly fine, just be aware of the
+      # above downside.
+      #
+      # ## Authentication frameworks automatically detected:
+      #
+      # If you use any of the following authentication frameworks, Timber will
+      # automatically set the user context for you.
+      #
+      # * Devise, or any Warden based authentication strategy
+      # * Clearance
+      #
+      # Or, you can use your own custom authentication, see the {.custom_user_context}
+      # class method for more details.
+      #
+      # @note This middleware is automatically inserted for frameworks we support.
+      #   Such as Rails. See {Timber::Frameworks} for a comprehensive list.
+      class UserContext < Middleware
+        class << self
+          # The custom user context allows you to hook in and set your own custom
+          # user context. This is used in situations where either:
+          #
+          # 1. Timber does not automatically support your authentication strategy (see module level docs)
+          # 2. You need to customize your authentication beyond Timber's defaults.
+          #
+          # @example Setting your own custom user context
+          #   Timber::Integrations::Rack::UserContext.custom_user_hash = lambda do |rack_env|
+          #     rack_env['my_custom_key'].user
+          #   end
+          def custom_user_hash=(proc)
+            if proc && !proc.is_a?(Proc)
+              raise ArgumentError.new("The value passed to #custom_user_hash must be a Proc")
+            end
+
+            @custom_user_hash = proc
+          end
+
+          # Accessor method for {#custom_user_hash=}.
+          def custom_user_hash
+            @custom_user_hash
+          end
+        end
+
+        def call(env)
+          user_hash = get_user_hash(env)
+          if user_hash
+            context = Contexts::User.new(user_hash)
+            CurrentContext.with(context) do
+              @app.call(env)
+            end
+          else
+            @app.call(env)
+          end
+        end
+
+        private
+          def get_user_hash(env)
+            # The order is relevant here. The 'warden' key can be set, but
+            # not return a user, in which case the user data might be in another key.
+            if self.class.custom_user_hash.is_a?(Proc)
+              Timber::Config.instance.debug { "Obtaining user context from the custom user hash" }
+              self.class.custom_user_hash.call(env)
+            elsif env[:clearance] && env[:clearance].signed_in?
+              Timber::Config.instance.debug { "Obtaining user context from the clearance user" }
+              user = env[:clearance].current_user
+              get_user_object_hash(user)
+            elsif env['warden'] && (user = env['warden'].user)
+              Timber::Config.instance.debug { "Obtaining user context from the warden user" }
+              get_user_object_hash(user)
+            else
+              Timber::Config.instance.debug { "Could not locate any user data" }
+              nil
+            end
+          end
+
+          def get_user_object_hash(user)
+            id = try_user_id(user)
+            name = try_user_name(user)
+            email = try_user_email(user)
+
+            if id || name || email
+              {id: id, name: name, email: email}
+            else
+              nil
+            end
+          end
+
+          def try_user_id(user)
+            user.respond_to?(:id) ? user.id : nil
+          end
+
+          def try_user_name(user)
+            if user.respond_to?(:name) && user.name.is_a?(String)
+              user.name
+            elsif user.respond_to?(:first_name) && user.first_name.is_a?(String) && user.respond_to?(:last_name) && user.last_name.is_a?(String)
+              "#{user.first_name} #{user.last_name}"
+            else
+              nil
+            end
+          end
+
+          def try_user_email(user)
+            if user.respond_to?(:email) && user.email.is_a?(String)
+              user.email
+            else
+              nil
+            end
+          end
+      end
+    end
+  end
+end

data/lib/timber-rack/util/request.rb

@@ -0,0 +1,65 @@
+module Timber
+  module Util
+    # @private
+    class Request < ::Rack::Request
+      # We store strings as constants since they are reused on a per request basis.
+      # This avoids string allocations.
+      HTTP_HEADER_ORIGINAL_DELIMITER = '_'.freeze
+      HTTP_HEADER_NEW_DELIMITER = '_'.freeze
+      HTTP_PREFIX = 'HTTP_'.freeze
+
+      REMOTE_IP_KEY_NAME = 'action_dispatch.remote_ip'.freeze
+      REQUEST_ID_KEY_NAME1 = 'action_dispatch.request_id'.freeze
+      REQUEST_ID_KEY_NAME2 = 'X-Request-ID'.freeze
+      REQUEST_ID_KEY_NAME3 = 'X-Request-Id'.freeze
+
+      def body_content
+        content = body.read
+        body.rewind
+        content
+      end
+
+      # Returns a list of request headers. The rack env contains a lot of data, this function
+      # identifies those that were the actual request headers.
+      #
+      # This was extracted from: https://github.com/ruby-grape/grape/blob/91c6c78ae3d3f3ffabaf57ffc4dc35ab7cfc7b5f/lib/grape/request.rb#L30
+      def headers
+        @headers ||= begin
+          headers = {}
+
+          @env.each_pair do |k, v|
+            next unless k.is_a?(String) && k.to_s.start_with?(HTTP_PREFIX)
+
+            k = k[5..-1].
+              split(HTTP_HEADER_ORIGINAL_DELIMITER).
+              each(&:capitalize!).
+              join(HTTP_HEADER_NEW_DELIMITER)
+
+            headers[k] = v
+          end
+
+          headers
+        end
+      end
+
+      def ip
+        @ip ||= if @env[REMOTE_IP_KEY_NAME]
+          @env[REMOTE_IP_KEY_NAME].to_s || super
+        else
+          super
+        end
+      end
+
+      def referer
+        # Rails 3.X returns "/" for some reason
+        @referer ||= super == "/" ? nil : super
+      end
+
+      def request_id
+        @request_id ||= @env[REQUEST_ID_KEY_NAME1] ||
+          @env[REQUEST_ID_KEY_NAME2] ||
+          @env[REQUEST_ID_KEY_NAME3]
+      end
+    end
+  end
+end

data/lib/timber-rack/version.rb

@@ -0,0 +1,7 @@
+module Timber
+  module Integrations
+    module Rack
+      VERSION = "1.0.0"
+    end
+  end
+end

data/timber-rack.gemspec

@@ -0,0 +1,42 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "timber-rack/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "timber-rack"
+  spec.version       = Timber::Integrations::Rack::VERSION
+  spec.authors       = ["Timber Technologies, Inc."]
+  spec.email         = ["hi@timber.io"]
+
+  spec.summary       = %q{Timber for Ruby is a drop in replacement for your Ruby logger that unobtrusively augments your logs with rich metadata and context making them easier to search, use, and read.}
+  spec.homepage      = "https://docs.timber.io/languages/ruby/"
+  spec.license       = "ISC"
+
+  spec.required_ruby_version     = '>= 1.9.0'
+
+  if spec.respond_to?(:metadata)
+    spec.metadata["homepage_uri"] = spec.homepage
+    spec.metadata["source_code_uri"] = "https://github.com/timberio/timber-ruby-rack"
+    spec.metadata["changelog_uri"] = "https://github.com/timberio/timber-ruby-rack/blob/master/README.md"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # spec.add_dependency "timber", "3.0.0.alpha.0"
+  spec.add_runtime_dependency "rack", ">= 1.2", "< 3.0"
+
+  spec.add_development_dependency "bundler", ">= 0.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: timber-rack
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Timber Technologies, Inc.
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-03-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !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.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: 
+email:
+- hi@timber.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.md
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/timber-rack.rb
+- lib/timber-rack/config.rb
+- lib/timber-rack/error_event.rb
+- lib/timber-rack/http_context.rb
+- lib/timber-rack/http_events.rb
+- lib/timber-rack/http_request.rb
+- lib/timber-rack/http_response.rb
+- lib/timber-rack/middleware.rb
+- lib/timber-rack/session_context.rb
+- lib/timber-rack/user_context.rb
+- lib/timber-rack/util/request.rb
+- lib/timber-rack/version.rb
+- timber-rack.gemspec
+homepage: https://docs.timber.io/languages/ruby/
+licenses:
+- ISC
+metadata:
+  homepage_uri: https://docs.timber.io/languages/ruby/
+  source_code_uri: https://github.com/timberio/timber-ruby-rack
+  changelog_uri: https://github.com/timberio/timber-ruby-rack/blob/master/README.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Timber for Ruby is a drop in replacement for your Ruby logger that unobtrusively
+  augments your logs with rich metadata and context making them easier to search,
+  use, and read.
+test_files: []