skylight 0.0.16 → 0.1.0.alpha1

data/lib/skylight/railtie.rb

@@ -11,65 +11,45 @@ module Skylight
     # The path to the configuration file
     config.skylight.config_path = "config/skylight.yml"
 
-    attr_accessor :instrumenter
+    initializer 'skylight.configure' do |app|
+      if activate?
+        if config = load_skylight_config(app)
+          @instrumenter = Instrumenter.start!(config)
 
-    initializer "skylight.configure" do |app|
-      if environments.include?(Rails.env.to_s)
-        config = load_config(app)
-
-        if good_to_go?(app, config)
-          @instrumenter = Instrumenter.new(config)
-
-          Rails.logger.debug "[SKYLIGHT] Installing middleware"
           app.middleware.insert 0, Middleware, @instrumenter
-        else
-          puts "[SKYLIGHT] Skipping Skylight boot"
+
+          Rails.logger.info "[SKYLIGHT] Skylight agent enabled"
         end
       end
     end
 
   private
 
-    def good_to_go?(app, config)
-      unless problems = check_for_problems(app, config)
-        return true
-      end
-
-      problems.each do |group, problem_list|
-        problem_list.each do |problem|
-          puts "[SKYLIGHT] PROBLEM: #{group} #{problem}"
-        end
-      end
+    def load_skylight_config(app)
+      path = config_path(app)
+      path = nil unless File.exist?(path)
 
-      false
-    end
+      config = Config.load(path, Rails.env.to_s, ENV)
+      config.logger = Rails.logger
+      config['normalizers.render.view_paths'] = app.config.paths["app/views"].existent
+      config.validate!
+      config
 
-    def check_for_problems(app, config)
-      checker = SanityChecker.new
-      checker.smoke_test(config_path(app)) || checker.sanity_check(config)
+    rescue ConfigError => e
+      Rails.logger.warn "[SKYLIGHT] #{e.message}; disabling Skylight agent"
+      nil
     end
 
-    def load_config(app)
-        config = Config.load_from_yaml(config_path(app), ENV).tap do |c|
-          c.logger = Rails.logger
-        end
-
-        config.normalizer.view_paths = app.config.paths["app/views"].existent
-        config
-    rescue => e
-      raise
-      Rails.logger.error "[SKYLIGHT] #{e.message} (#{e.class}) - #{e.backtrace.first}"
+    def config_path(app)
+      File.expand_path(config.skylight.config_path, app.root)
     end
 
     def environments
       Array(config.skylight.environments).map { |e| e && e.to_s }.compact
     end
 
-    def config_path(app)
-      path = config.skylight.config_path
-      File.expand_path(path, app.root)
+    def activate?
+      environments.include?(Rails.env.to_s)
     end
-
-
   end
 end

data/lib/skylight/subscriber.rb

@@ -1,43 +1,53 @@
 module Skylight
-  # TODO: Handle filtering out notifications that we don't care about
   class Subscriber
-    def self.register!(config=Config.new)
-      ActiveSupport::Notifications.subscribe nil, new(config)
-    end
+
+    attr_reader :config
 
     def initialize(config)
       @config = config
+      @normalizers = Normalizers.build(config)
+    end
+
+    def register!
+      ActiveSupport::Notifications.subscribe nil, self
+    end
+
+    def unregister!
+      ActiveSupport::Notifications.unsubscribe self
     end
 
     def start(name, id, payload)
-      return unless trace = Trace.current
+      return unless trace = Instrumenter.current_trace
 
-      name, title, desc, payload = Normalize.normalize(trace, name, payload, @config.normalizer)
+      cat, title, desc, annot = normalize(trace, name, payload)
+      trace.start(now - gc_time, cat, title, desc, annot)
 
-      trace.start(name, title, desc, payload)
+      trace
     end
 
     def finish(name, id, payload)
-      return unless trace = Trace.current
-      trace.stop
+      return unless trace = Instrumenter.current_trace
+      trace.stop(now - gc_time)
     end
 
-    def measure(name, id, payload)
-      return unless trace = Trace.current
-
-      name, title, desc, payload = Normalize.normalize(trace, name, payload)
-
-      trace.record(name, title, desc, payload)
+    def publish(name, *args)
+      # Ignored for now because nothing in rails uses it
     end
 
   private
 
