skylight 0.0.2

data/lib/skylight/config.rb

@@ -0,0 +1,82 @@
+require 'yaml'
+
+module Skylight
+  class Config
+
+    def self.load_from_yaml(path)
+      new do |config|
+        data = YAML.load_file(path)
+        data.each do |key, value|
+          if config.respond_to?("#{key}=")
+            config.send("#{key}=", value)
+          end
+        end
+      end
+    end
+
+    def initialize(attrs = {})
+      @ssl      = true
+      @deflate  = true
+      @host     = "agent.skylight.io"
+      @port     = 443
+      @interval = 5
+      @protocol = JsonProto.new(self)
+      @max_pending_traces = 500
+      @samples_per_interval = 100
+
+      @logger = Logger.new(STDOUT)
+      @logger.level = Logger::INFO
+
+      attrs.each do |k, v|
+        if respond_to?("#{k}=")
+          send("#{k}=", v)
+        end
+      end
+
+      yield self if block_given?
+    end
+
+    attr_accessor :authentication_token
+
+    attr_accessor :ssl
+    alias_method :ssl?, :ssl
+
+    attr_accessor :deflate
+    alias_method :deflate?, :deflate
+
+    attr_accessor :host
+
+    attr_accessor :port
+
+    attr_accessor :samples_per_interval
+
+    attr_accessor :interval
+
+    attr_accessor :max_pending_traces
+
+    attr_reader :protocol
+    def protocol=(val)
+      if val.is_a?(String) || val.is_a?(Symbol)
+        class_name = val.to_s.capitalize+"Proto"
+        val = Skylight.const_get(class_name).new(self)
+      end
+      @protocol = val
+    end
+
+    attr_accessor :logger
+
+    def log_level
+      logger && logger.level
+    end
+
+    def log_level=(level)
+      if logger
+        if level.is_a?(String) || level.is_a?(Symbol)
+          level = Logger.const_get(level.to_s.upcase)
+        end
+        logger.level = level
+      end
+    end
+
+  end
+end

data/lib/skylight/connection.rb

@@ -0,0 +1,25 @@
+module Skylight
+  class Connection
+
+    def self.open(host, port, ssl)
+      conn = new(host, port, ssl)
+      conn.open
+      conn
+    end
+
+    def initialize(host, port, ssl)
+      @host = host
+      @port = port
+      @ssl  = ssl
+    end
+
+    def open
+      # stuff
+    end
+
+    def close
+      # stuff
+    end
+
+  end
+end

data/lib/skylight/instrumenter.rb

