logtail-rack 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cc7cc7670a2f510b98d303a3a8a9d508f12845b3f4aa122a3ba85b74811a2612
+  data.tar.gz: 192cff59004342160a95c620d3c454a99466e7414229fd6530c09a7a588634ad
+SHA512:
+  metadata.gz: 352c298d34087b2465ee410376a2e1f7620617a2a739e92536675f2ad1228019c6964022cb5403935d344130c97080c5f5d705b813dd1abfbdfc07d2ce151526
+  data.tar.gz: 3d31454c761c8b61b54f3bf9f3d0147d886e95361532d03e92ae218b1e06a475916eefd54dc1a1256b10149b9a2d33571f7cffbc4168c562e42f4805c52385d6

data/.github/workflows/main.yml

@@ -0,0 +1,33 @@
+name: build
+
+on: [push, pull_request]
+
+jobs:
+  test:
+
+    runs-on: ubuntu-20.04
+
+    strategy:
+      matrix:
+        ruby-version:
+          - 3.0.0
+          - 2.7.2
+          - 2.6.6
+          - 2.5.8
+          - 2.4.10
+          - 2.3.8
+          - 2.2.10
+          - jruby-9.2.14.0
+          - truffleruby-21.0.0
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Set up Ruby ${{ matrix.ruby-version }}
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby-version }}
+          bundler-cache: true
+
+      - name: Run tests
+        run: bundle exec rspec --format documentation

data/.gitignore

@@ -0,0 +1,21 @@
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+.DS_Store
+.rvmrc
+.ruby-version
+coverage
+Gemfile.lock
+*.swp
+*.gem
+
+/.bundle
+/.yardoc
+/doc
+/log
+/tmp
+/pkg

data/.rspec

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

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/LICENSE.md

