baseline_red_rpm 1.0.0

data/lib/baseline_red_rpm/introspector.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module BaselineRedRpm
+  class Introspector
+
+    VALID_RUNNERS = [
+      :PhusionPassenger,
+      :Puma,
+      :Rainbows,
+      :Resque,
+      :Sidekiq,
+      :Sinatra,
+      :Unicorn,
+      :Webrick
+    ]
+    class << self
+
+      def agentable?
+        if raking? || rspecing?
+          BaselineRedRpm.logger.info("Detected rake, not initializing agent")
+          return false
+        end
+        BaselineRedRpm.logger.info("Detecting runner...")
+        VALID_RUNNERS.each do |runner|
+          if const_defined?(runner.to_s)
+            BaselineRedRpm.logger.info("#{runner} detected. You're valid")
+            return true
+          end
+        end
+        BaselineRedRpm.logger.info("No valid runner detected!")
+        false
+      end
+
+      def rspecing?
+        (File.basename($0) =~ /\Arspec/) == 0
+      end
+
+      def raking?
+        (File.basename($0) =~ /\Arake/) == 0
+      end
+
+      def const_defined?(string_const)
+        begin
+        Object.const_get(string_const)
+          true
+        rescue NameError
+          false
+        end
+      end
+
+    end
+  end
+end

data/lib/baseline_red_rpm/logger.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module BaselineRedRpm
+  class << self
+    attr_accessor :logger
+  end
+
+  class Logger
+    def info(msg)
+      BaselineRedRpm.info(msg)
+    end
+
+    def debug(msg)
+      BaselineRedRpm.info(msg)
+    end
+
+    def warn(msg)
+      BaselineRedRpm.info(msg)
+    end
+
+    def error(msg)
+      BaselineRedRpm.info(msg)
+    end
+
+    def fatal(msg)
+      BaselineRedRpm.info(msg)
+    end
+  end
+end
+
+BaselineRedRpm.logger = Logger.new(STDERR)
+BaselineRedRpm.logger.level = Logger::INFO

data/lib/baseline_red_rpm/rails.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+if defined?(::Rails)
+  if ::Rails::VERSION::MAJOR > 2
+    require 'baseline_red_rpm/railtie'
+  else
+    Rails.configuration.after_initialize do
+      unless BaselineRedRpm.disable_agent?
+        BaselineRedRpm.load
+        BaselineRedRpm.logger.info "Initializing rack middleware tracer."
+        Rails.configuration.middleware.insert 0, BaselineRedRpm::Instruments::Rack
+      end
+    end
+  end
+end

data/lib/baseline_red_rpm/railtie.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module BaselineRedRpm
+  class Railtie < ::Rails::Railtie
+    initializer "baseline_red.initialize" do |app|
+      unless BaselineRedRpm.disable_agent?
+        require 'baseline_red_rpm/instruments/rack'
+        BaselineRedRpm.logger.info "Initializing rack middleware tracer."
+        app.middleware.insert 0, BaselineRedRpm::Instruments::Rack
+      end
+
+      config.after_initialize do
+        BaselineRedRpm.config.app_root = Rails.root
+        BaselineRedRpm.config.reload
+        BaselineRedRpm.load
+      end
+    end
+  end
+end

