instana 1.10.1-java

data/lib/instana/agent/helpers.rb

@@ -0,0 +1,61 @@
+module AgentHelpers
+  # Indicates whether we are running in a pid namespace (such as
+  # Docker).
+  #
+  def pid_namespace?
+    return false unless @is_linux
+    Process.pid != get_real_pid
+  end
+
+  # Attempts to determine the true process ID by querying the
+  # /proc/<pid>/sched file.  This works on linux currently.
+  #
+  def get_real_pid
+    raise RuntimeError.new("Unsupported platform: get_real_pid") unless @is_linux
+
+    sched_file = "/proc/#{Process.pid}/sched"
+    pid = Process.pid
+
+    if File.exist?(sched_file)
+      v = File.open(sched_file, &:readline)
+      pid = v.match(/\d+/).to_s.to_i
+    end
+    pid
+  end
+
+  # Returns the PID that we are reporting to
+  #
+  def report_pid
+    @process[:report_pid]
+  end
+
+  # Determine whether the pid has changed since Agent start.
+  #
+  # @ return [Boolean] true or false to indicate if forked
+  #
+  def forked?
+    @process[:pid] != Process.pid
+  end
+
+  # Indicates if the agent is ready to send metrics
+  # and/or data.
+  #
+  def ready?
+    # In test, we're always ready :-)
+    return true if ENV.key?('INSTANA_TEST')
+
+    # Occasionally Run Fork detection
+    if rand(10) > 8
+      if !@is_resque_worker && (@process[:pid] != Process.pid)
+        ::Instana.logger.debug "Instana: detected fork. (this pid: #{Process.pid}/#{Process.ppid})  Calling after_fork"
+        after_fork
+      end
+    end
+
+    @state == :announced
+  rescue => e
+    Instana.logger.debug { "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}" }
+    Instana.logger.debug { e.backtrace.join("\r\n") } unless ENV.key?('INSTANA_TEST')
+    return false
+  end
+end

data/lib/instana/agent/hooks.rb

@@ -0,0 +1,37 @@
+module AgentHooks
+  # Used post fork to re-initialize state and restart communications with
+  # the host agent.
+  #
+  def after_fork
+    ::Instana.logger.debug "after_fork hook called. Falling back to unannounced state and spawning a new background agent thread."
+
+    # Reseed the random number generator for this
+    # new thread.
+    srand
+
+    transition_to(:unannounced)
+
+    setup
+    spawn_background_thread
+  end
+
+  def before_resque_fork
+    ::Instana.logger.debug "before_resque_fork hook called. pid/ppid: #{Process.pid}/#{Process.ppid}"
+    @is_resque_worker = true
+  end
+
+  def after_resque_fork
+    ::Instana.logger.debug "after_resque_fork hook called. pid/ppid: #{Process.pid}/#{Process.ppid}"
+
+    # Reseed the random number generator for this
+    # new thread.
+    srand
+
+    ::Instana.config[:metrics][:enabled] = false
+
+    @process[:pid] = Process.pid
+
+    setup
+    spawn_background_thread
+  end
+end

data/lib/instana/agent/tasks.rb

@@ -0,0 +1,48 @@
+module AgentTasks
+  # When request(s) are received by the host agent, it is sent here
+  # for handling & processing.
+  #
+  # @param json_string [String] the requests from the host agent
+  #
+
+  OJ_OPTIONS = {mode: :strict}
+
+  def handle_agent_tasks(json_string)
+    tasks = Oj.load(json_string, OJ_OPTIONS)
+
+    if tasks.is_a?(Hash)
+      process_agent_task(tasks)
+    elsif tasks.is_a?(Array)
+      tasks.each do |t|
+        process_agent_task(t)
+      end
+    end
+  end
+
+  # Process a task sent from the host agent.
+  #
+  # @param task [String] the request json from the host agent
+  #
+  def process_agent_task(task)
+    if task.key?("action")
+      if task["action"] == "ruby.source"
+        payload = ::Instana::Util.get_rb_source(task["args"]["file"])
+      else
+        payload = { :error => "Unrecognized action: #{task["action"]}. An newer Instana gem may be required for this. Current version: #{::Instana::VERSION}" }
+      end
+    else
+      payload = { :error => "Instana Ruby: No action specified in request." }
+    end
+
+    path = "com.instana.plugin.ruby/response.#{@process[:report_pid]}?messageId=#{URI.encode(task['messageId'])}"
+    uri = URI.parse("http://#{@discovered[:agent_host]}:#{@discovered[:agent_port]}/#{path}")
+    req = Net::HTTP::Post.new(uri)
+    req.body = Oj.dump(payload, OJ_OPTIONS)
+    ::Instana.logger.debug "Responding to agent request: #{req.inspect}"
+    make_host_agent_request(req)
+
+  rescue StandardError => e
+    Instana.logger.debug { "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}" }
+    Instana.logger.debug { e.backtrace.join("\r\n") }
+  end
+end

