metrician 0.0.1

data/lib/metrician/configuration.rb

@@ -0,0 +1,33 @@
+require "yaml"
+
+module Metrician
+  class Configuration
+    FileMissing = Class.new(StandardError)
+
+    def self.load
+      if env_location
+        # this should never raise unless a bad ENV setting has been set
+        raise(FileMissing.new(env_location)) unless File.exist?(env_location)
+        return YAML.load(env_location)
+      end
+
+      if File.exist?(app_location)
+        return YAML.load_file(app_location)
+      end
+
+      YAML.load_file(gem_location)
+    end
+
+    def self.env_location
+      ENV["METRICIAN_CONFIG"]
+    end
+
+    def self.app_location
+      File.join(Dir.pwd, "config", "metrician.yaml")
+    end
+
+    def self.gem_location
+      File.expand_path("../../../config/metrician.yaml", __FILE__)
+    end
+  end
+end

data/lib/metrician/jobs.rb

@@ -0,0 +1,32 @@
+module Metrician
+  module Jobs
+
+    RUN_METRIC   = "jobs.run".freeze
+    ERROR_METRIC = "jobs.error".freeze
+
+    def self.configuration
+      @configuration ||= Metrician.configuration[:jobs]
+    end
+
+    def self.enabled?
+      @enabled ||= configuration[:enabled]
+    end
+
+    def self.run?
+      @run ||= configuration[:run][:enabled]
+    end
+
+    def self.error?
+      @error ||= configuration[:error][:enabled]
+    end
+
+    def self.job_specific?
+      @job_specific ||= configuration[:job_specific][:enabled]
+    end
+
+    def self.instrumentation_name(job_name)
+      job_name.gsub(/[^\w]+/, ".").gsub(/\.+$/, "")
+    end
+
+  end
+end

data/lib/metrician/jobs/delayed_job_callbacks.rb

@@ -0,0 +1,33 @@
+module Metrician
+  module Jobs
+    class DelayedJobCallbacks < ::Delayed::Plugin
+
+      callbacks do |lifecycle|
+        lifecycle.around(:invoke_job) do |job, &block|
+          begin
+            start = Time.now
+            block.call(job)
+          ensure
+            if Jobs.run?
+              duration = Time.now - start
+              Metrician.gauge(Jobs::RUN_METRIC, duration)
+              if Jobs.job_specific?
+                Metrician.gauge("#{Jobs::RUN_METRIC}.job.#{Jobs.instrumentation_name(job.name)}", duration)
+              end
+            end
+          end
+        end
+
+        lifecycle.after(:error) do |_worker, job|
+          if Jobs.error?
+            Metrician.increment(Jobs::ERROR_METRIC)
+            if Jobs.job_specific?
+              Metrician.increment("#{Jobs::ERROR_METRIC}.job.#{Jobs.instrumentation_name(job.name)}")
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/metrician/jobs/resque_plugin.rb

@@ -0,0 +1,36 @@
+# Reference materials:
+# https://github.com/resque/resque/blob/master/docs/HOOKS.md
+module Metrician
+  module Jobs
+    module ResquePlugin
+
+      def around_perform_with_metrician(*_args)
+        start = Time.now
+        yield
+      ensure
+        if Jobs.run?
+          duration = Time.now - start
+          Metrician.gauge(Jobs::RUN_METRIC, duration)
+          if Jobs.job_specific?
+            Metrician.gauge("#{Jobs::RUN_METRIC}.job.#{Jobs.instrumentation_name(self.to_s)}", duration)
+          end
+          Metrician.agent.cleanup
+        end
+      end
+
+      def on_failure_with_metrician(_e, *_args)
+        if Jobs.error?
+          Metrician.increment(Jobs::ERROR_METRIC)
+          if Jobs.job_specific?
+            Metrician.increment("#{Jobs::ERROR_METRIC}.job.#{Jobs.instrumentation_name(self.to_s)}")
+          end
+          Metrician.agent.cleanup
+        end
+      end
+
+      ::Resque.before_fork = proc { Metrician.agent.cleanup }
+
+    end
+
+  end
+end

data/lib/metrician/jobs/sidekiq_middleware.rb

@@ -0,0 +1,28 @@
+module Metrician
+  module Jobs
+    class SidekiqMiddleware
+
+      def call(worker, _msg, _queue)
+        start = Time.now
+        yield
+      rescue
+        if Jobs.error?
+          Metrician.increment(Jobs::ERROR_METRIC)
+          if Jobs.job_specific?
+            Metrician.increment("#{Jobs::ERROR_METRIC}.job.#{Jobs.instrumentation_name(worker.class.name)}")
+          end
+        end
+        raise
+      ensure
+        if Jobs.run?
+          duration = Time.now - start
+          Metrician.gauge(Jobs::RUN_METRIC, duration)
+          if Jobs.job_specific?
+            Metrician.gauge("#{Jobs::RUN_METRIC}.job.#{Jobs.instrumentation_name(worker.class.name)}", duration)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/metrician/middleware.rb

