skylight 0.3.21 → 0.4.0.alpha1

data/lib/skylight/formatters/http.rb

@@ -14,4 +14,4 @@ module Skylight
       end
     end
   end
-end
+end

data/lib/skylight/instrumenter.rb

@@ -59,16 +59,27 @@ module Skylight
       end
     end
 
+    at_exit { stop! }
+
     attr_reader :config, :gc, :trace_info
 
-    def initialize(config)
-      if Hash === config
+    def self.new(config)
+      if config.nil?
+        raise ArgumentError, "config is required"
+      elsif Hash === config
         config = Config.new(config)
       end
 
+      config.validate!
+
+      inst = native_new(config.to_env)
+      inst.send(:initialize, config)
+      inst
+    end
+
+    def initialize(config)
       @gc = config.gc
       @config = config
-      @worker = config.worker.build
       @subscriber = Subscriber.new(config, self)
 
       @trace_info = @config[:trace_info] || TraceInfo.new
@@ -84,8 +95,6 @@ module Skylight
     end
 
     def start!
-      return unless config
-
       # Warn if there was an error installing Skylight.
       # We do this here since we can't report these issues via Gem install without stopping install entirely.
       Skylight.check_install_errors(config)
@@ -98,48 +107,37 @@ module Skylight
       t { "starting instrumenter" }
       @config.validate!
 
-      case @config.validate_token
-      when :ok
-        # Good to go
-      when :unknown
-        log_warn "unable to validate authentication token"
-      else
-        raise ConfigError, "authentication token is invalid"
+      t { "starting native instrumenter" }
+      unless native_start
+        warn "failed to start instrumenter"
+        return
       end
 
       @config.gc.enable
-
-      unless @worker.spawn
-        log_error "failed to spawn worker"
-        return nil
-      end
-
       @subscriber.register!
 
       self
 
     rescue Exception => e
       log_error "failed to start instrumenter; msg=%s; config=%s", e.message, @config.inspect
+      t { e.backtrace.join("\n") }
       nil
     end
 
     def shutdown
       @subscriber.unregister!
-      @worker.shutdown
+      native_stop
     end
 
     def trace(endpoint, cat, title=nil, desc=nil, annot=nil)
       # If a trace is already in progress, continue with that one
       if trace = @trace_info.current
-        t { "already tracing" }
         return yield(trace) if block_given?
         return trace
       end
 
-      t { "starting trace" }
-
       begin
-        trace = Messages::Trace::Builder.new(self, endpoint, Util::Clock.nanos, cat, title, desc, annot)
+        trace = Trace.new(self, endpoint, Util::Clock.nanos, cat, title, desc, annot)
       rescue Exception => e
         log_error e.message
         t { e.backtrace.join("\n") }
@@ -154,6 +152,7 @@ module Skylight
 
       ensure
         @trace_info.current = nil
+        t { "submitting trace" }
         trace.submit
       end
     end
@@ -231,20 +230,14 @@ module Skylight
       end
     end
 
-    def error(type, description, details=nil)
-      t { fmt "processing error; type=%s; description=%s", type, description }
-
-      message = Skylight::Messages::Error.build(type, description, details && details.to_json)
-
-      unless @worker.submit(message)
-        warn "failed to submit error to worker"
-      end
-    end
-
     def process(trace)
       t { fmt "processing trace" }
-      unless @worker.submit(trace)
-        warn "failed to submit trace to worker"
+      begin
+        native_submit_trace(trace)
+        true
+      rescue => e
+        warn "failed to submit trace to worker; err=%s", e
+        false
       end
     end
 

data/lib/skylight/native.rb

@@ -1,90 +1,76 @@
-module Skylight
-
-  if native?
-
-    # @api private
-    class Hello
-      DIGITS = /^\s*\d+\s*$/
-
-      alias serialize native_serialize
-      alias version native_get_version
-
-      class << self
-        alias deserialize native_load
-      end
+require 'skylight/util/platform'
 
-      def cmd
-        native_cmd_length.times.map do |offset|
-          native_cmd_get(offset)
-        end
-      end
+module Skylight
+  # @api private
+  # Whether or not the native extension is present
+  @@has_native_ext = false
 
-      def newer?(other = VERSION)
-        other = split(other)
-        curr  = split(version)
+  def self.native?
+    @@has_native_ext
+  end
 
-        [other.length, curr.length].max.times do |i|
-          next if other[i] == curr[i]
-          return true unless other[i]
+  def self.libskylight_path
+    ENV['SKYLIGHT_LIB_PATH'] || File.expand_path("../native/#{Util::Platform.tuple}", __FILE__)
+  end
 