data/lib/instana/base.rb

@@ -0,0 +1,54 @@
+require "logger"
+require "instana/version"
+require "instana/util"
+require "instana/helpers"
+
+module Instana
+  class << self
+    attr_accessor :agent
+    attr_accessor :collector
+    attr_accessor :tracer
+    attr_accessor :processor
+    attr_accessor :config
+    attr_accessor :logger
+    attr_accessor :pid
+
+    ##
+    # setup
+    #
+    # Setup the Instana language agent to an informal "ready
+    # to run" state.
+    #
+    def setup
+      @agent  = ::Instana::Agent.new
+      @tracer = ::Instana::Tracer.new
+      @processor = ::Instana::Processor.new
+      @collector = ::Instana::Collector.new
+    end
+  end
+end
+
+# Setup the logger as early as possible
+
+# Default Logger outputs to STDOUT
+::Instana.logger = Logger.new(STDOUT)
+
+# Can instead log to a file that is rotated every 10M
+# ::Instana.logger = Logger.new("instana.log", 10, 1073741824)
+
+if ENV.key?('INSTANA_GEM_TEST')
+  ::Instana.logger.level = Logger::DEBUG
+elsif ENV.key?('INSTANA_GEM_DEV') || ENV.key?('INSTANA_DEBUG')
+  ::Instana.logger.level = Logger::DEBUG
+elsif ENV.key?('INSTANA_QUIET')
+  ::Instana.logger.level = Logger::FATAL
+else
+  ::Instana.logger.level = Logger::WARN
+end
+
+::Instana.logger.formatter = proc do |severity, datetime, progname, msg|
+  "#{datetime}: #{severity.rjust(5)} Instana: #{progname} #{msg}\n"
+end
+
+
+::Instana.logger.info "Stan is on the scene.  Starting Instana instrumentation version #{::Instana::VERSION}"

data/lib/instana/collector.rb

@@ -0,0 +1,116 @@
+module Instana
+  class Collector
+    attr_accessor :collectors
+    attr_accessor :last_report_log
+
+    def initialize
+      @collectors = []
+
+      # Snapshot data is collected once per process but resent
+      # every 10 minutes along side process metrics.
+      @snapshot = ::Instana::Util.take_snapshot
+
+      # Set last snapshot to just under 10 minutes ago
+      # so we send a snapshot sooner than later
+      @last_snapshot = Time.now - 570
+
+      # We track what we last sent as a metric payload so that
+      # we can do delta reporting
+      @last_values = {}
+    end
+
+    # Register an individual collector.
+    #
+    # @param [Object] the class of the collector to register
+    #
+    def register(klass)
+      ::Instana.logger.debug "Adding #{klass} to collectors..."
+      @collectors << klass.new
+    end
+
+    # Resets the timer on when to send process snapshot data.
+    #
+    def reset_timer!
+      # Set last snapshot to 10 minutes ago
+      # so we send a snapshot on first report
+      @last_snapshot = Time.now - 601
+    end
+
+    ##
+    # collect_and_report
+    #
+    # Run through each collector, let them collect up
+    # data and then report what we have via the agent
+    #
+    # @return Boolean true on success
+    #
+    def collect_and_report
+      return unless ::Instana.config[:metrics][:enabled]
+
+      payload = {}
+      with_snapshot = false
+
+      # Run through the registered collectors and
+      # get all the metrics
+      #
+      @collectors.each do |c|
+        metrics = c.collect
+        if metrics
+          payload[c.payload_key] = metrics
+        else
+          payload.delete(c.payload_key)
+        end
+      end
+
+      # Every 5 minutes, send snapshot data as well
+      if (Time.now - @last_snapshot) > 600
+        with_snapshot = true
+        payload.merge!(@snapshot)
+
+        # Add in process related that could have changed since
+        # snapshot was taken.
+        p = { :pid => ::Instana.agent.report_pid }
+        p[:name] = ::Instana::Util.get_app_name
+        p[:exec_args] = ::Instana.agent.process[:arguments]
+        payload.merge!(p)
+      else
+        payload = enforce_deltas(payload, @last_values)
+      end
+
+      if ENV.key?('INSTANA_TEST')
+        true
+      else
+        # Report all the collected goodies
+        if ::Instana.agent.report_metrics(payload) && with_snapshot
+          @last_snapshot = Time.now
+        end
+      end
+    end
+
+    # Take two hashes and enforce delta reporting.
+    # We only report when values change (instead of reporting all of
+    # the time).  This is a recursive method.
+    #
+    # @param [Hash] the payload have delta reporting applied to
+    # @param [Hash] a hash of the last values reported
+    #
+    # @return [Hash] the candidate hash with delta reporting applied
+    #
+    def enforce_deltas(candidate, last)
+      candidate.each do |k,v|
+        if v.is_a?(Hash)
+          last[k] ||= {}
+          candidate[k] = enforce_deltas(candidate[k], last[k])
+          candidate.delete(k) if candidate[k].empty?
+        else
+          if last[k] == v
+            candidate.delete(k)
+          else
+            last[k] = candidate[k]
+          end
+        end
+      end
+      candidate
+    end
+  end
+end

