oneapm_rpm 1.1.0

data/lib/one_apm/support/environment_report.rb

@@ -0,0 +1,127 @@
+# encoding: utf-8
+
+module OneApm
+  # The EnvironmentReport is responsible for analyzing the application's
+  # environment and generating the data for the Environment Report in OneApm's interface.
+  #
+  # It contains useful system information like Ruby version, OS, loaded gems,
+  # etc.
+  #
+  # Additional logic can be registered by using the EnvironmentReport.report_on
+  # hook.
+  class EnvironmentReport
+
+    # This is the main interface for registering logic that should be included
+    # in the Environment Report. For example:
+    #
+    # EnvironmentReport.report_on "Day of week" do
+    #   Time.now.strftime("%A")
+    # end
+    #
+    # The passed blocks will be run in EnvironmentReport instances on #initialize.
+    #
+    # Errors raised in passed blocks will be handled and logged at debug, so it
+    # is safe to report on things that may not work in certain environments.
+    #
+    # The blocks should only return strings or arrays full of strings.  Falsey
+    # values will be ignored.
+    def self.report_on(key, &block)
+      registered_reporters[key] = block
+    end
+
+    def self.registered_reporters
+      @registered_reporters ||= Hash.new
+    end
+
+    # allow the logic to be swapped out in tests
+    def self.registered_reporters=(logic)
+      @registered_reporters = logic
+    end
+
+    # register reporting logic
+    ####################################
+    report_on('Gems') do
+      begin
+        Bundler.rubygems.all_specs.map { |_gem| "#{_gem.name}(#{_gem.version})" }
+      rescue
+        # There are certain rubygem, bundler, rails combinations (e.g. gem
+        # 1.6.2, rails 2.3, bundler 1.2.3) where the code above throws an error
+        # in bundler because of rails monkey patching gem.  The below does work
+        # though so try it if the above fails.
+        Bundler.load.specs.map do |spec|
+          version = (spec.respond_to?(:version) && spec.version)
+          spec.name + (version ? "(#{version})" : "")
+        end
+      end
+    end
+    report_on('Plugin List'       ) { ::Rails.configuration.plugins.to_a }
+    report_on('Ruby version'      ) { RUBY_VERSION                       }
+    report_on('Ruby description'  ) { RUBY_DESCRIPTION                   }
+    report_on('Ruby platform'     ) { RUBY_PLATFORM                      }
+    report_on('Ruby patchlevel'   ) { RUBY_PATCHLEVEL.to_s               }
+    report_on('JRuby version'     ) { JRUBY_VERSION                      }
+    report_on('Java VM version'   ) { ENV_JAVA['java.vm.version']        }
+    report_on('Logical Processors') { ::OneApm::Agent::SystemInfo.num_logical_processors }
+    report_on('Physical Cores'    ) { ::OneApm::Agent::SystemInfo.num_physical_cores     }
+    report_on('Arch'              ) { ::OneApm::Agent::SystemInfo.processor_arch         }
+    report_on('OS version'        ) { ::OneApm::Agent::SystemInfo.os_version             }
+    report_on('OS'                ) { ::OneApm::Agent::SystemInfo.ruby_os_identifier     }
+    report_on('Database adapter'  ) do
+      ActiveRecord::Base.configurations[OneApm::Probe.instance.env]['adapter']
+    end
+    report_on('Framework'       ) { Agent.config[:framework].to_s  }
+    report_on('Dispatcher'      ) { Agent.config[:dispatcher].to_s }
+    report_on('Environment'     ) { OneApm::Probe.instance.env }
+    report_on('Rails version'   ) { ::Rails::VERSION::STRING       }
+    report_on('Rails threadsafe') do
+      ::Rails.configuration.action_controller.allow_concurrency
+    end
+    report_on('Rails Env') do
+      if defined? ::Rails and ::Rails.respond_to?(:env)
+        ::Rails.env.to_s
+      else
+        ENV['RAILS_ENV']
+      end
+    end
+    # end reporting logic
+    ####################################
+
+
+    attr_reader :data
+    # Generate the report based on the class level logic.
+    def initialize
+      @data = self.class.registered_reporters.inject(Hash.new) do |data, (key, logic)|
+        begin
+          value = logic.call
+          if value
+            data[key] = value
+
+            Agent.record_metric("Supportability/EnvironmentReport/success", 0.0)
+            Agent.record_metric("Supportability/EnvironmentReport/success/#{key}", 0.0)
+          else
+            Agent.logger.debug("EnvironmentReport ignoring value for #{key.inspect} which came back falsey: #{value.inspect}")
+            Agent.record_metric("Supportability/EnvironmentReport/empty", 0.0)
+            Agent.record_metric("Supportability/EnvironmentReport/empty/#{key}", 0.0)
+          end
+        rescue => e
+          Agent.logger.debug("EnvironmentReport failed to retrieve value for #{key.inspect}: #{e}")
+          Agent.record_metric("Supportability/EnvironmentReport/error", 0.0)
+          Agent.record_metric("Supportability/EnvironmentReport/error/#{key}", 0.0)
+        end
+        data
+      end
+    end
+
+    def [](key)
+      @data[key]
+    end
+
+    def []=(key, value)
+      @data[key] = value
+    end
+
+    def to_a
+      @data.to_a
+    end
+  end
+end

