visionary-sdk 0.4.0

data/lib/visionary/body.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module Visionary
+  # Copies up to max bytes of a body as it streams past, and counts all of it.
+  class Capture
+    attr_reader :size
+
+    def initialize(max, enabled)
+      @max = max
+      @enabled = enabled
+      @buf = enabled ? String.new(capacity: [max, 1024].min, encoding: Encoding::BINARY) : nil
+      @size = 0
+    end
+
+    def feed(chunk, at = @size)
+      n = chunk.bytesize
+      if @enabled && at == @buf.bytesize && at < @max
+        @buf << chunk.byteslice(0, @max - at).b
+      end
+      @size = at + n if at + n > @size
+    end
+
+    def bytes = @buf || ""
+    def truncated? = @enabled && @size > @max
+  end
+
+  # Wraps rack.input: the app reads as before, and the first max bytes it
+  # reads are kept for the log.
+  class InputProxy
+    def initialize(input, capture)
+      @input = input
+      @capture = capture
+      @pos = 0
+    end
+
+    def read(*args)
+      data = @input.read(*args)
+      observe(data)
+      data
+    end
+
+    def gets(*args)
+      observe(@input.gets(*args))
+    end
+
+    def each
+      return enum_for(:each) unless block_given?
+      @input.each { |line| yield observe(line) }
+    end
+
+    def rewind
+      @pos = 0
+      @input.rewind
+    end
+
+    def close = @input.respond_to?(:close) ? @input.close : nil
+
+    def respond_to_missing?(name, include_all = false) = @input.respond_to?(name, include_all)
+
+    def method_missing(name, *args, &block)
+      @input.respond_to?(name) ? @input.public_send(name, *args, &block) : super
+    end
+
+    private
+
+    def observe(data)
+      if data.is_a?(String) && !data.empty?
+        @capture.feed(data, @pos)
+        @pos += data.bytesize
+      end
+      data
+    end
+  end
+
+  # Wraps a Rack response body. Chunks pass through untouched (streaming
+  # still streams); a capped copy is kept, and done is called once when the
+  # server closes the body.
+  class BodyProxy
+    def initialize(body, capture, &done)
+      @body = body
+      @capture = capture
+      @done = done
+    end
+
+    def each(&block)
+      return enum_for(:each) unless block
+      @body.each do |chunk|
+        @capture.feed(chunk.to_s)
+        yield chunk
+      end
+    end
+
+    # Rack 3: a body with to_ary must close itself when it is called.
+    def to_ary
+      arr = @body.to_ary
+      arr.each { |chunk| @capture.feed(chunk.to_s) }
+      arr
+    ensure
+      close
+    end
+
+    # Rack 3 streaming bodies.
+    def call(stream)
+      @body.call(StreamProxy.new(stream, @capture))
+    ensure
+      finish
+    end
+
+    def to_path = @body.to_path
+
+    def respond_to?(name, include_all = false)
+      case name.to_sym
+      when :to_ary, :to_path, :call, :each then @body.respond_to?(name, include_all)
+      else super
+      end
+    end
+
+    def close
+      @body.close if @body.respond_to?(:close) && !@closed
+    ensure
+      @closed = true
+      finish
+    end
+
+    private
+
+    def finish
+      done = @done
+      @done = nil
+      done&.call
+    end
+
+    def respond_to_missing?(name, include_all = false) = @body.respond_to?(name, include_all)
+
+    def method_missing(name, *args, &block)
+      @body.respond_to?(name) ? @body.public_send(name, *args, &block) : super
+    end
+  end
+
+  class StreamProxy
+    def initialize(stream, capture)
+      @stream = stream
+      @capture = capture
+    end
+
+    def write(data)
+      @capture.feed(data.to_s)
+      @stream.write(data)
+    end
+
+    def <<(data)
+      write(data)
+      self
+    end
+
+    def respond_to_missing?(name, include_all = false) = @stream.respond_to?(name, include_all)
+
+    def method_missing(name, *args, &block)
+      @stream.respond_to?(name) ? @stream.public_send(name, *args, &block) : super
+    end
+  end
+end

