apisonator 2.100.0

data/lib/3scale/backend/listener_metrics.rb

@@ -0,0 +1,99 @@
+require 'yabeda/prometheus'
+require 'rack'
+
+module ThreeScale
+  module Backend
+    class ListenerMetrics
+      REQUEST_TYPES = {
+        '/transactions/authorize.xml' => 'authorize',
+        '/transactions/oauth_authorize.xml' => 'authorize_oauth',
+        '/transactions/authrep.xml' => 'authrep',
+        '/transactions/oauth_authrep.xml' => 'authrep_oauth',
+        '/transactions.xml' => 'report'
+      }
+      private_constant :REQUEST_TYPES
+
+      class << self
+        ERRORS_4XX_TO_TRACK = Set[403, 404, 409].freeze
+        private_constant :ERRORS_4XX_TO_TRACK
+
+        def start_metrics_server(port = nil)
+          configure_data_store
+          define_metrics
+
+          # Yabeda does not accept the port as a param
+          ENV['PROMETHEUS_EXPORTER_PORT'] = port.to_s if port
+          Yabeda::Prometheus::Exporter.start_metrics_server!
+        end
+
+        def report_resp_code(path, resp_code)
+          Yabeda.apisonator_listener.response_codes.increment(
+            {
+              request_type: REQUEST_TYPES[path],
+              resp_code: code_group(resp_code)
+            },
+            by: 1
+          )
+        end
+
+        def report_response_time(path, request_time)
+          Yabeda.apisonator_listener.response_times.measure(
+            { request_type: REQUEST_TYPES[path] },
+            request_time
+          )
+        end
+
+        private
+
+        def configure_data_store
+          # Needed to aggregate metrics across processes.
+          # Ref: https://github.com/yabeda-rb/yabeda-prometheus#multi-process-server-support
+          Dir['/tmp/prometheus/*.bin'].each do |file_path|
+            File.unlink(file_path)
+          end
+
+          Prometheus::Client.config.data_store = Prometheus::Client::DataStores::DirectFileStore.new(
+            dir: '/tmp/prometheus'
+          )
+        end
+
+        def define_metrics
+          Yabeda.configure do
+            group :apisonator_listener do
+              counter :response_codes do
+                comment 'Response codes'
+                tags %i[request_type resp_code]
+              end
+
+              histogram :response_times do
+                comment 'Response times'
+                unit :seconds
+                tags %i[request_type]
+                # Most requests will be under 100ms, so use a higher granularity from there
+                buckets [0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09, 0.1, 0.25, 0.5, 0.75, 1]
+              end
+            end
+          end
+
+          # Note that this method raises if called more than once. Both
+          # listeners and workers define their metrics, but that's fine because
+          # a process cannot act as both.
+          Yabeda.configure!
+        end
+
+        def code_group(resp_code)
+          case resp_code
+          when (200...300)
+            '2xx'.freeze
+          when (400...500)
+            ERRORS_4XX_TO_TRACK.include?(resp_code) ? resp_code : '4xx'.freeze
+          when (500...600)
+            '5xx'.freeze
+          else
+            'unknown'.freeze
+          end
+        end
+      end
+    end
+  end
+end

data/lib/3scale/backend/logging.rb

@@ -0,0 +1,48 @@
+require '3scale/backend/environment'
+require '3scale/backend/configuration'
+require '3scale/backend/logging/logger'
+require '3scale/backend/logging/external'
+
+module ThreeScale
+  module Backend
+    # include this module to have a handy access to the default logger
+    module Logging
+      def self.included(base)
+        enable! on: base
+      end
+
+      def self.enable!(on:, with: [], as: :logger)
+        logger = if with.empty?
+                   Backend.logger
+                 else
+                   Backend::Logging::Logger.new(*with)
+                 end
+
+        # define the method before yielding
+        on.send :define_method, as do
+          logger
+        end
+
+        yield logger if block_given?
+      end
+    end
+
+    class << self
+
+      private
+
+      def enable_logging
+        Logging.enable! on: self.singleton_class,
+          with: [configuration.log_file, 10] do |logger|
+          logger.define_singleton_method(:notify, logger_notify_proc(logger))
+        end
+      end
+
+      def logger_notify_proc(logger)
+        Logging::External.notify_proc || logger.method(:error).to_proc
+      end
+    end
+
+    enable_logging
+  end
+end

