app_perf_rpm 0.0.5 → 0.0.6

data/lib/app_perf_rpm/instruments/sequel.rb

@@ -21,11 +21,13 @@ module AppPerfRpm
         end
 
         {
-          "name" => opts[:type],
-          "query" => sanitize_sql(sql),
-          "database" => db_opts[:database],
-          "host" => db_opts[:host],
-          "adapter" => db_opts[:adapter]
+          "db.type" => opts[:type],
+          "db.statement" => sanitize_sql(sql),
+          "db.instance" => db_opts[:database],
+          "db.user" => db_opts[:user],
+          "db.vendor" => db_opts[:adapter],
+          "peer.address" => db_opts[:host],
+          "peer.port" => db_opts[:port]
         }
       end
     end
@@ -35,19 +37,22 @@ module AppPerfRpm
 
       def run_with_trace(sql, options = ::Sequel::OPTS)
         if ::AppPerfRpm::Tracer.tracing?
-          begin
-            ::AppPerfRpm::Tracer.trace("sequel") do |span|
-              span.options = parse_opts(sql, options)
+          span = ::AppPerfRpm.tracer.start_span("sequel", tags: parse_opts(sql, options))
+          span.set_tag "component", "Sequel"
+          span.set_tag "span.kind", "client"
+          span.log(event: "backtrace", stack: ::AppPerfRpm::Backtrace.backtrace)
+          span.log(event: "source", stack: ::AppPerfRpm::Backtrace.source_extract)
+        end
 
-              run_without_trace(sql, options)
-            end
-          rescue => e
-            ::AppPerfRpm.logger.error e.inspect
-            raise
-          end
-        else
-          run_without_trace(sql, options)
+        run_without_trace(sql, options)
+      rescue Exception => e
+        if span
+          span.set_tag('error', true)
+          span.log_error(e)
         end
+        raise
+      ensure
+        span.finish if span
       end
     end
 
@@ -56,25 +61,28 @@ module AppPerfRpm
 
       def execute_with_trace(sql, options = ::Sequel::OPTS, &block)
         if ::AppPerfRpm::Tracer.tracing?
-          begin
-            ::AppPerfRpm::Tracer.trace("sequel", opts) do |span|
-              span.options = parse_opts(sql, options)
+          span = ::AppPerfRpm.tracer.start_span("sequel", tags: parse_opts(sql, options))
+          span.set_tag "component", "Sequel"
+          span.set_tag "span.kind", "client"
+          span.log(event: "backtrace", stack: ::AppPerfRpm::Backtrace.backtrace)
+          span.log(event: "source", stack: ::AppPerfRpm::Backtrace.source_extract)
+        end
 
-              execute_without_trace(sql, options, &block)
-            end
-          rescue => e
-            ::AppPerfRpm.logger.error e.inspect
-            raise
-          end
-        else
-          execute_without_trace(sql, options, &block)
+        execute_without_trace(sql, options, &block)
+      rescue Exception => e
+        if span
+          span.set_tag('error', true)
+          span.log_error(e)
         end
+        raise
+      ensure
+        span.finish if span
       end
     end
   end
 end
 
-if ::AppPerfRpm.configuration.instrumentation[:sequel][:enabled] && defined?(::Sequel)
+if ::AppPerfRpm.config.instrumentation[:sequel][:enabled] && defined?(::Sequel)
   ::AppPerfRpm.logger.info "Initializing sequel tracer."
 
   ::Sequel::Database.send(:include, AppPerfRpm::Instruments::SequelDatabase)

data/lib/app_perf_rpm/instruments/sidekiq.rb

@@ -3,41 +3,85 @@ module AppPerfRpm
     def call(*args)
       worker, msg, queue = args
 
