tingyun_rpm 1.0.6

data/lib/ting_yun/instrumentation/active_record.rb

@@ -0,0 +1,103 @@
+# encoding: utf-8
+
+require 'ting_yun/agent'
+require 'ting_yun/agent/transaction/transaction_state'
+require 'ting_yun/instrumentation/support/active_record_helper'
+require 'ting_yun/support/helper'
+require 'ting_yun/agent/method_tracer'
+
+
+module TingYun
+  module Instrumentation
+    module ActiveRecord
+
+      EXPLAINER = lambda do |config, query|
+        connection = TingYun::Agent::Database.get_connection(config) do
+          ::ActiveRecord::Base.send("#{config[:adapter]}_connection",
+                                    config)
+        end
+        if connection && connection.respond_to?(:execute)
+          return connection.execute("EXPLAIN #{query}")
+        end
+      end
+
+      def self.included(instrumented_class)
+        instrumented_class.class_eval do
+          unless instrumented_class.method_defined?(:log_without_tingyun_instrumentation)
+            alias_method :log_without_tingyun_instrumentation, :log
+            alias_method :log, :log_with_tingyun_instrumentation
+            protected :log
+          end
+        end
+      end
+
+      def self.instrument
+        if defined?(::ActiveRecord::VERSION::MAJOR) && ::ActiveRecord::VERSION::MAJOR.to_i >= 3
+          ::TingYun::Instrumentation::Support::ActiveRecordHelper.instrument_additional_methods
+        end
+
+        ::ActiveRecord::ConnectionAdapters::AbstractAdapter.module_eval do
+          include ::TingYun::Instrumentation::ActiveRecord
+        end
+      end
+
+      def log_with_tingyun_instrumentation(*args, &block)
+
+        state = TingYun::Agent::TransactionState.tl_get
+        sql, name, _ = args
+        metrics = ::TingYun::Instrumentation::Support::ActiveRecordHelper.metrics_for(
+            TingYun::Helper.correctly_encoded(name),
+            TingYun::Helper.correctly_encoded(sql),
+            @config && @config[:adapter])
+
+        scoped_metric = metrics.first
+
+        TingYun::Agent::MethodTracer.trace_execution_scoped(metrics) do
+          t0 = Time.now
+          begin
+            log_without_tingyun_instrumentation(*args, &block)
+          ensure
+            elapsed_time = (Time.now - t0).to_f
+            state.sql_duration = elapsed_time * 1000
+
+            TingYun::Agent.instance.transaction_sampler.notice_sql(sql, @config, elapsed_time,
+                                                                   state, EXPLAINER)
+            TingYun::Agent.instance.sql_sampler.notice_sql(sql, scoped_metric,
+                                                           @config, elapsed_time,
+                                                           state, EXPLAINER)
+          end
+
+        end
+      end
+
+    end
+  end
+end
+
+
+TingYun::Support::LibraryDetection.defer do
+  named :active_record
+
+  depends_on do
+    defined?(::ActiveRecord) && defined?(::ActiveRecord::Base) &&
+        (!defined?(::ActiveRecord::VERSION) ||
+            ::ActiveRecord::VERSION::MAJOR.to_i <= 3)
+  end
+
+  executes do
+    ::TingYun::Agent.logger.info 'Installing ActiveRecord instrumentation'
+  end
+
+  executes do
+    require 'ting_yun/instrumentation/support/active_record_helper'
+
+    if defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 3
+      ActiveSupport.on_load(:active_record) do
+        ::TingYun::Instrumentation::ActiveRecord.instrument
+      end
+    else
+      ::TingYun::Instrumentation::ActiveRecord.instrument
+    end
+  end
+
+end

data/lib/ting_yun/instrumentation/middleware_proxy.rb

@@ -0,0 +1,77 @@
+# encoding: utf-8
+require 'ting_yun/instrumentation/middleware_tracing'
+require 'ting_yun/instrumentation/support/transaction_namer'
+
+module TingYun
+  module Instrumentation
+    class MiddlewareProxy
+      include TingYun::Instrumentation::MiddlewareTracing
+
+
+
+      def self.is_sinatra_app?(target)
+        defined?(::Sinatra::Base) && target.kind_of?(::Sinatra::Base)
+      end
+
+      def self.needs_wrapping?(target)
+        (
+        !target.respond_to?(:_nr_has_middleware_tracing) &&
+            !is_sinatra_app?(target)
+        )
+      end
+
+      def self.wrap(target, is_app=false)
+        if needs_wrapping?(target)
+          self.new(target, is_app)
+        else
+          target
+        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
+        if @is_app
+          :rack
+        else
+          :middleware
+        end
+      end
+
+      def determine_prefix
+        TingYun::Instrumentation::Support::TransactionNamer.prefix_for_category(nil,@category)
+      end
+
+      def determine_class_name
+        clazz = class_for_target
+
+        name = clazz.name
+        name = clazz.superclass.name if name.nil? || name == ""
+        name
+      end
+
+      def class_for_target
+        if @target.is_a?(Class)
+          @target
+        else
+          @target.class
+        end
+      end
+
+    end
+  end
+end
+

