marlowe 1.0.3 → 3.0

data/lib/marlowe/config.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+# Configuration object for Marlowe.
+class Marlowe::Config
+  # The name of the default header to look for and put the correlation id in.
+  CORRELATION_HEADER = "X-Request-Id" # :nodoc:
+
+  class << self
+    # The global Marlowe configuration.
+    def global
+      @global ||= new
+    end
+
+    # Override the global Marlowe configuration.
+    def override(opts)
+      new(global, opts)
+    end
+
+    def configure(&block) # :nodoc:
+      @global = new(global, &block)
+    end
+
+    private
+
+    def clear_global!
+      @global = nil
+    end
+  end
+
+  # The name of the header to inspect. Defaults to 'X-Request-Id'.
+  attr_accessor :header
+  # The HTTP formatted version of the header name to inspect. Defaults to
+  # 'HTTP_X_REQUEST_ID'.
+  attr_reader :http_header
+  # The handler for request correlation IDs. Defaults to sanitizing provided
+  # request IDs or generating a UUID. If <tt>:simple</tt> is provided, provided
+  # request IDs will not be sanitized. A callable (expecting a single input of
+  # any possible existing request ID) may be provided to introduce more complex
+  # request ID handling.
+  attr_accessor :handler
+  # If +true+ (the default), the request correlation ID will be returned as
+  # part of the response headers. Only affects Marlowe::Middleware.
+  attr_accessor :return
+  # If +true+, Marlowe will add code to behave like
+  # <tt>ActionDispatch::RequestId</tt>. Depends on
+  # <tt>ActionDispatch::Request</tt>. Only affects Marlowe::Middleware.
+  attr_accessor :action_dispatch
+
+  # === Option Values
+  #
+  # <tt>:header</tt>:: The name of the header to inspect. Defaults to
+  #                    'X-Request-Id'. Also available as
+  #                    <tt>:correlation_header</tt>.
+  # <tt>:handler</tt>:: The handler for request correlation IDs. Defaults to
+  #                     sanitizing provided request IDs or generating a UUID.
+  #                     If <tt>:simple</tt> is provided, provided request IDs
+  #                     will not be sanitized. A callable (expecting a single
+  #                     input of any possible existing request ID) may be
+  #                     provided to introduce more complex request ID
+  #                     handling.
+  # <tt>:return</tt>:: If +true+ (the default), the request correlation ID
+  #                    will be returned as part of the response headers.
+  # <tt>:action_dispatch</tt>:: If +true+, Marlowe will add code to behave
+  #                             like <tt>ActionDispatch::RequestId</tt>.
+  #                             Depends on <tt>ActionDispatch::Request</tt>.
+  def initialize(base = nil, opts = nil) # :yields: self
+    opts =
+      if base.nil? && opts.nil?
+        {}
+      elsif base.nil? && opts.is_a?(Hash)
+        opts
+      elsif base.is_a?(Hash) && opts.nil?
+        base
+      elsif base.is_a?(self.class) && opts.nil?
+        base.to_hash
+      elsif (base.is_a?(Hash) || base.is_a?(self.class)) && opts.is_a?(Hash)
+        hash =
+          if base.is_a?(self.class)
+            base.to_hash
+          else
+            base
+          end
+        hash.update(opts)
+      end
+
+    @header, @http_header = format_header_name(
+      opts[:header] || opts[:correlation_header] || CORRELATION_HEADER
+    )
+
+    @handler = opts.fetch(:handler, :clean)
+    @return = opts.fetch(:return, true)
+    @action_dispatch = opts.fetch(:action_dispatch, false)
+
+    yield self if block_given?
+
+    freeze
+  end
+
+  def to_hash
+    {
+      header: header,
+      handler: handler,
+      return: self.return,
+      action_dispatch: action_dispatch
+    }
+  end
+
+  private
+
+  def format_header_name(header)
+    [
+      header.to_s.tr("_", "-").freeze,
+      "HTTP_#{header.to_s.tr("-", "_").upcase}"
+    ]
+  end
+end

data/lib/marlowe/faraday.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "marlowe"
+
+# Marlowe correlation ID middleware for Faraday. Including this into your
+# request middleware stack will use the captured correlation ID.
+class Marlowe::Faraday < Faraday::Middleware
+  def initialize(app, opts = {})
+    super(app)
+    @config = Marlowe::Config.override(opts)
+  end
+
+  def call(env)
+    env[:request_headers][@config.header] =
+      Marlowe.make_request_id(RequestStore[:correlation_id], @config)
+    @app.call(env)
+  end
+end
+
+Faraday::Request.register_middleware marlowe: -> { Marlowe::Faraday }

