oneapm_rpm 1.1.0

data/lib/one_apm/agent/samplers/object_sampler.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+require 'one_apm/agent/sampler'
+
+module OneApm
+  module Agent
+    module Samplers
+      class ObjectSampler < OneApm::Agent::Sampler
+        named :object
+
+        def self.supported_on_this_platform?
+          OneApm::LanguageSupport.object_space_usable? && ObjectSpace.respond_to?(:live_objects)
+        end
+
+        def poll
+          live_objects = ObjectSpace.live_objects
+          OneApm::Agent.record_metric("GC/objects", live_objects)
+        end
+      end
+    end
+  end
+end

data/lib/one_apm/agent/samplers/vm_sampler.rb

@@ -0,0 +1,124 @@
+# encoding: utf-8
+
+require 'one_apm/agent/sampler'
+require 'one_apm/support/vm'
+
+module OneApm
+  module Agent
+    module Samplers
+      class VMSampler < Sampler
+        GC_RUNS_METRIC                = 'RubyVM/GC/runs'.freeze
+        HEAP_LIVE_METRIC              = 'RubyVM/GC/heap_live'.freeze
+        HEAP_FREE_METRIC              = 'RubyVM/GC/heap_free'.freeze
+        THREAD_COUNT_METRIC           = 'RubyVM/Threads/all'.freeze
+        OBJECT_ALLOCATIONS_METRIC     = 'RubyVM/GC/total_allocated_object'.freeze
+        MAJOR_GC_METRIC               = 'RubyVM/GC/major_gc_count'.freeze
+        MINOR_GC_METRIC               = 'RubyVM/GC/minor_gc_count'.freeze
+        METHOD_INVALIDATIONS_METRIC   = 'RubyVM/CacheInvalidations/method'.freeze
+        CONSTANT_INVALIDATIONS_METRIC = 'RubyVM/CacheInvalidations/constant'.freeze
+
+        attr_reader :transaction_count
+
+        named :vm
+
+        def initialize
+          @lock = Mutex.new
+          @transaction_count = 0
+          @last_snapshot = take_snapshot
+        end
+
+        def take_snapshot
+          OneApm::Support::VM.snapshot
+        end
+
+        def setup_events(event_listener)
+          event_listener.subscribe(:transaction_finished, &method(:on_transaction_finished))
+        end
+
+        def on_transaction_finished(*_)
+          @lock.synchronize { @transaction_count += 1 }
+        end
+
+        def reset_transaction_count
+          @lock.synchronize do
+            old_count = @transaction_count
+            @transaction_count = 0
+            old_count
+          end
+        end
+
+        def record_gc_runs_metric(snapshot, txn_count) #THREAD_LOCAL_ACCESS
+          if snapshot.gc_total_time || snapshot.gc_runs
+            if snapshot.gc_total_time
+              gc_time = snapshot.gc_total_time - @last_snapshot.gc_total_time.to_f
+            end
+            if snapshot.gc_runs
+              gc_runs = snapshot.gc_runs - @last_snapshot.gc_runs
+            end
+            wall_clock_time = snapshot.taken_at - @last_snapshot.taken_at
+            OneApm::Agent.instance.stats_engine.tl_record_unscoped_metrics(GC_RUNS_METRIC) do |stats|
+              stats.call_count           += txn_count
+              stats.total_call_time      += gc_runs if gc_runs
+              stats.total_exclusive_time += gc_time if gc_time
+              stats.max_call_time         = (gc_time.nil? ? 0 : 1)
+              stats.sum_of_squares       += wall_clock_time
+            end
+          end
+        end
+
+        def record_delta(snapshot, key, metric, txn_count) #THREAD_LOCAL_ACCESS
+          value = snapshot.send(key)
+          if value
+            delta = value - @last_snapshot.send(key)
+            OneApm::Agent.instance.stats_engine.tl_record_unscoped_metrics(metric) do |stats|
+              stats.call_count      += txn_count
+              stats.total_call_time += delta
+            end
+          end
+        end
+
+        def record_gauge_metric(metric_name, value) #THREAD_LOCAL_ACCESS
+          OneApm::Agent.instance.stats_engine.tl_record_unscoped_metrics(metric_name) do |stats|
+            stats.call_count      = value
+            stats.sum_of_squares  = 1
+          end
+        end
+
+        def record_heap_live_metric(snapshot)
+          if snapshot.heap_live
+            record_gauge_metric(HEAP_LIVE_METRIC, snapshot.heap_live)
+          end
+        end
+
+        def record_heap_free_metric(snapshot)
+          if snapshot.heap_free
+            record_gauge_metric(HEAP_FREE_METRIC, snapshot.heap_free)
+          end
+        end
+
+        def record_thread_count_metric(snapshot)
+          if snapshot.thread_count
+            record_gauge_metric(THREAD_COUNT_METRIC, snapshot.thread_count)
+          end
+        end
+
+        def poll
+          snap = take_snapshot
+          tcount = reset_transaction_count
+
+          record_gc_runs_metric(snap, tcount)
+          record_delta(snap, :total_allocated_object, OBJECT_ALLOCATIONS_METRIC, tcount)
+          record_delta(snap, :major_gc_count, MAJOR_GC_METRIC, tcount)
+          record_delta(snap, :minor_gc_count, MINOR_GC_METRIC, tcount)
+          record_delta(snap, :method_cache_invalidations, METHOD_INVALIDATIONS_METRIC, tcount)
+          record_delta(snap, :constant_cache_invalidations, CONSTANT_INVALIDATIONS_METRIC, tcount)
+          record_heap_live_metric(snap)
+          record_heap_free_metric(snap)
+          record_thread_count_metric(snap)
+
+          @last_snapshot = snap
+        end
+      end
+    end
+  end
+end