data/lib/visionary/config.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module Visionary
+  # Everything the agent needs. Config.from_env fills it from VISIONARY_*
+  # (see sdks/SPEC.md "Environment"); set attributes in Visionary.configure to
+  # override or to add hooks.
+  #
+  # Storage is chosen in this order: +connection+ (an ActiveRecord connection
+  # class such as ActiveRecord::Base), then +database_url+, then the D1
+  # credentials.
+  class Config
+    COMMIT_VARIABLES = %w[
+      RAILWAY_GIT_COMMIT_SHA RENDER_GIT_COMMIT VERCEL_GIT_COMMIT_SHA HEROKU_SLUG_COMMIT
+      SOURCE_VERSION GIT_COMMIT GITHUB_SHA K_REVISION
+    ].freeze
+
+    attr_accessor :database_url, :d1_account_id, :d1_database_id, :d1_api_token, :d1_api_base,
+                  :connection, :instance, :logger,
+                  :log_requests, :path_prefix, :capture_bodies, :max_body_bytes,
+                  :queue_size, :batch_size, :flush_interval, :log_retention_days,
+                  :redact_headers, :redact_fields, :redact_request_fields,
+                  :error_code_field, :error_key_field,
+                  :system_metrics, :system_interval, :system_retention_days, :disk_path,
+                  :service, :version, :spans, :span_threshold_ms, :span_max, :errors
+
+    # Runs on the writer thread, once per distinct user per batch, for users
+    # missing a handle or role: ->(id) { [handle, role] } or nil.
+    attr_accessor :lookup_user
+    # Returns the route pattern for a Rack env when the integration can't
+    # see it: ->(env) { "/users/:id" }.
+    attr_accessor :route
+    # Returns pool stats as a Hash: total, idle, in_use, max, acquires,
+    # empty_acquires, acquire_wait_ms (the last three cumulative). Defaults to
+    # the ActiveRecord pool when ActiveRecord is loaded.
+    attr_accessor :db_stats
+
+    def initialize
+      @database_url = ""
+      @d1_account_id = @d1_database_id = @d1_api_token = @d1_api_base = ""
+      @connection = nil
+      @instance = ""
+      @logger = nil
+      @log_requests = true
+      @path_prefix = ""
+      @capture_bodies = true
+      @max_body_bytes = 8192
+      @queue_size = 5000
+      @batch_size = 50
+      @flush_interval = 3.0
+      @log_retention_days = 30
+      @redact_headers = []
+      @redact_fields = []
+      @redact_request_fields = []
+      @error_code_field = "error.code"
+      @error_key_field = "error.key"
+      @system_metrics = true
+      @system_interval = 15.0
+      @system_retention_days = 30
+      @disk_path = ""
+      @service = nil
+      @version = nil
+      @spans = true
+      @span_threshold_ms = 100.0
+      @span_max = 100
+      @errors = true
+    end
+
+    def self.from_env(env = ENV)
+      s = ->(key) { env[key].to_s.strip }
+      c = new
+      c.database_url = s.("VISIONARY_DATABASE_URL")
+      c.d1_account_id = s.("D1_ACCOUNT_ID")
+      c.d1_database_id = s.("D1_DATABASE_ID")
+      c.d1_api_token = s.("D1_API_TOKEN")
+      c.d1_api_base = s.("D1_API_BASE")
+      c.instance = s.("VISIONARY_INSTANCE")
+      c.log_requests = parse_bool(s.("VISIONARY_LOG_REQUESTS"), true)
+      c.path_prefix = s.("VISIONARY_LOG_PATH_PREFIX")
+      c.capture_bodies = parse_bool(s.("VISIONARY_LOG_BODIES"), true)
+      c.max_body_bytes = parse_int(s.("VISIONARY_LOG_MAX_BODY_BYTES"), 8192)
+      c.log_retention_days = parse_int(s.("VISIONARY_LOG_RETENTION_DAYS"), 30)
+      c.redact_headers = parse_list(s.("VISIONARY_LOG_REDACT_HEADERS"))
+      c.redact_fields = parse_list(s.("VISIONARY_LOG_REDACT_FIELDS"))
+      c.redact_request_fields = parse_list(s.("VISIONARY_LOG_REDACT_REQUEST_FIELDS"))
+      c.error_code_field = s.("VISIONARY_LOG_ERROR_CODE_FIELD").then { |v| v.empty? ? "error.code" : v }
+      c.error_key_field = s.("VISIONARY_LOG_ERROR_KEY_FIELD").then { |v| v.empty? ? "error.key" : v }
+      c.system_metrics = parse_bool(s.("VISIONARY_SYSTEM_METRICS"), true)
+      c.system_interval = parse_duration(s.("VISIONARY_SYSTEM_INTERVAL"), 15.0)
+      c.system_retention_days = parse_int(s.("VISIONARY_SYSTEM_RETENTION_DAYS"), 30)
+      c.service = s.("VISIONARY_SERVICE").then { |v| v.empty? ? nil : v }
+      c.version = release_from(env)
+      c.spans = parse_bool(s.("VISIONARY_SPANS"), true)
+      c.span_threshold_ms = parse_float(s.("VISIONARY_SPAN_THRESHOLD_MS"), 100.0)
+      c.span_max = parse_int(s.("VISIONARY_SPAN_MAX"), 100)
+      c.errors = parse_bool(s.("VISIONARY_ERRORS"), true)
+      c
+    end
+
+    # VISIONARY_RELEASE, else the platform's commit variable; commit hashes
+    # are shortened to 12 characters.
+    def self.release_from(env)
+      ["VISIONARY_RELEASE", *COMMIT_VARIABLES].each do |key|
+        v = env[key].to_s.strip
+        next if v.empty?
+        return v.match?(/\A\h{13,64}\z/) ? v[0, 12] : v
+      end
+      nil
+    end
+
+    def self.parse_bool(v, default)
+      case v.to_s.strip.downcase
+      when "true", "1", "yes" then true
+      when "false", "0", "no" then false
+      else default
+      end
+    end
+
+    def self.parse_int(v, default)
+      n = Integer(v.to_s.strip, 10)
+      n >= 0 ? n : default
+    rescue ArgumentError
+      default
+    end
+
+    def self.parse_float(v, default)
+      n = Float(v.to_s.strip)
+      n >= 0 ? n : default
+    rescue ArgumentError
+      default
+    end
+
+    def self.parse_list(v)
+      v.to_s.split(",").map(&:strip).reject(&:empty?)
+    end
+
+    # Seconds from "15", "15s", "500ms", "1m", "1h".
+    def self.parse_duration(v, default)
+      v = v.to_s.strip.downcase
+      return default if v.empty?
+      m = v.match(/\A(\d+(?:\.\d+)?)(ms|s|m|h)?\z/)
+      return default unless m
+      n = m[1].to_f
+      case m[2]
+      when "ms" then n / 1000.0
+      when "m" then n * 60
+      when "h" then n * 3600
+      else n
+      end
+    end
+  end
+end