data/lib/marlowe/formatter.rb

@@ -1,13 +1,13 @@
-require 'request_store'
+# frozen_string_literal: true
 
-module Marlowe
+require "request_store"
 
+module Marlowe
   # Marlowe::Formatter is a subclass of +ActiveSupport::Logger::Formatter+
   # that adds a correlation id string to a rails log.
   class Formatter < ActiveSupport::Logger::Formatter
-
     # Overrides the formatter return to add the correlation id.
-    def call(severity, timestamp, progname, msg)
+    def call(_severity, _timestamp, _progname, _msg)
       "[#{RequestStore.store[:correlation_id]}] #{super}"
     end
   end

data/lib/marlowe/middleware.rb

@@ -1,36 +1,66 @@
-require 'rack'
-require 'request_store'
-require 'securerandom'
+# frozen_string_literal: true
 
-module Marlowe
-  # Marlowe correlation id middleware. Including this into your
-  # middleware stack will add a correlation id header as an incoming
-  # request, and save that id in a request session variable.
-
-  # Name of the default header to look for and put the correlation id in.
-  CORRELATION_HEADER = 'Correlation-Id'.freeze
+require "rack"
+require "request_store"
+require "securerandom"
 
+module Marlowe
+  # Marlowe correlation id middleware. Including this into your middleware
+  # stack will capture or add a correlation id header on an incoming request,
+  # and save that id in a request session variable.
   class Middleware
-    # Sets the the rack application to +app+
-    def initialize(app, opts={})
+    # The name of the default header to look for and put the correlation id in.
+    CORRELATION_HEADER = Marlowe::Config::CORRELATION_HEADER # :nodoc:
+
+    # Configure the Marlowe middleware to call +app+ with options +opts+.
+    #
+    # === Options
+    #
+    # <tt>:header</tt>:: The name of the header to inspect. Defaults to
+    #                    'X-Request-Id'. Also available as
+    #                    <tt>:correlation_header</tt>.
+    # <tt>:handler</tt>:: The handler for request correlation IDs. Defaults to
+    #                     sanitizing provided request IDs or generating a UUID.
+    #                     If <tt>:simple</tt> is provided, provided request IDs
+    #                     will not be sanitized. A callable (expecting a single
+    #                     input of any possible existing request ID) may be
+    #                     provided to introduce more complex request ID
+    #                     handling.
+    # <tt>:return</tt>:: If +true+ (the default), the request correlation ID
+    #                    will be returned as part of the response headers.
+    # <tt>:action_dispatch</tt>:: If +true+, Marlowe will add code to behave
+    #                             like <tt>ActionDispatch::RequestId</tt>.
+    #                             Depends on <tt>ActionDispatch::Request</tt>.
+    def initialize(app, opts = nil)
       @app = app
-      @correlation_header = format_http_header(opts[:correlation_header] || Marlowe::CORRELATION_HEADER)
+      @config = Marlowe::Config.override(opts)
     end
 
     # Stores the incoming correlation id from the +env+ hash. If the correlation
     # id has not been sent, a new UUID is generated and the +env+ is modified.
     def call(env)
-      env[@correlation_header] ||= SecureRandom.uuid
-      RequestStore.store[:correlation_id] = env[@correlation_header]
+      req_id = Marlowe.make_request_id(env[config.http_header], config)
+      RequestStore.store[:correlation_id] = env[config.http_header] = req_id
+
+      if config.action_dispatch
+        req = ActionDispatch::Request.new(env)
+        req.request_id = req_id
+      end
 
-      @status, @headers, @response = @app.call(env)
-      [@status, @headers, @response]
+      app.call(env).tap { |_status, headers, _body|
+        if config.return
+          headers[config.header] =
+            if config.action_dispatch
+              req.request_id
+            else
+              RequestStore.store[:correlation_id]
+            end
+        end
+      }
     end
 
     private
 
-    def format_http_header(header)
-      ("HTTP_" + header.gsub(/-/, '_').upcase).freeze
-    end
+    attr_reader :app, :config
   end
 end

data/lib/marlowe/rails.rb

@@ -1,11 +1,26 @@
+# frozen_string_literal: true
+
 module Marlowe