data/lib/one_apm/support/event_buffer.rb

@@ -0,0 +1,82 @@
+# encoding: utf-8
+
+# EventBuffer is intended to be an abstract base class. It should not be
+# instantiated directly. Subclasses should define an `append_event` method
+# looking something like this:
+#
+# def append_event(x)
+#   <attempt to append>
+#   if append_success?
+#     return x
+#   else
+#     return nil
+#   end
+# end
+
+module OneApm
+  module Agent
+    class EventBuffer
+      attr_reader :capacity
+
+      def initialize(capacity)
+        @capacity = capacity
+        @items    = []
+        @seen     = 0
+      end
+
+      def reset!
+        @items = []
+        @seen  = 0
+      end
+
+      def capacity=(new_capacity)
+        @capacity = new_capacity
+        old_items = @items
+        @items    = []
+        old_seen  = @seen
+        old_items.each { |i| append(i) }
+        @seen     = old_seen
+      end
+
+      def append(x)
+        @seen += 1
+        append_event(x)
+      end
+
+      def <<(x)
+        append(x)
+        self # return self for method chaining
+      end
+
+      def full?
+        @items.size >= @capacity
+      end
+
+      def size
+        @items.size
+      end
+
+      def note_dropped
+        @seen += 1
+      end
+
+      def num_seen
+        @seen
+      end
+
+      def num_dropped
+        @seen - @items.size
+      end
+
+      def sample_rate
+        @seen > 0 ? (size.to_f / @seen) : 0.0
+      end
+
+      def to_a
+        @items.dup
+      end
+
+    end
+  end
+end
+

data/lib/one_apm/support/event_buffer/sampled_buffer.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+# http://xlinux.nist.gov/dads/HTML/reservoirSampling.html
+
+require 'one_apm/support/event_buffer'
+
+module OneApm
+  module Agent
+    class SampledBuffer < EventBuffer
+      attr_reader :seen_lifetime, :captured_lifetime
+
+      def initialize(capacity)
+        super
+        @captured_lifetime = 0
+        @seen_lifetime     = 0
+      end
+
+      def reset!
+        @captured_lifetime += @items.size
+        @seen_lifetime     += @seen
+        super
+      end
+
+      def append_event(x)
+        if @items.size < @capacity
+          @items << x
+          return x
+        else
+          m = rand(@seen) # [0, @seen)
+          if m < @capacity
+            @items[m] = x
+            return x
+          else
+            # discard current sample
+            return nil
+          end
+        end
+      end
+
+      def sample_rate_lifetime
+        @captured_lifetime > 0 ? (@captured_lifetime.to_f / @seen_lifetime) : 0.0
+      end
+    end
+  end
+end

data/lib/one_apm/support/event_buffer/sized_buffer.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require 'one_apm/support/event_buffer'
+
+module OneApm
+  module Agent
+    class SizedBuffer < EventBuffer
+
+      def append_event(x)
+        if @items.size < @capacity
+          @items << x
+          return x
+        else
+          return nil
+        end
+      end
+
+    end
+  end
+end
+