-          if other[i] =~ DIGITS
-            if curr[i] =~ DIGITS
-              other_i = other[i].to_i
-              curr_i = curr[i].to_i
+  begin
+    unless ENV["SKYLIGHT_DISABLE_AGENT"]
+      lib = "#{libskylight_path}/libskylight.#{Util::Platform.libext}"
 
-              next if other_i == curr_i
+      if File.exist?(lib)
+        # First attempt to require the native extension
+        require 'skylight_native'
 
-              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
+        # Attempt to link the dylib
+        load_libskylight(lib)
 
-        false
+        # If nothing was thrown, then the native extension is present
+        @@has_native_ext = true
       end
-
-      private
-
-        def split(v)
-          v.split('.')
-        end
-
     end
+  rescue LoadError => e
+    raise if ENV.key?("SKYLIGHT_REQUIRED")
+  end
 
-    # @api private
-    class Error
-      alias serialize native_serialize
-      alias type native_get_group
-      alias description native_get_description
-      alias details native_get_details
-
-      class << self
-        alias deserialize native_load
+  unless Skylight.native?
+    class Instrumenter
+      def self.native_new(*args)
+        allocate
       end
     end
+  end
 
-    # @api private
-    class Trace
-      alias serialize native_serialize
-    end
-
-    # @api private
-    class Batch
-      alias serialize native_serialize
+  # @api private
+  def self.check_install_errors(config)
+    # Note: An unsupported arch doesn't count as an error.
+    install_log = File.expand_path("../../ext/install.log", __FILE__)
+
+    if File.exist?(install_log) && File.read(install_log) =~ /ERROR/
+      config.alert_logger.error \
+          "[SKYLIGHT] [#{Skylight::VERSION}] The Skylight native extension failed to install. " \
+          "Please check #{install_log} and notify support@skylight.io." \
+          "The missing extension will not affect the functioning of your application."
     end
   end
 
   # @api private
-  # We have to declare this again due to a YARD bug
-  # https://github.com/lsegal/yard/issues/761
-  class Hello; end
-
+  def self.warn_skylight_native_missing(config)
+    # TODO: Dumping the error messages this way is pretty hacky
+    is_rails = defined?(Rails)
+    env_name = is_rails ? Rails.env : "development"
+
+    if env_name == "development" || env_name == "test"
+      config.alert_logger.warn \
+          "[SKYLIGHT] [#{Skylight::VERSION}] Running Skylight in #{env_name} mode. " \
+          "No data will be reported until you deploy your app.\n" \
+          "(To disable this message, set `alert_log_file` in your config.)"
+    else
+      config.alert_logger.error \
+          "[SKYLIGHT] [#{Skylight::VERSION}] The Skylight native extension for your platform wasn't found. " \
+          "The monitoring portion of Skylight is only supported on production servers running 32- or " \
+          "64-bit Linux. The missing extension will not affect the functioning of your application " \
+          "and you can continue local development without data being reported. If you are on a " \
+          "supported platform, please contact support at support@skylight.io."
+    end
+  end
 end

data/lib/skylight/normalizers.rb

@@ -76,7 +76,6 @@ module Skylight
             path[start, path.size]
           end
         else
-          annotations[:skylight_error] = ["absolute_path", path]
           "Absolute Path"
         end
       end

data/lib/skylight/normalizers/active_record/sql.rb

@@ -32,10 +32,6 @@ module Skylight
               sql:   sql,
               binds: binds,
             }
-          else
-            annotations = {
-              skylight_error: error
-            }
           end
 
           [ name, title, sql, annotations ]

data/lib/skylight/probes/excon/middleware.rb

@@ -1,3 +1,5 @@
+require 'skylight/formatters/http'
+
 module Skylight
   module Probes
     module Excon
@@ -60,4 +62,4 @@ module Skylight
       end
     end
   end
-end
+end

data/lib/skylight/probes/net_http.rb

@@ -1,3 +1,5 @@
+require 'skylight/formatters/http'
+
 module Skylight
   module Probes
     module NetHTTP
@@ -39,4 +41,4 @@ module Skylight
 
     register("Net::HTTP", "net/http", NetHTTP::Probe.new)
   end
-end
+end

data/lib/skylight/subscriber.rb

@@ -42,10 +42,6 @@ module Skylight
 
       cat, title, desc, annot = normalize(trace, name, payload)
 
-      if cat != :skip && error = annot.delete(:skylight_error)
-        @instrumenter.error(*error)
-      end
-
       unless cat == :skip
         span = trace.instrument(cat, title, desc, annot)
       end

data/lib/skylight/trace.rb