-  class Railtie < Rails::Railtie
-    initializer 'marlowe.configure_rails_initialization' do
-      app.middleware.insert_before Rails::Rack::Logger, Marlowe::Middleware, correlation_header: Rails.application.config.try(:marlowe_correlation_header)
+  class Railtie < Rails::Railtie # :nodoc:
+    initializer "marlowe.configure_rails_initialization" do
+      config = app.config
+
+      opts = {
+        header: config&.marlowe_header || config&.marlowe_correlation_header,
+        handler: config&.marlowe_request_id_handler,
+        return: config&.marlowe_return_request_id,
+        action_dispatch: config&.marlowe_replace_action_dispatch_request_id
+      }.compact
+
+      if opts[:action_dispatch]
+        app.middleware.insert_before ActionDispatch::RequestId, Marlowe::Middleware, opts
+        app.middleware.delete ActionDispatch::RequestId
+      else
+        app.middleware.insert_before Rails::Rack::Logger, Marlowe::Middleware, opts
+      end
     end
 
-    #:nodoc:
-    def app
+    def app # :nodoc:
       Rails.application
     end
   end

data/lib/marlowe/simple_formatter.rb

@@ -1,16 +1,15 @@
-require 'request_store'
+# frozen_string_literal: true
+
+require "request_store"
 
 module Marlowe
   # Marlowe::SimpleFormatter is a subclass of
   # +ActiveSupport::Logger::SimpleFormatter+ that adds a correlation id
   # string to a rails log.
   class SimpleFormatter < ActiveSupport::Logger::SimpleFormatter
-
     # Overrides the formatter return to add the correlation id.
     def call(severity, timestamp, progname, msg)
       "[#{RequestStore.store[:correlation_id]}] #{super}"
     end
   end
 end
-
-

data/lib/marlowe.rb

@@ -1,10 +1,45 @@
+# frozen_string_literal: true
+
 # Marlowe, a correlation id injector.
 module Marlowe
-  VERSION = '1.0.3' #:nodoc:
+  VERSION = "3.0" # :nodoc:
+
+  require "marlowe/config"
+  require "marlowe/middleware"
+  require "marlowe/rails" if defined? Rails::Railtie
+
+  autoload :Formatter, "marlowe/formatter"
+  autoload :SimpleFormatter, "marlowe/simple_formatter"
+
+  class << self
+    # Configure Marlowe
+    def configure(&block)
+      Marlowe::Config.configure(&block)
+    end
+
+    # Make a Marlowe request ID
+    def make_request_id(request_id, config = Marlowe::Config.global)
+      if config.handler == :simple
+        simple(request_id)
+      elsif config.handler.is_a?(Proc)
+        simple(config.handler.call(request_id))
+      else
+        clean(request_id)
+      end
+    end
+
+    private
 
-  require 'marlowe/middleware'
-  require 'marlowe/rails' if defined? Rails::Railtie
+    def clean(request_id)
+      simple(request_id).gsub(/[^\w\-]/, "")[0, 255]
+    end
 
-  autoload :Formatter, 'marlowe/formatter'
-  autoload :SimpleFormatter, 'marlowe/simple_formatter'
+    def simple(request_id)
+      if request_id && !request_id.empty? && request_id !~ /\A[[:space]]*\z/
+        request_id
+      else
+        SecureRandom.uuid
+      end
+    end
+  end
 end

data/test/minitest_config.rb

@@ -1,22 +1,11 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
-gem 'minitest'
+gem "minitest"
 
-require 'rack/test'
-require 'rack/mock'
-require 'minitest/autorun'
-require 'minitest/focus'
-require 'minitest/moar'
-require 'minitest/bisect'
+require "rack/test"
+require "rack/mock"
+require "minitest/autorun"
+require "minitest/focus"
+require "minitest/moar"
 
-require 'request_store'
-require 'marlowe'
-
-class RackApp
-  def call(env)
-  end
-
-  def coordination_id
-    RequestStore[:correlation_id]
-  end
-end
+require "marlowe"

data/test/test_marlowe.rb

@@ -1,32 +1,103 @@
-require 'minitest_config'
+# frozen_string_literal: true
+
+require "minitest_config"
 
 class TestMarlowe < Minitest::Test
+  include Rack::Test::Methods
+
+  attr_reader :marlowe_options
+
   def setup
