skylight 0.0.16 → 0.1.0.alpha1

data/lib/skylight/gc.rb

@@ -0,0 +1,109 @@
+require 'thread'
+
+module Skylight
+  class GC
+    METHODS = [ :enable, :total_time ]
+    TH_KEY  = :SK_GC_CURR_WINDOW
+
+    def self.update
+      if win = Thread.current[TH_KEY]
+        win.update
+      end
+    end
+
+    def self.time
+      if win = Thread.current[TH_KEY]
+        win.time
+      else
+        0.0
+      end
+    end
+
+    def initialize(profiler)
+      @listeners = []
+      @lock      = Mutex.new
+
+      if METHODS.all? { |m| profiler.respond_to?(m) }
+        @profiler = profiler
+      end
+    end
+
+    def start_track
+      return if Thread.current[TH_KEY]
+
+      unless @profiler
+        win = Window.new(nil)
+      else
+        win = Window.new(self)
+
+        @lock.synchronize do
+          @listeners << win
+        end
+      end
+
+      Thread.current[TH_KEY] = win
+    end
+
+    def stop_track
+      if win = Thread.current[TH_KEY]
+        Thread.current[TH_KEY] = nil
+        win.release
+      end
+    end
+
+    def track
+      return unless block_given?
+
+      start_track
+
+      begin
+        yield
+      ensure
+        stop_track
+      end
+    end
+
+    def release(win)
+      @lock.synchronize do
+        @listeners.delete(win)
+      end
+    end
+
+    def update
+      @lock.synchronize do
+        time = @profiler.total_time
+
+        if time > 0
+          @profiler.clear
+          @listeners.each do |l|
+            l.add(time)
+          end
+        end
+      end
+
+      nil
+    end
+
+    class Window
+      attr_reader :time
+
+      def initialize(global)
+        @global = global
+        @time   = 0.0
+      end
+
+      def update
+        @global.update if @global
+      end
+
+      def add(time)
+        @time += time
+      end
+
+      def release
+        @global.release(self) if @global
+      end
+    end
+
+  end
+end

data/lib/skylight/instrumenter.rb

@@ -1,57 +1,52 @@
+require 'thread'
+
 module Skylight
   class Instrumenter
+    KEY = :__skylight_current_trace
 
-    # Guards starting the instrumenter
-    LOCK = Mutex.new
+    include Util::Logging
 
-    # Maximum number of traces to sample for each interval
-    SAMPLE_SIZE = 100
+    def self.current_trace
+      Thread.current[KEY]
+    end
 
-    # Time interval for each sample in seconds
-    INTERVAL = 5
+    def self.current_trace=(trace)
+      Thread.current[KEY] = trace
+    end
 
     def self.start!(config = Config.new)
       new(config).start!
     end
 
-    attr_reader :config, :worker, :samples
+    attr_reader :config, :gc
 
     def initialize(config)
-      # Convert a hash to a config object
       if Hash === config
         config = Config.new(config)
       end
 
-      @config  = config
+      @gc = config.gc
+      @lock = Mutex.new
+      @config = config
+      @worker = config.worker.build
       @started = false
-      @worker  = Worker.new(self)
+      @subscriber = Subscriber.new(config)
     end
 
     def start!
       # Quick check
       return self if @started
+      return unless config
 
-      LOCK.synchronize do
+      @lock.synchronize do
         # Ensure that the instrumenter has not been started now that the lock
-        # as been acquired
+        # has been acquired.
         return self if @started
 
-        @worker.start!
-        Subscriber.register!(config)
-
-        # Ensure properly configured
-        return unless config
-
-        # Ensure that there is an API token
-        unless config.authentication_token
-          if logger = config.logger
-            logger.warn "[SKYLIGHT] No authentication token provided; cannot start agent."
-          end
-
-          return
-        end
-
-        config.gc_profiler.enable
+        t { "starting instrumenter" }
+        @config.validate!
+        @worker.spawn
+        @subscriber.register!
 
         @started = true
       end
@@ -59,74 +54,62 @@ module Skylight
       self
 
     rescue Exception => e
-      error(e.message)
+      error "failed to start instrumenter; msg=%s", e.message
       nil
     end
 
-    def trace(endpoint = nil)
+    def shutdown
+      @lock.synchronize do
+        return unless @started
+        @subscriber.unregister!
+        @worker.shutdown
+      end
+    end
+
+    def trace(endpoint = 'Unknown')
       # Ignore everything unless the instrumenter has been started
       unless @started
         return yield
       end
 
-      # If there already is a trace going on, then just continue
-      if Thread.current[Trace::KEY]
-        return yield
+      # If a trace is already in progress, continue with that one
+      if trace = Instrumenter.current_trace
+        t { "already tracing" }
+        return yield(trace)
       end
 
-      # If the request should not be sampled, yield
-      unless trace = create_trace(endpoint)
-        return yield
-      end
+      trace = Messages::Trace::Builder.new(endpoint, Util::Clock.now, @config)
 
-      # Otherwise, setup the new trace and continue
       begin