data/lib/one_apm/agent/synthetics_monitor.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+require 'one_apm/agent/inbound_request_monitor'
+
+module OneApm
+  module Agent
+    class SyntheticsMonitor < InboundRequestMonitor
+      SYNTHETICS_HEADER_KEY  = 'HTTP_X_ONEAPM_SYNTHETICS'.freeze
+
+      SUPPORTED_VERSION = 1
+      EXPECTED_PAYLOAD_LENGTH = 5
+
+      def on_finished_configuring(events)
+        events.subscribe(:before_call, &method(:on_before_call))
+      end
+
+      def on_before_call(request) #THREAD_LOCAL_ACCESS
+        encoded_header = request[SYNTHETICS_HEADER_KEY]
+        return unless encoded_header
+
+        incoming_payload = deserialize_header(encoded_header, SYNTHETICS_HEADER_KEY)
+
+        return unless incoming_payload &&
+            is_valid_payload?(incoming_payload) &&
+            is_supported_version?(incoming_payload) &&
+            is_trusted?(incoming_payload)
+
+        state = OneApm::TransactionState.tl_get
+        txn = state.current_transaction
+        txn.raw_synthetics_header = encoded_header
+        txn.synthetics_payload    = incoming_payload
+      end
+
+      def is_supported_version?(incoming_payload)
+        incoming_payload.first == SUPPORTED_VERSION
+      end
+
+      def is_trusted?(incoming_payload)
+        account_id = incoming_payload[1]
+        OneApm::Agent.config[:trusted_account_ids].include?(account_id)
+      end
+
+      def is_valid_payload?(incoming_payload)
+        incoming_payload.length == EXPECTED_PAYLOAD_LENGTH
+      end
+    end
+  end
+end

data/lib/one_apm/agent/threading/agent_thread.rb

