baseline_red_rpm 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2f48e985c64b6fe5ef0768cd698bdff34087adaf
+  data.tar.gz: 616121b88979893ded3bdc189d275621aee00f34
+SHA512:
+  metadata.gz: 472252bfc20315849876f30e1c9cff7a7916f53ffa0ffa300812344215168733ba4044d02127870ae0730f0568ef2a69f5eae0baa1c290c46ee71777ac1c9fc5
+  data.tar.gz: f1460dd9d695924e8ffcc177ba4ac96962dac1f73f2ea77e5a5378a551d7947be8bb6672c22053e80fbb0c5d921868a732ed29580c48fcc14128a57843a7fdf1

data/lib/baseline_red_rpm.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module BaselineRedRpm
+  require "opentracing"
+  require 'msgpack'
+  
+  require 'baseline_red_rpm/logger'
+  require 'baseline_red_rpm/configuration'
+  require 'baseline_red_rpm/backtrace'
+
+  require 'baseline_red_rpm/reporters/json_client'
+  require 'baseline_red_rpm/reporters/null_client'
+
+  require 'baseline_red_rpm/tracing/buffer'
+  require 'baseline_red_rpm/tracing/carrier'
+  require 'baseline_red_rpm/tracing/collector'
+  require 'baseline_red_rpm/tracing/endpoint'
+  require 'baseline_red_rpm/tracing/trace_id'
+  require 'baseline_red_rpm/tracing/span_context'
+  require 'baseline_red_rpm/tracing/span'
+  require 'baseline_red_rpm/tracing/managed_span'
+  require 'baseline_red_rpm/tracing/tracer'
+  require 'baseline_red_rpm/tracing/managed_tracer'
+  require 'baseline_red_rpm/tracing/thread_span_stack'
+
+  require 'baseline_red_rpm/tracer'
+  require 'baseline_red_rpm/utils'
+  require 'baseline_red_rpm/instrumentation'
+  require 'baseline_red_rpm/rails'
+  require 'baseline_red_rpm/introspector'
+
+  TRACE_CONTEXT_KEY = 'BaselineRed-Trace-Context'
+
+  class << self
+
+    attr_writer :config
+
+    def config
+      @config ||= Configuration.new
+    end
+
+    def configure
+      yield(config)
+    end
+
+    def load
+      #Oj.mimic_JSON
+      unless disable_agent?
+        BaselineRedRpm::Instrumentation.load
+        BaselineRedRpm.tracing_on
+      end
+    end
+
+    def mutex
+      @mutex ||= Mutex.new
+    end
+
+    def endpoint
+      @endpoint ||= BaselineRedRpm::Tracing::Endpoint.local_endpoint(config.application_name)
+    end
+
+    def collector
+      @collector ||= BaselineRedRpm::Tracing::Collector.new(endpoint)
+    end
+
+    def url
+      @url ||= "#{config.host}/api/listener/3/#{config.license_key}"
+    end
+
+    def sender
+      @sender ||= BaselineRedRpm::Reporters::JsonClient.new(
+        url: url,
+        collector: collector,
+        flush_interval: config.flush_interval
+      )
+    end
+
+    def tracer
+      @tracer ||= BaselineRedRpm::Tracing::ManagedTracer.new(
+        BaselineRedRpm::Tracing::Tracer.build(
+          :service_name => config.application_name,
+          :sender => sender,
+          :collector => collector
+        ),
+        BaselineRedRpm::Tracing::ThreadSpanStack.new
+      )
+    end
+
+    def tracing_on
+      if @without_tracing_enabled
+        BaselineRedRpm.logger.debug "Not turning tracing on due to without tracing mode."
+        return
+      end
+      mutex.synchronize do
+        BaselineRedRpm.logger.debug "Enabling tracing."
+        @tracing = true
+      end
+    end
+
+    def tracing_off
+      mutex.synchronize do
+        BaselineRedRpm.logger.debug "Disabling tracing."
+        @tracing = false
+      end
+    end
+
+    def tracing?
+      !!@tracing
+    end
+
+    def without_tracing
+      @previously_tracing = BaselineRedRpm.tracing?
+      @without_tracing_enabled = true
+      BaselineRedRpm.tracing_off
+      yield if block_given?
+      @without_tracing_enabled = false
+    ensure
+      BaselineRedRpm.tracing_on if @previously_tracing
+    end
+
+    def host
+      @host ||= Socket.gethostname
+    end
+
+    def round_time(t, sec = 1)
+      t = Time.parse(t.to_s)
+
+      down = t - (t.to_i % sec)
+      up = down + sec
+
+      difference_down = t - down
+      difference_up = up - t
+
+      if (difference_down < difference_up)
+        return down
+      else
+        return up
+      end
+    end
+
+    def floor_time(t, sec = 1)
+      Time.at((t.to_f / sec).floor * sec)
+    end
+
+    def disable_agent?
+      if config.agent_disabled
+        true
+      elsif Introspector.agentable?
+        false
+      else
+        true
+      end
+    end
+
+    def now
+      if defined?(Process::CLOCK_REALTIME)
+        Process.clock_gettime(Process::CLOCK_REALTIME)
+      else
+        Time.now
+      end
+    end
+
+  end
+end