data/lib/3scale/backend/logging/external.rb

@@ -0,0 +1,44 @@
+require '3scale/backend/configuration'
+require '3scale/backend/logging/external/impl'
+
+module ThreeScale
+  module Backend
+    module Logging
+      module External
+        class << self
+          private
+
+          attr_accessor :impl, :enabled
+          alias_method :enabled?, :enabled
+          public :enabled?
+
+          public
+
+          def setup
+            config = Backend.configuration.hoptoad
+
+            service = if config.service && !config.service.empty?
+                        config.service.to_sym
+                      else
+                        :default
+                      end
+            self.impl = Impl.load service
+            self.enabled = impl.setup(config.api_key)
+          end
+
+          def reset
+            self.enabled = false
+          end
+
+          # delegate methods not overriden to the impl
+          (Impl::METHODS - public_instance_methods(false)).each do |m|
+            define_method(m) do |*args|
+              setup unless enabled?
+              impl.public_send m, *args
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/3scale/backend/logging/external/impl.rb

@@ -0,0 +1,93 @@
+module ThreeScale
+  module Backend
+    module Logging
+      module External
+        # This is the module that each implementation has to populate with its
+        # own class. The implementation file must be named after the class and
+        # live in a specific subdirectory relative to this file matching this
+        # file's name.
+        #
+        # To load the class one must specify a symbol with the base name without
+        # extension as the file that implements it. The class name is expected
+        # to be the capitalized symbol.
+        module Impl
+          # methods to be implemented by each external logging service
+          #
+          # setup - Meant to configure the service for a general use. Each other
+          #         method in the list calls setup if it has not been called
+          #         before.
+          # setup_rake - Perform additional configuration for Rake
+          # setup_rack - Receives the Rack object, meant to add a middleware.
+          # setup_worker - Additional configuration for job worker usage.
+          # notify_proc - The global logger's notify method will call the proc
+          #               returned by this. If nil is returned a fallback will
+          #               be chosen for that method (typically local logging).
+          #
+          METHODS = [:setup, :setup_rake, :setup_rack,
+                     :setup_worker, :notify_proc].freeze
+
+          class Error < StandardError
+            class FileNotFound < self
+              def initialize(impl)
+                super "external logging implementation not found for #{impl.inspect}"
+              end
+            end
+
+            class ClassNotFound < self
+              def initialize(impl)
+                super "external logging implementation does not provide a " \
+                  "similarly named class: #{impl.inspect}"
+              end
+            end
+          end
+
+          class << self
+            # returns the class implementing the logging service
+            def load(impl)
+              require(find_file impl)
+
+              fetch_impl_klass impl
+            end
+
+            private
+
+            def find_file(impl)
+              re = build_regexp impl
+
+              impl_file = Dir[glob].find do |path|
+                re.match(File.basename path)
+              end
+
+              impl_file || raise(Error::FileNotFound.new(impl))
+            end
+
+            def fetch_impl_klass(impl)
+              const_get(impl.capitalize)
+            rescue NameError
+              raise Error::ClassNotFound.new(impl)
+            end
+
+            def build_regexp(impl)
+              Regexp.new("\\A#{Regexp.escape(impl.to_s + extname)}\\z")
+            end
+
+            # these are almost constants, but since this is meant to be init
+            # code with throw-away strings they are left here as helper methods
+            def glob
+              directory << File::SEPARATOR << '*' << File.extname(__FILE__)
+            end
+
+            def directory
+              __FILE__.chomp(extname) + File::SEPARATOR
+            end
+
+            def extname
+              # assume implementations will be coded in our own language
+              File.extname __FILE__
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/3scale/backend/logging/external/impl/airbrake.rb