data/lib/visionary/context.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Visionary
+  # What the request being handled has said about itself: the user, the route
+  # pattern, and the spans and errors recorded while it ran.
+  #
+  # The middleware puts one object in fiber storage (Ruby 3.2+, inherited by
+  # child fibers and threads, so it works under Falcon and in Async tasks) or a
+  # fiber-local variable on Ruby 3.1. Code anywhere in the request then
+  # mutates the same object, behind a mutex.
+  class RequestContext
+    KEY = :visionary_request
+
+    attr_reader :request_id, :method, :path, :started_at, :started_mono, :errors, :db_visible
+
+    def initialize(request_id:, method:, path:, started_at:, started_mono:, span_max:, db_visible:)
+      @request_id = request_id
+      @method = method
+      @path = path
+      @started_at = started_at
+      @started_mono = started_mono
+      @span_max = span_max
+      @db_visible = db_visible
+      @mutex = Mutex.new
+      @user = ["", "", ""]
+      @route = ""
+      @spans = []
+      @errors = []
+      @db_count = @http_count = 0
+      @db_ms = @http_ms = 0.0
+    end
+
+    def set_user(id, handle, role)
+      @mutex.synchronize { @user = [id.nil? ? "" : id.to_s, handle.to_s, role.to_s] }
+    end
+
+    def user
+      @mutex.synchronize { @user }
+    end
+
+    def route=(pattern)
+      @mutex.synchronize { @route = pattern.to_s }
+    end
+
+    def route
+      @mutex.synchronize { @route }
+    end
+
+    # Database and HTTP calls always count; rows are kept up to the cap.
+    def add_span(span)
+      @mutex.synchronize do
+        case span.kind
+        when "db"
+          @db_count += 1
+          @db_ms += span.duration_ms
+          @db_visible = true
+        when "http"
+          @http_count += 1
+          @http_ms += span.duration_ms
+        end
+        @spans << span if @spans.size < @span_max
+      end
+    end
+
+    def add_error(row)
+      @mutex.synchronize { @errors << row }
+    end
+
+    # [db_count, db_ms, http_count, http_ms]; database totals are NULL when no
+    # database hook could see this request's calls.
+    def totals
+      @mutex.synchronize do
+        [@db_visible ? @db_count : nil, @db_visible ? @db_ms.round(3) : nil, @http_count, @http_ms.round(3)]
+      end
+    end
+
+    def spans
+      @mutex.synchronize { @spans.sort_by(&:offset_ms) }
+    end
+
+    if Fiber.respond_to?(:[])
+      def self.current = Fiber[KEY]
+      def self.current=(ctx)
+        Fiber[KEY] = ctx
+      end
+    else
+      def self.current = Thread.current[KEY]
+      def self.current=(ctx)
+        Thread.current[KEY] = ctx
+      end
+    end
+  end
+
+  # One database, HTTP, cache, queue or custom call.
+  Span = Struct.new(:kind, :name, :target, :detail, :started_at, :offset_ms, :duration_ms,
+                    :status, :error, :row_count, :request_id, keyword_init: true)
+end

