oneapm_rpm 1.1.0

data/lib/one_apm/inst/http_clients/httpclient.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+LibraryDetection.defer do
+  named :httpclient
+
+  HTTPCLIENT_MINIMUM_VERSION = '2.2.0'
+
+  depends_on do
+    defined?(HTTPClient) && defined?(HTTPClient::VERSION)
+  end
+
+  depends_on do
+    minimum_supported_version = OneApm::VersionNumber.new(HTTPCLIENT_MINIMUM_VERSION)
+    current_version = OneApm::VersionNumber.new(HTTPClient::VERSION)
+
+    current_version >= minimum_supported_version
+  end
+
+  executes do
+    ::OneApm::Agent.logger.info 'Installing HTTPClient instrumentation'
+    require 'one_apm/agent/cross_app/cross_app_tracing'
+    require 'one_apm/support/http_clients/httpclient_wrappers'
+  end
+
+  executes do
+    class HTTPClient
+      def do_get_block_with_oneapm(req, proxy, conn, &block)
+        wrapped_request = OneApm::Support::HTTPClients::HTTPClientRequest.new(req)
+
+        response = nil
+        ::OneApm::Agent::CrossAppTracing.tl_trace_http_request(wrapped_request) do
+          do_get_block_without_oneapm(req, proxy, conn, &block)
+          response = conn.pop
+          conn.push response
+          ::OneApm::Support::HTTPClients::HTTPClientResponse.new(response)
+        end
+        response
+      end
+
+      alias do_get_block_without_oneapm do_get_block
+      alias do_get_block do_get_block_with_oneapm
+    end
+  end
+end

data/lib/one_apm/inst/http_clients/net.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+LibraryDetection.defer do
+  named :net_http
+
+  depends_on do
+    defined?(Net) && defined?(Net::HTTP)
+  end
+
+  executes do
+    ::OneApm::Agent.logger.info 'Installing Net instrumentation'
+    require 'one_apm/agent/cross_app/cross_app_tracing'
+    require 'one_apm/support/http_clients/net_http_wrappers'
+  end
+
+  executes do
+    class Net::HTTP
+      def request_with_oneapm_trace(request, *args, &block)
+        wrapped_request = OneApm::Support::HTTPClients::NetHTTPRequest.new(self, request)
+
+        OneApm::Agent::CrossAppTracing.tl_trace_http_request( wrapped_request ) do
+          # RUBY-1244 Disable further tracing in request to avoid double
+          # counting if connection wasn't started (which calls request again).
+          OneApm::Agent.disable_all_tracing do
+            request_without_oneapm_trace( request, *args, &block )
+          end
+        end
+      end
+
+      alias request_without_oneapm_trace request
+      alias request request_with_oneapm_trace
+    end
+  end
+end

data/lib/one_apm/inst/http_clients/typhoeus.rb

@@ -0,0 +1,76 @@
+# encoding: utf-8
+
+LibraryDetection.defer do
+  named :typhoeus
+
+  depends_on do
+    defined?(Typhoeus) && defined?(Typhoeus::VERSION)
+  end
+
+  depends_on do
+    OneApm::Agent::Instrumentation::TyphoeusTracing.is_supported_version?
+  end
+
+  executes do
+    ::OneApm::Agent.logger.info 'Installing Typhoeus instrumentation'
+    require 'one_apm/agent/cross_app/cross_app_tracing'
+    require 'one_apm/support/http_clients/typhoeus_wrappers'
+  end
+
+  # Basic request tracing
+  executes do
+    Typhoeus.before do |request|
+      OneApm::Agent::Instrumentation::TyphoeusTracing.trace(request)
+
+      # Ensure that we always return a truthy value from the before block,
+      # otherwise Typhoeus will bail out of the instrumentation.
+      true
+    end
+  end
+
+  # Apply single TT node for Hydra requests until async support
+  executes do
+    class Typhoeus::Hydra
+      include OneApm::Support::MethodTracer
+
+      def run_with_oneapm(*args)
+        trace_execution_scoped("External/Multiple/Typhoeus::Hydra/run") do
+          run_without_oneapm(*args)
+        end
+      end
+
+      alias run_without_oneapm run
+      alias run run_with_oneapm
+    end
+  end
+end
+
+
+module OneApm::Agent::Instrumentation::TyphoeusTracing
+
+  EARLIEST_VERSION = OneApm::VersionNumber.new("0.5.3")
+
+  def self.is_supported_version?
+    OneApm::VersionNumber.new(Typhoeus::VERSION) >= OneApm::Agent::Instrumentation::TyphoeusTracing::EARLIEST_VERSION
+  end
+
+  def self.request_is_hydra_enabled?(request)
+    request.respond_to?(:hydra) && request.hydra
+  end
+
+  def self.trace(request)
+    state = OneApm::TransactionState.tl_get
+    if state.is_execution_traced? && !request_is_hydra_enabled?(request)
+      wrapped_request = ::OneApm::Support::HTTPClients::TyphoeusHTTPRequest.new(request)
+      t0 = Time.now
+      segment = ::OneApm::Agent::CrossAppTracing.start_trace(state, t0, wrapped_request)
+      callback = Proc.new do
+        wrapped_response = ::OneApm::Support::HTTPClients::TyphoeusHTTPResponse.new(request.response)
+        ::OneApm::Agent::CrossAppTracing.finish_trace(state, t0, segment, wrapped_request, wrapped_response)
+      end
+      request.on_complete.unshift(callback)
+    end
+  rescue => e
+    OneApm::Agent.logger.error("Exception during trace setup for Typhoeus request", e)
+  end
+end