data/lib/ting_yun/instrumentation/middleware_tracing.rb

@@ -0,0 +1,84 @@
+# encoding: utf-8
+
+require 'ting_yun/agent/transaction/transaction_state'
+require 'rack/request'
+require 'ting_yun/instrumentation/support/queue_time'
+require 'ting_yun/agent/transaction'
+require 'ting_yun/agent'
+require 'ting_yun/instrumentation/support/external_error'
+
+module TingYun
+  module Instrumentation
+    module MiddlewareTracing
+      TXN_STARTED_KEY = 'tingyun.transaction_started'.freeze unless defined?(TXN_STARTED_KEY)
+
+      def _nr_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 => TingYun::Instrumentation::Support::QueueTime.parse_frontend_timestamp(env)
+        )
+      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
+      # the trailing unless is for the benefit for Ruby 1.8.7 and can be removed
+      # when it is deprecated.
+      CONTENT_TYPE = 'Content-Type'.freeze unless defined?(CONTENT_TYPE)
+
+      def capture_response_content_type(state, result)
+        if result.is_a?(Array) && state.current_transaction
+          _, headers, _ = result
+          state.current_transaction.response_content_type = headers[CONTENT_TYPE]
+        end
+      end
+
+      def call(env)
+        first_middleware = note_transaction_started(env)
+
+        state = TingYun::Agent::TransactionState.tl_get
+        begin
+          TingYun::Agent::Transaction.start(state, category, build_transaction_options(env, first_middleware))
+          events.notify(:before_call, env) if first_middleware
+
+          result = target.call(env)
+
+          if first_middleware
+            capture_http_response_code(state, result)
+            capture_response_content_type(state, result)
+            events.notify(:after_call, result)
+          end
+
+          result
+        rescue Exception => e
+
+          TingYun::Agent.notice_error(e)
+          raise e
+        ensure
+          TingYun::Agent::Transaction.stop(state)
+        end
+      end
+
+
+      def note_transaction_started(env)
+        env[TXN_STARTED_KEY] = true unless env[TXN_STARTED_KEY]
+      end
+
+      def events
+        ::TingYun::Agent.instance.events
+      end
+    end
+  end
+end

data/lib/ting_yun/instrumentation/mongo.rb

@@ -0,0 +1,103 @@
+# encoding: utf-8
+
+require 'ting_yun/agent'
+require 'ting_yun/instrumentation/support/metric_translator'
+
+module TingYun
+  module Instrumentation
+    module Mongo
+      extend self
+
+      def install_mongo_instrumentation
+        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
+          require 'ting_yun/agent/method_tracer'
+
+          def record_mongo_duration(duration)
+            state = TingYun::Agent::TransactionState.tl_get
+            unless state.nil?
+              state.mon_duration += duration * 1000
+            end
+          end
+
+          def ting_yun_generate_metrics(operation, payload = nil)
+            payload ||= { :collection => self.name, :database => self.db.name }
+            TingYun::Instrumentation::Support::MetricTranslator.metrics_for(operation, payload)
+          end
+
+          def instrument_with_ting_yun_trace(name, payload = {}, &block)
+            metrics = ting_yun_generate_metrics(name, payload)
+
+            TingYun::Agent::MethodTracer.trace_execution_scoped(metrics, payload, method(:record_mongo_duration)) do
+              instrument_without_ting_yun_trace(name, payload, &block)
+            end
+          end
+
+          alias_method :instrument_without_ting_yun_trace, :instrument
+          alias_method :instrument, :instrument_with_ting_yun_trace
+        end
+      end
+
+      def instrument_save
+        ::Mongo::Collection.class_eval do
+          def save_with_ting_yun_trace(doc, opts = {}, &block)
+            metrics = ting_yun_generate_metrics(:save)
+            TingYun::Agent::MethodTracer.trace_execution_scoped(metrics, opts, method(:record_mongo_duration)) do
+              save_without_ting_yun_trace(doc, opts, &block)
+            end
+          end
+
+          alias_method :save_without_ting_yun_trace, :save
+          alias_method :save, :save_with_ting_yun_trace
+        end
+      end
+
+      def instrument_ensure_index
+        ::Mongo::Collection.class_eval do
+          def ensure_index_with_ting_yun_trace(spec, opts = {}, &block)
+            metrics = ting_yun_generate_metrics(:ensureIndex)
+            TingYun::Agent::MethodTracer.trace_execution_scoped(metrics, opts, method(:record_mongo_duration)) do
+              ensure_index_with_out_ting_yun_trace(spec, opts, &block)
+            end
+          end
+
+          alias_method :ensure_index_with_out_ting_yun_trace, :ensure_index
+          alias_method :ensure_index, :ensure_index_with_ting_yun_trace
+        end
+      end
+    end
+  end
+end
+
+TingYun::Support::LibraryDetection.defer do
+  named :mongo
+
+  depends_on do
+    defined?(::Mongo)
+  end
+
+  depends_on do
+    TingYun::Agent::Datastore::Mongo.supported_version? && !TingYun::Agent::Datastore::Mongo.unsupported_2x?
+  end
+
+  executes do
+    TingYun::Agent.logger.info 'Installing Mongo instrumentation'
+  end
+
+  executes do
+    TingYun::Instrumentation::Mongo.install_mongo_instrumentation
+  end
+end