data/lib/visionary/fork.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Visionary
+  # Process._fork (Ruby 3.1+) runs for every fork: Kernel#fork, Process.fork
+  # and the forks Puma and Unicorn make for their workers. Only the child
+  # restarts Visionary's threads.
+  module ForkHook
+    def _fork
+      pid = super
+      Visionary.after_fork if pid.zero?
+      pid
+    end
+  end
+
+  Process.singleton_class.prepend(ForkHook) if Process.respond_to?(:_fork)
+end

data/lib/visionary/middleware.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Visionary
+  # Rack middleware: logs each request to api_logs, counts throughput for
+  # system_metrics, collects the request's spans and records exceptions.
+  # Mount it outermost so it sees the final status. Works with any Rack app
+  # (Rails via the Railtie, Sinatra, Hanami, Roda, Grape).
+  #
+  #   use Visionary::Middleware
+  class Middleware
+    REQUEST_ID = "HTTP_X_REQUEST_ID"
+    # Where frameworks leave an exception they turned into an error page.
+    EXCEPTION_KEYS = %w[visionary.exception action_dispatch.exception sinatra.error rack.exception].freeze
+    UNCAPTURABLE = %w[multipart/ image/ video/ audio/ application/octet-stream application/zip application/pdf].freeze
+
+    def initialize(app, agent = nil)
+      @app = app
+      @agent = agent
+    end
+
+    def call(env)
+      agent = @agent || Visionary.agent
+      return @app.call(env) unless agent&.enabled?
+
+      path = "#{env['SCRIPT_NAME']}#{env['PATH_INFO']}"
+      path = "/" if path.empty?
+      return passthrough(agent, env) unless agent.log_path?(path)
+
+      log(agent, env, path)
+    end
+
+    def self.capturable?(content_type)
+      ct = content_type.to_s.downcase
+      ct.empty? || UNCAPTURABLE.none? { |p| ct.start_with?(p) }
+    end
+
+    # Rack env headers as [[name, value], ...], e.g. ["User-Agent", "curl/8"].
+    def self.header_pairs(env)
+      out = []
+      env.each do |k, v|
+        next unless k.is_a?(String)
+        if k.start_with?("HTTP_") && k != "HTTP_VERSION"
+          out << [k[5..].split("_").map(&:capitalize).join("-"), v.to_s]
+        elsif k == "CONTENT_TYPE" || k == "CONTENT_LENGTH"
+          out << [k.split("_").map(&:capitalize).join("-"), v.to_s] unless v.to_s.empty?
+        end
+      end
+      out
+    end
+
+    # A response header by lowercase name, whatever case the app used.
+    def self.header(headers, name)
+      return nil unless headers.respond_to?(:each)
+      v = headers[name]
+      if v.nil?
+        headers.each do |k, val|
+          next unless k.to_s.casecmp?(name)
+          v = val
+          break
+        end
+      end
+      v.is_a?(Array) ? v.join(", ") : v
+    rescue StandardError
+      nil
+    end
+
+    private
+
+    # Not logged: count it, and still record what escapes.
+    def passthrough(agent, env)
+      agent.http.started
+      status = 500
+      begin
+        res = @app.call(env)
+        status = res[0].to_i
+        res
+      rescue Exception => e # re-raised below; the app's handling is unchanged
+        agent.telemetry&.exception(e, handled: false, ctx: nil)
+        raise
+      ensure
+        agent.http.finished(status)
+      end
+    end
+
+    def log(agent, env, path)
+      cfg = agent.config
+      started_at = Time.now
+      t0 = Telemetry.now_ms
+      request_id = env[REQUEST_ID].to_s
+      request_id = SecureRandom.hex(16) if request_id.empty? || request_id.length > 128
+      headers = self.class.header_pairs(env)
+      env[REQUEST_ID] = request_id # so the app (Rails' RequestId) uses the same id
+
+      req_type = env["CONTENT_TYPE"].to_s
+      req_capture = Capture.new(cfg.max_body_bytes, cfg.capture_bodies && self.class.capturable?(req_type))
+      env["rack.input"] = InputProxy.new(env["rack.input"], req_capture) if env["rack.input"] && cfg.capture_bodies
+
+      ctx = RequestContext.new(
+        request_id: request_id, method: env["REQUEST_METHOD"].to_s, path: path, started_at: started_at,
+        started_mono: t0, span_max: cfg.span_max.to_i, db_visible: Telemetry::ActiveRecordHook.installed?
+      )
+      agent.http.started
+      outer = RequestContext.current
+      RequestContext.current = ctx
+      begin
+        status, res_headers, body = @app.call(env)
+      rescue Exception => e # re-raised below; the app's handling is unchanged
+        agent.telemetry&.exception(e, handled: false, ctx: ctx)
+        finish(agent, env, ctx, headers, req_capture, 500, nil, Capture.new(0, false), t0)
+        raise
+      ensure
+        RequestContext.current = outer
+      end
+
+      status = status.to_i
+      begin
+        res_headers["x-request-id"] = request_id unless self.class.header(res_headers, "x-request-id")
+      rescue StandardError
+        nil
+      end
+      if status >= 500 && (exc = EXCEPTION_KEYS.lazy.map { |k| env[k] }.find { |x| x.is_a?(Exception) })
+        agent.telemetry&.exception(exc, handled: false, ctx: ctx)
+      end
+      resp_type = self.class.header(res_headers, "content-type").to_s
+      resp_capture = Capture.new(cfg.max_body_bytes, cfg.capture_bodies && self.class.capturable?(resp_type))
+      proxy = BodyProxy.new(body, resp_capture) do
+        finish(agent, env, ctx, headers, req_capture, status, res_headers, resp_capture, t0)
+      end
+      [status, res_headers, proxy]
+    end
+
+    def finish(agent, env, ctx, headers, req_capture, status, res_headers, resp_capture, t0)
+      agent.http.finished(status)
+      duration = (Telemetry.now_ms - t0).round(3)
+      route = ctx.route
+      route = agent.route_for(env) if route.empty?
+      user_id, handle, role = ctx.user
+      tel = agent.telemetry
+      entry = Entry.new(
+        request_id: ctx.request_id, started_at: ctx.started_at, method: ctx.method, path: ctx.path,
+        route: route, query: env["QUERY_STRING"].to_s, status: status, duration_ms: duration,
+        ip: client_ip(env), user_agent: env["HTTP_USER_AGENT"].to_s,
+        user_id: user_id, user_handle: handle, user_role: role, headers: headers,
+        request_content_type: env["CONTENT_TYPE"].to_s, request_body: req_capture.bytes,
+        request_truncated: req_capture.truncated?,
+        request_size: [env["CONTENT_LENGTH"].to_i, req_capture.size].max,
+        response_content_type: self.class.header(res_headers, "content-type").to_s,
+        response_body: resp_capture.bytes, response_truncated: resp_capture.truncated?,
+        response_size: [self.class.header(res_headers, "content-length").to_i, resp_capture.size].max,
+        totals: tel&.spans_on ? ctx.totals : [nil, nil, nil, nil],
+        span_rows: tel ? tel.request_span_rows(ctx, duration, status) : [],
+        error_rows: tel ? ctx.errors.map { |row| tel.error_row(row, ctx, route, user_id) } : []
+      )
+      agent.enqueue([:request, entry])
+    rescue StandardError => e
+      agent.logger.error("visionary: dropping request log entry: #{e.class}: #{e.message}")
+    end
+
+    # The first X-Forwarded-For hop (most deployments sit behind a proxy),
+    # else the peer. Informational only.
+    def client_ip(env)
+      fwd = env["HTTP_X_FORWARDED_FOR"].to_s
+      return fwd.split(",", 2).first.strip unless fwd.empty?
+      env["REMOTE_ADDR"].to_s
+    end
+  end
+end