-    @app = RackApp.new
-    @middleware = Marlowe::Middleware.new(@app)
+    @marlowe_options = {}
+    Marlowe::Config.send(:clear_global!)
+  end
+
+  def app
+    options = marlowe_options
+    Rack::Builder.new do
+      use Marlowe::Middleware, options
+
+      run lambda { |_env|
+        [
+          200,
+          {"Content-Type" => "text/plain"},
+          [RequestStore[:correlation_id]]
+        ]
+      }
+    end
+  end
+
+  def test_default_config_no_header_value
+    get "/"
+    assert last_response.header.key?("X-Request-Id")
+    refute_empty last_response.header["X-Request-Id"]
+    assert_equal last_response.header["X-Request-Id"], last_response.body
+  end
+
+  def test_default_config_with_header_value
+    get "/", {}, {"HTTP_X_REQUEST_ID" => "testvalue"}
+    assert last_response.header.key?("X-Request-Id")
+    refute_empty last_response.header["X-Request-Id"]
+    assert_equal last_response.header["X-Request-Id"], last_response.body
+    assert_equal "testvalue", last_response.header["X-Request-Id"]
+  end
+
+  def test_header_config_no_header_value
+    marlowe_options[:header] = "Correlation-Id"
+    get "/"
+    assert last_response.header.key?("Correlation-Id")
+    refute_empty last_response.header["Correlation-Id"]
+    assert_equal last_response.header["Correlation-Id"], last_response.body
+  end
+
+  def test_header_config_no_header_with_header_value
+    marlowe_options[:header] = "Correlation-Id"
+    get "/", {}, {"HTTP_CORRELATION_ID" => "testvalue"}
+    assert last_response.header.key?("Correlation-Id")
+    refute_empty last_response.header["Correlation-Id"]
+    assert_equal last_response.header["Correlation-Id"], last_response.body
+    assert_equal "testvalue", last_response.header["Correlation-Id"]
+  end
+
+  def test_handler_config_default_handler
+    get "/", {}, {"HTTP_X_REQUEST_ID" => "test+value"}
+    assert last_response.header.key?("X-Request-Id")
+    refute_empty last_response.header["X-Request-Id"]
+    assert_equal last_response.header["X-Request-Id"], last_response.body
+    assert_equal "testvalue", last_response.header["X-Request-Id"]
   end
 
-  def test_no_header
-    @middleware.call({})
-    refute_empty @app.coordination_id
+  def test_handler_config_with_simple_handler
+    marlowe_options[:handler] = :simple
+    get "/", {}, {"HTTP_X_REQUEST_ID" => "test+value"}
+    assert last_response.header.key?("X-Request-Id")
+    refute_empty last_response.header["X-Request-Id"]
+    assert_equal last_response.header["X-Request-Id"], last_response.body
+    assert_equal "test+value", last_response.header["X-Request-Id"]
   end
 
-  def test_with_header
-    @middleware.call({'HTTP_CORRELATION_ID' => 'testvalue'})
-    refute_empty @app.coordination_id
-    assert_equal 'testvalue', @app.coordination_id
+  def test_handler_config_with_proc_handler
+    marlowe_options[:handler] = ->(item) { item && item.reverse || SecureRandom.uuid }
+    get "/", {}, {"HTTP_X_REQUEST_ID" => "test+value"}
+    assert last_response.header.key?("X-Request-Id")
+    refute_empty last_response.header["X-Request-Id"]
+    assert_equal last_response.header["X-Request-Id"], last_response.body
+    assert_equal "eulav+tset", last_response.header["X-Request-Id"]
   end
 
-  def test_with_custom_no_header
-    @customized_middleware = Marlowe::Middleware.new(@app, correlation_header: "Custom-Header")
-    @customized_middleware.call({})
-    refute_empty @app.coordination_id
+  def test_handler_config_with_proc_handler_returning_nil
+    marlowe_options[:handler] = ->(_item) {}
+    get "/", {}, {"HTTP_X_REQUEST_ID" => "test+value"}
+    assert last_response.header.key?("X-Request-Id")
+    refute_empty last_response.header["X-Request-Id"]
+    assert_equal last_response.header["X-Request-Id"], last_response.body
+    assert_match(/\A[-\w]+\z/, last_response.header["X-Request-Id"])
   end
 
-  def test_with_custom_header
-    @customized_middleware = Marlowe::Middleware.new(@app, correlation_header: "Custom-Header")
-    @customized_middleware.call({'HTTP_CUSTOM_HEADER' => 'testvalue'})
-    refute_empty @app.coordination_id
-    assert_equal 'testvalue', @app.coordination_id
+  def test_return_config_false
+    marlowe_options[:return] = false
+    get "/"
+    refute last_response.header.key?("X-Request-Id")
+    assert_equal RequestStore[:correlation_id], last_response.body
   end
 end

