oneapm_rpm 1.1.0

data/lib/one_apm/rack/middleware_base.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require 'one_apm/rack/middleware_tracing'
+
+module OneApm
+  module Rack
+    class MiddlewareBase
+      include MiddlewareTracing
+
+      attr_reader :transaction_options, :category, :target
+
+      def initialize(app, options={})
+        @app = app
+        @category = :middleware
+        @target   = self
+        @transaction_options = {
+          :transaction_name => build_transaction_name
+        }
+      end
+
+      def build_transaction_name
+        prefix = OneApm::TransactionNamer.prefix_for_category(nil, @category)
+        "#{prefix}#{self.class.name}/call"
+      end
+    end
+  end
+end

data/lib/one_apm/rack/middleware_hooks.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+require 'one_apm/rack/middleware_base'
+
+module OneApm::Rack
+  class MiddlewareHooks < MiddlewareBase
+
+    def self.needed?
+      !OneApm::Agent.config[:disable_rack_middleware]
+    end
+
+    def traced_call(env)
+      @app.call(env)
+    end
+
+  end
+end

data/lib/one_apm/rack/middleware_tracing.rb

@@ -0,0 +1,81 @@
+# encoding: utf-8
+
+require 'one_apm/support/method_tracer'
+require 'one_apm/transaction'
+require 'one_apm/transaction/transaction_state'
+require 'one_apm/inst/support/queue_time'
+require 'one_apm/inst/transaction_base'
+
+# This module is intended to be included into both MiddlewareWrapper and our
+# internal middleware classes.
+#
+# Host classes must define two methods:
+#
+# * target: returns the original middleware being traced
+# * category: returns the category for the resulting agent transaction
+#             should be either :middleware or :rack
+# * transaction_options: returns an options hash to be passed to
+#                        Transaction.start when tracing this middleware.
+#
+# The target may be self, in which case the host class should define a
+# #traced_call method, instead of the usual #call.
+
+module OneApm::Rack
+  module MiddlewareTracing
+    TXN_STARTED_KEY = 'oneapm.transaction_started'.freeze unless defined?(TXN_STARTED_KEY)
+
+    def _oa_has_middleware_tracing
+      true
+    end
+
+    def build_transaction_options(env, first_middleware)
+      opts = transaction_options
+      opts = merge_first_middleware_options(opts, env) if first_middleware
+      opts
+    end
+
+    def merge_first_middleware_options(opts, env)
+      opts.merge(
+        :request          => ::Rack::Request.new(env),
+        :apdex_start_time => OneApm::Agent::Instrumentation::QueueTime.parse_frontend_timestamp(env)
+      )
+    end
+
+    def note_transaction_started(env)
+      env[TXN_STARTED_KEY] = true unless env[TXN_STARTED_KEY]
+    end
+
+    def capture_http_response_code(state, result)
+      if result.is_a?(Array) && state.current_transaction
+        state.current_transaction.http_response_code = result[0]
+      end
+    end
+
+    def call(env)
+      first_middleware = note_transaction_started(env)
+
+      state = OneApm::TransactionState.tl_get
+
+      begin
+        OneApm::Transaction.start(state, category, build_transaction_options(env, first_middleware))
+        events.notify(:before_call, env) if first_middleware
+
+        result = (target == self) ? traced_call(env) : target.call(env)
+
+        capture_http_response_code(state, result)
+        events.notify(:after_call, env, result) if first_middleware
+
+        result
+      rescue Exception => e
+        OneApm::Agent.notice_error(e)
+        raise e
+      ensure
+        OneApm::Transaction.stop(state)
+      end
+    end
+
+    def events
+      OneApm::Agent.instance.events
+    end
+  end
+end

data/lib/one_apm/rack/middleware_wrapper.rb