-    def controller_action(payload)
-      "#{payload[:controller]}##{payload[:action]}"
+    def normalize(*args)
+      @normalizers.normalize(*args)
     end
 
-    def logger
-      @config.logger
+    def gc_time
+      GC.update
+      GC.time
     end
+
+    def now
+      Util::Clock.default.now
+    end
+
   end
 end

data/lib/skylight/util/clock.rb

@@ -1,37 +1,24 @@
 module Skylight
   module Util
     class Clock
-      MICROSEC_PER_SEC = 1.to_f / 1_000_000
-
-      # Resolution is in seconds
-      def initialize(resolution)
-        @resolution = resolution
-        @usec_mult  = MICROSEC_PER_SEC / resolution
-      end
 
       def now
-        at(Time.now)
+        n = Time.now
+        n.to_i + n.usec.to_f / 1_000_000
       end
 
-      def at(time)
-        sec  = time.to_i / @resolution
-        usec = time.usec * @usec_mult
-        (sec + usec).floor
+      def self.now
+        default.now
       end
 
-      def convert(secs)
-        (secs / @resolution).floor
+      def self.default
+        @clock ||= Clock.new
       end
 
-      def to_seconds(clock_val)
-        (clock_val * @resolution).floor
+      def self.default=(clock)
+        @clock = clock
       end
-    end
-
-    @clock = Clock.new(0.0001)
 
-    def self.clock
-      @clock
     end
   end
 end

data/lib/skylight/util/http.rb

@@ -1,4 +1,5 @@
-require "json"
+require 'json'
+require 'net/http'
 
 module Skylight
   module Util
@@ -12,86 +13,132 @@ module Skylight
       DEFLATE          = 'deflate'.freeze
       GZIP             = 'gzip'.freeze
 
-      def initialize(config)
+      include Logging
+
+      attr_accessor :authentication, :config
+
+      def initialize(config, service = :report)
         @config = config
+        @ssl  = config["#{service}.ssl"]
+        @host = config["#{service}.host"]
+        @port = config["#{service}.port"]
+        @deflate = config["#{service}.deflate"]
+        @authentication = config[:'authentication']
       end
 
-      def auth(email, password)
-        req = Net::HTTP::Get.new("/login")
-        req.basic_auth email, password
-        response = make_request(req, nil, ACCEPT => APPLICATION_JSON)
-        JSON.parse(response)
+      def get(endpoint, hdrs = {})
+        request = build_request(Net::HTTP::Get, endpoint, hdrs)
+        execute(request)
+      rescue Exception => e
+        error "http GET failed; msg=%s", e.message
+        t { e.backtrace.join("\n") }
+        nil
       end
 
-      def create_app(user_token, app_name)
-        req = Net::HTTP::Post.new("/apps")
-        req["Authorization"] = user_token
-
-        body = JSON.dump(app: { name: app_name })
-        headers = { ACCEPT => APPLICATION_JSON }
-        headers[CONTENT_TYPE] = APPLICATION_JSON
-        headers[CONTENT_ENCODING] = GZIP if @config.deflate?
-        response = make_request(req, body, headers)
+      def post(endpoint, body, hdrs = {})
+        unless body.respond_to?(:to_str)
+          hdrs[CONTENT_TYPE] = APPLICATION_JSON
+          body = body.to_json
+        end
 
-        JSON.parse(response)
+        request = build_request(Net::HTTP::Post, endpoint, hdrs, body.bytesize)
+        execute(request, body)
+      rescue Exception => e
+        error "http POST failed; msg=%s", e.message
+        t { e.backtrace.join("\n") }
+        nil
       end
 
-      def post(endpoint, body)
-        req = request(Net::HTTP::Post, endpoint, body.bytesize)
-        make_request(req, body)
-      rescue => e
-        logger.error "[SKYLIGHT] POST #{@config.host}:#{@config.port}(ssl=#{@config.ssl?}) - #{e.message} - #{e.class} - #{e.backtrace.first}"
-        debug(e.backtrace.join("\n"))
-      end
+    private
 
-      def request(type, endpoint, length=nil)
+      def build_request(type, endpoint, hdrs, length=nil)
         headers = {}
 
         headers[CONTENT_LENGTH]   = length.to_s if length