data/lib/instana/collectors/gc.rb

@@ -0,0 +1,57 @@
+module Instana
+  module Collectors
+    class GC
+      attr_accessor :payload_key
+
+      def initialize
+        @payload_key = :gc
+        @this_gc = {}
+        @last_major_count = 0
+        @last_minor_count = 0
+        ::GC::Profiler.enable
+      end
+
+      ##
+      # collect
+      #
+      # To collect garbage collector related metrics.
+      #
+      def collect
+        @this_gc.clear
+        stats = ::GC.stat
+
+        # Time spent in GC.  Report in milliseconds
+        @this_gc[:totalTime] = ::GC::Profiler.total_time * 1000
+        ::GC::Profiler.clear
+
+        # GC metrics only available on newer Ruby versions
+        if RUBY_VERSION >= '2.1'
+          # GC runs.  Calculate how many have occurred since the last call
+          @this_gc[:minorGcs] = stats[:minor_gc_count] - @last_minor_count
+          @this_gc[:majorGcs] = stats[:major_gc_count] - @last_major_count
+
+          # Store these counts so that we have something to compare to next
+          # time around.
+          @last_major_count = stats[:major_gc_count]
+          @last_minor_count = stats[:minor_gc_count]
+
+          @this_gc[:heap_live] = stats[:heap_live_slots] || stats[:heap_live_num]
+          @this_gc[:heap_free] = stats[:heap_free_slots] || stats[:heap_free_num]
+        else
+          @this_gc[:heap_live] = stats[:heap_live_slot] || stats[:heap_live_num]
+          @this_gc[:heap_free] = stats[:heap_free_slot] || stats[:heap_free_num]
+        end
+
+        @this_gc
+      rescue => e
+        ::Instana.logger.info "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
+        ::Instana.logger.debug { e.backtrace.join("\r\n") }
+      end
+    end
+  end
+end
+
+# Register the metrics collector if enabled
+if ::Instana.config[:metrics][:gc][:enabled]
+  ::Instana.collector.register(::Instana::Collectors::GC)
+end

data/lib/instana/collectors/memory.rb

@@ -0,0 +1,34 @@
+require 'get_process_mem'
+
+module Instana
+  module Collectors
+    class Memory
+      attr_accessor :payload_key
+
+      def initialize
+        @payload_key = :memory
+        @this_mem = {}
+      end
+
+      ##
+      # collect
+      #
+      # To collect process memory usage.
+      #
+      # @return [Hash] a collection of metrics (if any)
+      #
+      def collect
+        @this_mem[:rss_size] = ::GetProcessMem.new(Process.pid).kb
+        @this_mem
+      rescue => e
+        ::Instana.logger.info "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
+        ::Instana.logger.debug { e.backtrace.join("\r\n") }
+      end
+    end
+  end
+end
+
+# Register the metrics collector if enabled
+if ::Instana.config[:metrics][:memory][:enabled]
+  ::Instana.collector.register(::Instana::Collectors::Memory)
+end

data/lib/instana/collectors/thread.rb

@@ -0,0 +1,30 @@
+module Instana
+  module Collectors
+    class Thread
+      attr_accessor :payload_key
+
+      def initialize
+        @payload_key = :thread
+        @this_count = {}
+      end
+
+      ##
+      # collect
+      #
+      # To collect thread count
+      #
+      def collect
+        @this_count[:count] = ::Thread.list.count
+        @this_count
+      rescue => e
+        ::Instana.logger.info "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
+        ::Instana.logger.debug { e.backtrace.join("\r\n") }
+      end
+    end
+  end
+end
+
+# Register the metrics collector if enabled
+if ::Instana.config[:metrics][:thread][:enabled]
+  ::Instana.collector.register(::Instana::Collectors::Thread)
+end