fiveruns-dash-ruby 0.7.0

data/lib/fiveruns/dash/recipe.rb

@@ -0,0 +1,63 @@
+module Fiveruns::Dash
+  
+  class Recipe
+    
+    class ConfigurationError < ::ArgumentError; end
+    
+    def self.scope_stack
+      @scope_stack ||= []
+    end
+    
+    def self.current
+      scope_stack.last
+    end
+    
+    def self.in_scope(recipe)
+      scope_stack << recipe
+      yield
+      scope_stack.pop
+    end
+    
+    attr_reader :name, :url, :options
+    def initialize(name, options = {}, &block)
+      @name = name
+      @options = options
+      @url = options[:url]
+      @block = block
+      validate!
+    end
+    
+    def add_to(configuration)
+      self.class.in_scope self do
+        @block.call(configuration)
+      end
+    end
+    
+    def matches?(criteria)
+      criteria.all? { |k, v| options[k] == v }
+    end
+    
+    def ==(other)
+      name == other.name && other.options == options
+    end
+    
+    def info
+      {
+        :name => name.to_s,
+        :url => url.to_s
+      }
+    end
+        
+    #######
+    private
+    #######
+
+    def validate!
+      unless @url
+        raise ConfigurationError, "Recipe requires :url option"
+      end
+    end
+    
+  end
+  
+end

data/lib/fiveruns/dash/reporter.rb

