vitals 0.0.2 → 0.3.0

data/lib/vitals/formats/host_last_format.rb

@@ -0,0 +1,26 @@
+module Vitals::Formats
+  class HostLastFormat
+    attr_accessor :environment
+    attr_accessor :host
+    attr_accessor :facility
+
+    def initialize(environment:'development', facility:'default', host:'localhost')
+      @environment = environment
+      @facility = facility
+      @host = host
+      @host =  Vitals::Utils.normalize_metric(host).freeze if @host
+      @prefix = [environment, facility].compact.map{|m| Vitals::Utils.normalize_metric(m) }
+                                       .join(Vitals::Utils::SEPARATOR).freeze
+      @prefix_with_host = [environment, facility, @host].compact.map{|m| Vitals::Utils.normalize_metric(m) }
+                                       .join(Vitals::Utils::SEPARATOR).freeze
+    end
+
+    def format(m)
+      return @prefix_with_host if (m.nil? || m.empty?)
+      # TODO optimize by building a renderer function (inlining this) in the initializer.
+      # see https://github.com/evanphx/benchmark-ips/blob/master/lib/benchmark/ips/job/entry.rb#L63
+      [@prefix, Vitals::Utils.normalize_metric(m), @host].reject{|s| s.nil? || s.empty? }.join(Vitals::Utils::SEPARATOR)
+    end
+  end
+end
+

data/lib/vitals/formats/production_format.rb

@@ -0,0 +1,21 @@
+module Vitals::Formats
+  class ProductionFormat
+    attr_accessor :environment
+    attr_accessor :host
+    attr_accessor :facility
+
+    def initialize(environment:'development', facility:'default', host:'localhost')
+      @environment = environment
+      @facility = facility
+      @host = host
+      @prefix = [environment, host, facility].compact.map{|m| Vitals::Utils.normalize_metric(m) }
+                                             .join(".").freeze
+      # TODO prematerialize working prefix with metric name sanitation
+    end
+
+    def format(m)
+      return @prefix if (m.nil? || m.empty?)
+      "#{@prefix}.#{Vitals::Utils.normalize_metric(m)}"
+    end
+  end
+end

data/lib/vitals/integrations/notifications/action_controller.rb

@@ -0,0 +1,26 @@
+require 'vitals/integrations/notifications/base'
+
+module Vitals::Integrations::Notifications
+  class ActionController < Base
+    def self.event_name
+      'process_action.action_controller'
+    end
+
+    private
+
+    def self.handle(name, started, finished, unique_id, payload)
+      method  = payload[:method].downcase
+      status  = payload[:status]
+      action  = payload[:action]
+      ctrl    = payload[:controller].sub(/Controller$/, '').downcase
+      # format  = payload[:format]
+
+      m = "controllers.#{ctrl}_#{action}_#{method}.#{status}"
+      Vitals.timing("#{m}.all", duration(started, finished))
+      Vitals.timing("#{m}.db", payload[:db_runtime]) if payload[:db_runtime]
+      Vitals.timing("#{m}.view", payload[:view_runtime]) if payload[:view_runtime]
+    end
+
+  end
+end
+

data/lib/vitals/integrations/notifications/active_job.rb

@@ -0,0 +1,18 @@
+require 'vitals/integrations/notifications/base'
+
+module Vitals::Integrations::Notifications
+  # see https://github.com/rails/rails/blob/master/activejob/lib/active_job/logging.rb#L23
+  class ActiveJob < Base
+    def self.event_name
+      'perform.active_job'
+    end
+
+  private
+    def self.handle(name, started, finished, unique_id, payload)
+      job  = payload[:job]
+      name = job.class.name.sub(/Job$/, '').sub(/Worker$/,'').downcase
+
+      Vitals.timing("jobs.#{job.queue_name}.#{name}", duration(started, finished))
+    end
+  end
+end

data/lib/vitals/integrations/notifications/base.rb

@@ -0,0 +1,20 @@
+require 'active_support'
+
+module Vitals::Integrations::Notifications
+  class Base
+    def self.subscribe!
+      subscriber = ActiveSupport::Notifications.subscribe(event_name, &method(:handle))
+
+      subscriber
+    end
+
+    def self.handle
+      raise "#handle not implemented"
+    end
+
+    def self.duration(started, finished)
+      Vitals::Utils.sec_to_ms(finished - started)
+    end
+  end
+end
+

data/lib/vitals/integrations/notifications/grape.rb