@@ -0,0 +1,66 @@
+require '3scale/backend/environment'
+require '3scale/backend/configuration'
+
+module ThreeScale
+  module Backend
+    module Logging
+      module External
+        module Impl
+          module Airbrake
+            class << self
+              def setup(api_key)
+                do_require
+
+                configure api_key
+              end
+
+              def setup_rack(rack)
+                rack.use middleware
+              end
+
+              def setup_rake
+                require 'airbrake/tasks'
+                require 'airbrake/rake_handler'
+
+                ::Airbrake.configure do |config|
+                  config.rescue_rake_exceptions = true
+                end
+              end
+
+              def setup_worker
+                require '3scale/backend/logging/external/resque'
+
+                External::Resque.setup klass
+              end
+
+              def notify_proc
+                klass.method(:notify).to_proc
+              end
+
+              private
+
+              def do_require
+                require 'airbrake'
+              end
+
+              def klass
+                ::Airbrake
+              end
+
+              def middleware
+                ::Airbrake::Sinatra
+              end
+
+              def configure(api_key)
+                ::Airbrake.configure do |config|
+                  config.api_key = api_key
+                  config.environment_name = Backend.environment
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/3scale/backend/logging/external/impl/bugsnag.rb

@@ -0,0 +1,69 @@
+require '3scale/backend/version'
+require '3scale/backend/environment'
+require '3scale/backend/util'
+require '3scale/backend/logging'
+
+module ThreeScale
+  module Backend
+    module Logging
+      module External
+        module Impl
+          module Bugsnag
+            class << self
+              def setup(api_key)
+                do_require
+
+                configure api_key
+              end
+
+              def setup_rack(rack)
+                rack.use middleware
+              end
+
+              def setup_rake
+                # no-op
+              end
+
+              def setup_worker
+                require '3scale/backend/logging/external/resque'
+
+                External::Resque.setup klass
+              end
+
+              def notify_proc
+                klass.method(:notify).to_proc
+              end
+
+              private
+
+              def do_require
+                require 'bugsnag'
+              end
+
+              def klass
+                ::Bugsnag
+              end
+
+              def middleware
+                ::Bugsnag::Rack
+              end
+
+              def configure(api_key)
+                ::Bugsnag.configure do |config|
+                  config.api_key = api_key
+                  config.release_stage = Backend.environment
+                  config.app_version = Backend::VERSION
+                  config.timeout = 3
+                  config.logger = Backend.logger
+                  config.meta_data_filters = []
+                  config.notify_release_stages = ['production', 'preview']
+                  config.project_root = Backend::Util.root_dir
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/3scale/backend/logging/external/impl/default.rb

@@ -0,0 +1,18 @@
+module ThreeScale
+  module Backend
+    module Logging
+      module External
+        module Impl
+          # the default implementation does nothing
+          class Default
+            class << self
+              (Impl::METHODS - public_instance_methods(false)).each do |m|
+                define_method(m) { |*| }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/3scale/backend/logging/external/resque.rb

@@ -0,0 +1,57 @@
+# This is a module to configure an external error logging service for Resque.
+#
+# The requirement is that an object be passed in that implements the same
+# interface as Airbrake.
+#
+# This requires a Resque version with https://github.com/resque/resque/pull/1602
+#
+module ThreeScale
+  module Backend
+    module Logging
+      module External
+        module Resque
+          class << self
+            def setup(klass)
+              load_resque_failure_for klass
+
+              ::Resque::Failure::Multiple.classes = [
+                ::Resque::Failure::Redis,
+                Class.new(::Resque::Failure::Airbrake) do
+                  def self.configure(&block)
+                    # calling this hook is an error
+                    raise "error: tried to configure #{self.inspect} from Resque"
+                  end
+                end,
+              ]
+              ::Resque::Failure.backend = ::Resque::Failure::Multiple
+            end
+
+            private
+
+            # set the argument as ::Airbrake and load Resque::Failure
+            def load_resque_failure_for(klass)
+              require 'resque/failure/base'
+              require 'resque/failure/multiple'
+              require 'resque/failure/redis'
+
+              # ensure we have a matching ::Airbrake top-level constant or
+              # define it if missing
+              begin
+                airbrake = ::Kernel.const_get(:Airbrake)
+              rescue NameError
+                # not defined, so set our own
+                ::Kernel.const_set(:Airbrake, klass)
+              else
+                # defined, expect it's our own object
+                raise "Airbrake constant pre-defined as #{airbrake.inspect}, " \
+                      " required to be #{klass.inspect}!" if airbrake != klass
+              end
+
+              require 'resque/failure/airbrake'
+            end
+          end
+        end
+      end
+    end
+  end
+end