@@ -0,0 +1,16 @@
+# License
+
+Copyright (c) 2021, Logtail
+
+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,9 @@
+# 🪵 Logtail Integration For Rack
+
+[![ISC License](https://img.shields.io/badge/license-ISC-ff69b4.svg)](LICENSE.md)
+[![Build Status](https://github.com/logtail/logtail-ruby-rack/workflows/build/badge.svg)](https://github.com/logtail/logtail-ruby-rack/actions?query=workflow%3Abuild)
+
+This library integrates the [`logtail` Ruby library](https://github.com/logtail/logtail-ruby) with the [rack](https://github.com/rack/rack) framework,
+turning your Rack logs into rich structured events.
+
+* **Sign-up: [https://logtail.com](https://logtail.com)**

data/Rakefile

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

data/lib/logtail-rack.rb

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

data/lib/logtail-rack/config.rb

@@ -0,0 +1,85 @@
+require "logtail"
+
+Logtail::Config.instance.define_singleton_method(:logrageify!) do
+  integrations.rack.http_events.collapse_into_single_event = true
+end
+
+module Logtail
+  class Config
+    module Integrations
+      extend self
+      # Convenience module for accessing the various `Logtail::Integrations::Rack::*` classes
+      # through the {Logtail::Config} object. Logtail 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 Logtail classes.
+      #
+      # For example:
+      #
+      #     config = Logtail::Config.instance
+      #     config.integrations.rack.http_events.enabled = false
+      def rack
+        Rack
+      end
+
+      module Rack
+        extend self
+
+        # Convenience method for accessing the {Logtail::Integrations::Rack::ErrorEvent}
+        # middleware class specific configuration. See {Logtail::Integrations::Rack::ExceptionEvent}
+        # for a list of methods available.
+        #
+        # @example
+        #   config = Logtail::Config.instance
+        #   config.integrations.rack.error_event.enabled = false
+        def error_event
+          Logtail::Integrations::Rack::ErrorEvent
+        end
+
+        # Convenience method for accessing the {Logtail::Integrations::Rack::HTTPContext}
+        # middleware class specific configuration. See {Logtail::Integrations::Rack::HTTPContext}
+        # for a list of methods available.
+        #
+        # @example
+        #   config = Logtail::Config.instance
+        #   config.integrations.rack.http_context.enabled = false
+        def http_context
+          Logtail::Integrations::Rack::HTTPContext
+        end
+
+        # Convenience method for accessing the {Logtail::Integrations::Rack::HTTPEvents}
+        # middleware class specific configuration. See {Logtail::Integrations::Rack::HTTPEvents}
+        # for a list of methods available.
+        #
+        # @example
+        #   config = Logtail::Config.instance
+        #   config.integrations.rack.http_events.enabled = false
+        def http_events
+          Logtail::Integrations::Rack::HTTPEvents
+        end
+
+        # Convenience method for accessing the {Logtail::Integrations::Rack::SessionContext}
+        # middleware class specific configuration. See {Logtail::Integrations::Rack::SessionContext}
+        # for a list of methods available.
+        #
+        # @example
+        #   config = Logtail::Config.instance
+        #   config.integrations.rack.session_context.enabled = false
+        def session_context
+          Logtail::Integrations::Rack::SessionContext
+        end
+
+        # Convenience method for accessing the {Logtail::Integrations::Rack::UserContext}
+        # middleware class specific configuration. See {Logtail::Integrations::Rack::UserContext}
+        # for a list of methods available.
+        #
+        # @example
+        #   config = Logtail::Config.instance
+        #   config.integrations.rack.user_context.enabled = false
+        def user_context
+          Logtail::Integrations::Rack::UserContext
+        end
+      end
+    end
+  end
+end

data/lib/logtail-rack/error_event.rb

@@ -0,0 +1,28 @@
+require "logtail/config"
+require "logtail/events/error"
+require "logtail-rack/middleware"
+
+module Logtail
+  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/logtail-rack/http_context.rb

@@ -0,0 +1,27 @@
+require "logtail/contexts/http"
+require "logtail/current_context"
+require "logtail-rack/middleware"
+require "logtail-rack/util/request"
+
+module Logtail
+  module Integrations
+    module Rack
+      # A Rack middleware that is reponsible for adding the HTTP context {Logtail::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.add(context.to_hash)
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/logtail-rack/http_events.rb

@@ -0,0 +1,277 @@
+require "set"
+
+require "logtail/config"
+require "logtail/contexts/http"
+require "logtail/current_context"
+require "logtail-rack/http_request"
+require "logtail-rack/http_response"
+require "logtail-rack/middleware"
+
+module Logtail
+  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
+          #   Logtail::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 {Logtail::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 {Logtail::Events::HTTPRequest} event would
+          # provide.
+          #
+          # @example
+          #   Logtail::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 = CurrentContext.fetch(:http)
+              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/logtail-rack/http_request.rb

@@ -0,0 +1,37 @@
+module Logtail
+  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
+        attr_reader :body, :content_length, :headers, :headers_json, :host, :method, :path, :port,
+          :query_string, :request_id, :scheme, :service_name
+
+        def initialize(attributes)
+          @body = attributes[:body]
+          @content_length = attributes[:content_length]
+          @headers = attributes[:headers]
+          @host = attributes[:host]
+          @method = attributes[:method]
+          @path = attributes[:path]
+          @port = attributes[:port]
+          @query_string = attributes[:query_string]
+          @scheme = attributes[:scheme]
+          @request_id = attributes[:request_id]
+          @service_name = attributes[:service_name]
+
+          if @headers
+            @headers_json = @headers.to_json
+          end
+        end
+
+        def message
+          'Started %s "%s"' % [method, path]
+        end
+      end
+    end
+  end
+end

data/lib/logtail-rack/http_response.rb

@@ -0,0 +1,54 @@
+module Logtail
+  module Integrations
+    module Rack
+      # The HTTP server response event tracks outgoing HTTP responses that you send
+      # to clients.
+
+      class HTTPResponse
+        attr_reader :body, :content_length, :headers, :headers_json, :http_context, :request_id, :service_name,
+          :status, :duration_ms
+
+        def initialize(attributes)
+          @body = attributes[:body]
+          @content_length  = attributes[:content_length]
+          @headers = attributes[:headers]
+          @http_context = attributes[:http_context]
+          @request_id = attributes[:request_id]
+          @service_name = attributes[:service_name]
+          @status = attributes[:status]
+          @duration_ms = attributes[:duration_ms]
+
+          if @headers
+            @headers_json = @headers.to_json
+          end
+        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/logtail-rack/middleware.rb

@@ -0,0 +1,28 @@
+module Logtail
+  module Integrations
+    module Rack
+      # Base class that all Logtail Rack middlewares extend. See the class level methods for
+      # configuration options.
+      class Middleware
+        class << self
+          # Easily enable / disable specific middlewares.
+          #
+          # @example
+          #   Logtail::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/logtail-rack/session_context.rb

@@ -0,0 +1,47 @@
+require "logtail/config"
+require "logtail/contexts/session"
+require "logtail-rack/middleware"
+
+module Logtail
+  module Integrations
+    module Rack
+      # A Rack middleware that is responsible for adding the Session context
+      # {Logtail::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)
+                Logtail::Config.instance.debug { "Rack env session detected, using id attribute" }
+                session.id
+              elsif session.respond_to?(:[])
+                Logtail::Config.instance.debug { "Rack env session detected, using the session_id key" }
+                session["session_id"]
+              else
+                Logtail::Config.instance.debug { "Rack env session detected but could not extract id" }
+                nil
+              end
+            else
+              Logtail::Config.instance.debug { "No session data could be detected, skipping" }
+
+              nil
+            end
+          rescue Exception => e
+            nil
+          end
+      end
+    end
+  end
+end

data/lib/logtail-rack/user_context.rb

@@ -0,0 +1,132 @@
+require "logtail/config"
+require "logtail/contexts/user"
+require "logtail-rack/middleware"
+
+module Logtail
+  module Integrations
+    module Rack
+      # This is a Rack middleware responsible for setting the user context.
+      # See {Logtail::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, Logtail 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 {Logtail::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. Logtail does not automatically support your authentication strategy (see module level docs)
+          # 2. You need to customize your authentication beyond Logtail's defaults.
+          #
+          # @example Setting your own custom user context
+          #   Logtail::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
+            CurrentContext.add({user: user_hash})
+          end
+
+          @app.call(env)
+        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)
+              Logtail::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?
+              Logtail::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)
+              Logtail::Config.instance.debug { "Obtaining user context from the warden user" }
+              get_user_object_hash(user)
+            else
+              Logtail::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/logtail-rack/util/request.rb

@@ -0,0 +1,63 @@
+module Logtail
+  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 = 'HTTP_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]
+      end
+    end
+  end
+end

data/lib/logtail-rack/version.rb

@@ -0,0 +1,7 @@
+module Logtail
+  module Integrations
+    module Rack
+      VERSION = "0.1.0"
+    end
+  end
+end

data/logtail-ruby-rack.gemspec

@@ -0,0 +1,36 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "logtail-rack/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "logtail-rack"
+  spec.version       = Logtail::Integrations::Rack::VERSION
+  spec.authors       = ["Logtail"]
+  spec.email         = ["hi@logtail.com"]
+
+  spec.summary       = %q{Logtail integration for Rack}
+  spec.homepage      = "https://github.com/logtail/logtail-ruby-rack"
+  spec.license       = "ISC"
+
+  spec.required_ruby_version     = '>= 2.2.10'
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/logtail/logtail-ruby-rack"
+  spec.metadata["changelog_uri"] = "https://github.com/logtail/logtail-ruby-rack/blob/master/README.md"
+
+  # 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 "logtail-ruby", "~> 0.1"
+  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,142 @@
+--- !ruby/object:Gem::Specification
+name: logtail-rack
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Logtail
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2021-02-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: logtail-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !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@logtail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/main.yml"
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.md
+- README.md
+- Rakefile
+- lib/logtail-rack.rb
+- lib/logtail-rack/config.rb
+- lib/logtail-rack/error_event.rb
+- lib/logtail-rack/http_context.rb
+- lib/logtail-rack/http_events.rb
+- lib/logtail-rack/http_request.rb
+- lib/logtail-rack/http_response.rb
+- lib/logtail-rack/middleware.rb
+- lib/logtail-rack/session_context.rb
+- lib/logtail-rack/user_context.rb
+- lib/logtail-rack/util/request.rb
+- lib/logtail-rack/version.rb
+- logtail-ruby-rack.gemspec
+homepage: https://github.com/logtail/logtail-ruby-rack
+licenses:
+- ISC
+metadata:
+  homepage_uri: https://github.com/logtail/logtail-ruby-rack
+  source_code_uri: https://github.com/logtail/logtail-ruby-rack
+  changelog_uri: https://github.com/logtail/logtail-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: 2.2.10
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.3
+signing_key:
+specification_version: 4
+summary: Logtail integration for Rack
+test_files: []