fiveruns-dash-ruby 0.7.0

data/lib/fiveruns/dash/host.rb

@@ -0,0 +1,173 @@
+module Fiveruns::Dash
+
+  class Host
+  
+    UNIXES = [:osx, :linux, :solaris]
+    
+    def initialize
+      configure_host
+    end
+  
+    def architecture
+      @architecture
+    end
+  
+    def os_name
+      @os_name
+    end
+  
+    def os_version
+      @os_version
+    end
+  
+    def big_endian?
+      @big_endian
+    end
+
+    def little_endian?
+      !@big_endian
+    end
+
+    def ip_addresses
+      @ip_addresses
+    end
+  
+    def os_name_match?(name)
+      platform == name
+    end
+  
+    def platform
+      execute_on_osx { return :osx }
+      execute_on_windows { return :windows }
+      execute_on_linux { return :linux }
+      execute_on_solaris { return :solaris }
+      :unknown
+    end
+  
+    def execute_on_unix(&block)
+      UNIXES.each do |unix|
+        send "execute_on_#{unix}", &block
+      end
+    end
+
+    def execute_on_osx(&block)
+      block.call if RUBY_PLATFORM =~ /darwin/
+    end
+
+    def execute_on_linux(&block)
+      block.call if RUBY_PLATFORM =~ /linux/
+    end
+
+    def execute_on_solaris(&block)
+      block.call if RUBY_PLATFORM =~ /solaris/
+    end
+  
+    def execute_on_windows(&block)
+      block.call if RUBY_PLATFORM =~ /win32|i386-mingw32/
+    end
+
+    def hostname
+      @hostname
+    end
+  
+    def ip_address
+      address = ip_addresses[0]
+      address ? address[1] : "127.0.0.1"
+    end
+  
+    def mac_address
+      @mac_address
+    end
+
+    def configure_host
+      @hostname ||= `hostname`.strip!
+      @big_endian = ([123].pack("s") == [123].pack("n"))
+      case RUBY_PLATFORM
+      when /darwin|linux/
+        begin # use Sys::Uname library if present
+          require 'sys/uname'
+          @os_name = Sys::Uname.sysname
+          @architecture = Sys::Uname.machine
+          @os_version = Sys::Uname.release 
+        rescue LoadError # otherwise shell out and scrape out the information
+          @os_name = `uname -s`.strip
+          @architecture = `uname -p`.strip
+          @os_version = `uname -r`.strip
+        end
+      when /win32|i386-mingw32/
+        require "dl/win32"
+        getVersionEx = Win32API.new("kernel32", "GetVersionExA", ['P'], 'L')
+    
+        lpVersionInfo = [148, 0, 0, 0, 0].pack("LLLLL") + "�0" * 128 
+        getVersionEx.Call lpVersionInfo
+  
+        dwOSVersionInfoSize, dwMajorVersion, dwMinorVersion, dwBuildNumber, dwPlatformId, szCSDVersion = lpVersionInfo.unpack("LLLLLC128")
+        @os_name = ['Windows 3.1/3.11', 'Windows 95/98', 'Windows NT/XP'][dwPlatformId]
+        @os_version = "#{dwMajorVersion}.#{dwMinorVersion}"
+        @architecture = ENV['PROCESSOR_ARCHITECTURE']
+      end
+
+      @ip_addresses = []
+      begin # use Sys::Host library if present
+        require 'sys/host'
+        Sys::Host.ip_addr.each do |ip|
+          addresses << ip
+        end
+      rescue LoadError # otherwise shell out and scrape out the information
+        execute_on_osx  do
+          ifconfig = `ifconfig`
+          x = 0
+          while true
+            if ifconfig =~ /en#{x}:/
+              x+=1
+            else
+              break
+            end
+          end
+          x.times do |dev|
+            ifconfig = `ifconfig en#{dev}`
+            ifconfig.scan(/ether ([0-9a-f\:]*) /) do |mac_address|
+              @mac_address ||= mac_address[0]
+            end
+            ifconfig.scan(/inet ([0-9\.]*) /) { |ip| @ip_addresses << ["en#{dev}", ip[0]] }
+          end
+        end
+        execute_on_solaris do
+          arp = `/usr/sbin/arp -an`.split("\n")
+          re = /^(\w+).*?(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}).*((([a-f0-9]{2}):){5}[a-f0-9]{2})/
+          arp.find do |line|
+            line =~ re
+          end
+          @ip_addresses << $2
+          @mac_address = $3
+        end
+        execute_on_linux do
+          ifconfig = `/sbin/ifconfig`
+          x = 0
+          while true
+            if ifconfig =~ /eth#{x} /
+              x+=1
+            else
+              break
+            end
+          end
+          x.times do |dev|
+            ifconfig = `/sbin/ifconfig eth#{dev}`
+            ifconfig.scan(/HWaddr ([0-9A-Fa-f\:]*) /) do |mac_address|
+              @mac_address ||= mac_address[0]
+            end
+            ifconfig.scan(/inet addr:([0-9\.]*) /) { |ip| @ip_addresses << ["eth#{dev}", ip[0]] }
+          end
+          @mac_address ||= "#{@hostname}-UNKNOWN-MAC"
+        end
+        execute_on_windows do
+          addrs = Socket.getaddrinfo(Socket.gethostname, 80)
+          addrs.each do |addr|
+            @ip_addresses << ['eth0', addr[3]]
+          end
+        end
+      end
+    end
+  end
+
+end