@@ -0,0 +1,74 @@
+# encoding: utf-8
+
+module OneApm
+  module Agent
+    module Threading
+      class AgentThread
+
+        def self.create(label, &blk)
+          ::OneApm::Agent.logger.debug("Creating OneApm thread: #{label}")
+          wrapped_blk = Proc.new do
+            begin
+              blk.call
+            rescue => e
+              ::OneApm::Agent.logger.error("Thread #{label} exited with error", e)
+            rescue Exception => e
+              ::OneApm::Agent.logger.error("Thread #{label} exited with exception. Re-raising in case of interupt.", e)
+              raise
+            ensure
+              ::OneApm::Agent.logger.debug("Exiting OneApm thread: #{label}")
+            end
+          end
+
+          thread = backing_thread_class.new(&wrapped_blk)
+          thread[:oneapm_label] = label
+          thread
+        end
+
+        # Simplifies testing if we don't directly use ::Thread.list, so keep
+        # the accessor for it here on AgentThread to use and stub.
+        def self.list
+          backing_thread_class.list
+        end
+
+        def self.bucket_thread(thread, profile_agent_code) #THREAD_LOCAL_ACCESS
+          if thread.key?(:oneapm_label)
+            profile_agent_code ? :agent : :ignore
+          else
+            state = TransactionState.tl_state_for(thread)
+            if state.in_background_transaction?
+              :background
+            elsif state.in_web_transaction?
+              :request
+            else
+              :other
+            end
+          end
+        end
+
+        def self.scrub_backtrace(thread, profile_agent_code)
+          begin
+            bt = thread.backtrace
+          rescue Exception => e
+            ::OneApm::Agent.logger.debug("Failed to backtrace #{thread.inspect}: #{e.class.name}: #{e.to_s}")
+          end
+          return nil unless bt
+          bt.reject! { |t| t.include?('one_apm') } unless profile_agent_code
+          bt
+        end
+
+        # To allow tests to swap out Thread for a synchronous alternative,
+        # surface the backing class we'll use from the class level.
+        @backing_thread_class = ::Thread
+
+        def self.backing_thread_class
+          @backing_thread_class
+        end
+
+        def self.backing_thread_class=(clazz)
+          @backing_thread_class = clazz
+        end
+      end
+    end
+  end
+end

data/lib/one_apm/agent/threading/backtrace_node.rb