-      result = AppPerfRpm::Tracer.start_trace("sidekiq-worker") do |span|
-        span.type = "job"
-        span.controller = "Sidekiq_#{queue}"
-        span.action = msg["wrapped"]
-        span.url = "/sidekiq/#{queue}/#{msg['wrapped']}"
-        span.domain = Socket.gethostname
-        span.options = {
-          "job_name" => worker.class.to_s,
-          "queue" => queue
-        }
-
-        yield
+      parent_span_context = extract(msg)
+      AppPerfRpm::Tracer.sample!(parent_span_context)
+
+      if AppPerfRpm::Tracer.tracing?
+        operation = "Sidekiq_#{queue}##{msg["wrapped"]}"
+        span = AppPerfRpm.tracer.start_span(operation, :child_of => parent_span_context, tags: {
+          "component" => "Sidekiq",
+          "span.kind" => "server",
+          "http.url" => "/sidekiq/#{queue}/#{msg['wrapped']}",
+          "peer.address" => Socket.gethostname,
+          "bg.queue" => queue,
+          "bg.job_name" => worker.class.to_s
+        })
+        span.log(event: "backtrace", stack: ::AppPerfRpm::Backtrace.backtrace)
+        span.log(event: "source", stack: ::AppPerfRpm::Backtrace.source_extract)
+      end
+
+      yield
+    rescue Exception => e
+      if span
+        span.set_tag('error', true)
+        span.log_error(e)
       end
+      raise
+    ensure
+      span.finish if span
+    end
+
+    private
 
-      result
+    def extract(job)
+      carrier = job[AppPerfRpm::TRACE_CONTEXT_KEY]
+      return unless carrier
+      AppPerfRpm::tracer.extract(OpenTracing::FORMAT_TEXT_MAP, carrier)
     end
   end
 
   class SidekiqClient
     def call(*args)
+      worker, msg, queue = args
+
       if ::AppPerfRpm::Tracer.tracing?
-        worker, msg, queue = args
+        operation = "Sidekiq_#{queue}##{msg["wrapped"]}"
+        span = AppPerfRpm.tracer.start_span(operation, tags: {
+          "component" => "Sidekiq",
+          "span.kind" => "client",
+          "http.url" => "/sidekiq/#{queue}/#{msg['wrapped']}",
+          "peer.address" => Socket.gethostname,
+          "bg.queue" => queue,
+          "bg.job_name" => worker.class.to_s
+        })
+        span.log(event: "backtrace", stack: ::AppPerfRpm::Backtrace.backtrace)
+        span.log(event: "source", stack: ::AppPerfRpm::Backtrace.source_extract)
+
+        inject(span, msg)
+      end
 
-        result = AppPerfRpm::Tracer.trace("sidekiq-client") do |span|
-          yield
-        end
-      else
-        result = yield
+      yield
+    rescue Exception => e
+      if span
+        span.set_tag('error', true)
+        span.log_error(e)
       end
-      result
+      raise
+    ensure
+      span.finish if span
+    end
+
+    private
+
+    def inject(span, job)
+      carrier = {}
+      AppPerfRpm.tracer.inject(span.context, OpenTracing::FORMAT_TEXT_MAP, carrier)
+      job[AppPerfRpm::TRACE_CONTEXT_KEY] = carrier
     end
   end
 end
 
-if ::AppPerfRpm.configuration.instrumentation[:sidekiq][:enabled] &&
+if ::AppPerfRpm.config.instrumentation[:sidekiq][:enabled] &&
   defined?(::Sidekiq)
   AppPerfRpm.logger.info "Initializing sidekiq tracer."
 

data/lib/app_perf_rpm/instruments/sinatra.rb

@@ -4,15 +4,23 @@ module AppPerfRpm
       module Base
         def dispatch_with_trace
           if ::AppPerfRpm::Tracer.tracing?
-            ::AppPerfRpm::Tracer.trace("sinatra") do |span|
-              span.controller = self.class.to_s
-              span.action = env["PATH_INFO"]
+            operation = "#{self.class}##{env["PATH_INFO"]}"
+            span = ::AppPerfRpm.tracer.start_span(operation, tags: {
+              component: "Sinatra"
+            })
+            span.log(event: "backtrace", stack: ::AppPerfRpm::Backtrace.backtrace)
+            span.log(event: "source", stack: ::AppPerfRpm::Backtrace.source_extract)
+          end
 
-              dispatch_without_trace
-            end
-          else
-            dispatch_without_trace
+          dispatch_without_trace
+        rescue Exception => e
+          if span
+            span.set_tag('error', true)
+            span.log_error(e)
           end
+          raise
+        ensure
+          span.finish if span
         end
 
         def handle_exception_with_trace(boom)