@@ -0,0 +1,106 @@
+module Skylight
+  class Instrumenter
+
+    # Maximum number of traces to sample for each interval
+    SAMPLE_SIZE = 100
+
+    # Time interval for each sample in seconds
+    INTERVAL = 5
+
+    def self.start!(config = Config.new)
+      # Convert a hash to a config object
+      if Hash === config
+        config = Config.new config
+      end
+
+      new(config).start!
+    end
+
+    attr_reader :config, :worker, :samples
+
+    def initialize(config)
+      @config = config
+      @worker = Worker.new(self)
+    end
+
+    def start!
+      @worker.start!
+      Subscriber.register!
+
+      # 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
+
+      self
+    end
+
+    def trace(endpoint = nil)
+      # If there already is a trace going on, then just continue
+      if Thread.current[Trace::KEY]
+        return yield
+      end
+
+      # If the request should not be sampled, yield
+      unless trace = create_trace(endpoint)
+        return yield
+      end
+
+      # Otherwise, setup the new trace and continue
+      begin
+        Thread.current[Trace::KEY] = trace
+        yield(trace)
+      ensure
+        Thread.current[Trace::KEY] = nil
+
+        begin
+          trace.commit
+          process(trace)
+        rescue Exception => e
+          error(e)
+        end
+      end
+    end
+
+  private
+
+    def create_trace(endpoint)
+      Trace.new(endpoint)
+    # Paranoia
+    rescue => e
+      error e
+      nil
+    end
+
+    def process(trace)
+      debug "Submitting trace to worker"
+      unless @worker.submit(trace)
+        config.logger.warn("[SKYLIGHT] Could not 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/json_proto.rb

@@ -0,0 +1,82 @@
+require 'json'
+
+module Skylight
+  class JsonProto
+    def initialize(config)
+      @config = config
+    end
+
+    def write(out, from, counts, sample)
+
+# {
+#   batch: {
+#     timestamp: 123456, // Second granularity
+#     endpoints: [
+#       {
+#         name: "WidgetsController#index",
+#         count: 100, // There can be a higher count # than there are traces
+#         traces: [
+#           {
+#             // Trace UUID
+#             uuid: "d11d7190-40cc-11e2-a25f-0800200c9a66",
+#             spans: [
+#               [
+#                 null, // parent-id -- index of the parent span or null if root node
+#                 0292352, // Span start timestamp in 0.1ms granularity
+#                 20, // Duration of the span in 0.1ms granularity
+#                 "action_controller.process", // Span category
+#                 "Processing WidgetsController#index" // Span description
+#               ],
+#               [
+#                 0, // The previous span is this span's parent
+#                 1340923,
+#                 0, // No duration
+#                 "log.info", // category
+#                 "Doing some stuff..." // Span description
+#               ]
+#             ]
+#           }
+#         ]
+#       },
+#       // etc...
+#     ]
+#   }
+# }
+
+      hash = {
+        :batch => {
+          :timestamp => Util.clock.to_seconds(from),
+        }
+      }
+
+      hash[:batch][:endpoints] = counts.map do |endpoint, count|
+        ehash = {
+          :name => endpoint,
+          :count => count
+        }
+
+        traces = sample.select{|t| t.endpoint == endpoint }
+
+        ehash[:traces] = traces.map do |t|
+          # thash = { :uuid => t.ident }
+          thash = { :uuid => "TODO" }
+
+          thash[:spans] = t.spans.map do |s|
+            [s.parent,
+             s.started_at,
+             s.ended_at - s.started_at,
+             s.category,
+             s.description
+            ]
+          end
+
+          thash
+        end
+
+        ehash
+      end
+
+      out << hash.to_json
+    end
+  end
+end

data/lib/skylight/middleware.rb

@@ -0,0 +1,23 @@
+module Skylight
+  class Middleware
+    attr_reader :instrumenter
+
+    def self.new(app, instrumenter)
+      return app unless instrumenter
+      super
+    end
+
+    def initialize(app, instrumenter)
+      @instrumenter = instrumenter
+      @app = app
+    end
+
+    def call(env)
+      instrumenter.trace("Rack") do
+        ActiveSupport::Notifications.instrument("rack.request") do
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/skylight/railtie.rb

@@ -0,0 +1,67 @@
+require 'skylight'
+require 'rails'
+
+module Skylight
+  class Railtie < Rails::Railtie
+    # The environments in which skylight should be inabled
+    config.environments = ['production']
+
+    # The path to the configuration file
+    config.skylight_config_path = "config/skylight.yml"
+
+    attr_accessor :instrumenter
+
+    initializer "skylight.configure" do |app|
+      if self.instrumenter = load_instrumenter
+        Rails.logger.debug "[SKYLIGHT] Installing middleware"
+        app.middleware.insert 0, Middleware, instrumenter
+      end
+    end
+
+  private
+
+    def environments
+      Array(config.environments).map { |e| e && e.to_s }.compact
+    end
+
+    def load_instrumenter
+      if environments.include?(Rails.env.to_s)
+        if c = load_config
+          Rails.logger.debug "[SKYLIGHT] Starting instrumenter"
+          Instrumenter.start!(c)
+        end
+      end
+    # Paranoia
+    rescue
+      nil
+    end
+
+    def load_config
+      unless path = config.skylight_config_path
+        Rails.logger.warn "[SKYLIGHT] Path to config YAML file unset"
+        return
+      end
+
+      path = File.expand_path(Rails.root.join(path))
+
+      unless File.exist?(path)
+        Rails.logger.warn "[SKYLIGHT] Config does not exist at `#{path}`"
+        return
+      end
+
+      ret = Config.load_from_yaml(path)
+
+      unless ret.authentication_token
+        Rails.logger.warn "[SKYLIGHT] Config does not include an authentication token"
+        return
+      end
+
+      ret.logger = Rails.logger
+
+      ret
+    rescue => e
+      Rails.logger.error "[SKYLIGHT] #{e.message} (#{e.class}) - #{e.backtrace.first}"
+    end
+
+  end
+end

data/lib/skylight/subscriber.rb

@@ -0,0 +1,37 @@
+module Skylight
+  # TODO: Handle filtering out notifications that we don't care about
+  class Subscriber
+    PROCESS_ACTION = "process_action.action_controller"
+
+    def self.register!
+      ActiveSupport::Notifications.subscribe nil, new
+    end
+
+    def start(name, id, payload)
+      return unless trace = Trace.current
+
+      if name == PROCESS_ACTION
+        trace.endpoint = controller_action(payload)
+      end
+
+      trace.start(name, nil, payload)
+    end
+
+    def finish(name, id, payload)
+      return unless trace = Trace.current
+      trace.stop
+    end
+
+    def measure(name, id, payload)
+      return unless trace = Trace.current
+      trace.record(name, nil, payload)
+    end
+
+  private
+
+    def controller_action(payload)
+      "#{payload[:controller]}##{payload[:action]}"
+    end
+
+  end
+end

data/lib/skylight/trace.rb

@@ -0,0 +1,109 @@
+module Skylight
+  class Trace
+    KEY = :__skylight_current_trace
+
+    def self.current
+      Thread.current[KEY]
+    end
+
+    # Struct to track each span
+    class Span < Struct.new(
+      :parent,
+      :started_at,
+      :ended_at,
+      :category,
+      :description,
+      :annotations)
+
+      def key
+        @key ||= [category, description]
+      end
+    end
+
+    attr_reader :endpoint, :ident, :spans
+    attr_writer :endpoint
+
+    def initialize(endpoint = "Unknown", ident = nil)
+      @ident    = ident
+      @endpoint = endpoint
+      @spans    = []
+
+      # Tracks the ID of the current parent
+      @parent = nil
+    end
+
+    def from
+      return unless span = @spans.first
+      span.started_at
+    end
+
+    def to
+      return unless span = @spans.last
+      span.ended_at
+    end
+
+    def record(cat, desc = nil, annot = nil)
+      span = build_span(cat, desc, annot)
+      span.ended_at = span.started_at
+
+      @spans << span
+
+      self
+    end
+
+    def start(cat, desc = nil, annot = nil)
+      span = build_span(cat, desc, annot)
+
+      @parent = @spans.length
+
+      @spans << span
+
+      self
+    end
+
+    def stop
+      # Find last unclosed span
+      span = @spans.last
+      while span && span.ended_at
+        span = span.parent ? @spans[span.parent] : nil
+      end
+
+      raise "trace unbalanced" unless span
+
+      # Set ended_at
+      span.ended_at = now
+
+      # Update the parent
+      @parent = @spans[@parent].parent
+
+      self
+    end
+
+    # Requires global synchronization
+    def commit
+      raise "trace unbalanced" if @parent
+
+      @ident ||= gen_ident
+
+      # No more changes should be made
+      freeze
+
+      self
+    end
+
+  private
+
+    def now
+      Util.clock.now
+    end
+
+    def gen_ident
+      Util::UUID.gen Digest::MD5.digest(@endpoint)[0, 2]
+    end
+
+    def build_span(cat, desc, annot)
+      Span.new(@parent, now, nil, cat, desc || "", annot)
+    end
+
+  end
+end