data/lib/one_apm/support/event_buffer/synthetics_event_buffer.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+
+require 'one_apm/support/event_buffer'
+require 'one_apm/support/event_buffer/sized_buffer'
+
+module OneApm
+  module Agent
+    class SyntheticsEventBuffer < SizedBuffer
+
+      def append_with_reject(x)
+        @seen += 1
+        if full?
+          timestamp = timestamp_for(x)
+          latest_event = @items.max_by do |item|
+            timestamp_for(item)
+          end
+
+          if timestamp < timestamp_for(latest_event)
+            # Make room!
+            @items.delete(latest_event)
+            return [append_event(x), latest_event]
+          else
+            return [nil, x]
+          end
+        else
+          return [append_event(x), nil]
+        end
+      end
+
+      TIMESTAMP = "timestamp".freeze
+
+      def timestamp_for(event)
+        main_event, _ = event
+        main_event[TIMESTAMP]
+      end
+
+    end
+  end
+end
+

data/lib/one_apm/support/helper.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+module OneApm
+  module Helper
+    extend self
+
+    # confirm a string is correctly encoded (in >= 1.9)
+    # If not force the encoding to ASCII-8BIT (binary)
+    if OneApm::LanguageSupport.supports_string_encodings?
+      def correctly_encoded(string)
+        return string unless string.is_a? String
+        # The .dup here is intentional, since force_encoding mutates the target,
+        # and we don't know who is going to use this string downstream of us.
+        string.valid_encoding? ? string : string.dup.force_encoding("ASCII-8BIT")
+      end
+    else
+      def correctly_encoded(string)
+        string
+      end
+    end
+
+    def instance_method_visibility(klass, method_name)
+      if klass.private_instance_methods.map{|s|s.to_sym}.include? method_name.to_sym
+        :private
+      elsif klass.protected_instance_methods.map{|s|s.to_sym}.include? method_name.to_sym
+        :protected
+      else
+        :public
+      end
+    end
+
+    def instance_methods_include?(klass, method_name)
+      method_name_sym = method_name.to_sym
+      (
+        klass.instance_methods.map{ |s| s.to_sym }.include?(method_name_sym)          ||
+        klass.protected_instance_methods.map{ |s|s.to_sym }.include?(method_name_sym) ||
+        klass.private_instance_methods.map{ |s|s.to_sym }.include?(method_name_sym)
+      )
+    end
+
+    def time_to_millis(time)
+      (time.to_f * 1000).round
+    end
+
+    def milliseconds_to_seconds(milliseconds)
+      milliseconds / 1000.0
+    end
+  end
+end

data/lib/one_apm/support/hostname.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+module OneApm
+  module Agent
+    module Hostname
+
+      def self.get
+        Socket.gethostname
+      end
+
+    end
+  end
+end

data/lib/one_apm/support/http_clients/curb_wrappers.rb

@@ -0,0 +1,65 @@
+# encoding: utf-8
+
+module OneApm
+  module Support
+    module HTTPClients
+
+      class CurbRequest
+        def initialize( curlobj )
+          @curlobj = curlobj
+        end
+
+        def type
+          'Curb'
+        end
+
+        def host
+          self["host"] || self["Host"] || self.uri.host
+        end
+
+        def method
+          @curlobj._oa_http_verb
+        end
+
+        def []( key )
+          @curlobj.headers[ key ]
+        end
+
+        def []=( key, value )
+          @curlobj.headers[ key ] = value
+        end
+
+        def uri
+          @uri ||= OneApm::Support::HTTPClients::URIUtil.parse_url(@curlobj.url)
+        end
+      end
+
+
+      class CurbResponse
+
+        def initialize(curlobj)
+          @headers = {}
+          @curlobj = curlobj
+        end
+
+        def [](key)
+          @headers[ key.downcase ]
+        end
+
+        def to_hash
+          @headers.dup
+        end
+
+        def append_header_data( data )
+          key, value = data.split( /:\s*/, 2 )
+          @headers[ key.downcase ] = value
+          @curlobj._oa_header_str ||= ''
+          @curlobj._oa_header_str << data
+        end
+
+      end
+
+    end
+
+  end
+end