data/lib/fiveruns/dash/instrument.rb

@@ -0,0 +1,128 @@
+module Fiveruns::Dash
+  
+  module Instrument
+        
+    class Error < ::NameError; end
+
+    def self.handlers
+      @handlers ||= []
+    end
+    
+    # call-seq:
+    #  Instrument.add("ClassName#instance_method", ...) { |instance, time, *args| ... }
+    #  Instrument.add("ClassName::class_method", ...) { |klass, time, *args| ... }
+    #  Instrument.add("ClassName.class_method", ...) { |klass, time, *args| ... }
+    #
+    # Add a handler to be called every time a method is invoked
+    def self.add(*raw_targets, &handler)
+      options = raw_targets.last.is_a?(Hash) ? raw_targets.pop : {}
+      raw_targets.each do |raw_target|
+        begin
+          obj, meth = case raw_target
+          when /^(.+)#(.+)$/
+            [$1.constantize, $2]
+          when /^(.+)(?:\.|::)(.+)$/
+            [(class << $1.constantize; self; end), $2]
+          else
+            raise Error, "Bad target format: #{raw_target}"
+          end
+          instrument(obj, meth, options, &handler)
+        rescue Fiveruns::Dash::Instrument::Error => em
+          raise em
+        rescue => e
+          Fiveruns::Dash.logger.error "Unable to instrument '#{raw_target}': #{e.message}"
+          Fiveruns::Dash.logger.error e.backtrace.join("\n\t")
+        end
+      end
+    end
+
+    def self.reentrant_timing(token, offset, this, args)
+      # token allows us to handle re-entrant timing, see e.g. ar_time
+      Thread.current[token] = 0 if Thread.current[token].nil?
+      Thread.current[token] = Thread.current[token] + 1
+      begin
+        start = Time.now
+        result = yield
+      ensure
+        time = Time.now - start
+        Thread.current[token] = Thread.current[token] - 1
+        if Thread.current[token] == 0
+          ::Fiveruns::Dash::Instrument.handlers[offset].call(this, time, *args)
+        end
+      end
+      result
+    end
+    
+    def self.timing(offset, this, args)
+      start = Time.now
+      begin
+        result = yield
+      ensure
+        time = Time.now - start
+        ::Fiveruns::Dash::Instrument.handlers[offset].call(this, time, *args)
+      end
+      result
+    end
+    
+    #######
+    private
+    #######
+
+    def self.instrument(obj, meth, options = {}, &handler)
+      handlers << handler unless handlers.include?(handler)
+      offset = handlers.size - 1
+      identifier = "instrument_#{handler.hash}"
+      code = wrapping meth, identifier do |without|
+        if options[:exceptions]
+          <<-EXCEPTIONS
+            begin
+              #{without}(*args, &block)
+            rescue Exception => _e
+              _sample = ::Fiveruns::Dash::Instrument.handlers[#{offset}].call(_e, self, *args)
+              ::Fiveruns::Dash.session.add_exception(_e, _sample)
+              raise
+            end
+          EXCEPTIONS
+        elsif options[:reentrant_token]
+          <<-REENTRANT
+            ::Fiveruns::Dash::Instrument.reentrant_timing(:id#{options[:reentrant_token]}, #{offset}, self, args) do
+              #{without}(*args, &block)
+            end
+          REENTRANT
+        else
+          <<-PERFORMANCE
+            ::Fiveruns::Dash::Instrument.timing(#{offset}, self, args) do
+              #{without}(*args, &block)
+            end
+          PERFORMANCE
+        end
+      end
+      obj.module_eval code, __FILE__, __LINE__
+      identifier
+    rescue SyntaxError => e
+      puts "Syntax error (#{e.message})\n#{code}"
+      raise
+    rescue => e
+      raise Error, "Could not attach (#{e.message})"
+    end
+
+    def self.wrapping(meth, feature)
+      format = meth =~ /^(.*?)(\?|!|=)$/ ? "#{$1}_%s_#{feature}#{$2}" : "#{meth}_%s_#{feature}" 
+      <<-DYNAMIC
+        def #{format % :with}(*args, &block)
+          _trace = Thread.current[:trace]
+          if _trace
+            _trace.step do
+              #{yield(format % :without)}
+            end
+          else
+            #{yield(format % :without)}
+          end
+        end
+        alias_method_chain :#{meth}, :#{feature}
+      DYNAMIC
+    end
+      
+  end
+  
+end

data/lib/fiveruns/dash/metric.rb

@@ -0,0 +1,379 @@
+require 'dash/typable'
+
+module Fiveruns::Dash
+          
+  class Metric
+    include Typable
+    
+    attr_reader :name, :description, :help_text, :options
+    attr_accessor :recipe
+    def initialize(name, *args, &block)
+      @@warned = false
+      @name = name.to_s
+      @options = args.extract_options!
+      @description = args.shift || @name.titleize
+      @help_text = args.shift
+      @operation = block
+      @virtual = !!options[:sources]
+      @abstract = options[:abstract]
+      validate!
+    end
+
+    # Indicates that this metric is calculated based on the value(s)
+    # of other metrics.
+    def virtual?
+      @virtual
+    end
+
+    # Indicates that this metric is only used for virtual calculations
+    # and should not be sent to the server for storage.
+    def abstract?
+      @abstract
+    end
+
+    def data
+      return nil if virtual?
+      value_hash.merge(key)
+    end
+    
+    def calculate(real_data)
+      return nil unless virtual?
+
+      datas = options[:sources].map {|met_name| real_data.detect { |hash| hash[:name] == met_name } }.compact
+
+      if datas.size != options[:sources].size && options[:sources].include?('response_time')
+        Fiveruns::Dash.logger.warn(<<-LOG
+          ActiveRecord utilization metrics require a time metric so Dash can calculate a percentage of time spent in the database.
+          Please set the :ar_total_time option when configuring Dash:
+
+          # Define an application-specific metric cooresponding to the total processing time for this app.
+          Fiveruns::Dash.register_recipe :loader, :url => 'http://dash.fiveruns.com' do |recipe|
+            recipe.time :total_time, 'Load Time', :method => 'Loader::Engine#load'
+          end
+
+          # Pass the name of this custom metric to Dash so it will be used in the AR metric calculations.
+          Fiveruns::Dash.configure :app => token, :ar_total_time => 'total_time' do |config|
+            config.add_recipe :activerecord
+            config.add_recipe :loader, :url => 'http://dash.fiveruns.com'
+          end
+        LOG
+        ) unless @@warned
+        @@warned = true
+        return nil
+      else
+        raise ArgumentError, "Could not find one or more of #{options[:sources].inspect} in #{real_data.map { |h| h[:name] }.inspect}" unless datas.size == options[:sources].size
+      end
+
+      combine(datas.map { |hsh| hsh[:values] }).merge(key)
+    end
+
+    def reset
+      # Abstract
+    end
+    
+    def info
+      key
+    end
+    
+    def key
+      @key ||= begin
+        {
+          :name => name,
+          :recipe_url => recipe ? recipe.url : nil,
+          :recipe_name => recipe ? recipe.name.to_s : nil,
+          :data_type => self.class.metric_type, 
+          :description => description, 
+          :help_text => help_text,
+        }.merge(optional_info)
+      end
+    end
+    
+    def ==(other)
+      key == other.key
+    end
+    
+    # Set context finder
+    def find_context_with(&block)
+      @context_finder = block
+    end
+    
+    #######
+    private
+    #######
+    
+    def validate!
+      raise ArgumentError, "#{name} - Virtual metrics should have source metrics" if virtual? && options[:sources].blank?
+      raise ArgumentError, "#{name} - metrics should not have source metrics" if !virtual? && options[:sources]
+    end
+    
+    def optional_info
+      returning({}) do |optional|
+        copy = optional.merge(@options[:unit] ? {:unit => @options[:unit].to_s} : {})
+        copy = copy.merge(@options[:scope] ? {:scope => @options[:scope].to_s} : {})        
+        copy = copy.merge(abstract? ? {:abstract => true} : {})
+        optional.merge!(copy)
+      end
+    end
+
+    def combine(source_values)
+      # Get the intersection of contexts for all the source metrics.
+      # We combine the values for all shared contexts.
+      contexts = source_values.map { |values| values.map { |value| value[:context] }}
+      intersection = nil
+      contexts.each_with_index do |arr, idx|
+        if idx == 0
+          intersection = arr
+        else
+          intersection = intersection & arr
+        end
+      end
+
+      values = intersection.map do |context|
+        args = source_values.map do |values|
+          values.detect { |value| value[:context] == context }[:value]
+        end
+
+        { :value => @operation.call(*args), :context => context }
+      end
+
+      {:values => values}
+    end
+
+    def value_hash
+      current_value = ::Fiveruns::Dash.sync { @operation.call }
+      {:values => parse_value(current_value)}
+    end
+    
+    # Verifies value matches one of the following patterns:
+    # * A numeric value (indicates no namespace)
+    # * A hash of [namespace_kind, namespace_name, ...] => value pairs, eg:
+    #     [:controller, 'FooController', :action, 'bar'] => 12
+    def parse_value(value)
+      case value
+      when Numeric
+        [{:context => [], :value => value}]
+      when Hash
+        value.inject([]) do |all, (key, val)|
+          case key
+          when nil
+            all.push :context => [], :value => val
+          when Array
+            if key.size % 2 == 0
+              all.push :context => key, :value => val
+            else
+              bad_value! "Contexts must have an even number of items"
+            end
+          else
+            bad_value! "Unknown context type"
+          end
+          all
+        end
+      else
+        bad_value! "Unknown value type"
+      end
+    end
+    
+    def bad_value!(message)
+      raise ArgumentError, "Bad data for `#{@name}' #{self.class.metric_type} metric: #{message}"
+    end
+    
+    # Note: only to be used when the +@operation+
+    #       block is used to set contexts
+    def find_containers(*args, &block) #:nodoc:
+      contexts = Array(current_context_for(*args))
+      if contexts.empty? || contexts == [[]]
+        contexts = [[]]
+      elsif contexts.all? { |item| !item.is_a?(Array) }
+        contexts = [contexts]
+      end
+      if Thread.current[:trace]
+        result = yield blank_data[[]]
+        Thread.current[:trace].add_data(self, contexts, result)
+      end
+      contexts.each do |context|
+        with_container_for_context(context, &block)
+      end
+    end
+    
+    # Get the container for this context, allow modifications to it,
+    # and store it
+    # * Note: We sync here when looking up the container, while
+    #         the block is being executed, and when it is stored
+    def with_container_for_context(context)
+      ctx = (context || []).dup # normalize nil context to empty
+      ::Fiveruns::Dash.sync do
+        container = @data[ctx]
+        new_container = yield container
+        #Fiveruns::Dash.logger.info "#{name}/#{context.inspect}/#{new_container.inspect}"
+        @data[ctx] = new_container # For hash defaults
+      end
+    end
+    
+    def context_finder
+      @context_finder ||= begin
+        context_setting = @options[:context] || @options[:contexts]
+        context_setting.is_a?(Proc) ? context_setting : lambda { |*args| Array(context_setting) } 
+      end
+    end
+    
+    # Retrieve the context for the given arguments
+    # * Note: We need to sync here (and wherever the context is modified)
+    def current_context_for(*args)
+      ::Fiveruns::Dash.sync { context_finder.call(*args) }
+    end
+    
+  end
+  
+  class TimeMetric < Metric
+    
+    def initialize(*args)
+      super(*args)
+      reset
+      install_hook
+    end
+    
+    def reset
+      ::Fiveruns::Dash.sync do
+        @data = blank_data
+      end
+    end
+    
+    #######
+    private
+    #######
+    
+    def blank_data
+      Hash.new {{ :invocations => 0, :value => 0 }}
+    end
+    
+    def value_hash
+      returning(:values => current_value) do
+        reset
+      end
+    end
+
+    def install_hook
+      @operation ||= lambda { nil }
+      methods_to_instrument.each do |meth|
+        Instrument.add meth, instrument_options do |obj, time, *args|
+          find_containers(obj, *args) do |container|
+            container[:invocations] += 1
+            container[:value] += time
+            container
+          end
+        end
+      end
+    end
+    
+    def instrument_options
+      returning({}) do |options|
+        options[:reentrant_token] = self.object_id if @options[:reentrant]
+      end
+    end
+
+    def methods_to_instrument
+      @methods_to_instrument ||= Array(@options[:method]) + Array(@options[:methods])
+    end
+    
+    def validate!
+      super
+      raise ArgumentError, "Can not set :unit for `#{@name}' time metric" if @options[:unit]
+      if methods_to_instrument.blank?
+        raise ArgumentError, "Must set :method or :methods option for `#{@name}` time metric"
+      end
+    end
+    
+    # Get the current value
+    # * Note: We sync here (and wherever @data is being written)
+    def current_value
+      ::Fiveruns::Dash.sync do
+        @data.inject([]) do |all, (context, data)|
+          all.push(data.merge(:context => context))
+        end
+      end
+    end
+    
+  end
+      
+  class CounterMetric < Metric
+    
+    def initialize(*args)
+      super(*args)
+      if incrementing_methods.any?
+        reset
+        install_hook
+      end
+    end
+    
+    def value_hash
+      if incrementing_methods.any?
+        returning(:values => current_value) do
+          reset
+        end
+      else
+        super
+      end
+    end
+    
+    def install_hook
+      if incrementing_methods.blank?
+        raise RuntimeError, "Bad configuration for `#{@name}` counter metric"
+      end
+      @operation ||= lambda { nil }
+      incrementing_methods.each do |meth|
+        Instrument.add meth do |obj, time, *args|
+          find_containers(obj, *args) do |container|
+            container += 1
+            container
+          end
+        end
+      end
+    end
+    
+    # Reset the current value
+    # * Note: We sync here (and wherever @data is being written)
+    def reset
+      ::Fiveruns::Dash.sync { @data = blank_data }
+    end
+    
+    def blank_data
+      Hash.new(0)
+    end
+    
+    def incrementing_methods
+      @incrementing_methods ||= Array(@options[:incremented_by])
+    end
+    
+    def validate!
+      super
+      if !@options[:incremented_by]
+        raise ArgumentError, "No block given to capture counter `#{@name}'" unless @operation
+      end
+    end
+    
+    # Get the current value
+    # * Note: We sync here (and wherever @data is being written)
+    def current_value
+      result = ::Fiveruns::Dash.sync do
+        # Ensure the empty context is stored with a default of 0
+        @data[[]] = @data.fetch([], 0)
+        @data
+      end
+      parse_value result
+    end
+    
+  end
+  
+  class PercentageMetric < Metric
+    
+    def validate!
+      super
+      raise ArgumentError, "Can not set :unit for `#{@name}' percentage metric" if @options[:unit]
+    end
+      
+  end
+  
+  class AbsoluteMetric < Metric
+  end
+      
+end