data/lib/one_apm/inst/nosql/memcache.rb

@@ -0,0 +1,134 @@
+# encoding: utf-8
+
+require 'one_apm/agent/datastores/metric_helper'
+
+module OneApm
+  module Agent
+    module Instrumentation
+      module Memcache
+        module_function
+
+        def enabled?
+          !::OneApm::Agent.config[:disable_memcache]
+        end
+
+        METHODS = [:get, :get_multi, :set, :add, :incr, :decr, :delete, :replace, :append,
+                   :prepend, :cas, :single_get, :multi_get, :single_cas, :multi_cas]
+
+        def supported_methods_for(client_class, methods)
+          methods.select do |method_name|
+            client_class.method_defined?(method_name) || client_class.private_method_defined?(method_name)
+          end
+        end
+
+        def instrument_methods(client_class, requested_methods = METHODS)
+          supported_methods_for(client_class, requested_methods).each do |method_name|
+
+            visibility = OneApm::Helper.instance_method_visibility client_class, method_name
+            method_name_without = :"#{method_name}_without_oneapm_trace"
+
+            client_class.class_eval do
+              alias_method method_name_without, method_name
+
+              define_method method_name do |*args, &block|
+                metrics = Datastores::MetricHelper.metrics_for("Memcached", method_name)
+
+                OneApm::Support::MethodTracer.trace_execution_scoped(metrics) do
+                  t0 = Time.now
+                  begin
+                    send method_name_without, *args, &block
+                  ensure
+                    if OneApm::Agent.config[:capture_memcache_keys]
+                      OneApm::Agent.instance.transaction_sampler.notice_nosql(args.first.inspect, (Time.now - t0).to_f) rescue nil
+                    end
+                  end
+                end
+              end
+
+              send visibility, method_name
+              send visibility, method_name_without
+            end
+          end
+        end
+
+      end
+    end
+  end
+end
+
+LibraryDetection.defer do
+  named :memcache_client
+
+  depends_on do
+    OneApm::Agent::Instrumentation::Memcache.enabled?
+  end
+
+  depends_on do
+    defined?(::MemCache)
+  end
+
+  executes do
+    ::OneApm::Agent.logger.info 'Installing Memcached instrumentation for memcache-client gem'
+    OneApm::Agent::Instrumentation::Memcache.instrument_methods(::MemCache)
+  end
+end
+
+LibraryDetection.defer do
+  named :memcached
+
+  depends_on do
+    OneApm::Agent::Instrumentation::Memcache.enabled?
+  end
+
+  depends_on do
+    defined?(::Memcached)
+  end
+
+  executes do
+    ::OneApm::Agent.logger.info 'Installing Memcached instrumentation for memcached gem'
+    ::OneApm::Agent::Instrumentation::Memcache.instrument_methods(::Memcached)
+  end
+end
+
+LibraryDetection.defer do
+  named :dalli
+
+  depends_on do
+    OneApm::Agent::Instrumentation::Memcache.enabled?
+  end
+
+  depends_on do
+    defined?(::Dalli::Client)
+  end
+
+  executes do
+    ::OneApm::Agent.logger.info 'Installing Memcache instrumentation for dalli gem'
+    ::OneApm::Agent::Instrumentation::Memcache.instrument_methods(::Dalli::Client)
+  end
+end
+
+LibraryDetection.defer do
+  named :dalli_cas_client
+
+  depends_on do
+    OneApm::Agent::Instrumentation::Memcache.enabled?
+  end
+
+  depends_on do
+    # These CAS client methods are only optionally defined if users require
+    # dalli/cas/client. Use a separate dependency block so it can potentially
+    # re-evaluate after they've done that require.
+    defined?(::Dalli::Client) &&
+      ::OneApm::Agent::Instrumentation::Memcache.supported_methods_for(::Dalli::Client,
+                                                                         CAS_CLIENT_METHODS).any?
+  end
+
+  CAS_CLIENT_METHODS = [:get_cas, :get_multi_cas, :set_cas, :replace_cas,
+                        :delete_cas]
+
+  executes do
+    ::OneApm::Agent.logger.info 'Installing Dalli CAS Client Memcache instrumentation'
+    ::OneApm::Agent::Instrumentation::Memcache.instrument_methods(::Dalli::Client,
+                                                                    CAS_CLIENT_METHODS)
+  end
+end