@@ -0,0 +1,30 @@
+require 'vitals/integrations/notifications/base'
+
+module Vitals::Integrations::Notifications
+  class Grape < Base
+    def self.event_name
+      'endpoint_run.grape'
+    end
+
+    private
+
+    def self.handle(name, started, finished, unique_id, payload)
+      endpoint = payload[:endpoint]
+      route    = endpoint.route
+      version  = route.route_version
+      method   = route.route_method.downcase
+
+      path = route.route_path.dup
+      path.sub!(/\(\..*\)$/, '')
+      path.sub!(":version", version) if version
+      path.gsub!(/\//, ".")
+
+      # TODO move 'grape' to configuration opts in subscribe!(opts)
+      m = "grape#{path}_#{method}.#{endpoint.status}.all"
+      Vitals.timing(m, duration(started, finished))
+    end
+
+  end
+end
+
+

data/lib/vitals/integrations/rack/requests.rb

@@ -0,0 +1,23 @@
+
+module Vitals::Integrations::Rack
+  class Requests
+    REQUEST_METHOD = 'REQUEST_METHOD'.freeze
+    PATH_INFO = 'PATH_INFO'.freeze
+
+    def initialize(app, options = {})
+      @app = app
+    end
+
+    def call(env)
+      start = Time.now
+      status, header, body = @app.call(env)
+
+      # TODO add option to customize 'requests' through options
+      m = "requests.#{env[PATH_INFO]}.#{env[REQUEST_METHOD].downcase}.#{status}"
+      Vitals.timing(m, Vitals::Utils.sec_to_ms(Time.now - start))
+
+      [status, header, body]
+    end
+  end
+end
+

data/lib/vitals/reporters/base_reporter.rb

@@ -0,0 +1,9 @@
+module Vitals::Reporters
+  class BaseReporter
+    def time(m)
+      start = Time.now
+      yield
+      timing(m, Vitals::Utils::sec_to_ms(Time.now - start))
+    end
+  end
+end

data/lib/vitals/reporters/console_reporter.rb

@@ -0,0 +1,23 @@
+module Vitals::Reporters
+  class ConsoleReporter < BaseReporter
+    attr_accessor :format
+
+    def initialize(category:'main', format:nil)
+      @format = format
+      @category = category
+    end
+
+    def inc(m)
+      puts "#{@category} INC #{self.format.format(m)}"
+    end
+
+    def gauge(m, v)
+      puts "#{@category} GAUGE #{self.format.format(m)} #{v}"
+    end
+
+    def timing(m, v)
+      puts "#{@category} TIME #{self.format.format(m)} #{v}"
+    end
+  end
+end
+

data/lib/vitals/reporters/inmem_reporter.rb

@@ -0,0 +1,31 @@
+module Vitals::Reporters
+  class InmemReporter < BaseReporter
+    attr_accessor :reports
+    attr_accessor :format
+
+    def initialize
+      flush
+    end
+
+    def flush
+      @reports = []
+    end
+
+    def inc(m)
+      @reports << { :inc => n( m ) }
+    end
+
+    def gauge(m, v)
+      @reports << { :gauge => n( m ), :val => v }
+    end
+
+    def timing(m, v)
+      @reports << { :timing => n( m ), :val => v }
+    end
+
+  private
+    def n(m)
+      Vitals::Utils.normalize_metric(m)
+    end
+  end
+end

data/lib/vitals/reporters/multi_reporter.rb

@@ -0,0 +1,24 @@
+module Vitals::Reporters
+  class MultiReporter < BaseReporter
+    attr_accessor :format
+
+    def initialize(format:nil, reporters:[])
+      @format = format
+      @reporters = reporters
+    end
+
+    def inc(m)
+      @reporters.each{|r| r.inc(m) }
+    end
+
+    def gauge(m, v)
+      @reporters.each{|r| r.gauge(m, v) }
+    end
+
+    def timing(m, v)
+      @reporters.each{|r| r.timing(m, v) }
+    end
+  end
+end
+
+

data/lib/vitals/reporters/statsd_reporter.rb

@@ -0,0 +1,27 @@
+require 'statsd-ruby'
+
+module Vitals::Reporters
+  class StatsdReporter < BaseReporter
+    attr_accessor :format
+    attr_accessor :statsd
+
+    def initialize(host:'localhost', port:8125, format:nil)
+      @statsd = Statsd.new(host, port)
+      @format = format
+    end
+
+    def inc(m)
+      @statsd.increment(format.format(m))
+    end
+
+    def gauge(m, v)
+      @statsd.gauge(format.format(m), v)
+    end
+
+    def timing(m, v)
+      @statsd.timing(format.format(m), v)
+    end
+  end
+end
+
+

data/lib/vitals/utils.rb

@@ -0,0 +1,15 @@
+module Vitals
+  module Utils
+    BAD_METRICS_CHARS = Regexp.compile('[\/\-:\s]').freeze
+    SEPARATOR = '.'.freeze
+    def self.normalize_metric(m)
+      m.gsub(BAD_METRICS_CHARS, '_')
+    end
+    def self.hostname
+      `hostname -s`.chomp
+    end
+    def self.sec_to_ms(sec)
+      (1000.0 * sec).round
+    end
+  end
+end

data/lib/vitals/version.rb

@@ -1,3 +1,3 @@
 module Vitals
-  VERSION = "0.0.2"
+  VERSION = "0.3.0"
 end

data/lib/vitals.rb

@@ -1,33 +1,56 @@
-require 'active_support/notifications'
-require 'vitals/reporter'
+require "vitals/version"
+module Vitals
+  module Formats;end
+  module Reporters;end
+  module Integrations
+    module Notifications;end
+  end
+end
+
+require 'vitals/configuration'
+require 'vitals/utils'
+
+require 'vitals/reporters/base_reporter'
+require 'vitals/reporters/inmem_reporter'
+require 'vitals/reporters/console_reporter'
+require 'vitals/reporters/multi_reporter'
+require 'vitals/reporters/statsd_reporter'
+
+require 'vitals/formats/production_format'
+require 'vitals/formats/host_last_format'
+
 
 module Vitals
-  class Engine < Rails::Engine
-    config.vitals = ActiveSupport::OrderedOptions.new
-
-    config.vitals.enabled = true
-    config.vitals.host = 'localhost'
-    config.vitals.port = 8125
-
-    initializer "vitals.configure" do |app|
-      Vitals.configure(app.config.vitals.host, app.config.vitals.port) if app.config.vitals.enabled
-    end
-
-    initializer "vitals.subscribe" do |app|
-      ActiveSupport::Notifications.subscribe /[^!]$/ do |*args|
-        Vitals.report! args 
-      end
-    end
+  def self.configure!
+    @config = Configuration.new
+    yield(@config) if block_given?
+    @reporter = @config.reporter
+    @reporter.format = @config.build_format
   end
 
+  def self.reporter=(r)
+    @reporter = r
+  end
 
-  @reporter = NullReporter.new
+  def self.reporter
+    @reporter
+  end
+
+  #
+  # reporter delegators
+  #
+  # hardwired for performance
+  # 
+  # TODO timing
+  def self.inc(m)
+    reporter.inc(m)
+  end
 
-  def self.report!(args)
-    @reporter.report!(args)
+  def self.timing(m, val)
+    reporter.timing(m, val)
   end
 
-  def self.configure(host, port)
-    @reporter = Reporter.new(host, port)
+  def self.gauge(m, val)
+    reporter.gauge(m, val)
   end
 end

data/vitals.gemspec

@@ -0,0 +1,48 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'vitals/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "vitals"
+  spec.version       = Vitals::VERSION
+  spec.authors       = ["Dotan Nahum"]
+  spec.email         = ["jondotan@gmail.com"]
+
+  spec.summary       = %q{Flexible StatsD instrumentation for Rails, Rack, Grape and more}
+  spec.description   = %q{Flexible StatsD instrumentation for Rails, Rack, Grape and more}
+  spec.homepage      = "https://github.com/jondot/vitals"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|multiverse)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "statsd-ruby", "~> 1.3.0"
+
+  spec.add_development_dependency "guard-rubocop", "~> 1.2.0"
+  spec.add_development_dependency "guard-minitest", "~> 2.4.4"
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "rack-test", "~> 0.6.3"
+  spec.add_development_dependency "rr", "~> 1.1.2"
+  spec.add_development_dependency "benchmark-ips", "~> 2.5.0"
+  spec.add_development_dependency "memory_profiler", "~> 0.9.6"
+
+  spec.add_development_dependency "coveralls", "~> 0.8.13"
+  # integrations
+  # TODO we should test these under isolated environment while removing
+  # these from here and running without bundler, inside docker, or by
+  # doing what newrelic does - which is hooking into bundler and Gemfile so that
+  # we simulate different bundler environment, so,
+  # we should test many versions of rails, grape, and so on with the same
+  # set of integration tests
+  # for now, we keep latest versions
+  spec.add_development_dependency "grape", "~> 0.15.0"
+  spec.add_development_dependency "activesupport", "~> 4.2.6"
+  spec.add_development_dependency "sinatra", "~> 1.4.7"
+
+
+end