data/lib/ting_yun/instrumentation/mongo2.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+require 'ting_yun/agent'
+require 'ting_yun/agent/method_tracer'
+
+module TingYun
+  module Instrumentation
+    module Mongo2
+      def self.install_mongo_command_log_subscriber
+        require 'ting_yun/instrumentation/mongo_command_log_subscriber'
+        ::Mongo::Monitoring::Global.subscribe(
+            ::Mongo::Monitoring::COMMAND,
+            TingYun::Instrumentation::MongoCommandLogSubscriber.new
+        )
+      end
+    end
+  end
+end
+
+
+
+TingYun::Support::LibraryDetection.defer do
+  named :mongo2
+
+  depends_on do
+    require 'ting_yun/agent/datastore/mongo'
+    defined?(::Mongo) && TingYun::Agent::Datastore::Mongo.unsupported_2x? && defined?(::Mongo::Monitoring::Global)
+  end
+
+  executes do
+    TingYun::Agent.logger.info 'Installing Mongo2 instrumentation'
+  end
+
+  executes do
+    TingYun::Instrumentation::Mongo2.install_mongo_command_log_subscriber
+  end
+end

data/lib/ting_yun/instrumentation/mongo_command_log_subscriber.rb

@@ -0,0 +1,97 @@
+# encoding: utf-8
+
+require 'ting_yun/agent'
+require 'ting_yun/agent/transaction/transaction_state'
+require 'ting_yun/agent/datastore/metric_helper'
+require 'ting_yun/agent/datastore/mongo'
+require 'ting_yun/instrumentation/support/event_formatter'
+
+
+module TingYun
+  module Instrumentation
+    class MongoCommandLogSubscriber
+
+      MONGODB = 'MongoDB'.freeze
+      GET_MORE = "getMore".freeze
+      COLLECTION = "collection".freeze
+
+      def started(event)
+        begin
+          operations[event.operation_id] = event
+        rescue Exception => e
+          log_notification_error('started', e)
+        end
+      end
+
+
+      def completed(event)
+        begin
+          state = TingYun::Agent::TransactionState.tl_get
+          state.mon_duration = event.duration*1000
+          started_event = operations.delete(event.operation_id)
+
+          base, *other_metrics = metrics(started_event)
+
+          TingYun::Agent.instance.stats_engine.tl_record_scoped_and_unscoped_metrics(
+              base, other_metrics, event.duration*1000
+          )
+          notice_nosql_statement(state, started_event, base, event.duration)
+        rescue Exception => e
+          log_notification_error('completed', e)
+        end
+      end
+
+      alias :succeeded :completed
+      alias :failed :completed
+
+
+
+
+      private
+
+      def collection(event)
+        if event.command_name == GET_MORE
+          event.command[COLLECTION]
+        else
+          event.command.values.first
+        end
+      end
+
+      def log_notification_error(event_type, error)
+        TingYun::Agent.logger.error("Error during MongoDB #{event_type} event:")
+        TingYun::Agent.logger.log_exception(:error, error)
+      end
+
+
+      def operations
+        @operations ||= {}
+      end
+
+      def metrics(event)
+        TingYun::Agent::Datastore::MetricHelper.metrics_for(MONGODB, TingYun::Agent::Datastore::Mongo.transform_operation(event.command_name), collection(event))
+      end
+
+      def generate_statement(event)
+        TingYun::Instrumentation::Support::EventFormatter.format(
+            event.command_name,
+            event.database_name,
+            event.command
+        )
+      end
+
+      def notice_nosql_statement(state, event, metric, duration)
+        end_time = Time.now.to_f
+
+        stack  = state.traced_method_stack
+
+        # enter transaction trace node
+        frame = stack.push_frame(state, :mongo_db, end_time - duration)
+
+        TingYun::Agent.instance.transaction_sampler.notice_nosql_statement(generate_statement(event),duration*1000)
+
+        # exit transaction trace node
+        stack.pop_frame(state, frame, metric, end_time)
+      end
+    end
+  end
+end