-        headers[AUTHORIZATION]    = @config.authentication_token
-        headers[CONTENT_TYPE]     = APPLICATION_JSON if length
+        headers[AUTHORIZATION]    = authentication if authentication
         headers[ACCEPT]           = APPLICATION_JSON
-        headers[CONTENT_ENCODING] = GZIP if @config.deflate?
+        headers[CONTENT_ENCODING] = GZIP if @deflate
+
+        hdrs.each do |k, v|
+          headers[k] = v
+        end
 
         type.new(endpoint, headers)
       end
 
-    private
-      def make_request(req, body=nil, headers={})
+      def execute(req, body=nil)
+        t { fmt "executing HTTP request; host=%s; port=%s; body=%s",
+              @host, @port, body && body.bytesize }
+
         if body
-          body = Gzip.compress(body) if @config.deflate?
+          body = Gzip.compress(body) if @deflate
           req.body = body
         end
 
-        headers.each do |name, value|
-          req[name] = value
-        end
-
-        http = Net::HTTP.new @config.host, @config.port
+        http = Net::HTTP.new @host, @port
 
-        if @config.ssl?
+        if @ssl
           http.use_ssl = true
           http.verify_mode = OpenSSL::SSL::VERIFY_PEER
         end
 
         http.start do |client|
-          response = client.request(req)
+          res = client.request(req)
 
-          unless response.code == '200'
-            debug "Server responded with #{response.code}"
+          unless res.code =~ /2\d\d/
+            debug "server responded with #{res.code}"
+            t { fmt "body=%s", res.body }
           end
 
-          return response.body
+          Response.new(res.code.to_i, res, res.body)
         end
       end
 
-      def logger
-        @config.logger
-      end
+      class Response
+        attr_reader :status, :headers, :body
+
+        def initialize(status, headers, body)
+          @status  = status
+          @headers = headers
+
+          if headers[CONTENT_TYPE] == APPLICATION_JSON
+            @body = JSON.parse(body)
+          else
+            @body = body
+          end
+        end
+
+        def success?
+          status >= 200 && status < 300
+        end
 
-      def debug(msg)
-        logger.debug "[SKYLIGHT] #{msg}" if logger.debug?
+        def to_s
+          body.to_s
+        end
+
+        def get(key)
+          return nil unless Hash === body
+
+          res = body
+          key.split('.').each do |part|
+            return unless res = res[part]
+          end
+          res
+        end
+
+        def respond_to_missing?(name, include_all=false)
+          super || body.respond_to?(name, include_all)
+        end
+
+        def method_missing(name, *args, &blk)
+          if respond_to_missing?(name)
+            body.send(name, *args, &blk)
+          else
+            super
+          end
+        end
       end
+
     end
   end
 end

data/lib/skylight/util/logging.rb

@@ -0,0 +1,66 @@
+require 'logger'
+
+module Skylight
+  module Util
+    module Logging
+      if ENV[TRACE_ENV_KEY]
+        def trace(msg, *args)
+          log :DEBUG, msg, *args
+        end
+
+        def t
+          log :DEBUG, yield
+        end
+      else
+        def trace(*)
+        end
+
+        def t
+        end
+      end
+
+      def debug(msg, *args)
+        log :DEBUG, msg, *args
+      end
+
+      def info(msg, *args)
+        log :INFO, msg, *args
+      end
+
+      def warn(msg, *args)
+        log :WARN, msg, *args
+      end
+
+      def error(msg, *args)
+        log :ERROR, msg, *args
+      end
+
+      alias fmt sprintf
+
+      MAP = {
+        :DEBUG => Logger::DEBUG,
+        :INFO  => Logger::INFO,
+        :WARN  => Logger::WARN,
+        :ERROR => Logger::ERROR }
+
+      def log(level, msg, *args)
+        return unless respond_to?(:config)
+        return unless c = config
+
+        if logger = c.logger
+          if args.length > 0
+            logger.log MAP[level], sprintf("[SKYLIGHT] #{msg}", *args)
+          else
+            logger.log MAP[level], "[SKYLIGHT] #{msg}"
+          end
+        end
+      rescue Exception => e
+        if ENV[TRACE_ENV_KEY]
+          puts "[ERROR] #{e.message}"
+          puts e.backtrace
+        end
+      end
+
+    end
+  end
+end