@@ -0,0 +1,64 @@
+module Metrician
+  module Middleware
+    ENV_REQUEST_TOTAL_TIME   = "METRICIAN_REQUEST_TOTAL_TIME".freeze
+    ENV_QUEUE_START_KEYS     = ["X-Request-Start".freeze,
+                                "X-Queue-Start".freeze,
+                                "X-REQUEST-START".freeze,
+                                "X_REQUEST_START".freeze,
+                                "HTTP_X_QUEUE_START".freeze]
+    ENV_CONTROLLER_PATH      = "action_controller.instance".freeze
+    ENV_REQUEST_PATH         = "REQUEST_PATH".freeze
+    HEADER_CONTENT_LENGTH    = "Content-Length".freeze
+    ASSET_CONTROLLER_ROUTE   = "assets".freeze
+    UNKNOWN_CONTROLLER_ROUTE = "unknown_endpoint".freeze
+    UNKNOWN_ACTION           = "unknown_action".freeze
+    ASSET_PATH_MATCHER       = %r|\A/{0,2}/assets|.freeze
+    APDEX_SATISFIED_METRIC   = "web.apdex.satisfied".freeze
+    APDEX_TOLERATED_METRIC   = "web.apdex.tolerated".freeze
+    APDEX_FRUSTRATED_METRIC  = "web.apdex.frustrated".freeze
+
+    def self.configuration
+      @configuration ||= Metrician.configuration[:request_timing]
+    end
+
+    def self.enabled?
+      @enabled ||= configuration[:enabled]
+    end
+
+    def self.request_timing_required?
+      request? || apdex?
+    end
+
+    def self.request?
+      @request ||= configuration[:request][:enabled]
+    end
+
+    def self.error?
+      @request ||= configuration[:error][:enabled]
+    end
+
+    def self.idle?
+      @idle ||= configuration[:idle][:enabled]
+    end
+
+    def self.response_size?
+      @response_size ||= configuration[:response_size][:enabled]
+    end
+
+    def self.middleware?
+      @middleware ||= configuration[:middleware][:enabled]
+    end
+
+    def self.queue_time?
+      @queue_time ||= configuration[:queue_time][:enabled]
+    end
+
+    def self.route_tracking?
+      @route_tracking ||= configuration[:route_tracking][:enabled]
+    end
+
+    def self.apdex?
+      @apdex ||= configuration[:apdex][:enabled]
+    end
+  end
+end

data/lib/metrician/middleware/application_timing.rb

@@ -0,0 +1,29 @@
+module Metrician
+  module Middleware
+    # RequestTiming and ApplicationTiming work in concert to time the middleware
+    # separate from the request processing. RequestTiming should be the first
+    # or near first middleware loaded since it will be timing from the moment
+    # the the app server is hit and setting up the env for tracking the
+    # middleware execution time. RequestTiming should be the last or near
+    # last middleware loaded as it times the application execution (separate from
+    # middleware).
+    class ApplicationTiming
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        if Middleware.request_timing_required?
+          start_time = Time.now.to_f
+        end
+        @app.call(env)
+      ensure
+        if Middleware.request_timing_required?
+          env[ENV_REQUEST_TOTAL_TIME] ||= (Time.now.to_f - start_time)
+        end
+      end
+
+    end
+  end
+end

data/lib/metrician/middleware/request_timing.rb