@@ -25,27 +33,33 @@ module AppPerfRpm
           if ::AppPerfRpm::Tracer.tracing?
             name = data
 
-            ::AppPerfRpm::Tracer.trace("sinatra") do |span|
-              span.options = {
-                "engine" => engine,
-                "name" => name,
-                "type" => "render",
-                "file" => __FILE__,
-                "line_number" => __LINE__
-              }
+            span = ::AppPerfRpm.tracer.start_span("render", tags: {
+              "component" => "Sinatra",
+              "view.engine" => engine,
+              "view.name" => name,
+              "view.line_number" => __LINE__,
+              "view.template" => __FILE__
+            })
+            span.log(event: "backtrace", stack: ::AppPerfRpm::Backtrace.backtrace)
+            span.log(event: "source", stack: ::AppPerfRpm::Backtrace.source_extract)
+          end
 
-              render_without_trace(engine, data, options, locals, &block)
-            end
-          else
-            render_without_trace(engine, data, options, locals, &block)
+          render_without_trace(engine, data, options, locals, &block)
+        rescue Exception => e
+          if span
+            span.set_tag('error', true)
+            span.log_error(e)
           end
+          raise
+        ensure
+          span.finish if span
         end
       end
     end
   end
 end
 
-if ::AppPerfRpm.configuration.instrumentation[:sinatra][:enabled] &&
+if ::AppPerfRpm.config.instrumentation[:sinatra][:enabled] &&
   defined?(::Sinatra)
   ::AppPerfRpm.logger.info "Initializing sinatra tracer."
 

data/lib/app_perf_rpm/instruments/typhoeus.rb

@@ -2,43 +2,62 @@ module AppPerfRpm
   module Instruments
     module TyphoeusRequest
       def run_with_trace
-        if ::AppPerfRpm.tracing?
-          span = ::AppPerfRpm::Tracer.start_span("typhoeus")
-          response = run_without_trace
-          span.finish
+        if ::AppPerfRpm::Tracer.tracing?
+          span = ::AppPerfRpm.tracer.start_span("typhoeus", tags: {
+            "component" => "Typhoeus"
+          })
+          AppPerfRpm.tracer.inject(span.context, OpenTracing::FORMAT_RACK, options[:headers])
 
+          response = run_without_trace
+          span.exit
           uri = URI(response.effective_url)
 
-          span.options = {
-            "http_status" => response.code,
-            "remote_url" => uri.to_s,
-            "http_method" => options[:method]
-          }
-          span.submit(opts)
-
-          response
+          span.set_tag "http.status_code", response.code
+          span.set_tag "http.url", uri.to_s
+          span.set_tag "http.method", options[:method]
+          span.log(event: "backtrace", stack: ::AppPerfRpm::Backtrace.backtrace)
+          span.log(event: "source", stack: ::AppPerfRpm::Backtrace.source_extract)
         else
-          run_without_trace
+          response = run_without_trace
+        end
+        response
+      rescue Exception => e
+        if span
+          span.set_tag('error', true)
+          span.log_error(e)
         end
+        raise
+      ensure
+        span.finish if span
       end
     end
 
     module TyphoeusHydra
       def run_with_trace
-        ::AppPerfRpm::Tracer.trace("typhoeus") do |span|
-          span.options = {
-            "method" => :hydra,
-            "queued_requests" => queued_requests.count,
-            "max_concurrency" => max_concurrency
-          }
-          run_without_trace
+        span = ::AppPerfRpm.tracer.start_span("typhoeus", tags: {
+          "component" => "Typhoeus",
+          "method" => "hydra",
+          "http.queued_requests" => queued_requests.count,
+          "http.max_concurrency" => max_concurrency
+        })
+        span.log(event: "backtrace", stack: ::AppPerfRpm::Backtrace.backtrace)
+        span.log(event: "source", stack: ::AppPerfRpm::Backtrace.source_extract)
+
+        run_without_trace
+      rescue Exception => e
+        if span
+          span.set_tag('error', true)
+          span.log_error(e)
         end
+        raise
+      ensure
+        span.finish if span
       end
     end
   end
 end
 