@@ -0,0 +1,86 @@
+# encoding: utf-8
+
+require 'one_apm/support/method_tracer'
+require 'one_apm/transaction'
+require 'one_apm/transaction/transaction_state'
+require 'one_apm/inst/support/queue_time'
+require 'one_apm/inst/transaction_base'
+require 'one_apm/rack/middleware_tracing'
+
+module OneApm::Rack
+  class MiddlewareWrapper
+    include MiddlewareTracing
+
+    class MiddlewareClassWrapper
+
+      def initialize(middleware_class)
+        @middleware_class = middleware_class
+      end
+
+      def new(*args, &blk)
+        middleware_instance = @middleware_class.new(*args, &blk)
+        MiddlewareWrapper.wrap(middleware_instance)
+      end
+
+    end
+
+    class << self
+
+      def is_sinatra_app?(target)
+        defined?(::Sinatra::Base) && target.kind_of?(::Sinatra::Base)
+      end
+
+      def wrap_class(target_class)
+        MiddlewareClassWrapper.new(target_class)
+      end
+
+      def needs_wrapping?(target)
+        !target.respond_to?(:_oa_has_middleware_tracing) &&
+        !is_sinatra_app?(target)
+      end
+
+      def wrap(target, is_app = false)
+        if needs_wrapping?(target)
+          self.new(target, is_app)
+        else
+          target
+        end
+      end
+
+    end
+
+    attr_reader :target, :category, :transaction_options
+
+    def initialize(target, is_app = false)
+      @target               = target
+      @is_app               = is_app
+      @category             = determine_category
+      @target_class_name    = determine_class_name
+      @transaction_name     = "#{determine_prefix}#{@target_class_name}/call"
+      @transaction_options  = {
+        :transaction_name => @transaction_name
+      }
+    end
+
+    def determine_category
+      @is_app ? :rack : :middleware
+    end
+
+    def determine_prefix
+      OneApm::TransactionNamer.prefix_for_category(nil, @category)
+    end
+
+    # In 'normal' usage, the target will be an application instance that
+    # responds to #call. With Rails, however, the target may be a subclass
+    # of Rails::Application that defines a method_missing that proxies #call
+    # to a singleton instance of the the subclass. We need to ensure that we
+    # capture the correct name in both cases.
+    def determine_class_name
+      if @target.is_a?(Class)
+        @target.name
+      else
+        @target.class.name
+      end
+    end
+  end
+end

data/lib/one_apm/support/chained_call.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+# This class is used by OneApm::Agent.set_sql_obfuscator to chain multiple
+# obfuscation blocks when not using the default :replace action
+class OneApm::ChainedCall
+  def initialize(block1, block2)
+    @block1 = block1
+    @block2 = block2
+  end
+
+  def call(sql)
+    sql = @block1.call(sql)
+    @block2.call(sql)
+  end
+end

data/lib/one_apm/support/coerce.rb

@@ -0,0 +1,81 @@
+# encoding: utf-8
+
+module OneApm
+  # We really don't want to send bad values to the collector, and it doesn't
+  # accept types like Rational that have occasionally slipped into our data.
+  #
+  # These methods are intended to safely coerce things into the form we want,
+  # to provide documentation of expected types on to_collector_array methods,
+  # and to log failures if totally invalid data gets into outgoing data
+  module Coerce
+    def int(value, context=nil)
+      Integer(value)
+    rescue => error
+      log_failure(value, Integer, context, error)
+      0
+    end
+
+    def int_or_nil(value, context=nil)
+      return nil if value.nil?
+      Integer(value)
+    rescue => error
+      log_failure(value, Integer, context, error)
+      nil
+    end
+
+    def float(value, context=nil)
+      result = Float(value)
+      raise "Value #{result.inspect} is not finite." unless result.finite?
+      result
+    rescue => error
+      log_failure(value, Float, context, error)
+      0.0
+    end
+
+    def string(value, context=nil)
+      return value if value.nil?
+      String(value)
+    rescue => error
+      log_failure(value.class, String, context, error)
+      ""
+    end
+
+    # Convert a hash into a format acceptable to be included with Transaction
+    # event data.
+    #
+    # We accept a hash and will return a new hash where all of the keys
+    # have been converted to strings.  As values we only allow Strings,
+    # Floats, Integers. Symbols are also allowed but are converted to strings.
+    # Any values of other type (e.g. Hash, Array, any other class) are
+    # discarded. Their keys are also removed from the results hash.
+    def event_params(value, context=nil)
+      unless value.is_a? Hash
+        raise ArgumentError, "Expected Hash but got #{value.class}"
+      end
+      value.inject({}) do |memo, (key, val)|
+        case val
+        when String, Integer, TrueClass, FalseClass
+          memo[key.to_s] = val
+        when Float
+          if val.finite?
+            memo[key.to_s] = val
+          else
+            memo[key.to_s] = nil
+          end
+        when Symbol
+          memo[key.to_s] = val.to_s
+        end
+        memo
+      end
+    rescue => error
+      log_failure(value.class, 'valid event params', context, error)
+      {}
+    end
+
+    def log_failure(value, type, context, error)
+      msg = "Unable to convert '#{value}' to #{type}"
+      msg += " in context '#{context}'" if context
+      OneApm::Agent.logger.warn(msg, error)
+    end
+  end
+end