@@ -0,0 +1,152 @@
+module Metrician
+  module Middleware
+    # RequestTiming and ApplicationTiming work in concert to time the middleware
+    # separate from the request processing. RequestTiming should be the first
+    # or near first middleware loaded since it will be timing from the moment
+    # the the app server is hit and setting up the env for tracking the
+    # middleware execution time. RequestTiming should be the last or near
+    # last middleware loaded as it times the application execution (separate from
+    # middleware).
+    class RequestTiming
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        process_start_time = Time.now.to_f
+        response_size = 0
+
+        if Middleware.queue_time?
+          queue_start_time = self.class.extract_request_start_time(env)
+          gauge(:queue_time, process_start_time - queue_start_time) if queue_start_time
+        end
+
+        if Middleware.idle?
+          if @request_end_time
+            gauge(:idle, process_start_time - @request_end_time)
+            @request_end_time = nil
+          end
+        end
+
+        begin
+          status, headers, body = @app.call(env)
+          [status, headers, body]
+        ensure
+          if need_route?
+            current_route = self.class.extract_route(
+              controller: env[ENV_CONTROLLER_PATH],
+              path: env[ENV_REQUEST_PATH]
+            )
+            if Middleware.request_timing_required?
+              request_time = env[ENV_REQUEST_TOTAL_TIME].to_f
+              env[ENV_REQUEST_TOTAL_TIME] = nil
+            end
+            if Middleware.request?
+              gauge(:request, request_time, current_route)
+            end
+            if Middleware.apdex?
+              apdex(request_time)
+            end
+            if Middleware.error?
+              # We to_i the status because in some circumstances it is a
+              # Fixnum and some it is a string. Because why not.
+              increment(:error, current_route) if status.to_i >= 500
+            end
+            if Middleware.response_size?
+              # Note that 30xs don't have content-length, so cached
+              # items will report other metrics but not this one
+              response_size = self.class.get_response_size(headers: headers, body: body)
+              if response_size && !response_size.to_s.strip.empty?
+                gauge(:response_size, response_size.to_i, current_route)
+              end
+            end
+          end
+
+          if Middleware.middleware?
+            middleware_time = (Time.now.to_f - process_start_time) - request_time
+            gauge(:middleware, middleware_time)
+          end
+
+          @request_end_time = Time.now.to_f
+        end
+      end
+
+      def gauge(kind, value, route = nil)
+        Metrician.gauge("web.#{kind}", value)
+        if route && Middleware.route_tracking?
+          Metrician.gauge("web.#{kind}.#{route}", value)
+        end
+      end
+
+      def increment(kind, route = nil)
+        Metrician.increment("web.#{kind}")
+        if route && Middleware.route_tracking?
+          Metrician.increment("web.#{kind}.#{route}")
+        end
+      end
+
+      def need_route?
+        Middleware.request? ||
+          Middleware.error? ||
+          Middleware.response_size?
+      end
+
+      def apdex(request_time)
+        satisfied_threshold = Middleware.configuration[:apdex][:satisfied_threshold]
+        tolerated_threshold = satisfied_threshold * 4
+
+        case
+        when request_time <= satisfied_threshold
+          Metrician.gauge(APDEX_SATISFIED_METRIC, request_time)
+        when request_time <= tolerated_threshold
+          Metrician.gauge(APDEX_TOLERATED_METRIC, request_time)
+        else
+          Metrician.gauge(APDEX_FRUSTRATED_METRIC, request_time)
+        end
+      end
+
+      def self.extract_request_start_time(env)
+        return if no_queue_start_marker?
+        unless queue_start_marker
+          define_queue_start_marker(env)
+        end
+        return if no_queue_start_marker?
+        result = env[queue_start_marker].to_f
+        result > 1_000_000_000 ? result : nil
+      end
+
+      def self.no_queue_start_marker?
+        @no_queue_start_marker
+      end
+
+      def self.queue_start_marker
+        @queue_start_marker
+      end
+
+      def self.define_queue_start_marker(env)
+        @queue_start_marker = ENV_QUEUE_START_KEYS.detect do |key|
+          env.keys.include?(key)
+        end
+        @no_queue_start_marker = @queue_start_marker.nil?
+      end
+
+      def self.extract_route(controller:, path:)
+        unless controller
+          return ASSET_CONTROLLER_ROUTE if path =~ ASSET_PATH_MATCHER
+          return UNKNOWN_CONTROLLER_ROUTE
+        end
+        controller_name = Metrician.dotify(controller.class)
+        action_name     = controller.action_name.blank? ? UNKNOWN_ACTION : controller.action_name
+        method_name     = controller.request.request_method.to_s
+        "#{controller_name}.#{action_name}.#{method_name}".downcase
+      end
+
+      def self.get_response_size(headers:, body:)
+        return headers[HEADER_CONTENT_LENGTH] if headers[HEADER_CONTENT_LENGTH]
+        body.first.length.to_s if body.respond_to?(:length) && body.length == 1
+      end
+
+    end
+  end
+end

data/lib/metrician/reporter.rb

@@ -0,0 +1,41 @@
+require "set"
+
+module Metrician
+  class Reporter
+
+    def self.all
+      reporters.select(&:enabled?).map(&:new)
+    end
+
+    class << self
+
+      attr_reader :reporters
+
+    end
+
+    def self.inherited(subclass)
+      @reporters ||= Set.new
+      @reporters << subclass
+    end
+
+    def self.enabled?
+      false
+    end
+
+    def instrument
+      nil
+    end
+
+  end
+end
+
+require "metrician/reporters/active_record"
+require "metrician/reporters/delayed_job"
+require "metrician/reporters/honeybadger"
+require "metrician/reporters/memcache"
+require "metrician/reporters/method_tracer"
+require "metrician/reporters/middleware"
+require "metrician/reporters/net_http"
+require "metrician/reporters/redis"
+require "metrician/reporters/resque"
+require "metrician/reporters/sidekiq"