data/lib/ting_yun/instrumentation/moped.rb

@@ -0,0 +1,95 @@
+# encoding: utf-8
+
+require 'ting_yun/agent'
+require 'ting_yun/agent/datastore'
+require 'ting_yun/agent/datastore/mongo'
+require 'ting_yun/agent/transaction/transaction_state'
+
+module TingYun
+  module Instrumentation
+    module Moped
+
+      MONGODB = 'MongoDB'.freeze
+
+      def self.included(instrumented_class)
+        instrumented_class.class_eval do
+          unless instrumented_class.method_defined?(:log_without_tingyun_instrumentation)
+            alias_method :log_without_tingyun_instrumentation, :logging
+            alias_method :logging, :log_with_tingyun_instrumentation
+          end
+        end
+      end
+
+      def self.instrument
+        ::Moped::Node.class_eval do
+          include ::TingYun::Instrumentation::Moped
+        end
+      end
+
+
+      def log_with_tingyun_instrumentation(operations, &blk)
+        operation_name, collection = determine_operation_and_collection(operations.first)
+        operation = TingYun::Agent::Datastore::Mongo.transform_operation(operation_name)
+
+        res = nil
+        TingYun::Agent::Datastore.wrap(MONGODB, operation, collection, method(:record_mongo_duration)) do
+          res = log_without_tingyun_instrumentation(operations, &blk)
+        end
+
+        res
+      end
+
+      def determine_operation_and_collection(operation)
+        log_statement = operation.log_inspect.encode("UTF-8")
+
+        collection = operation.collection if operation.respond_to?(:collection)
+
+        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
+
+      def record_mongo_duration(_1, _2, duration)
+        state = TingYun::Agent::TransactionState.tl_get
+        unless state.nil?
+          state.mon_duration += duration * 1000
+        end
+      end
+
+    end
+  end
+end
+
+
+
+
+
+
+
+TingYun::Support::LibraryDetection.defer do
+  named :mongo_moped
+  depends_on do
+    defined?(::Moped)
+  end
+
+  executes do
+    TingYun::Agent.logger.info 'Installing Mongo Moped instrumentation'
+  end
+
+  executes do
+    ::TingYun::Instrumentation::Moped.instrument
+  end
+end
+

data/lib/ting_yun/instrumentation/net.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+
+TingYun::Support::LibraryDetection.defer do
+
+  named :net_http
+
+  depends_on do
+    defined?(Net) && defined?(Net::HTTP)
+  end
+
+  executes do
+    ::TingYun::Agent.logger.info 'Installing Net instrumentation'
+    require 'ting_yun/agent/cross_app/cross_app_tracing'
+    require 'ting_yun/http/net_http_request'
+    require 'ting_yun/instrumentation/support/external_error'
+  end
+
+  executes do
+    class Net::HTTP
+      def request_with_tingyun_trace(request, *args, &block)
+        tingyun_request = TingYun::Http::NetHttpRequest.new(self, request)
+
+        TingYun::Agent::CrossAppTracing.tl_trace_http_request(tingyun_request) do
+          TingYun::Agent.disable_all_tracing do
+            request_without_tingyun_trace(request, *args, &block )
+          end
+        end
+      end
+
+      alias :request_without_tingyun_trace :request
+      alias :request :request_with_tingyun_trace
+
+
+      class << self
+        def get_response_with_tingyun(uri_or_host, path = nil, port = nil, &block)
+          begin
+            get_response_without_tingyun(uri_or_host, path = nil, port = nil, &block)
+          rescue => e
+            klass = "External/#{uri_or_host.to_s.gsub('/','%2F')}/net%2Fhttp"
+            ::TingYun::Instrumentation::Support::ExternalError.handle_error(e,klass)
+          end
+        end
+        alias get_response_without_tingyun get_response
+        alias get_response get_response_with_tingyun
+
+        def start_with_tingyun(address, *arg, &block)
+          begin
+            start_without_tingyun(address, *arg, &block)
+          rescue => e
+            klass = "External/#{address.to_s.gsub('/','%2F')}/net%2Fhttp"
+            ::TingYun::Instrumentation::Support::ExternalError.handle_error(e,klass)
+          end
+        end
+        alias :start_without_tingyun :start
+        alias :start :start_with_tingyun
+      end
+    end
+  end
+end