data/test/test_marlowe_config.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "minitest_config"
+
+class TestMarloweConfig < Minitest::Test
+  include Rack::Test::Methods
+
+  attr_reader :marlowe_options
+
+  def setup
+    @marlowe_options = {}
+    Marlowe::Config.send(:clear_global!)
+  end
+
+  def app
+    Marlowe.configure do |config|
+      marlowe_options.each do |k, v|
+        config.send(:"#{k}=", v) if config.respond_to?(:"#{k}=")
+      end
+    end
+
+    options = marlowe_options
+    Rack::Builder.new do
+      use Marlowe::Middleware, options
+
+      run lambda { |_env|
+        [
+          200,
+          {"Content-Type" => "text/plain"},
+          [RequestStore[:correlation_id]]
+        ]
+      }
+    end
+  end
+
+  def test_default_config_no_header_value
+    get "/"
+    assert last_response.header.key?("X-Request-Id")
+    refute_empty last_response.header["X-Request-Id"]
+    assert_equal last_response.header["X-Request-Id"], last_response.body
+  end
+
+  def test_default_config_with_header_value
+    get "/", {}, {"HTTP_X_REQUEST_ID" => "testvalue"}
+    assert last_response.header.key?("X-Request-Id")
+    refute_empty last_response.header["X-Request-Id"]
+    assert_equal last_response.header["X-Request-Id"], last_response.body
+    assert_equal "testvalue", last_response.header["X-Request-Id"]
+  end
+
+  def test_header_config_no_header_value
+    marlowe_options[:header] = "Correlation-Id"
+    get "/"
+    assert last_response.header.key?("Correlation-Id")
+    refute_empty last_response.header["Correlation-Id"]
+    assert_equal last_response.header["Correlation-Id"], last_response.body
+  end
+
+  def test_header_config_no_header_with_header_value
+    marlowe_options[:header] = "Correlation-Id"
+    get "/", {}, {"HTTP_CORRELATION_ID" => "testvalue"}
+    assert last_response.header.key?("Correlation-Id")
+    refute_empty last_response.header["Correlation-Id"]
+    assert_equal last_response.header["Correlation-Id"], last_response.body
+    assert_equal "testvalue", last_response.header["Correlation-Id"]
+  end
+
+  def test_handler_config_default_handler
+    get "/", {}, {"HTTP_X_REQUEST_ID" => "test+value"}
+    assert last_response.header.key?("X-Request-Id")
+    refute_empty last_response.header["X-Request-Id"]
+    assert_equal last_response.header["X-Request-Id"], last_response.body
+    assert_equal "testvalue", last_response.header["X-Request-Id"]
+  end
+
+  def test_handler_config_with_simple_handler
+    marlowe_options[:handler] = :simple
+    get "/", {}, {"HTTP_X_REQUEST_ID" => "test+value"}
+    assert last_response.header.key?("X-Request-Id")
+    refute_empty last_response.header["X-Request-Id"]
+    assert_equal last_response.header["X-Request-Id"], last_response.body
+    assert_equal "test+value", last_response.header["X-Request-Id"]
+  end
+
+  def test_handler_config_with_proc_handler
+    marlowe_options[:handler] = ->(item) { item && item.reverse || SecureRandom.uuid }
+    get "/", {}, {"HTTP_X_REQUEST_ID" => "test+value"}
+    assert last_response.header.key?("X-Request-Id")
+    refute_empty last_response.header["X-Request-Id"]
+    assert_equal last_response.header["X-Request-Id"], last_response.body
+    assert_equal "eulav+tset", last_response.header["X-Request-Id"]
+  end
+
+  def test_handler_config_with_proc_handler_returning_nil
+    marlowe_options[:handler] = ->(_item) {}
+    get "/", {}, {"HTTP_X_REQUEST_ID" => "test+value"}
+    assert last_response.header.key?("X-Request-Id")
+    refute_empty last_response.header["X-Request-Id"]
+    assert_equal last_response.header["X-Request-Id"], last_response.body
+    assert_match(/\A[-\w]+\z/, last_response.header["X-Request-Id"])
+  end
+
+  def test_return_config_false
+    marlowe_options[:return] = false
+    get "/"
+    refute last_response.header.key?("X-Request-Id")
+    assert_equal RequestStore[:correlation_id], last_response.body
+  end
+end