@@ -0,0 +1,208 @@
+require 'thread'
+
+module Fiveruns::Dash
+
+  class ShutdownSignal < ::Exception; end
+    
+  class Reporter
+    
+    attr_accessor :interval
+    attr_reader :started_at
+    def initialize(session, interval = 60.seconds.to_i)
+      @session = session
+      @interval = interval
+    end
+    
+    def revive!
+      return if !started? || foreground?
+      start if !@thread || !@thread.alive?
+    end
+    
+    def alive?
+      @thread && @thread.alive? && started?
+    end
+
+    def start(run_in_background = true)
+      restarted = @started_at ? true : false
+      unless defined?(@started_at)
+        @started_at = ::Fiveruns::Dash::START_TIME
+      end
+      setup_for run_in_background
+      if @background
+        @thread = Thread.new { run(restarted) }
+      else
+        # Will it be run in foreground?
+        run(restarted)
+      end
+    end
+    
+    def started?
+      @started_at
+    end
+    
+    def foreground?
+      started? && !@background
+    end
+    
+    def background?
+      started? && @background
+    end
+    
+    def send_trace(trace)
+      if trace.data
+        payload = TracePayload.new(trace)
+        Fiveruns::Dash.logger.debug "Sending trace: #{payload.to_json}"
+        Thread.new { Update.new(payload).store(*update_locations) }
+      else
+        Fiveruns::Dash.logger.debug "No trace to send"      
+      end
+    end
+    
+    def ping
+      payload = PingPayload.new(@session.info, @started_at)
+      Update.new(payload).ping(*update_locations)
+    end
+
+    def stop
+      @thread && @thread.alive? && @thread.raise(ShutdownSignal.new)
+    end
+
+    #######
+    private
+    #######
+
+    TRAPS = {}
+
+    def install_signals
+      %w(INT TERM).each do |sym|
+        TRAPS[sym] = Signal.trap(sym) do
+          stop
+          TRAPS[sym].call if TRAPS[sym]
+        end
+      end
+    end
+
+    def run(restarted)
+      Fiveruns::Dash.logger.info "Starting reporter thread; endpoints are #{update_locations.inspect}"
+
+      install_signals
+      error_barrier do
+        total_time = 0
+        loop do
+          # account for the amount of time it took to upload, and adjust the sleep time accordingly
+          total_time += time_for { send_info_update }
+          rest(@interval - total_time)
+          total_time = 0
+          total_time += time_for do
+            send_data_update
+            send_exceptions_update
+          end
+        end
+      end
+    end
+
+    def error_barrier
+      begin
+        yield
+      rescue Fiveruns::Dash::ShutdownSignal => me
+        return
+      rescue Exception => e
+        Fiveruns::Dash.logger.error "#{e.class.name}: #{e.message}"
+        Fiveruns::Dash.logger.error e.backtrace.join("\n\t")
+        retry
+      end
+    end
+
+    def rest(amount)
+      amount > 0 ? sleep(amount) : nil
+    end
+
+    def time_for(&block)
+      a = Time.now
+      block.call
+      Time.now - a
+    end
+
+    def setup_for(run_in_background = true)
+      @background = run_in_background
+    end
+    
+    def send_info_update
+      @info_update_sent ||= begin
+        payload = InfoPayload.new(@session.info, @started_at)
+        Fiveruns::Dash.logger.debug "Sending info: #{payload.to_json}"
+        result = Update.new(payload).store(*update_locations)
+        send_fake_info(payload)
+        result
+      end
+    end
+    
+    def send_exceptions_update
+      if @info_update_sent
+        data = @session.exception_data
+        if data.empty?
+          Fiveruns::Dash.logger.debug "No exceptions for this interval"
+        else
+          payload = ExceptionsPayload.new(data)
+          Fiveruns::Dash.logger.debug "Sending exceptions: #{payload.to_json}"
+          Update.new(payload).store(*update_locations)
+        end        
+      else
+        # Discard data
+        @session.reset
+        Fiveruns::Dash.logger.warn "Discarding interval exceptions"
+      end
+    end
+    
+    def send_data_update
+      if @info_update_sent
+        data = @session.data
+        payload = DataPayload.new(data)
+        Fiveruns::Dash.logger.debug "Sending data: #{payload.to_json}"
+        result = Update.new(payload).store(*update_locations)
+        send_fake_data(payload)
+        result
+      else
+        # Discard data
+        @session.reset
+        Fiveruns::Dash.logger.warn "Discarding interval data"
+      end
+    end
+    
+    def update_locations
+      @update_locations ||= if ENV['DASH_UPDATE']
+        ENV['DASH_UPDATE'].strip.split(/\s*,\s*/)
+      else
+        default_update_locations
+      end
+    end
+
+    def send_fake_data(payload)
+      fake_host_count.times do |idx|
+        payload.params[:process_id] = Fiveruns::Dash.process_ids[idx+1]
+        Fiveruns::Dash.logger.debug "Sending data: #{payload.to_json}"
+        Update.new(payload).store(*update_locations)
+      end
+    end
+
+    def send_fake_info(payload)
+      host = payload.params[:hostname]
+      fake_host_count.times do |idx|
+        payload.params[:mac] += idx.to_s
+        payload.params[:hostname] = host + idx.to_s
+        Fiveruns::Dash.logger.debug "Sending info: #{payload.to_json}"
+        Update.new(payload).store(*update_locations)
+      end
+    end
+
+    def fake_host_count
+      ENV['DASH_FAKE_HOST_COUNT'].to_i
+    end
+    
+    def default_update_locations
+      %w(https://dash-collector.fiveruns.com https://dash-collector02.fiveruns.com)
+    end
+
+  end
+      
+end

data/lib/fiveruns/dash/scm.rb

@@ -0,0 +1,126 @@
+require 'date'
+module Fiveruns::Dash
+  class SCM
+    include Typable
+    
+    def self.matching(startpath)
+      scm_hash = {}
+      types.each do |name, klass|
+        if path = locate_upwards(startpath, ".#{name}")
+          Fiveruns::Dash.logger.info "SCM: Found #{name} in #{path}"
+          scm_hash[path] = klass
+        end
+      end
+      winning_path = best_match(scm_hash.keys)
+      return nil if winning_path.nil?
+      Fiveruns::Dash.logger.info "SCM: Using #{scm_hash[winning_path].name} in #{winning_path}" 
+      begin
+        scm_hash[winning_path].new(winning_path)
+      rescue Exception => e
+        Fiveruns::Dash.logger.warn "WARNING: #{e.message}"
+        nil
+      end
+    end
+    
+    def self.best_match( scm_paths )
+      scm_paths.max{|a,b| a.split("/").length <=> b.split("/").length}
+    end
+    
+    def initialize(path)
+      @path = path
+      require_binding
+    end
+    
+    def time
+      raise NotImplementedError, 'Abstract'
+    end
+    
+    def revision
+      raise NotImplementedError, 'Abstract'
+    end
+    
+    #######
+    private
+    #######
+    
+    def self.locate_upwards(startpath, target)
+      return nil unless startpath
+      startpath = File.expand_path(startpath)
+      return startpath if File.exist?(File.join( startpath, target ))
+      return locate_upwards( File.dirname(startpath), target) unless File.dirname(startpath) == startpath
+      nil
+    end
+
+    def require_binding
+    end
+    
+  end
+  
+  class GitSCM < SCM
+    
+    def revision
+      commit.sha
+    end
+    
+    def time
+      commit.date
+    end
+    
+    def url
+      @url ||= begin
+        origin = repo.remotes.detect { |r| r.name == 'origin' }
+        origin.url if origin
+      end
+    end
+    
+    #######
+    private
+    #######
+    
+    def commit
+      @commit ||= repo.object('HEAD')
+    end
+    
+    def repo
+      @repo ||= Git.open(@path)
+    end
+
+    def require_binding
+      require 'git'
+    rescue LoadError
+      raise LoadError, "Dash deployment tracking for Git apps requires the 'git' gem"
+    end
+    
+  end
+
+  class SvnSCM < SCM
+    
+    def revision
+        @yaml['Last Changed Rev'] || @yaml['Revision']
+    end
+    
+    def time
+      datestring = @yaml['Last Changed Date']
+      datestring.nil? ? nil : DateTime.parse(datestring.split("(").first.strip)
+    end
+    
+    def url
+      @url ||= @yaml['URL']
+    end
+    
+    #######
+    private
+    #######
+    
+    def require_binding
+      @yaml = YAML.load(svn_info)
+      @yaml = {} unless Hash === @yaml
+    end
+
+    def svn_info
+      `svn info #{@path}`
+    end
+    
+  end
+  
+end

data/lib/fiveruns/dash/session.rb

@@ -0,0 +1,81 @@
+module Fiveruns::Dash
+    
+  class Session
+    
+    attr_reader :configuration, :reporter
+    def initialize(configuration)
+      @configuration = configuration
+      # eager create the host data in the main thread
+      # as it is dangerous to load in the reporter thread
+      Fiveruns::Dash.host
+    end
+    
+    def start(background = true, &block)
+      reporter.start(background, &block)
+    end
+    
+    def exceptions
+      @exceptions ||= []
+    end
+    
+    # Trace and send metric collection
+    def trace(name)
+      Thread.current[:trace] = ::Fiveruns::Dash::Trace.new(name)
+      result = yield
+      reporter.send_trace(Thread.current[:trace])
+      Thread.current[:trace] = nil
+      result
+    end
+    
+    def add_exception(exception, sample=nil)
+      exception_recorder.record(exception, sample)
+    end
+    
+    def info
+      {
+        :recipes => recipe_metadata,
+        :metric_infos => metric_metadata
+      }
+    end
+    
+    def recipe_metadata
+      configuration.recipes.inject([]) do |recipes, recipe|
+        recipes << recipe.info
+      end
+    end
+    
+    def metric_metadata
+      configuration.metrics.inject([]) do |metrics, metric|
+        metrics << metric.info
+      end
+    end
+    
+    def reset
+      exception_recorder.reset
+      configuration.metrics.each(&:reset)
+    end
+    
+    def data
+      real_data = configuration.metrics.map { |metric| metric.data }.compact
+      virtual_data = configuration.metrics.map { |metric| metric.calculate(real_data) }.compact
+      # Return any metrics which are not abstract and should be sent to the server
+      metric_payload = (real_data + virtual_data).find_all { |data| !data[:abstract] }
+      #puts "Sending #{metric_payload.map { |met| [met[:name], met[:values].size] }.inspect} metrics"
+      metric_payload
+    end
+
+    def exception_data
+      exception_recorder.data
+    end
+
+    def exception_recorder
+      @exception_recorder ||= ExceptionRecorder.new(self)
+    end
+    
+    def reporter
+      @reporter ||= Reporter.new(self)
+    end
+    
+  end
+      
+end