data/lib/one_apm/inst/nosql/mongo.rb

@@ -0,0 +1,126 @@
+# encoding: utf-8
+
+LibraryDetection.defer do
+  named :mongo
+
+  depends_on do
+    defined?(::Mongo)
+  end
+
+  depends_on do
+    require 'one_apm/agent/datastores/mongo'
+    OneApm::Agent::Datastores::Mongo.is_supported_version?
+  end
+
+  executes do
+    OneApm::Agent.logger.info 'Installing Mongo instrumentation'
+    install_mongo_instrumentation
+  end
+
+  def install_mongo_instrumentation
+    require 'one_apm/agent/datastores/mongo/metric_translator'
+    require 'one_apm/agent/datastores/mongo/statement_formatter'
+
+    hook_instrument_methods
+    instrument_save
+    instrument_ensure_index
+  end
+
+  def hook_instrument_methods
+    hook_instrument_method(::Mongo::Collection)
+    hook_instrument_method(::Mongo::Connection)
+    hook_instrument_method(::Mongo::Cursor)
+    hook_instrument_method(::Mongo::CollectionWriter) if defined?(::Mongo::CollectionWriter)
+  end
+
+  def hook_instrument_method(target_class)
+    target_class.class_eval do
+      include OneApm::Support::MethodTracer
+
+      # It's key that this method eats all exceptions, as it rests between the
+      # Mongo operation the user called and us returning them the data. Be safe!
+      def one_apm_notice_statement(t0, payload, name)
+        statement = OneApm::Agent::Datastores::Mongo::StatementFormatter.format(payload, name)
+        if statement
+          OneApm::Agent.instance.transaction_sampler.notice_nosql_statement(statement, (Time.now - t0).to_f)
+        end
+      rescue => e
+        OneApm::Agent.logger.debug("Exception during Mongo statement gathering", e)
+      end
+
+      def one_apm_generate_metrics(operation, payload = nil)
+        payload ||= { :collection => self.name, :database => self.db.name }
+        OneApm::Agent::Datastores::Mongo::MetricTranslator.metrics_for(operation, payload)
+      end
+
+      def instrument_with_one_apm_trace(name, payload = {}, &block)
+        metrics = one_apm_generate_metrics(name, payload)
+
+        trace_execution_scoped(metrics) do
+          t0 = Time.now
+
+          result = OneApm::Agent.disable_all_tracing do
+            instrument_without_one_apm_trace(name, payload, &block)
+          end
+
+          one_apm_notice_statement(t0, payload, name)
+          result
+        end
+      end
+
+      alias_method :instrument_without_one_apm_trace, :instrument
+      alias_method :instrument, :instrument_with_one_apm_trace
+    end
+  end
+
+  def instrument_save
+    ::Mongo::Collection.class_eval do
+      def save_with_one_apm_trace(doc, opts = {}, &block)
+        metrics = one_apm_generate_metrics(:save)
+        trace_execution_scoped(metrics) do
+          t0 = Time.now
+
+          result = OneApm::Agent.disable_all_tracing do
+            save_without_one_apm_trace(doc, opts, &block)
+          end
+
+          one_apm_notice_statement(t0, doc, :save)
+          result
+        end
+      end
+
+      alias_method :save_without_one_apm_trace, :save
+      alias_method :save, :save_with_one_apm_trace
+    end
+  end
+
+  def instrument_ensure_index
+    ::Mongo::Collection.class_eval do
+      def ensure_index_with_one_apm_trace(spec, opts = {}, &block)
+        metrics = one_apm_generate_metrics(:ensureIndex)
+        trace_execution_scoped(metrics) do
+          t0 = Time.now
+
+          result = OneApm::Agent.disable_all_tracing do
+            ensure_index_without_one_apm_trace(spec, opts, &block)
+          end
+
+          spec = case spec
+                 when Array
+                   Hash[spec]
+                 when String, Symbol
+                   { spec => 1 }
+                 else
+                   spec.dup
+                 end
+
+          one_apm_notice_statement(t0, spec, :ensureIndex)
+          result
+        end
+      end
+
+      alias_method :ensure_index_without_one_apm_trace, :ensure_index
+      alias_method :ensure_index, :ensure_index_with_one_apm_trace
+    end
+  end
+end

