truex-skylight 0.6.0

data/lib/skylight/sinatra.rb

@@ -0,0 +1,4 @@
+require 'skylight'
+require 'skylight/probes/sinatra'
+require 'skylight/probes/tilt'
+require 'skylight/probes/sequel'

data/lib/skylight/subscriber.rb

@@ -0,0 +1,92 @@
+module Skylight
+  # @api private
+  class Subscriber
+    include Util::Logging
+
+    attr_reader :config
+
+    def initialize(config, instrumenter)
+      @config       = config
+      @subscriber   = nil
+      @normalizers  = Normalizers.build(config)
+      @instrumenter = instrumenter
+    end
+
+    def register!
+      unregister! if @subscriber
+      @subscriber = ActiveSupport::Notifications.subscribe nil, self
+    end
+
+    def unregister!
+      ActiveSupport::Notifications.unsubscribe @subscriber
+      @subscriber = nil
+    end
+
+    #
+    #
+    # ===== ActiveSupport::Notifications API
+    #
+    #
+
+    class Notification
+      attr_reader :name, :span
+
+      def initialize(name, span)
+        @name, @span = name, span
+      end
+    end
+
+    def start(name, id, payload)
+      return if @instrumenter.disabled?
+      return unless trace = @instrumenter.current_trace
+
+      cat, title, desc, annot = normalize(trace, name, payload)
+
+      unless cat == :skip
+        span = trace.instrument(cat, title, desc, annot)
+      end
+
+      trace.notifications << Notification.new(name, span)
+    rescue Exception => e
+      error "Subscriber#start error; msg=%s", e.message
+      debug "trace=%s", trace.inspect
+      debug "in:  name=%s", name.inspect
+      debug "in:  payload=%s", payload.inspect
+      debug "out: cat=%s, title=%s, desc=%s", cat.inspect, name.inspect, desc.inspect
+      debug "out: annot=%s", annot.inspect
+      t { e.backtrace.join("\n") }
+      nil
+    end
+
+    def finish(name, id, payload)
+      return if @instrumenter.disabled?
+      return unless trace = @instrumenter.current_trace
+
+      while curr = trace.notifications.pop
+        if curr.name == name
+          trace.done(curr.span) if curr.span
+          return
+        end
+      end
+
+    rescue Exception => e
+      error "Subscriber#finish error; msg=%s", e.message
+      debug "trace=%s", trace.inspect
+      debug "in:  name=%s", name.inspect
+      debug "in:  payload=%s", payload.inspect
+      t { e.backtrace.join("\n") }
+      nil
+    end
+
+    def publish(name, *args)
+      # Ignored for now because nothing in rails uses it
+    end
+
+  private
+
+    def normalize(*args)
+      @normalizers.normalize(*args)
+    end
+
+  end
+end

data/lib/skylight/trace.rb

@@ -0,0 +1,191 @@
+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
+      @traced = 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
+      @traced = true
+      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 unless @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

data/lib/skylight/util.rb

@@ -0,0 +1,16 @@
+module Skylight
+  # @api private
+  module Util
+    # Used from the main lib
+    require 'skylight/util/allocation_free'
+    require 'skylight/util/clock'
+    require 'skylight/util/hostname'
+    require 'skylight/util/logging'
+    require 'skylight/util/ssl'
+    require 'skylight/util/http'
+
+    # Used from the CLI
+    autoload :Gzip,      'skylight/util/gzip'
+    autoload :Inflector, 'skylight/util/inflector'
+  end
+end

data/lib/skylight/util/allocation_free.rb

@@ -0,0 +1,17 @@
+module Skylight
+  module Util
+    module AllocationFree
+      def array_find(array)
+        i = 0
+
+        while i < array.size
+          item = array[i]
+          return item if yield item
+          i += 1
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/skylight/util/clock.rb

@@ -0,0 +1,53 @@
+module Skylight
+  module Util
+    class Clock
+
+      if Skylight.native?
+        def tick
+          native_hrtime
+        end
+      else
+        def tick
+          now = Time.now
+          now.to_i * 1_000_000_000 + now.usec * 1_000
+        end
+      end
+
+      # TODO: rename to secs
+      def absolute_secs
+        Time.now.to_i
+      end
+
+      # TODO: remove
+      def nanos
+        tick
+      end
+
+      # TODO: remove
+      def secs
+        nanos / 1_000_000_000
+      end
+
+      def self.absolute_secs
+        default.absolute_secs
+      end
+
+      def self.nanos
+        default.nanos
+      end
+
+      def self.secs
+        default.secs
+      end
+
+      def self.default
+        @clock ||= Clock.new
+      end
+
+      def self.default=(clock)
+        @clock = clock
+      end
+
+    end
+  end
+end

data/lib/skylight/util/gzip.rb

@@ -0,0 +1,15 @@
+require 'zlib'
+
+module Skylight
+  module Util
+    module Gzip
+      def self.compress(str)
+        output = StringIO.new
+        gz = Zlib::GzipWriter.new(output)
+        gz.write(str)
+        gz.close
+        output.string
+      end
+    end
+  end
+end

data/lib/skylight/util/hostname.rb

@@ -0,0 +1,17 @@
+require 'socket'
+require 'securerandom'
+
+module Skylight
+  module Util
+    module Hostname
+      def self.default_hostname
+        if hostname = Socket.gethostname
+          hostname.strip!
+          hostname = nil if hostname == ''
+        end
+
+        hostname || "gen-#{SecureRandom.uuid}"
+      end
+    end
+  end
+end

data/lib/skylight/util/http.rb