data/lib/one_apm/support/collection_helper.rb

@@ -0,0 +1,79 @@
+# encoding: utf-8
+
+require 'one_apm/probe'
+
+module OneApm
+  module CollectionHelper
+  DEFAULT_TRUNCATION_SIZE=16 * 1024
+  DEFAULT_ARRAY_TRUNCATION_SIZE=128
+  # Transform parameter hash into a hash whose values are strictly
+  # strings
+  def normalize_params(params)
+    case params
+      when Hash
+        # optimize for empty hash since that is often what this is called with.
+        return params if params.empty?
+        new_params = {}
+        params.each do | key, value |
+          new_params[truncate(normalize_params(key),64)] = normalize_params(value)
+        end
+        new_params
+      when Symbol, FalseClass, TrueClass, nil
+        params
+      when Numeric
+        truncate(params.to_s)
+      when String
+        truncate(params)
+      when Array
+        params.first(DEFAULT_ARRAY_TRUNCATION_SIZE).map{|item| normalize_params(item)}
+    else
+      truncate(flatten(params))
+    end
+  end
+
+  # Return an array of strings (backtrace), cleaned up for readability
+  # Return nil if there is no backtrace
+
+  def strip_oa_from_backtrace(backtrace)
+    if backtrace && !Agent.config[:disable_backtrace_cleanup]
+      # this is for 1.9.1, where strings no longer have Enumerable
+      backtrace = backtrace.split("\n") if String === backtrace
+      backtrace = backtrace.map(&:to_s)
+      backtrace = backtrace.reject do |line|
+        line.include?(OneApm::Probe.oneapm_root) or
+        line =~ /^oneapm_rpm\s/
+      end
+      # rename methods back to their original state
+      backtrace = backtrace.collect {|line| line.gsub(/_without_(oneapm|trace)/, "")}
+    end
+    backtrace
+  end
+
+  private
+
+  # Convert any kind of object to a short string.
+  def flatten(object)
+    case object
+      when nil then ''
+      when object.instance_of?(String) then object
+      when String then String.new(object)  # convert string subclasses to strings
+      else "#<#{object.class.to_s}>"
+    end
+  end
+  def truncate(string, len=DEFAULT_TRUNCATION_SIZE)
+    case string
+    when Symbol then string
+    when nil then ""
+    when String
+      real_string = flatten(string)
+      if real_string.size > len
+        real_string = real_string.slice(0...len)
+        real_string << "..."
+      end
+      real_string
+    else
+      truncate(flatten(string), len)
+    end
+  end
+  end
+end

data/lib/one_apm/support/dotted_hash.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+module OneApm
+  module Support
+    class DottedHash < ::Hash
+
+      def self.symbolize(hash)
+        hash.keys.each do |key|
+          hash[key.to_sym] = hash.delete(key)
+        end
+      end
+
+      def initialize(hash, keep_nesting = false)
+        merge!(hash) if keep_nesting
+        merge!(dot_flattened(hash))
+
+        DottedHash.symbolize(self)
+      end
+
+      def inspect
+        "#<#{self.class.name}:#{object_id} #{super}>"
+      end
+
+      def to_hash
+        {}.replace(self)
+      end
+
+      protected
+
+      # turns {'a' => {'b' => 'c'}} into {'a.b' => 'c'}
+      def dot_flattened(nested_hash, names=[], result={})
+        nested_hash.each do |key, val|
+          next if val == nil
+          if val.respond_to?(:has_key?)
+            dot_flattened(val, names + [key], result)
+          else
+            result[(names + [key]).join('.')] = val
+          end
+        end
+        result
+      end
+    end
+
+  end
+end

data/lib/one_apm/support/encoders.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+require 'base64'
+require 'zlib'
+
+module OneApm
+  module Support
+    module Encoders
+      module Identity
+        def self.encode(data, opts=nil)
+          data
+        end
+      end
+
+      module Compressed
+        def self.encode(data, opts=nil)
+          Zlib::Deflate.deflate(data, Zlib::DEFAULT_COMPRESSION)
+        end
+      end
+
+      module Base64CompressedJSON
+        def self.encode(data, opts={})
+          normalize_encodings = if opts[:skip_normalization]
+            false
+          else
+            Agent.config[:normalize_json_string_encodings]
+          end
+          json = ::OneApm::JSONWrapper.dump(data, :normalize => normalize_encodings)
+          Base64.encode64(Compressed.encode(json))
+        end
+      end
+    end
+  end
+end