data/lib/visionary/queue.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Visionary
+  # A bounded queue that never blocks producers: when full, push drops the
+  # item and counts it. Consumers wait with a deadline (Thread::Queue#pop
+  # gained a timeout only in Ruby 3.2).
+  class BoundedQueue
+    def initialize(max)
+      @max = max
+      @items = []
+      @dropped = 0
+      @closed = false
+      @mutex = Mutex.new
+      @cond = ConditionVariable.new
+    end
+
+    def push(item)
+      @mutex.synchronize do
+        if @items.size >= @max
+          @dropped += 1
+          return false
+        end
+        @items << item
+        @cond.signal
+        true
+      end
+    end
+
+    # Up to n items, waiting until at least one is there, the deadline (a
+    # monotonic time in seconds) passes, or the queue is closed.
+    def take(n, deadline)
+      @mutex.synchronize do
+        while @items.empty? && !@closed
+          left = deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          break if left <= 0
+          @cond.wait(@mutex, left)
+        end
+        @items.shift(n)
+      end
+    end
+
+    def size = @mutex.synchronize { @items.size }
+
+    def take_dropped
+      @mutex.synchronize { @dropped.tap { @dropped = 0 } }
+    end
+
+    def close
+      @mutex.synchronize do
+        @closed = true
+        @cond.broadcast
+      end
+    end
+
+    def closed? = @mutex.synchronize { @closed }
+  end
+end