-if ::AppPerfRpm.configuration.instrumentation[:typhoeus][:enabled] && defined?(::Typhoeus)
+if ::AppPerfRpm.config.instrumentation[:typhoeus][:enabled] && defined?(::Typhoeus)
   ::AppPerfRpm.logger.info "Initializing typhoeus tracer."
 
   ::Typhoeus::Request::Operations.send(:include, AppPerfRpm::Instruments::TyphoeusRequest)

data/lib/app_perf_rpm/rails.rb

@@ -5,7 +5,8 @@ if defined?(::Rails)
     Rails.configuration.after_initialize do
       unless AppPerfRpm.disable_agent?
         AppPerfRpm.load
-        Rails.configuration.middleware.use AppPerfRpm::Middleware
+        AppPerfRpm.logger.info "Initializing rack middleware tracer."
+        Rails.configuration.middleware.insert 0, AppPerfRpm::Instruments::Rack
       end
     end
   end

data/lib/app_perf_rpm/railtie.rb

@@ -1,15 +1,15 @@
 module AppPerfRpm
   class Railtie < ::Rails::Railtie
-    # TODO: Why this isn't working with the initializer?
     initializer "app_perf.initialize" do |app|
       unless AppPerfRpm.disable_agent?
         require 'app_perf_rpm/instruments/rack'
-        app.middleware.use AppPerfRpm::Middleware
+        AppPerfRpm.logger.info "Initializing rack middleware tracer."
+        app.middleware.insert 0, AppPerfRpm::Instruments::Rack
       end
 
       config.after_initialize do
-        AppPerfRpm.configuration.app_root = Rails.root
-        AppPerfRpm.configuration.reload
+        AppPerfRpm.config.app_root = Rails.root
+        AppPerfRpm.config.reload
         AppPerfRpm.load
       end
     end

data/lib/app_perf_rpm/reporters/json_client.rb

@@ -0,0 +1,69 @@
+require 'net/http'
+require 'uri'
+require 'json'
+require 'base64'
+
+module AppPerfRpm
+  module Reporters
+    class JsonClient
+      def initialize(url:, collector:, flush_interval:)
+        @collector = collector
+        @flush_interval = flush_interval
+        @spans_uri = URI.parse(url)
+      end
+
+      def start
+        @thread = Thread.new do
+          loop do
+            emit_batch(@collector.retrieve)
+            sleep @flush_interval
+          end
+        end
+      end
+
+      def stop
+        @thread.terminate if @thread
+        emit_batch(@collector.retrieve)
+      end
+
+      private
+
+      def compress_body(data)
+        body = Oj.dump({
+          "name" => AppPerfRpm.config.application_name,
+          "host" => AppPerfRpm.host,
+          "data" => data
+        })
+
+        compressed_body = Zlib::Deflate.deflate(body, Zlib::DEFAULT_COMPRESSION)
+        Base64.encode64(compressed_body)
+      end
+
+      def emit_batch(spans)
+        return if spans.empty?
+
+        sock = Net::HTTP.new(@spans_uri.host, @spans_uri.port)
+        sock.use_ssl = ::AppPerfRpm.config.ssl
+
+        request = Net::HTTP::Post.new(@spans_uri.request_uri, {
+          'Content-Type' => 'application/json',
+          "Accept-Encoding" => "gzip",
+          "User-Agent" => "gzip"
+        })
+        request.body = compress_body(spans)
+        request.content_type = "application/octet-stream"
+
+        response = sock.start do |http|
+          http.read_timeout = 30
+          http.request(request)
+        end
+
+        if response.code != 202
+          STDERR.puts(response.body)
+        end
+      rescue => e
+        STDERR.puts("Error emitting spans batch: #{e.message}\n#{e.backtrace.join("\n")}")
+      end
+    end
+  end
+end

data/lib/app_perf_rpm/reporters/null_client.rb

@@ -0,0 +1,14 @@
+module AppPerfRpm
+  module Reporters
+    class NullClient
+      def initialize
+      end
+
+      def start
+      end
+
+      def stop
+      end
+    end
+  end
+end

data/lib/app_perf_rpm/tracer.rb

@@ -1,69 +1,37 @@
+require 'opentracing'
+
 module AppPerfRpm
   class Tracer
     class << self