@@ -0,0 +1,133 @@
+# encoding: utf-8
+
+module OneApm
+  module Agent
+    module Threading
+      MAX_THREAD_PROFILE_DEPTH = 500
+      UNKNOWN_LINE_NUMBER = -1
+
+      class BacktraceBase
+        attr_reader :children
+
+        def initialize
+          @children = []
+          @depth    = 0
+        end
+
+        def add_child_unless_present(child)
+          child.depth = @depth + 1
+          @children << child unless @children.include? child
+        end
+
+        def add_child(child)
+          child.depth = @depth + 1
+          @children << child
+        end
+
+        def find_child(raw_line)
+          @children.find { |child| child.raw_line == raw_line }
+        end
+      end
+
+
+      class BacktraceRoot < BacktraceBase
+        attr_reader :flattened
+
+        def initialize
+          super
+          @flattened = []
+        end
+
+        def ==(other)
+          true # all roots are at the same depth and have no raw_line
+        end
+
+        def as_array
+          @children.map { |c| c.as_array }.compact
+        end
+
+        def aggregate(backtrace)
+          current = self
+
+          depth = 0
+          backtrace.reverse_each do |frame|
+            break if depth >= MAX_THREAD_PROFILE_DEPTH
+
+            existing_node = current.find_child(frame)
+            if existing_node
+              node = existing_node
+            else
+              node = Threading::BacktraceNode.new(frame)
+              current.add_child(node)
+              @flattened << node
+            end
+
+            node.runnable_count += 1
+            current = node
+            depth += 1
+          end
+        end
+
+        def dump_string
+          result = "#<BacktraceRoot:#{object_id}>"
+          child_results = @children.map { |c| c.dump_string(2) }.join("\n")
+          result << "\n" unless child_results.empty?
+          result << child_results
+        end
+      end
+
+
+      class BacktraceNode < BacktraceBase
+        attr_reader   :file, :method, :line_no, :raw_line, :as_array
+        attr_accessor :runnable_count, :depth
+
+        def initialize(line)
+          super()
+          @raw_line = line
+          @children = []
+          @runnable_count = 0
+        end
+
+        def ==(other)
+          (
+            @raw_line       == other.raw_line &&
+            @depth          == other.depth    &&
+            @runnable_count == other.runnable_count
+          )
+        end
+
+        def mark_for_array_conversion
+          @as_array = []
+        end
+
+        include OneApm::Coerce
+
+        def complete_array_conversion
+          child_arrays = @children.map { |c| c.as_array }.compact
+
+          file, method, line = parse_backtrace_frame(@raw_line)
+
+          @as_array << [string(file), string(method), line ? int(line) : UNKNOWN_LINE_NUMBER]
+          @as_array << int(@runnable_count)
+          @as_array << 0
+          @as_array << child_arrays
+        end
+
+        def dump_string(indent=0)
+          @file, @method, @line_no = parse_backtrace_frame(@raw_line)
+          result = "#{" " * indent}#<BacktraceNode:#{object_id} [#{@runnable_count}] #{@file}:#{@line_no} in #{@method}>"
+          child_results = @children.map { |c| c.dump_string(indent+2) }.join("\n")
+          result << "\n" unless child_results.empty?
+          result << child_results
+        end
+
+        # Returns [filename, method, line number]
+        def parse_backtrace_frame(frame)
+          frame =~ /([^:]*)(\:(\d+))?\:in `(.*)'/
+          [$1, $4, $3] # sic
+        end
+      end
+
+    end
+  end
+end

data/lib/one_apm/agent/threading/backtrace_service.rb

@@ -0,0 +1,259 @@
+# encoding: utf-8
+
+module OneApm
+  module Agent
+    module Threading
+      class BacktraceService
+        ALL_TRANSACTIONS = "**ALL**".freeze
+
+        def self.is_supported?
+          RUBY_VERSION >= "1.9.2"
+        end
+
+        attr_reader :worker_loop, :buffer,
+                    :effective_polling_period,
+                    :overhead_percent_threshold
+        attr_accessor :worker_thread, :profile_agent_code
+
+        def initialize(event_listener=nil)
+          @profiles = {}
+          @buffer = {}
+
+          # synchronizes access to @profiles and @buffer above
+          @lock = Mutex.new
+
+          @running = false
+          @profile_agent_code = false
+          @worker_loop = OneApm::Agent::WorkerLoop.new
+
+          # Memoize overhead % to avoid getting stale OR looked up every poll
+          @overhead_percent_threshold = OneApm::Agent.config[:'xray_session.max_profile_overhead']
+          OneApm::Agent.config.register_callback(:'xray_session.max_profile_overhead') do |new_value|
+            @overhead_percent_threshold = new_value
+          end
+
+          if event_listener
+            event_listener.subscribe(:transaction_finished, &method(:on_transaction_finished))
+          end
+        end
+
+        # Public interface
+
+        def running?
+          @running
+        end
+
+        def subscribe(transaction_name, command_arguments={})
+          if !self.class.is_supported?
+            OneApm::Agent.logger.debug("Backtracing not supported, so not subscribing transaction '#{transaction_name}'")
+            return
+          end
+
+          OneApm::Agent.logger.debug("Backtrace Service subscribing transaction '#{transaction_name}'")
+
+          profile = ThreadProfile.new(command_arguments)
+
+          @lock.synchronize do
+            @profiles[transaction_name] = profile
+            update_values_from_profiles
+          end
+
+          start
+          profile
+        end
+
+        def unsubscribe(transaction_name)
+          return unless self.class.is_supported?
+
+          OneApm::Agent.logger.debug("Backtrace Service unsubscribing transaction '#{transaction_name}'")
+          @lock.synchronize do
+            @profiles.delete(transaction_name)
+            if @profiles.empty?
+              stop
+            else
+              update_values_from_profiles
+            end
+          end
+        end
+
+        def update_values_from_profiles
+          self.effective_polling_period = find_effective_polling_period
+          self.profile_agent_code = should_profile_agent_code?
+        end
+
+        def subscribed?(transaction_name)
+          @lock.synchronize do
+            @profiles.has_key?(transaction_name)
+          end
+        end
+
+        def harvest(transaction_name)
+          @lock.synchronize do
+            if @profiles[transaction_name]
+              profile = @profiles.delete(transaction_name)
+              profile.finished_at = Time.now
+              @profiles[transaction_name] = ThreadProfile.new(profile.command_arguments)
+              profile
+            end
+          end
+        end
+
+        def on_transaction_finished(payload)
+          name     = payload[:name]
+          start    = payload[:start_timestamp]
+          duration = payload[:duration]
+          thread   = payload[:thread] || Thread.current
+          @lock.synchronize do
+            backtraces = @buffer.delete(thread)
+            if backtraces && @profiles.has_key?(name)
+              aggregate_backtraces(backtraces, name, start, duration, thread)
+            end
+          end
+        end
+
+        # Internals
+
+        # This method is expected to be called with @lock held.
+        def aggregate_backtraces(backtraces, name, start, duration, thread)
+          end_time = start + duration
+          backtraces.each do |(timestamp, backtrace)|
+            if timestamp >= start && timestamp < end_time
+              @profiles[name].aggregate(backtrace, :request, thread)
+            end
+          end
+        end
+
+        def start
+          return if @running || !self.class.is_supported?
+
+          @running = true
+          self.worker_thread = AgentThread.create('Backtrace Service') do
+            # Not passing period because we expect it's already been set.
+            self.worker_loop.run(&method(:poll))
+          end
+        end
+
+        # This method is expected to be called with @lock held
+        def stop
+          return unless @running
+          @running = false
+          self.worker_loop.stop
+
+          @buffer = {}
+        end
+
+        def effective_polling_period=(new_period)
+          @effective_polling_period = new_period
+          self.worker_loop.period = new_period
+        end
+
+        def poll
+          poll_start = Time.now
+
+          @lock.synchronize do
+            AgentThread.list.each do |thread|
+              sample_thread(thread)
+            end
+            @profiles.each_value { |p| p.increment_poll_count }
+            @buffer.delete_if { |thread, _| !thread.alive? }
+          end
+
+          end_time = Time.now
+          adjust_polling_time(end_time, poll_start)
+          record_supportability_metrics(end_time, poll_start)
+        end
+
+        # This method is expected to be called with @lock held.
+        attr_reader :profiles
+
+        # This method is expected to be called with @lock held.
+        def should_buffer?(bucket)
+          bucket == :request && @profiles.keys.any? { |k| k != ALL_TRANSACTIONS }
+        end
+
+        # This method is expected to be called with @lock held.
+        def need_backtrace?(bucket)
+          (
+            bucket != :ignore &&
+            (@profiles[ALL_TRANSACTIONS] || should_buffer?(bucket))
+          )
+        end
+
+        MAX_BUFFER_LENGTH = 500
+
+        # This method is expected to be called with @lock held.
+        def buffer_backtrace_for_thread(thread, timestamp, backtrace, bucket)
+          if should_buffer?(bucket)
+            @buffer[thread] ||= []
+            if @buffer[thread].length < MAX_BUFFER_LENGTH
+              @buffer[thread] << [timestamp, backtrace]
+            else
+              OneApm::Agent.increment_metric('Supportability/XraySessions/DroppedBacktraces')
+            end
+          end
+        end
+
+        # This method is expected to be called with @lock held.
+        def aggregate_global_backtrace(backtrace, bucket, thread)
+          if @profiles[ALL_TRANSACTIONS]
+            @profiles[ALL_TRANSACTIONS].aggregate(backtrace, bucket, thread)
+          end
+        end
+
+        # This method is expected to be called with @lock held.
+        def sample_thread(thread)
+          bucket = AgentThread.bucket_thread(thread, @profile_agent_code)
+
+          if need_backtrace?(bucket)
+            timestamp = Time.now.to_f
+            backtrace = AgentThread.scrub_backtrace(thread, @profile_agent_code)
+            aggregate_global_backtrace(backtrace, bucket, thread)
+            buffer_backtrace_for_thread(thread, timestamp, backtrace, bucket)
+          end
+        end
+
+        # This method is expected to be called with @lock held.
+        def find_effective_polling_period
+          @profiles.values.map { |p| p.requested_period }.min
+        end
+
+        # This method is expected to be called with @lock held.
+        def should_profile_agent_code?
+          @profiles.values.any? { |p| p.profile_agent_code }
+        end
+
+        # If our overhead % exceeds the threshold, bump the next poll period
+        # relative to how much larger our overhead is than allowed
+        def adjust_polling_time(now, poll_start)
+          duration = now - poll_start
+          overhead_percent = duration / effective_polling_period
+
+          if overhead_percent > self.overhead_percent_threshold
+            scale_up_by = overhead_percent / self.overhead_percent_threshold
+            worker_loop.period = effective_polling_period * scale_up_by
+          else
+            worker_loop.period = effective_polling_period
+          end
+        end
+
+        def record_supportability_metrics(now, poll_start)
+          record_polling_time(now, poll_start)
+          record_skew(poll_start)
+        end
+
+        def record_polling_time(now, poll_start)
+          OneApm::Agent.record_metric('Supportability/ThreadProfiler/PollingTime', now - poll_start)
+        end
+
+        def record_skew(poll_start)
+          if @last_poll
+            skew = poll_start - @last_poll - worker_loop.period
+            OneApm::Agent.record_metric('Supportability/ThreadProfiler/Skew', skew)
+          end
+          @last_poll = poll_start
+        end
+
+      end
+    end
+  end
+end