data/lib/visionary/railtie.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Visionary
+  # Rails integration: inserts the middleware first in the stack, records
+  # database spans from ActiveRecord, sees exceptions Rails turns into error
+  # pages, and reads route patterns from Rails routing. Configure in an
+  # initializer with Visionary.configure.
+  class Railtie < ::Rails::Railtie
+    initializer "visionary.middleware" do |app|
+      app.middleware.insert_before 0, Visionary::Middleware
+    end
+
+    initializer "visionary.active_record" do
+      ActiveSupport.on_load(:active_record) do
+        Visionary::Telemetry::ActiveRecordHook.install if Visionary.config.spans
+      end
+    end
+
+    # ShowExceptions and DebugExceptions rescue errors below the middleware;
+    # the interceptor hands each one to it (it is recorded when the response
+    # is a 5xx, so RecordNotFound turned into a 404 is not an error row).
+    initializer "visionary.exceptions" do
+      ActiveSupport.on_load(:action_controller) do
+        if ActionDispatch::DebugExceptions.respond_to?(:register_interceptor)
+          ActionDispatch::DebugExceptions.register_interceptor do |request, exception|
+            request.set_header("visionary.exception", exception)
+          end
+        end
+      end
+    end
+
+    config.after_initialize do
+      cfg = Visionary.config
+      cfg.logger ||= Rails.logger
+      # Rails 7.1+ leaves the pattern in the env (request.route_uri_pattern);
+      # older versions are asked to recognize the request again.
+      cfg.route ||= Visionary::Railtie.method(:recognize) unless ActionDispatch::Request.method_defined?(:route_uri_pattern)
+    end
+
+    def self.recognize(env)
+      req = ActionDispatch::Request.new(env)
+      Rails.application.routes.router.recognize(req) { |route, _| return route.path.spec.to_s }
+      ""
+    rescue StandardError
+      ""
+    end
+  end
+end