truex-skylight 0.6.0

data/lib/skylight/formatters/http.rb

@@ -0,0 +1,17 @@
+module Skylight
+  module Formatters
+    module HTTP
+      def self.build_opts(method, scheme, host, port, path, query)
+        { category: "api.http.#{method.downcase}",
+          title:    "#{method.upcase} #{host}",
+          annotations: {
+            method: method.upcase,
+            scheme: scheme,
+            host:   host,
+            port:   port ? port.to_i : nil,
+            path:   path,
+            query:  query }}
+      end
+    end
+  end
+end

data/lib/skylight/gc.rb

@@ -0,0 +1,107 @@
+require 'thread'
+
+module Skylight
+  # @api private
+  class GC
+    METHODS   = [ :enable, :total_time ]
+    TH_KEY    = :SK_GC_CURR_WINDOW
+    MAX_COUNT = 1000
+    MAX_TIME  = 30_000_000
+
+    include Util::Logging
+
+    attr_reader :config
+
+    def initialize(config, profiler)
+      @listeners = []
+      @config    = config
+      @lock      = Mutex.new
+      @time      = 0
+
+      if METHODS.all? { |m| profiler.respond_to?(m) }
+        @profiler = profiler
+        @time = @profiler.total_time
+      else
+        debug "disabling GC profiling"
+      end
+    end
+
+    def enable
+      @profiler.enable if @profiler
+    end
+
+    def track
+      unless @profiler
+        win = Window.new(nil)
+      else
+        win = Window.new(self)
+
+        @lock.synchronize do
+          __update
+          @listeners << win
+
+          # Cleanup any listeners that might have leaked
+          until @listeners[0].time < MAX_TIME
+            @listeners.shift
+          end
+
+          if @listeners.length > MAX_COUNT
+            @listeners.shift
+          end
+        end
+      end
+
+      win
+    end
+
+    def release(win)
+      @lock.synchronize do
+        @listeners.delete(win)
+      end
+    end
+
+    def update
+      @lock.synchronize do
+        __update
+      end
+
+      nil
+    end
+
+  private
+
+    def __update
+      time  = @profiler.total_time
+      diff  = time - @time
+      @time = time
+
+      if diff > 0
+        @listeners.each do |l|
+          l.add(diff)
+        end
+      end
+    end
+
+    class Window
+      attr_reader :time
+
+      def initialize(global)
+        @global = global
+        @time   = 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/helpers.rb

