fiveruns-dash-ruby 0.7.0

data/lib/fiveruns/dash/store/file.rb

@@ -0,0 +1,24 @@
+module Fiveruns::Dash::Store
+  
+  module File
+    
+    def store_file(*uris)
+      uris.each do |uri|
+        directory = uri.path
+        write_to filename(directory)
+      end
+    end
+    
+    def write_to(path)
+      ::File.open(path, 'w') { |f| f.write @payload.to_json }
+    end
+    
+    def filename(directory)
+      kind = payload.class.name =~ /(\w+)Payload/
+      name = kind ? $1 : 'unknown'
+      ::File.join(directory, "#{guid}.#{name}.json")
+    end
+    
+  end
+  
+end

data/lib/fiveruns/dash/store/http.rb

@@ -0,0 +1,198 @@
+require 'net/https'
+#require 'resolv'
+require 'ostruct'
+
+if defined?(Socket)
+  Socket.do_not_reverse_lookup=true
+end
+
+module Fiveruns::Dash::Store
+  
+  module HTTP
+    
+    def resolved_hostnames
+      Thread.current[:resolved_hostnames] ||= {}
+      Thread.current[:resolved_hostnames]
+    end
+    
+    def resolved_hostname(hostname)
+      if resolved_hostnames[hostname] && Time.now < resolved_hostnames[hostname].next_update
+        ip = resolved_hostnames[hostname].ip
+      else
+        ip = hostname == 'localhost' ? '127.0.0.1' : IPSocket.getaddress(hostname)
+        ip_struct = OpenStruct.new(:ip => ip, :next_update => Time.now + 23.hours + rand(60).minutes)
+        resolved_hostnames[hostname] = ip_struct
+      end
+      ip
+    end
+      
+    
+    def store_http(*uris)
+      Fiveruns::Dash.logger.info "Attempting to send #{payload.class}"
+      if (uri = uris.detect { |u| transmit_to(add_path_to(u)) })
+        Fiveruns::Dash.logger.info "Sent #{payload.class} to #{uri}"
+        uri
+      else
+        Fiveruns::Dash.logger.warn "Could not send #{payload.class}"
+        false
+      end
+    end
+
+    def transmit_to(uri)
+      response = nil
+      safely do
+        http = Net::HTTP.new(resolved_hostname(uri.host), uri.port)
+        http.use_ssl = true if uri.scheme == 'https'
+        http.open_timeout = 10
+        http.read_timeout = 10
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        extra_params = extra_params_for(payload)
+        multipart = Multipart.new(payload.io, payload.params.merge(extra_params))
+        response = http.post(uri.request_uri, multipart.to_s, "Content-Type" => multipart.content_type, "Host" => uri.host) 
+      end
+      check_response_of response
+    end
+
+    def safely
+      yield
+    rescue Exception => e
+      Fiveruns::Dash.logger.error "Could not access Dash service: #{e.message}"
+      Fiveruns::Dash.logger.error e.backtrace.join("\n\t")
+      false
+    end
+    
+    def check_response_of(response)
+      unless response
+        Fiveruns::Dash.logger.debug "Received no response from Dash service"
+        return false
+      end
+      case response.code.to_i
+      when 201
+        data = JSON.load(response.body)
+        set_trace_contexts(data)
+        true
+      when 400..499
+        Fiveruns::Dash.logger.warn "Could not access Dash service (#{response.code.to_i}, #{response.body.inspect})"
+        false
+      else
+        Fiveruns::Dash.logger.debug "Received unknown response from Dash service (#{response.inspect})"
+        false
+      end
+    rescue JSON::ParserError => e
+      puts response.body
+      Fiveruns::Dash.logger.error "Received non-JSON response (#{response.inspect})"
+      false
+    end
+    
+    def set_trace_contexts(data)
+      trace_contexts = data['traces']
+      if trace_contexts.is_a?(Array)
+        Fiveruns::Dash.trace_contexts = trace_contexts
+      end
+    end
+    
+    def add_path_to(uri)
+      returning uri.dup do |new_uri|
+        path = case payload
+        when Fiveruns::Dash::PingPayload
+          ::File.join('/apps', app_token, "ping")
+        when Fiveruns::Dash::InfoPayload
+          ::File.join('/apps', app_token, "processes.json")
+        when Fiveruns::Dash::DataPayload
+          ::File.join('/apps', app_token, "metrics.json")
+        when Fiveruns::Dash::TracePayload
+          ::File.join('/apps', app_token, "traces.json")
+        when Fiveruns::Dash::ExceptionsPayload
+          ::File.join('/apps', app_token, "exceptions.json")
+        else
+          raise ArgumentError, 'Unknown payload type: #{payload.class}'
+        end
+        new_uri.path = path
+      end
+    end
+    
+    def extra_params_for(payload)
+      case payload
+      when Fiveruns::Dash::ExceptionsPayload
+        {:app_id => app_token}
+      else
+        Hash.new
+      end
+    end
+    
+    def normalize_key(key)
+      key.to_a.flatten.map(&:to_s).sort
+    end
+    
+    def app_token
+      ::Fiveruns::Dash.configuration.options[:app]
+    end
+
+    class Multipart
+
+      BOUNDARY_ROOT = 'B0UND~F0R~UPL0AD'
+
+      attr_reader :file, :params
+      def initialize(file, params={})
+        @file = file
+        @params = params
+      end
+
+      def content_type
+        %(multipart/form-data, boundary="#{boundary}")
+      end
+
+      def to_s
+        %(#{parts}\r\n#{separator}--)
+      end
+
+      #######
+      private
+      #######
+
+      def boundary
+        "#{BOUNDARY_ROOT}*#{nonce}"
+      end
+
+      def parts
+        params.merge(:file => file).map do |name, value|
+          [
+            separator,
+            headers_for(name, value)
+          ].flatten.join(crlf) + crlf + crlf + content_of(value)
+        end.flatten.join(crlf)
+      end
+
+      def separator
+        %(--#{boundary})
+      end
+
+      def crlf
+        @crlf ||= "\r\n"
+      end
+
+      def headers_for(name, value)
+        if value.respond_to?(:read)
+          [
+            %(Content-Disposition: form-data; name="#{name}"; filename="metrics.json.gz"),
+            %(Content-Transfer-Encoding: binary),
+            %(Content-Type: application/octet-stream)
+          ]
+        else
+          [ %(Content-Disposition: form-data; name="#{name}") ]
+        end
+      end
+
+      def nonce
+        @nonce ||= (Time.now.utc.to_f * 1000).to_i
+      end
+
+      def content_of(value)
+        value.respond_to?(:read) ? value.read : value.to_s
+      end
+
+    end
+
+  end
+
+end

data/lib/fiveruns/dash/threads.rb

@@ -0,0 +1,24 @@
+require 'thread'
+
+module Fiveruns::Dash
+  
+  module Threads
+    
+    def self.included(base)
+      base.extend ClassMethods
+    end
+    
+    module ClassMethods
+      
+      def monitor
+        @monitor ||= Monitor.new
+      end
+      
+      def sync(&block)
+        monitor.synchronize(&block)
+      end
+    end
+    
+  end
+  
+end

data/lib/fiveruns/dash/trace.rb

@@ -0,0 +1,65 @@
+module Fiveruns::Dash
+  
+  class Trace
+    
+    attr_reader :context, :data, :stack
+    def initialize(context)
+      @context = context
+      @stack = []
+      validate!
+    end
+    
+    def step(&block)
+      s = Step.new
+      @stack.last.children << s if !@stack.empty?
+      @stack << s
+      result = yield
+      last_step = @stack.pop
+      @data = last_step if @stack.empty?
+      result
+    end
+        
+    def add_data(metric, contexts, value)
+      unless @stack.empty?
+        @stack.last.metrics.push(
+          metric.key.merge({:value => value, :contexts => contexts})
+        )
+      end
+    end
+        
+    def to_json
+      { :context => context,
+        :data => (@data || {})
+      }.to_json
+    end
+    
+    private
+    
+    def validate!
+      unless @context.is_a?(Array) && @context.size % 2 == 0
+        raise ArgumentError, 'Invalid context: #{@context.inspect} (must be an array with an even number of elements)'
+      end
+    end
+    
+    class Step
+                  
+      def metrics
+        @metrics ||= []
+      end
+      
+      def children
+        @children ||= []
+      end
+            
+      def to_json
+        {
+          :metrics => metrics,
+          :children => children,
+        }.to_json
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/fiveruns/dash/typable.rb

@@ -0,0 +1,29 @@
+module Fiveruns::Dash
+  
+  module Typable
+    
+    def self.included(base)
+      name = base.name.demodulize.underscore
+      base.class_eval %{
+        def self.#{name}_type
+          @#{name}_type ||= name.demodulize.underscore.sub(/_#{name}$/, '').to_sym
+        end
+      }
+      base.extend ClassMethods
+    end
+    
+    module ClassMethods
+      
+      def inherited(klass)
+        types[klass.__send__("#{name.demodulize.underscore}_type")] = klass
+      end
+
+      def types
+        @types ||= {}
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/fiveruns/dash/update.rb

@@ -0,0 +1,215 @@
+require 'zlib'
+
+require 'dash/store/http'
+require 'dash/store/file'
+
+module Fiveruns::Dash
+
+  class Pinger
+
+    attr_reader :payload
+    def initialize(payload)
+      @payload = payload
+    end
+
+    def ping(*urls)
+      try_urls(urls) do |url|
+        send_ping(url, payload)
+      end
+    end
+
+    def send_ping(url, payload)
+      begin
+        http = Net::HTTP.new(url.host, url.port)
+        http.use_ssl = true if url.scheme == 'https'
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        multipart = Fiveruns::Dash::Store::HTTP::Multipart.new(payload.io, payload.params)
+        response = http.post("/apps/#{token}/ping", multipart.to_s, "Content-Type" => multipart.content_type)
+        case response.code.to_i
+        when 201
+          data = JSON.load(response.body)
+          [:success, "Found application '#{data['name']}'"]
+        else
+          # Error message
+          [:failed, response.body.to_s]
+        end
+      rescue => e
+        [:error, e.message]
+      end
+    end
+
+    def token
+      ::Fiveruns::Dash.configuration.options[:app]
+    end
+
+    def try_urls(urls)
+      results = urls.map do |u|
+        result = yield(URI.parse(u))
+        case result[0]
+        when :success
+          puts "OK: #{result[1]}"
+          true
+        when :failed
+          puts "Failed talking to #{u}: #{result[1]}"
+          false
+        when :error
+          puts "Error contacting #{u}: #{result[1]}"
+          false
+        end
+      end
+      results.all?
+    end
+  end
+
+  class Update
+
+    include Store::HTTP
+    include Store::File
+
+    attr_reader :payload, :handler
+    def initialize(payload, &handler)
+      @payload = payload
+      @handler = handler
+    end
+    
+    def store(*urls)
+      uris_by_scheme(urls).each do |scheme, uris|
+        value = __send__("store_#{storage_method_for(scheme)}", *uris)
+        return value if value
+      end
+      return false
+    end
+    
+    def ping(*urls)
+      Pinger.new(payload).ping(*urls)
+    end
+
+    def guid
+      @guid ||= timestamp << "_#{Process.pid}"
+    end
+    
+    #######
+    private
+    #######
+    
+    def timestamp
+      Time.now.utc.strftime('%Y%m%d%H%M%S')
+    end
+    
+    def uris_by_scheme(urls)
+      urls.map { |url| safe_parse(url) }.group_by(&:scheme)
+    end
+    
+    def storage_method_for(scheme)
+      scheme =~ /^http/ ? :http : :file
+    end
+    
+    def safe_parse(url)
+      url.respond_to?(:scheme) ? url : URI.parse(url)
+    end
+    
+  end
+
+  class Payload
+        
+    def initialize(data)
+      @version = Fiveruns::Dash::Version::STRING
+      @data = data
+    end
+
+    def io
+      returning StringIO.new do |io|
+        io.write compressed
+        io.rewind
+      end
+    end
+    
+    def params
+      {}
+    end
+    
+    def to_json
+      @data.to_json
+    end
+    
+    #######
+    private
+    #######
+    
+    def timestamp
+      Time.now.utc.rfc2822
+    end
+
+    def compressed
+      Zlib::Deflate.deflate(to_json)
+    end
+
+  end
+  
+  class InfoPayload < Payload
+    def initialize(data, started_at)
+      super(data)
+      @started_at = started_at
+    end
+    def params
+      @params ||= begin
+        params = {
+          :type => 'info',
+          :ip => Fiveruns::Dash.host.ip_address,
+          :hostname => Fiveruns::Dash.host.hostname,
+          :pid => Process.pid,
+          :os_name => Fiveruns::Dash.host.os_name,
+          :os_version => Fiveruns::Dash.host.os_version,
+          :arch => Fiveruns::Dash.host.architecture,
+          :dash_version => Fiveruns::Dash::Version::STRING,
+          :ruby_version => RUBY_VERSION,
+          :started_at => @started_at
+        }
+        if (scm = Fiveruns::Dash.scm)
+          params.update(
+            :scm_revision => scm.revision,
+            :scm_time => scm.time,
+            :scm_type => scm.class.scm_type,
+            :scm_url => scm.url
+          )
+        end
+        params
+      end
+    end
+    
+  end
+  
+  class PingPayload < InfoPayload
+  end
+
+  class ExceptionsPayload < Payload
+    def params
+      @params ||= {
+        :type => 'exceptions',
+        :collected_at => timestamp,
+        :hostname => Fiveruns::Dash.host.hostname,
+      }
+    end
+  end
+  
+  class DataPayload < Payload
+    def params
+      @params ||= {
+        :type => 'data',
+        :collected_at => timestamp,
+        :hostname => Fiveruns::Dash.host.hostname,
+      }
+    end
+  end
+  
+  class TracePayload < Payload
+    def params
+      @params ||= {
+        :type => 'trace',
+        :collected_at => timestamp,
+        :hostname => Fiveruns::Dash.host.hostname,
+      }
+    end
+  end
+
+end