data/lib/one_apm/inst/nosql/mongo_moped.rb

@@ -0,0 +1,85 @@
+# encoding: utf-8
+
+require 'one_apm/support/method_tracer'
+require 'one_apm/agent/datastores'
+
+LibraryDetection.defer do
+  @name = :mongo_moped
+
+  depends_on do
+    defined?(::Moped) && !OneApm::Agent.config[:disable_mongo_moped]
+  end
+
+  executes do
+    OneApm::Agent.logger.info 'Installing Mongo Moped instrumentation'
+  end
+
+  executes do
+    Moped::Node.class_eval do
+      include OneApm::Agent::Instrumentation::Moped
+      alias_method :logging_without_oneapm_trace, :logging
+      alias_method :logging, :logging_with_oneapm_trace
+    end
+  end
+end
+
+module OneApm
+  module Agent
+    module Instrumentation
+      module Moped
+        def logging_with_oneapm_trace(operations, &blk)
+          operation_name, collection = determine_operation_and_collection(operations.first)
+          log_statement = operations.first.log_inspect.encode("UTF-8")
+
+          operation = case operation_name
+                   when 'INSERT', 'UPDATE', 'CREATE', 'FIND_AND_MODIFY'  then 'save'
+                   when 'QUERY', 'COUNT', 'GET_MORE', 'AGGREGATE'        then 'find'
+                   when 'DELETE'                                         then 'destroy'
+                   else
+                     nil
+                   end
+
+          command = Proc.new { logging_without_oneapm_trace(operations, &blk) }
+          res = nil
+
+          if operation
+            callback = Proc.new do |result, metric, elapsed|
+              OneApm::Agent::Datastores.notice_statement(log_statement, elapsed)
+            end
+
+            OneApm::Agent::Datastores.wrap('MongoDB', operation, collection, callback) do
+              res = command.call
+            end
+          else
+            res = command.call
+          end
+
+          res
+        end
+
+        def determine_operation_and_collection(operation)
+          log_statement = operation.log_inspect.encode("UTF-8")
+          collection = "Unknown"
+          if operation.respond_to?(:collection)
+            collection = operation.collection
+          end
+          operation_name = log_statement.split[0]
+          if operation_name == 'COMMAND' && log_statement.include?(":mapreduce")
+            operation_name = 'MAPREDUCE'
+            collection = log_statement[/:mapreduce=>"([^"]+)/,1]
+          elsif operation_name == 'COMMAND' && log_statement.include?(":count")
+            operation_name = 'COUNT'
+            collection = log_statement[/:count=>"([^"]+)/,1]
+          elsif operation_name == 'COMMAND' && log_statement.include?(":aggregate")
+            operation_name = 'AGGREGATE'
+            collection = log_statement[/:aggregate=>"([^"]+)/,1]
+          elsif operation_name == 'COMMAND' && log_statement.include?(":findAndModify")
+            operation_name = 'FIND_AND_MODIFY'
+            collection = log_statement[/:findAndModify=>"([^"]+)/,1]
+          end
+          return operation_name, collection
+        end
+      end
+    end
+  end
+end