data/lib/baseline_red_rpm/backtrace.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module BaselineRedRpm
+  class Backtrace
+    class << self
+      def backtrace(opts = {})
+        kind = opts[:kind]
+
+        if kind
+          bt = Kernel.caller
+          bt = clean(bt)
+          bt = filter(bt, kind)
+          trim_backtrace(bt)
+        end
+      end
+
+      def clean(backtrace)
+        Array(backtrace)
+          .map {|b| clean_line(b) }
+          .select {|b| b !~ %r{lib/baseline_red_rpm} }
+      end
+
+      def filter(backtrace, kind)
+        case kind
+        when :all
+          backtrace
+        when :app
+          backtrace.select {|b| b =~ /\[APP_PATH\]/ }
+        when :gem
+          backtrace.select {|b| b =~ /\[GEM_PATH\]/ }
+        else
+          []
+        end
+      end
+
+      #def source_extract(_backtrace = Kernel.caller(2))
+      #  if(trace = _backtrace.first)
+      #    file, line_number = extract_file_and_line_number(trace)
+
+      #    {
+      #      code: source_fragment(file, line_number),
+      #      line_number: line_number
+      #    }
+      #  else
+      #    nil
+      #  end
+      #end
+
+      def source_extract(opts = {})
+        backtrace = opts[:backtrace] || Kernel.caller(0)
+
+        Array(backtrace).select {|bt| bt[/^#{::BaselineRedRpm.config.app_root.to_s}\//] }.map do |trace|
+          file, line_number = extract_file_and_line_number(trace)
+          source_to_hash(file, line_number)
+        end
+      end
+
+      def source_to_hash(file, line_number)
+        {
+          "file" => clean_line(file),
+          "code" => source_fragment(file, line_number),
+          "line_number" => line_number
+        }
+      end
+
+      def clean_line(line)
+        line
+          .sub(/#{::BaselineRedRpm.config.app_root.to_s}\//, "[APP_PATH]/")
+          .sub(gems_regexp, '\2 (\3) [GEM_PATH]/\4')
+      end
+
+      private
+
+      def gems_regexp
+        gems_paths = (Gem.path | [Gem.default_dir]).map { |p| Regexp.escape(p) }
+        if gems_paths
+          %r{(#{gems_paths.join('|')})/gems/([^/]+)-([\w.]+)/(.*)}
+        else
+          nil
+        end
+      end
+
+      def source_fragment(path, line)
+        return unless BaselineRedRpm.config.app_root
+        full_path = BaselineRedRpm.config.app_root.join(path)
+        if File.exist?(full_path)
+          File.open(full_path, "r") do |file|
+            start = [line - 3, 0].max
+            lines = file.each_line.drop(start).take(6)
+            Hash[*(start + 1..(lines.count + start)).zip(lines).flatten]
+          end
+        end
+      end
+
+      def extract_file_and_line_number(trace)
+        file, line = trace.match(/^(.+?):(\d+).*$/, &:captures) || trace
+        [file, line.to_i]
+      end
+
+      def trim_backtrace(_backtrace, opts = {})
+        kind = opts[:kind]
+
+        return _backtrace unless _backtrace.is_a?(Array)
+
+        length = _backtrace.size
+        if length > 80
+          trimmed = _backtrace[0, 80]
+          trimmed += ['...[snip]...']
+          trimmed += _backtrace[length - 20, 20]
+        else
+          trimmed = _backtrace
+        end
+        trimmed
+      end
+     end
+  end
+end

data/lib/baseline_red_rpm/configuration.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module BaselineRedRpm
+  class Configuration
+    attr_accessor :app_root,
+                  :host,
+                  :port,
+                  :license_key,
+                  :ssl,
+                  :sample_rate,
+                  :sample_threshold,
+                  :flush_interval,
+                  :application_name,
+                  :instrumentation,
+                  :agent_disabled,
+                  :ignore_paths
+
+    def initialize
+      reload
+    end
+
+    def reload
+      ::BaselineRedRpm.mutex.synchronize do
+        self.app_root = app_root ? Pathname.new(app_root.to_s) : nil
+        self.host ||= default_if_blank(ENV["BASELINE_RED_HOST"], "http://localhost:5000")
+        self.ssl ||= default_if_blank(ENV["BASELINE_RED_SSL"], false)
+        self.license_key ||= default_if_blank(ENV["BASELINE_RED_LICENSE_KEY"], nil)
+        self.application_name ||= "Default"
+        self.sample_rate ||= 10 # Percentage of request to sample
+        self.sample_threshold ||= 0 # Minimum amount of duration to sample
+        self.flush_interval ||= 60 # In seconds
+        self.agent_disabled ||= default_if_blank(ENV["BASELINE_RED_AGENT_DISABLED"], false)
+        self.ignore_paths ||= /\/assets/
+        self.instrumentation = {
+          :rack                    => { :enabled => true, :backtrace => :app, :source => true, :trace_middleware => false },
+          :roda                    => { :enabled => true, :backtrace => :app, :source => true },
+          :grape                   => { :enabled => true, :backtrace => :app, :source => true },
+          :active_record           => { :enabled => true, :backtrace => :app, :source => true },
+          :active_record_import    => { :enabled => true, :backtrace => :app, :source => true },
+          :active_model_serializer => { :enabled => true, :backtrace => :app, :source => true },
+          :action_view             => { :enabled => true, :backtrace => :app, :source => true },
+          :action_controller       => { :enabled => true, :backtrace => :app, :source => true },
+          :emque_consuming         => { :enabled => true, :backtrace => :app, :source => true },
+          :redis                   => { :enabled => true, :backtrace => :app, :source => true },
+          :sequel                  => { :enabled => true, :backtrace => :app, :source => true },
+          :sidekiq                 => { :enabled => true, :backtrace => :app, :source => true },
+          :sinatra                 => { :enabled => true, :backtrace => :app, :source => true },
+          :net_http                => { :enabled => true, :backtrace => :app, :source => true },
+          :typhoeus                => { :enabled => true, :backtrace => :app, :source => true },
+          :faraday                 => { :enabled => true, :backtrace => :app, :source => true }
+        }
+      end
+    end
+
+    private
+
+    def default_if_blank(value, default)
+      value.nil? || value.blank? ? default : value
+    end
+  end
+end

data/lib/baseline_red_rpm/instrumentation.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module BaselineRedRpm
+  class Instrumentation
+    class << self
+      def load
+        pattern = File.join(File.dirname(__FILE__), 'instruments', '**', '*.rb')
+        Dir.glob(pattern) do |f|
+          begin
+            require f
+          rescue => e
+            BaselineRedRpm.logger.error "Error loading instrumentation file '#{f}' : #{e}"
+            BaselineRedRpm.logger.error "#{e.backtrace[0..10]}"
+          end
+        end
+
+        if defined? Rails::Railtie
+          require "baseline_red_rpm/railtie"
+        end
+      end
+    end
+  end
+end

data/lib/baseline_red_rpm/instruments/action_controller.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module BaselineRedRpm
+  module Instruments
+    module ActionController
+      def process_action_with_trace(method_name, *args)
+        if ::BaselineRedRpm::Tracer.tracing?
+          operation = "#{self.class.name}##{self.action_name}"
+          span = BaselineRedRpm.tracer.start_span(operation, tags: {
+            "component" => "ActionController",
+            "span.kind" => "client"
+          })
+          BaselineRedRpm::Utils.log_source_and_backtrace(span, :action_controller)
+        end
+
+        process_action_without_trace(method_name, *args)
+      rescue Exception => e
+        puts e.message.inspect
+        puts e.backtrace.join("\n")
+        if span
+          span.set_tag('error', true)
+          span.log_error(e)
+        end
+        raise
+      ensure
+        span.finish if span
+      end
+
+      def perform_action_with_trace(*arguments)
+        if ::BaselineRedRpm::Tracer.tracing?
+          operation = "#{@_request.path_parameters['controller']}##{@_request.path_parameters['action']}"
+          span = BaselineRedRpm.tracer.start_span(operation, tags: {
+            "component" => "ActionController",
+            "span.kind" => "client"
+          })
+          BaselineRedRpm::Utils.log_source_and_backtrace(span, :action_controller)
+        end
+        perform_action_without_trace(*arguments)
+      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 ::BaselineRedRpm.config.instrumentation[:action_controller][:enabled] &&
+  defined?(::ActionController)
+  BaselineRedRpm.logger.info "Initializing actioncontroller tracer."
+
+  ::ActionController::Base.send(
+    :include,
+    BaselineRedRpm::Instruments::ActionController
+  )
+
+  ::ActionController::Base.class_eval do
+    if ::Rails::VERSION::MAJOR > 2
+      alias_method :process_action_without_trace, :process_action
+      alias_method :process_action, :process_action_with_trace
+    else
+      alias_method :perform_action_without_trace, :perform_action
+      alias_method :perform_action, :perform_action_with_trace
+    end
+  end
+end