@@ -0,0 +1,218 @@
+require 'uri'
+require 'json'
+require 'openssl'
+require 'net/http'
+require 'net/https'
+require 'skylight/util/gzip'
+require 'skylight/util/ssl'
+
+module Skylight
+  module Util
+    class HTTP
+      CONTENT_ENCODING = 'content-encoding'.freeze
+      CONTENT_LENGTH   = 'content-length'.freeze
+      CONTENT_TYPE     = 'content-type'.freeze
+      ACCEPT           = 'Accept'.freeze
+      X_VERSION_HDR    = 'x-skylight-agent-version'.freeze
+      APPLICATION_JSON = 'application/json'.freeze
+      AUTHORIZATION    = 'authorization'.freeze
+      DEFLATE          = 'deflate'.freeze
+      GZIP             = 'gzip'.freeze
+
+      include Logging
+
+      attr_accessor :authentication
+      attr_reader :host, :port
+
+      READ_EXCEPTIONS = [Timeout::Error, EOFError]
+      # This doesn't exist on Ruby 1.9.3
+      READ_EXCEPTIONS << Net::ReadTimeout if defined?(Net::ReadTimeout)
+      READ_EXCEPTIONS.freeze
+
+      class StartError < StandardError; end
+      class ReadResponseError < StandardError; end
+
+      def initialize(config, service = :auth, opts = {})
+        @config = config
+
+        unless url = config["#{service}_url"]
+          raise ArgumentError, "no URL specified"
+        end
+
+        url = URI.parse(url)
+
+        @ssl  = url.scheme == 'https'
+        @host = url.host
+        @port = url.port
+
+        if proxy_url = config[:proxy_url]
+          proxy_url = URI.parse(proxy_url)
+          @proxy_addr, @proxy_port = proxy_url.host, proxy_url.port
+          @proxy_user, @proxy_pass = (proxy_url.userinfo || '').split(/:/)
+        end
+
+        @open_timeout = get_timeout(:connect, config, service, opts)
+        @read_timeout = get_timeout(:read, config, service, opts)
+
+        @deflate = config["#{service}_http_deflate"]
+        @authentication = config[:'authentication']
+      end
+
+      def get(endpoint, hdrs = {})
+        request = build_request(Net::HTTP::Get, endpoint, hdrs)
+        execute(request)
+      end
+
+      def post(endpoint, body, hdrs = {})
+        unless body.respond_to?(:to_str)
+          hdrs[CONTENT_TYPE] = APPLICATION_JSON
+          body = body.to_json
+        end
+
+        request = build_request(Net::HTTP::Post, endpoint, hdrs, body.bytesize)
+        execute(request, body)
+      end
+
+    private
+
+      def get_timeout(type, config, service, opts)
+        config.duration_ms("#{service}_http_#{type}_timeout") ||
+          opts[:timeout] || 15
+      end
+
+      def build_request(type, endpoint, hdrs, length=nil)
+        headers = {}
+
+        headers[CONTENT_LENGTH]   = length.to_s if length
+        headers[AUTHORIZATION]    = authentication if authentication
+        headers[ACCEPT]           = APPLICATION_JSON
+        headers[X_VERSION_HDR]    = VERSION
+        headers[CONTENT_ENCODING] = GZIP if length && @deflate
+
+        hdrs.each do |k, v|
+          headers[k] = v
+        end
+
+        type.new(endpoint, headers)
+      end
+
+      def do_request(http, req)
+        begin
+          client = http.start
+        rescue => e
+          # TODO: Retry here
+          raise StartError, e.inspect
+        end
+
+        begin
+          res = client.request(req)
+        rescue *READ_EXCEPTIONS => e
+          raise ReadResponseError, e.inspect
+        end
+
+        yield res
+      ensure
+        client.finish if client
+      end
+
+      def execute(req, body=nil)
+        t { fmt "executing HTTP request; host=%s; port=%s; path=%s, body=%s",
+              @host, @port, req.path, body && body.bytesize }
+
+        if body
+          body = Gzip.compress(body) if @deflate
+          req.body = body
+        end
+
+        http = Net::HTTP.new(@host, @port,
+          @proxy_addr, @proxy_port, @proxy_user, @proxy_pass)
+
+        http.open_timeout = @open_timeout
+        http.read_timeout = @read_timeout
+
+        if @ssl
+          http.use_ssl = true
+
+          unless SSL.ca_cert_file?
+            http.ca_file = SSL.ca_cert_file_or_default
+          end
+
+          http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        end
+
+        do_request(http, req) do |res|
+          unless res.code =~ /2\d\d/
+            debug "server responded with #{res.code}"
+            t { fmt "body=%s", res.body }
+          end
+
+          Response.new(res.code.to_i, res, res.body)
+        end
+      rescue Exception => e
+        error "http %s %s failed; error=%s; msg=%s", req.method, req.path, e.class, e.message
+        t { e.backtrace.join("\n") }
+        ErrorResponse.new(req, e)
+      end
+
+      class Response
+        attr_reader :status, :headers, :body, :exception
+
+        def initialize(status, headers, body)
+          @status  = status
+          @headers = headers
+
+          if (headers[CONTENT_TYPE] || "").include?(APPLICATION_JSON)
+            begin
+              @body = JSON.parse(body)
+            rescue JSON::ParserError
+              @body = body # not really JSON I guess
+            end
+          else
+            @body = body
+          end
+        end
+
+        def success?
+          status >= 200 && status < 300
+        end
+
+        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
+
+      class ErrorResponse < Struct.new(:request, :exception)
+        def status
+          nil
+        end
+
+        def success?
+          false
+        end
+      end
+
+    end
+  end
+end