-        Thread.current[Trace::KEY] = trace
-        yield(trace)
+
+        Instrumenter.current_trace = trace
+        yield trace
+
       ensure
-        Thread.current[Trace::KEY] = nil
+        Instrumenter.current_trace = nil
 
         begin
-          trace.commit
-          process(trace)
+          built = trace.build
+
+          if built.valid?
+            process(built)
+          else
+            debug "trace invalid -- dropping"
+          end
         rescue Exception => e
-          error(e)
+          error e
         end
       end
     end
 
   private
 
-    def create_trace(endpoint)
-      Trace.new(config, endpoint)
-    # Paranoia
-    rescue => e
-      error e
-      nil
-    end
-
     def process(trace)
-      debug "Submitting trace to worker"
+      t { fmt "processing trace; spans=%d", trace.spans.length }
       unless @worker.submit(trace)
-        config.logger.warn("[SKYLIGHT] Could not submit trace to worker")
+        warn "failed to submit trace to worker"
       end
     end
 
-    def error(msg)
-      return unless l = config.logger
-
-      if Error == msg
-        msg = "#{e.message} (#{e.class}) - #{e.backtrace && e.backtrace.first}"
-      end
-
-      l.error "[SKYLIGHT] #{msg}"
-    rescue
-    end
-
-    def debug(msg)
-      return unless l = config.logger
-      l.debug "[SKYLIGHT] #{msg}"
-    end
-
   end
 end

data/lib/skylight/messages.rb

@@ -0,0 +1,19 @@
+module Skylight
+  module Messages
+    def self.get(id)
+      (@id_map ||= {})[id]
+    end
+
+    def self.set(id, klass)
+      (@id_map ||= {})[id] = klass
+    end
+
+    require 'skylight/messages/annotation'
+    require 'skylight/messages/event'
+    require 'skylight/messages/span'
+    require 'skylight/messages/trace'
+    require 'skylight/messages/endpoint'
+    require 'skylight/messages/batch'
+    require 'skylight/messages/hello'
+  end
+end

data/lib/skylight/messages/annotation.rb

@@ -0,0 +1,13 @@
+module Skylight
+  module Messages
+    class Annotation
+      include Beefcake::Message
+
+      optional :key,    :string,    1
+      optional :int,    :int64,     2
+      optional :double, :double,    3
+      optional :string, :string,    4
+      repeated :nested, Annotation, 5
+    end
+  end
+end

data/lib/skylight/messages/base.rb

@@ -0,0 +1,24 @@
+module Skylight
+  module Messages
+    class Base
+      module ClassMethods
+        attr_accessor :message_id
+      end
+
+      def self.inherited(klass)
+        klass.class_eval do
+          include Beefcake::Message
+          extend  ClassMethods
+        end
+
+        klass.message_id = (@count ||= 0)
+        Messages.set(klass.message_id, klass)
+        @count += 1
+      end
+
+      def message_id
+        self.class.message_id
+      end
+    end
+  end
+end

data/lib/skylight/messages/batch.rb

@@ -0,0 +1,11 @@
+module Skylight
+  module Messages
+    class Batch
+      include Beefcake::Message
+
+      required :timestamp, :uint32,  1
+      repeated :endpoints, Endpoint, 2
+
+    end
+  end
+end

data/lib/skylight/messages/endpoint.rb

@@ -0,0 +1,12 @@
+module Skylight
+  module Messages
+    class Endpoint
+      include Beefcake::Message
+
+      required :name,   :string, 1
+      required :count,  :uint64, 2
+      repeated :traces, Trace,   3
+
+    end
+  end
+end

data/lib/skylight/messages/event.rb

@@ -0,0 +1,12 @@
+module Skylight
+  module Messages
+    class Event
+      include Beefcake::Message
+
+      required :category,    :string, 1
+      optional :title,       :string, 2
+      optional :description, :string, 3
+
+    end
+  end
+end

data/lib/skylight/messages/hello.rb

@@ -0,0 +1,53 @@
+require 'skylight/messages/base'
+
+module Skylight
+  module Messages
+    class Hello < Base
+
+      DIGITS = /^\s*\d+\s*$/
+
+      required :version, :string, 1
+      optional :config,  :uint32, 2
+      repeated :cmd,     :string, 3
+
+      def newer?(other = VERSION)
+        other = split(other)
+        curr  = split(version)
+
+        [other.length, curr.length].max.times do |i|
+          next if other[i] == curr[i]
+          return true unless other[i]
+
+          if other[i] =~ DIGITS
+            if curr[i] =~ DIGITS
+              other_i = other[i].to_i
+              curr_i = curr[i].to_i
+
+              next if other_i == curr_i
+
+              return curr_i > other_i
+            else
+              return false
+            end
+          else
+            if curr[i] =~ DIGITS
+              return true
+            else
+              next if curr[i] == other[i]
+              return curr[i] > other[i]
+            end
+          end
+        end
+
+        false
+      end
+
+    private
+
+      def split(v)
+        v.split('.')
+      end
+
+    end
+  end
+end