@@ -0,0 +1,189 @@
+module Skylight
+  class Trace
+    GC_CAT = 'noise.gc'.freeze
+
+    include Util::Logging
+
+    attr_reader :endpoint, :notifications
+
+    def self.new(instrumenter, endpoint, start, cat, title = nil, desc = nil, annot = nil)
+      inst = native_new(normalize_time(start), "TODO", endpoint)
+      inst.send(:initialize, instrumenter, cat, title, desc, annot)
+      inst.endpoint = endpoint
+      inst
+    end
+
+    # TODO: Move this into native
+    def self.normalize_time(time)
+      # At least one customer has extensions that cause integer division to produce rationals.
+      # Since the native code expects an integer, we force it again.
+      (time.to_i / 100_000).to_i
+    end
+
+    def initialize(instrumenter, cat, title, desc, annot)
+      raise ArgumentError, 'instrumenter is required' unless instrumenter
+
+      @instrumenter = instrumenter
+      @submitted = false
+      @broken = false
+
+      @notifications = []
+
+      if Hash === title
+        annot = title
+        title = desc = nil
+      elsif Hash === desc
+        annot = desc
+        desc = nil
+      end
+
+      # create the root node
+      @root = native_start_span(native_get_started_at, cat)
+      native_span_set_title(@root, title) if title
+      native_span_set_description(@root, desc) if desc
+
+      @gc = config.gc.track unless ENV.key?("SKYLIGHT_DISABLE_GC_TRACKING")
+    end
+
+    def endpoint=(value)
+      @endpoint = value
+      native_set_endpoint(value)
+      value
+    end
+
+    def config
+      @instrumenter.config
+    end
+
+    def record(cat, title=nil, desc=nil, annot=nil)
+      @return if @broken
+
+      if Hash === title
+        annot = title
+        title = desc = nil
+      elsif Hash === desc
+        annot = desc
+        desc = nil
+      end
+
+      title.freeze if title.is_a?(String)
+      desc.freeze  if desc.is_a?(String)
+
+      desc = @instrumenter.limited_description(desc)
+
+      time = Util::Clock.nanos - gc_time
+
+      stop(start(time, cat, title, desc), time)
+
+      nil
+    rescue => e
+      error "failed to record span; msg=%s", e.message
+      @broken = true
+      nil
+    end
+
+    def instrument(cat, title=nil, desc=nil, annot=nil)
+      return if @broken
+      t { "instrument: #{cat}, #{title}" }
+
+      if Hash === title
+        annot = title
+        title = desc = nil
+      elsif Hash === desc
+        annot = desc
+        desc = nil
+      end
+
+      title.freeze if title.is_a?(String)
+      desc.freeze  if desc.is_a?(String)
+
+      original_desc = desc
+      now           = Util::Clock.nanos
+      desc          = @instrumenter.limited_description(desc)
+
+      if desc == Instrumenter::TOO_MANY_UNIQUES
+        debug "[SKYLIGHT] [#{Skylight::VERSION}] A payload description produced <too many uniques>"
+        debug "original desc=%s", original_desc
+        debug "cat=%s, title=%s, desc=%s, annot=%s", cat, title, desc, annot.inspect
+      end
+
+      start(now - gc_time, cat, title, desc, annot)
+    rescue => e
+      error "failed to instrument span; msg=%s", e.message
+      @broken = true
+      nil
+    end
+
+    def done(span)
+      return unless span
+      return if @broken
+      stop(span, Util::Clock.nanos - gc_time)
+    rescue => e
+      error "failed to close span; msg=%s", e.message
+      @broken = true
+      nil
+    end
+
+    def release
+      return unless @instrumenter.current_trace == self
+      @instrumenter.current_trace = nil
+    end
+
+    def traced
+      time = gc_time
+      now = Util::Clock.nanos
+
+      if time > 0
+        t { fmt "tracking GC time; duration=%d", time }
+        stop(start(now - time, GC_CAT, nil, nil, {}), now)
+      end
+
+      stop(@root, now)
+    end
+
+    def submit
+      return if @broken
+
+      t { "submitting trace" }
+
+      if @submitted
+        t { "already submitted" }
+        return
+      end
+
+      release
+      @submitted = true
+
+      traced
+
+      @instrumenter.process(self)
+    rescue Exception => e
+      error e
+      t { e.backtrace.join("\n") }
+    end
+
+  private
+
+    def start(time, cat, title, desc, annot=nil)
+      span(self.class.normalize_time(time), cat, title, desc, annot)
+    end
+
+    def stop(span, time)
+      native_stop_span(span, self.class.normalize_time(time))
+      nil
+    end
+
+    def span(time, cat, title=nil, desc=nil, annot=nil)
+      sp = native_start_span(time, cat.to_s)
+      native_span_set_title(sp, title.to_s) if title
+      native_span_set_description(sp, desc.to_s) if desc
+      sp
+    end
+
+    def gc_time
+      return 0 unless @gc
+      @gc.update
+      @gc.time
+    end
+  end
+end