@@ -0,0 +1,137 @@
+module Skylight
+  # Instrumenting a specific method will cause an event to be created every time that method is called.
+  # The event will be inserted at the appropriate place in the Skylight trace.
+  #
+  # To instrument a method, the first thing to do is include {Skylight::Helpers Skylight::Helpers}
+  # into the class that you will be instrumenting. Then, annotate each method that
+  # you wish to instrument with {Skylight::Helpers::ClassMethods#instrument_method instrument_method}.
+  module Helpers
+
+    # @see Skylight::Helpers
+    module ClassMethods
+      # @api private
+      def method_added(name)
+        super
+
+        if opts = @__sk_instrument_next_method
+          @__sk_instrument_next_method = nil
+          title = "#{to_s}##{name}"
+          __sk_instrument_method_on(self, name, title, opts)
+        end
+      end
+
+      # @api private
+      def singleton_method_added(name)
+        super
+
+        if opts = @__sk_instrument_next_method
+          @__sk_instrument_next_method = nil
+          title = "#{to_s}.#{name}"
+          __sk_instrument_method_on(__sk_singleton_class, name, title, opts)
+        end
+      end
+
+      # @overload instrument_method
+      #   Instruments the following method
+      #
+      #   @example
+      #     class MyClass
+      #       include Skylight::Helpers
+      #
+      #       instrument_method
+      #       def my_method
+      #         do_expensive_stuff
+      #       end
+      #
+      #     end
+      #
+      # @overload instrument_method([name], opts={})
+      #   @param [Symbol|String] [name]
+      #   @param [Hash] opts
+      #   @option opts [String] :category ('app.method')
+      #   @option opts [String] :title (ClassName#method_name)
+      #   @option opts [String] :description
+      #
+      #   You may also declare the methods to instrument at any time by passing the name
+      #   of the method as the first argument to `instrument_method`.
+      #
+      #   @example With name
+      #     class MyClass
+      #       include Skylight::Helpers
+      #
+      #       def my_method
+      #         do_expensive_stuff
+      #       end
+      #
+      #       instrument_method :my_method
+      #
+      #     end
+      #
+      #   By default, the event will be titled using the name of the class and the
+      #   method. For example, in our previous example, the event name will be:
+      #   +MyClass#my_method+. You can customize this by passing using the *:title* option.
+      #
+      #   @example Without name
+      #     class MyClass
+      #       include Skylight::Helpers
+      #
+      #       instrument_method title: 'Expensive work'
+      #       def my_method
+      #         do_expensive_stuff
+      #       end
+      #     end
+      def instrument_method(*args)
+        opts = args.pop if Hash === args.last
+
+        if name = args.pop
+          title = "#{to_s}##{name}"
+          __sk_instrument_method_on(self, name, title, opts || {})
+        else
+          @__sk_instrument_next_method = opts || {}
+        end
+      end
+
+    private
+
+      def __sk_instrument_method_on(klass, name, title, opts)
+        category = (opts[:category] || "app.method").to_s
+        title    = (opts[:title] || title).to_s
+        desc     = opts[:description].to_s if opts[:description]
+
+        klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          alias_method :"before_instrument_#{name}", :"#{name}"
+
+          def #{name}(*args, &blk)
+            span = Skylight.instrument(
+              category:  :"#{category}",
+              title:       #{title.inspect},
+              description: #{desc.inspect})
+
+            begin
+              before_instrument_#{name}(*args, &blk)
+            ensure
+              Skylight.done(span) if span
+            end
+          end
+        RUBY
+      end
+
+      if respond_to?(:singleton_class)
+        alias :__sk_singleton_class :singleton_class
+      else
+        def __sk_singleton_class
+          class << self; self; end
+        end
+      end
+    end
+
+    # @api private
+    def self.included(base)
+      base.class_eval do
+        @__sk_instrument_next_method = nil
+        extend ClassMethods
+      end
+    end
+
+  end
+end

data/lib/skylight/instrumenter.rb

@@ -0,0 +1,290 @@
+require 'thread'
+require 'strscan'
+require 'skylight/api'
+
+module Skylight
+  # @api private
+  class Instrumenter
+    KEY  = :__skylight_current_trace
+    LOCK = Mutex.new
+    DESC_LOCK = Mutex.new
+
+    TOO_MANY_UNIQUES = "<too many unique descriptions>"
+
+    include Util::Logging
+
+    class TraceInfo
+      def current
+        Thread.current[KEY]
+      end
+
+      def current=(trace)
+        Thread.current[KEY] = trace
+      end
+    end
+
+    def self.instance
+      @instance
+    end
+
+    # Do start
+    # @param [Config] config The config
+    def self.start!(config = nil)
+      return @instance if @instance
+
+      LOCK.synchronize do
+        return @instance if @instance
+        @instance = new(config).start!
+      end
+    rescue => e
+      message = sprintf("[SKYLIGHT] [#{Skylight::VERSION}] Unable to start Instrumenter; msg=%s; class=%s", e.message, e.class)
+      if config && config.respond_to?(:logger)
+        config.logger.warn message
+      else
+        warn message
+      end
+      false
+    end
+
+    def self.stop!
+      LOCK.synchronize do
+        return unless @instance
+        # This is only really helpful for getting specs to pass.
+        @instance.current_trace = nil
+
+        @instance.shutdown
+        @instance = nil
+      end
+    end
+
+    at_exit do
+      if RUBY_VERSION == '1.9.2'
+        # workaround for MRI bug losing exit status in at_exit block
+        # http://bugs.ruby-lang.org/issues/5218
+        exit_status = $!.status if $!.is_a?(SystemExit)
+        stop!
+        exit exit_status if exit_status
+      else
+        stop!
+      end
+    end
+
+    attr_reader :config, :gc, :trace_info
+
+    def self.new(config)
+      config ||= {}
+      config = Config.load(config) unless config.is_a?(Config)
+      config.validate!
+
+      inst = native_new(config.to_env)
+      inst.send(:initialize, config)
+      inst
+    end
+
+    def initialize(config)
+      @gc = config.gc
+      @config = config
+      @subscriber = Subscriber.new(config, self)
+
+      @trace_info = @config[:trace_info] || TraceInfo.new
+      @descriptions = Hash.new { |h,k| h[k] = {} }
+    end
+
+    def current_trace
+      @trace_info.current
+    end
+
+    def current_trace=(trace)
+      @trace_info.current = trace
+    end
+
+    def start!
+      # 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)
+
+      unless Skylight.native?
+        Skylight.warn_skylight_native_missing(config)
+        return
+      end
+
+      t { "starting instrumenter" }
+      @config.validate!
+
+      unless validate_authentication
+        warn "invalid authentication token"
+        return
+      end
+
+      t { "starting native instrumenter" }
+      unless native_start
+        warn "failed to start instrumenter"
+        return
+      end
+
+      @config.gc.enable
+      @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!
+      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
+        return yield(trace) if block_given?
+        return trace
+      end
+
+      begin
+        trace = Trace.new(self, endpoint, Util::Clock.nanos, cat, title, desc, annot)
+      rescue Exception => e
+        log_error e.message
+        t { e.backtrace.join("\n") }
+        return
+      end
+
+      @trace_info.current = trace
+      return trace unless block_given?
+
+      begin
+        yield trace
+
+      ensure
+        @trace_info.current = nil
+        t { "submitting trace" }
+        trace.submit
+      end
+    end
+
+    def disable
+      @disabled = true
+      yield
+    ensure
+      @disabled = false
+    end
+
+    def disabled?
+      @disabled
+    end
+
+    @scanner = StringScanner.new('')
+    def self.match?(string, regex)
+      @scanner.string = string
+      @scanner.match?(regex)
+    end
+
+    def match?(string, regex)
+      self.class.match?(string, regex)
+    end
+
+    def done(span)
+      return unless trace = @trace_info.current
+      trace.done(span)
+    end
+
+    def instrument(cat, title=nil, desc=nil, annot=nil)
+      raise ArgumentError, 'cat is required' unless cat
+
+      unless trace = @trace_info.current
+        return yield if block_given?
+        return
+      end
+
+      cat = cat.to_s
+
+      unless match?(cat, CATEGORY_REGEX)
+        warn "invalid skylight instrumentation category; value=%s", cat
+        return yield if block_given?
+        return
+      end
+
+      cat = "other.#{cat}" unless match?(cat, TIER_REGEX)
+
+      unless sp = trace.instrument(cat, title, desc, annot)
+        return yield if block_given?
+        return
+      end
+
+      return sp unless block_given?
+
+      begin
+        yield sp
+      ensure
+        trace.done(sp)
+      end
+    end
+
+    def limited_description(description)
+      endpoint = @trace_info.current.endpoint
+
+      DESC_LOCK.synchronize do
+        set = @descriptions[endpoint]
+
+        if set.size >= 100
+          return TOO_MANY_UNIQUES
+        end
+
+        set[description] = true
+        description
+      end
+    end
+
+    def process(trace)
+      t { fmt "processing trace" }
+
+      if ignore?(trace)
+        t { fmt "ignoring trace" }
+        return false
+      end
+
+      begin
+        native_submit_trace(trace)
+        true
+      rescue => e
+        warn "failed to submit trace to worker; err=%s", e
+        false
+      end
+    end
+
+    def ignore?(trace)
+      @config.ignored_endpoints.include?(trace.endpoint)
+    end
+
+    # Validates that the provided authentication token is valid. This is done
+    # by issuing a request for a session token and checking the response
+    def validate_authentication
+      # If a session token is specified, don't bother attempting to validate
+      if config[:session_token]
+        debug "using pre-generated session token"
+        true
+      else
+        api = Api.new(config)
+        api.authentication = config[:authentication]
+
+        case res = api.validate_authentication
+        when :ok
+          true
+        when :invalid
+          false
+        when :unknown
+          warn "unable to validate authentication token"
+          true
+        else
+          error "[BUG] unexpected validate_token result; res=%s", res
+          true
+        end
+      end
+    end
+
+  end
+end