data/lib/baseline_red_rpm/reporters/json_client.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'uri'
+require 'base64'
+
+module BaselineRedRpm
+  module Reporters
+    class JsonClient
+      def initialize(opts = { :url => nil, :collector => nil, :flush_interval => nil })
+        @collector = opts[:collector]
+        @flush_interval = opts[:flush_interval]
+        @spans_uri = URI.parse(opts[: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 = MessagePack.pack({
+          "name" => BaselineRedRpm.config.application_name,
+          "host" => BaselineRedRpm.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 = ::BaselineRedRpm.config.ssl
+
+        request = Net::HTTP::Post.new(@spans_uri.request_uri, {
+          "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/baseline_red_rpm/reporters/null_client.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module BaselineRedRpm
+  module Reporters
+    class NullClient
+      def initialize
+      end
+
+      def start
+      end
+
+      def stop
+      end
+    end
+  end
+end

data/lib/baseline_red_rpm/tracer.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module BaselineRedRpm
+  class Tracer
+    class << self
+      # 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, force = false)
+        # 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.
+        sample_off! if !BaselineRedRpm.tracer.active_span
+
+        # Now determine if we want to trace, either by an incoming
+        # trace or meeting the sample rate.
+        Thread.current[:sample] = force || !!incoming_trace || should_sample?
+        Thread.current[:sample]
+      end
+
+      def sample_off!
+        Thread.current[:sample] = false
+      end
+
+      def sampled?
+        !!Thread.current[:sample]
+      end
+
+      def tracing?
+        BaselineRedRpm.tracing? && sampled?
+      end
+
+      def random_percentage
+        rand * 100
+      end
+
+      def should_sample?
+        random_percentage <= ::BaselineRedRpm.config.sample_rate.to_i
+      end
+
+      def profile(layer, opts = {})
+        if defined?(TracePoint)
+          @times = {}
+          traces = []
+          tracer = TracePoint.new(:call, :return) do |tp|
+            backtrace = caller(0)
+            key = "#{tp.defined_class}_#{tp.method_id}_#{backtrace.size}"
+            if tp.event == :call
+              @times[key] = Time.now.to_f
+            else
+              if @times[key]
+                @times[key] = Time.now.to_f - @times[key].to_f
+                traces << {
+                  "duration "=> @times[key].to_f,
+                  "class" => tp.defined_class,
+                  "method" => tp.method_id,
+                  "backtrace" => backtrace,
+                  "line" => ::BaselineRedRpm::Backtrace.send(:clean_line, tp.path),
+                  "line_number" => tp.lineno
+                }
+              end
+            end
+          end
+
+          result = tracer.enable { yield }
+          @times = {}
+
+          return traces, result
+        else
+          return [], yield
+        end
+      end
+    end
+  end
+end

data/lib/baseline_red_rpm/tracing/buffer.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module BaselineRedRpm
+  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/baseline_red_rpm/tracing/carrier.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module BaselineRedRpm
+  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

data/lib/baseline_red_rpm/tracing/collector.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module BaselineRedRpm
+  module Tracing
+    class Collector
+      attr_reader :buffer
+
+      def initialize(local_endpoint)
+        @buffer = Buffer.new
+        @local_endpoint = local_endpoint
+      end
+
+      def retrieve
+        @buffer.retrieve
+      end
+
+      def send_span(span, end_time)
+        duration = end_time - span.start_time
+
+        @buffer << {
+          "traceId" => span.context.trace_id,
+          "id" => span.context.span_id,
+          "parentId" => span.context.parent_id,
+          "name" => span.operation_name,
+          "timestamp" => span.start_time,
+          "duration" => duration * 1_000,
+          "logEntries" => span.log_entries,
+          "tags" => span.tags
+        }
+      end
+    end
+  end
+end

data/lib/baseline_red_rpm/tracing/endpoint.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'socket'
+
+module BaselineRedRpm
+  module Tracing
+    class Endpoint
+      LOCAL_IP = (
+        Socket.ip_address_list.detect(&:ipv4_private?) ||
+        Socket.ip_address_list.reverse.detect(&:ipv4?)
+      ).ip_address
+
+      def self.local_endpoint(service_name)
+        {
+          "serviceName" => service_name,
+          "ipv4" => LOCAL_IP
+        }
+      end
+    end
+  end
+end

data/lib/baseline_red_rpm/tracing/managed_span.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module BaselineRedRpm
+  module Tracing
+    class ManagedSpan < Span
+      extend Forwardable
+
+      def_delegators :@span, :context, :operation_name=, :set_tag, :set_baggage_item, :get_baggage_item, :log, :finish
+
+      def initialize(span, deactivate)
+        @span = span
+        @deactivate = deactivate.respond_to?(:call) ? deactivate : nil
+        @active = true
+      end
+
+      def wrapped
+        @span
+      end
+
+      def active?
+        @active
+      end
+
+      def deactivate
+        if @active && @deactivate
+          deactivated_span = @deactivate.call
+          warn "ActiveSpan::SpanSource inconsistency found during deactivation" unless deactivated_span == self
+          @active = false
+        end
+      end
+
+      def finish(opts = {})
+        opts[:end_time] ||= BaselineRedRpm.now
+
+        deactivate
+        @span.finish(end_time: opts[:end_time])
+      end
+    end
+  end
+end

data/lib/baseline_red_rpm/tracing/managed_tracer.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module BaselineRedRpm
+  module Tracing
+    class ManagedTracer
+      extend Forwardable
+      def_delegators :@tracer, :inject, :extract
+
+      attr_reader :thread_span_stack
+
+      def initialize(tracer, thread_span_stack = ThreadSpanStack.new)
+        @tracer = tracer
+        @thread_span_stack = thread_span_stack
+      end
+
+      def wrapped
+        @tracer
+      end
+
+      def collector
+        @tracer.collector
+      end
+
+      def active_span
+        thread_span_stack.active_span
+      end
+
+      def start_span(operation_name, opts = {}, *args)
+        opts[:child_of] ||= active_span
+
+        span = @tracer.start_span(operation_name, opts, *args)
+        @thread_span_stack.set_active_span(span)
+      end
+    end
+  end
+end