BigW Consortium Gitlab

rack_middleware.rb 2.55 KB
Newer Older
1 2
module Gitlab
  module Metrics
3
    # Rack middleware for tracking Rails and Grape requests.
4 5
    class RackMiddleware
      CONTROLLER_KEY = 'action_controller.instance'
6
      ENDPOINT_KEY   = 'api.endpoint'
7 8 9 10 11 12 13 14 15 16 17
      CONTENT_TYPES = {
        'text/html' => :html,
        'text/plain' => :txt,
        'application/json' => :json,
        'text/js' => :js,
        'application/atom+xml' => :atom,
        'image/png' => :png,
        'image/jpeg' => :jpeg,
        'image/gif' => :gif,
        'image/svg+xml' => :svg
      }
18 19 20 21 22 23 24 25 26 27 28 29 30

      def initialize(app)
        @app = app
      end

      # env - A Hash containing Rack environment details.
      def call(env)
        trans  = transaction_from_env(env)
        retval = nil

        begin
          retval = trans.run { @app.call(env) }

31 32 33 34
        rescue Exception => error # rubocop: disable Lint/RescueException
          trans.add_event(:rails_exception)

          raise error
35 36 37 38 39
        # Even in the event of an error we want to submit any metrics we
        # might've gathered up to this point.
        ensure
          if env[CONTROLLER_KEY]
            tag_controller(trans, env)
40 41
          elsif env[ENDPOINT_KEY]
            tag_endpoint(trans, env)
42 43 44 45 46 47 48 49 50 51 52
          end

          trans.finish
        end

        retval
      end

      def transaction_from_env(env)
        trans = Transaction.new

53
        trans.set(:request_uri, filtered_path(env))
54
        trans.set(:request_method, env['REQUEST_METHOD'])
55 56 57 58 59

        trans
      end

      def tag_controller(trans, env)
60 61 62 63 64 65 66 67 68
        controller = env[CONTROLLER_KEY]
        action = "#{controller.class.name}##{controller.action_name}"
        suffix = CONTENT_TYPES[controller.content_type]

        if suffix && suffix != :html
          action += ".#{suffix}"
        end

        trans.action = action
69
      end
70 71 72 73 74 75 76 77 78

      def tag_endpoint(trans, env)
        endpoint = env[ENDPOINT_KEY]
        path = endpoint_paths_cache[endpoint.route.route_method][endpoint.route.route_path]
        trans.action = "Grape##{endpoint.route.route_method} #{path}"
      end

      private

79 80 81 82
      def filtered_path(env)
        ActionDispatch::Request.new(env).filtered_path.presence || env['REQUEST_URI']
      end

83 84 85 86 87 88 89 90 91 92 93
      def endpoint_paths_cache
        @endpoint_paths_cache ||= Hash.new do |hash, http_method|
          hash[http_method] = Hash.new do |inner_hash, raw_path|
            inner_hash[raw_path] = endpoint_instrumentable_path(raw_path)
          end
        end
      end

      def endpoint_instrumentable_path(raw_path)
        raw_path.sub('(.:format)', '').sub('/:version', '')
      end
94 95 96
    end
  end
end