-      def trace_id
-        Thread.current[:trace_id]
+      # This method should be called by any components that are
+      # capable of starting the tracing process.
+      # ie. rack, sidekiq worker, etc
+      def sample!(incoming_trace = nil)
+        # Since we keep track of the active span, meaning we have entered into
+        # tracing at some point, and we no longer have an active span,
+        # reset tracing.
+        Thread.current[:sample] = false if !AppPerfRpm.tracer.active_span
+
+        # Now determine if we want to trace, either by an incoming
+        # trace or meeting the sample rate.
+        Thread.current[:sample] = !!incoming_trace || should_sample?
+        Thread.current[:sample]
       end
 
-      def trace_id=(t)
-        Thread.current[:trace_id] = t
+      def sampled?
+        !!Thread.current[:sample]
       end
 
       def tracing?
-        Thread.current[:trace_id]
-      end
-
-      def in_trace?
-        !Thread.current[:trace_id].nil?
-      end
-
-      def start_span(layer, opts = {})
-        Instance.new(layer, opts)
+        AppPerfRpm.tracing? && sampled?
       end
 
       def random_percentage
         rand * 100
       end
 
-      def should_trace?
-        random_percentage < ::AppPerfRpm.configuration.sample_rate.to_i
-      end
-
-      def start_trace(layer, opts = {})
-        start = Time.now.to_f
-
-        trace_id = opts.delete("trace_id")
-        if trace_id || should_trace?
-          self.trace_id = trace_id || generate_trace_id
-          result = trace(layer, opts) do |span|
-            yield(span)
-          end
-          self.trace_id = nil
-        else
-          span = Span.new
-          result = yield(span)
-        end
-
-        return result, (Time.now.to_f - start) * 1000
-      end
-
-      def trace(layer, opts = {})
-        result = nil
-
-        if tracing?
-          span = Span.new
-          span.layer = layer
-          span.trace_id = self.trace_id
-          span.started_at = Time.now.to_f
-          result = yield(span)
-          span.ended_at = Time.now.to_f
-          span.options.merge!(opts)
-          ::AppPerfRpm.store(span)
-        else
-          result = yield
-        end
-
-        result
+      def should_sample?
+        random_percentage <= ::AppPerfRpm.config.sample_rate.to_i
       end
 
       def profile(layer, opts = {})
@@ -98,43 +66,6 @@ module AppPerfRpm
           return [], yield
         end
       end
-
-      def log_event(event, opts = {})
-        ::AppPerfRpm.store([event, generate_trace_id, Time.now.to_f, opts])
-      end
-
-      def generate_trace_id
-        Digest::SHA1.hexdigest([Time.now, rand].join)
-      end
-
-      class Instance
-        attr_accessor :layer, :opts, :start, :duration
-
-        def initialize(layer, opts = {})
-          @span = Span.new
-          @span.layer = layer
-          @span.options = opts
-          @span.started_at = Time.now.to_f
-        end
-
-        def finish(opts = {})
-          @span.options.merge!(opts)
-          @span.ended_at = Time.now.to_f
-        end
-
-        def submit(opts = {})
-          if ::AppPerfRpm::Tracer.tracing?
-            @span.options.merge!(opts)
-            ::AppPerfRpm.store(@span)
-          end
-        end
-
-        private
-
-        def trace_id
-          ::AppPerfRpm::Tracer.trace_id
-        end
-      end
     end
   end
 end

data/lib/app_perf_rpm/tracing/buffer.rb

@@ -0,0 +1,25 @@
+module AppPerfRpm
+  module Tracing
+    class Buffer
+      def initialize
+        @buffer = []
+        @mutex = Mutex.new
+      end
+
+      def <<(element)
+        @mutex.synchronize do
+          @buffer << element
+          true
+        end
+      end
+
+      def retrieve
+        @mutex.synchronize do
+          elements = @buffer.dup
+          @buffer.clear
+          elements
+        end
+      end
+    end
+  end
+end

data/lib/app_perf_rpm/tracing/carrier.rb

@@ -0,0 +1,23 @@
+module AppPerfRpm
+  module Tracing
+    class Carrier
+      def initialize
+        @data = {}
+      end
+
+      def [](key)
+        @data[key]
+      end
+
+      def []=(key, value)
+        @data[key] = value
+      end
+
+      def each(&block)
+        @data.each do |datum|
+          yield(datum)
+        end
+      end
+    end
+  end
+end