tingyun_rpm 1.2.0 → 1.3.0

data/lib/ting_yun/instrumentation/http_client.rb

@@ -0,0 +1,70 @@
+# encoding: utf-8
+module TingYun::Instrumentation::HttpClient
+
+  HTTPCLIENT_MIN_VERSION = '2.1.5'.freeze
+
+  def self.version_support?
+    TingYun::Support::VersionNumber.new(HTTPClient::VERSION) >= TingYun::Support::VersionNumber.new(HTTPCLIENT_MIN_VERSION)
+  end
+end
+
+TingYun::Support::LibraryDetection.defer do
+
+  named :http_client
+
+  depends_on do
+    defined?(::HTTPClient) && TingYun::Instrumentation::HttpClient.version_support?
+  end
+
+  depends_on do
+    !::TingYun::Agent.config[:disable_http_client]
+  end
+
+  executes do
+    ::TingYun::Agent.logger.info 'Installing HTTPClient instrumentation'
+    require 'ting_yun/agent/cross_app/cross_app_tracing'
+    require 'ting_yun/http/http_client_request'
+    require 'ting_yun/instrumentation/support/external_error'
+  end
+
+  executes do
+    ::HTTPClient.class_eval do
+
+      if private_method_defined? :follow_redirect
+        private
+        alias_method :follow_redirect_without_tingyun_trace, :follow_redirect
+
+        def follow_redirect(*args, &block)
+          begin
+            follow_redirect_without_tingyun_trace(*args, &block)
+          rescue => e
+            args[1] = (::Module.private_method_defined? :to_resource_url) ? to_resource_url(args[1]) : urify(args[1])
+            proxy = no_proxy?(args[1]) ? nil : @proxy
+            tingyun_request = TingYun::Http::HttpClientRequest.new(proxy, *args, &block)
+            ::TingYun::Instrumentation::Support::ExternalError.handle_error(e, "External/#{tingyun_request.uri.to_s.gsub(/\/\z/,'').gsub('/','%2F')}/http_client%2Fhttp")
+            raise e
+          end
+        end
+      end
+
+      private
+      alias :do_request_without_tingyun_trace :do_request
+
+      def do_request(*args, &block)
+        proxy = no_proxy?(args[1]) ? nil : @proxy
+        tingyun_request = TingYun::Http::HttpClientRequest.new(proxy, *args, &block)
+        TingYun::Agent::CrossAppTracing.tl_trace_http_request(tingyun_request) do
+          TingYun::Agent.disable_all_tracing do
+            do_request_without_tingyun_trace(*tingyun_request.args, &block)
+          end
+        end
+      end
+    end
+
+    ::HTTP::Message.class_eval do
+      def message
+        header.reason_phrase
+      end
+    end
+  end
+end

data/lib/ting_yun/instrumentation/kafka.rb

@@ -0,0 +1,218 @@
+# encoding: utf-8
+
+module TingYun::Instrumentation::Kafka
+
+  KAFKA_MIN_VERSION = '0.2.0'.freeze
+  KAFKA_MAX_VERSION = '0.3.16'.freeze
+  UNKNOWN = 'Unknown:Unknown'.freeze
+
+  def self.version_support?
+    if defined? RUBY_VERSION
+      kafka_version = TingYun::Support::VersionNumber.new(Kafka::VERSION)
+      kafka_version >= TingYun::Support::VersionNumber.new(KAFKA_MIN_VERSION) &&
+          kafka_version <= TingYun::Support::VersionNumber.new(KAFKA_MAX_VERSION)
+    else
+      false
+    end
+  end
+end
+
+TingYun::Support::LibraryDetection.defer do
+  named :ruby_kafka
+
+  depends_on do
+    begin
+      require 'kafka'
+      defined?(::Kafka)  &&
+          TingYun::Instrumentation::Kafka.version_support? && false
+    rescue LoadError
+      false
+    end
+  end
+
+  executes do
+    TingYun::Agent.logger.info 'Installing Ruby-Kafka Instrumentation'
+  end
+
+  executes do
+    Kafka::Producer.class_eval do
+      attr_reader :cluster
+    end
+
+    if defined? (Kafka::Consumer)
+      Kafka::Consumer.class_eval do
+        attr_reader :cluster
+      end
+    end
+
+    if defined? (Kafka::Cluster)
+      Kafka::Cluster.class_eval do
+        attr_reader :seed_brokers
+      end
+    end
+
+    if defined?(Kafka::AsyncProducer) && defined?(Kafka::AsyncProducer::Worker)
+      Kafka::AsyncProducer::Worker.class_eval do
+        attr_reader :producer
+      end
+    end
+
+    Kafka::Client.class_eval do
+      if public_method_defined? :deliver_message
+        alias_method :deliver_message_without_tingyun, :deliver_message
+
+        def deliver_message(*args, **options, &block)
+          begin
+            state = TingYun::Agent::TransactionState.tl_get
+            ip_and_hosts = @seed_brokers.map{|a| [a.host, a.port].join(':')}.join(',') rescue TingYun::Instrumentation::Kafka::UNKNOWN
+            metric_name = "Message Kafka/#{ip_and_hosts}%2FTopic%2F#{options[:topic]}/Produce"
+            summary_metrics = TingYun::Agent::Datastore::MetricHelper.metrics_for_message('Kafka', ip_and_hosts, 'Produce')
+            TingYun::Agent::Transaction.wrap(state, metric_name, :Kafka, {}, summary_metrics) do
+              TingYun::Agent.record_metric("#{metric_name}%2FByte", args[0].bytesize) if args[0]
+              deliver_message_without_tingyun(*args, **options, &block)
+            end
+          rescue => e
+            TingYun::Agent.logger.error("Failed to kafka deliver_message : ", e)
+            deliver_message_without_tingyun(*args, **options, &block)
+          end
+        end
+      end
+
+      if public_method_defined?(:each_message)&& TingYun::Agent.config[:'nbs.mq.conume']
+        alias_method :each_message_without_tingyun, :each_message
+
+        def each_message(*args, **options, &block)
+          wrap_block = Proc.new do |message|
+            begin
+              state = TingYun::Agent::TransactionState.tl_get
+              state.reset
+              ip_and_hosts = @seed_brokers.map{|a| [a.host, a.port].join(':')}.join(',') rescue TingYun::Instrumentation::Kafka::UNKNOWN
+              metric_name = "#{ip_and_hosts}%2FTopic%2F#{message.topic}/Consume"
+              summary_metrics = TingYun::Agent::Datastore::MetricHelper.metrics_for_message('Kafka', ip_and_hosts, 'Consume')
+              TingYun::Agent::Transaction.start(state,:message, {:transaction_name => "WebAction/Kafka/Topic%2F#{message.topic}/Consume"})
+              TingYun::Agent::Transaction.wrap(state, "Message Kafka/#{metric_name}" , :Kafka, {}, summary_metrics)  do
+                TingYun::Agent.record_metric("Message Kafka/#{metric_name}%2FByte",message.value.bytesize) if message.value
+                block.call(message)
+              end
+            rescue => e
+              TingYun::Agent.logger.error("Failed to kafka each_message in client : ", e)
+              block.call(message)
+            ensure
+              TingYun::Agent::Transaction.stop(state, Time.now, summary_metrics)
+            end
+          end
+          each_message_without_tingyun(*args, **options, &wrap_block)
+        end
+      end
+    end
+
+    if defined?(::Kafka::Consumer)
+      Kafka::Consumer.class_eval do
+        if public_method_defined?(:each_message) && TingYun::Agent.config[:'nbs.mq.conume']
+          alias_method :each_message_without_tingyun, :each_message
+          def each_message(*args, **options, &block)
+            wrap_block = Proc.new do |message|
+              begin
+                state = TingYun::Agent::TransactionState.tl_get
+                state.reset
+                ip_and_hosts = self.cluster.seed_brokers.map{|a| [a.host, a.port].join(':')}.join(',') rescue TingYun::Instrumentation::Kafka::UNKNOWN
+                metric_name = "#{ip_and_hosts}%2FTopic%2F#{message.topic}/Consume"
+                summary_metrics = TingYun::Agent::Datastore::MetricHelper.metrics_for_message('Kafka', ip_and_hosts, 'Consume')
+                TingYun::Agent::Transaction.start(state,:message, {:transaction_name => "WebAction/Kafka/Topic%2F#{message.topic}/Consume"})
+                TingYun::Agent::Transaction.wrap(state, "Message Kafka/#{metric_name}" , :Kafka, {}, summary_metrics)  do
+                  TingYun::Agent.record_metric("Message Kafka/#{metric_name}%2FByte", message.value.bytesize) if message.value
+                  block.call(message)
+                end
+              rescue => e
+                TingYun::Agent.logger.error("Failed to Bunny call_with_tingyun : ", e)
+                block.call(message)
+              ensure
+                TingYun::Agent::Transaction.stop(state, Time.now, summary_metrics)
+              end
+            end
+            if options.empty? && args.empty?
+              each_message_without_tingyun(&wrap_block)
+            else
+              each_message_without_tingyun(*args, **options, &wrap_block)
+            end
+          end
+        end
+
+        if public_method_defined?(:each_batch) && TingYun::Agent.config[:'nbs.mq.conume']
+          alias_method :each_batch_without_tingyun, :each_batch
+          def each_batch(*args, **options, &block)
+            wrap_block = Proc.new do |batch|
+              begin
+                state = TingYun::Agent::TransactionState.tl_get
+                state.reset
+                ip_and_hosts = self.cluster.seed_brokers.map{|a| [a.host, a.port].join(':')}.join(',') rescue TingYun::Instrumentation::Kafka::UNKNOWN
+                metric_name = "#{ip_and_hosts}%2FTopic%2F#{batch.topic}/Consume"
+                summary_metrics = TingYun::Agent::Datastore::MetricHelper.metrics_for_message('Kafka', ip_and_hosts, 'Consume')
+                TingYun::Agent::Transaction.start(state,:message, {:transaction_name => "WebAction/Kafka/Topic%2F#{message.topic}/Consume"})
+                TingYun::Agent::Transaction.wrap(state, "Message Kafka/#{metric_name}" , :Kafka, {}, summary_metrics)  do
+                  bytesize = batch.messages.reduce(0){ |res, msg| res += (msg.value ? msg.value.bytesize : 0)}
+                  TingYun::Agent.record_metric("Message Kafka/#{metric_name}%2FByte", bytesize) if bytesize.to_i > 0
+                  block.call(batch)
+                end
+              rescue => e
+                TingYun::Agent.logger.error("Failed to Bunny call_with_tingyun : ", e)
+                block.call(batch)
+              ensure
+                TingYun::Agent::Transaction.stop(state, Time.now, summary_metrics)
+              end
+            end
+            if options.empty? && args.empty?
+              each_batch_without_tingyun(&wrap_block)
+            else
+              each_batch_without_tingyun(*args, **options, &wrap_block)
+            end
+          end
+        end
+      end
+    end
+
+    Kafka::Producer.class_eval do
+      alias_method :produce_without_tingyun, :produce
+      def produce(*args, **options, &block)
+        begin
+          state = TingYun::Agent::TransactionState.tl_get
+          return produce_without_tingyun(*args, **options, &block) unless state.current_transaction
+          ip_and_hosts = @cluster.seed_brokers.map{|a| [a.host, a.port].join(':')}.join(',') rescue TingYun::Instrumentation::Kafka::UNKNOWN
+          metric_name = "Message Kafka/#{ip_and_hosts}%2FTopic%2F#{options[:topic]}/Produce"
+          summary_metrics = TingYun::Agent::Datastore::MetricHelper.metrics_for_message('Kafka', ip_and_hosts, 'Produce')
+          TingYun::Agent::Transaction.wrap(state, metric_name, :Kafka, {}, summary_metrics) do
+            TingYun::Agent.record_metric("#{metric_name}%2FByte",args[0].bytesize) if args[0]
+            produce_without_tingyun(*args, **options, &block)
+          end
+        rescue => e
+          TingYun::Agent.logger.error("Failed to kafka produce sync : ", e)
+          produce_without_tingyun(*args, **options, &block)
+        end
+      end
+    end
+
+    if defined?(Kafka::AsyncProducer)
+      Kafka::AsyncProducer.class_eval do
+        if public_method_defined? :produce
+          alias_method :produce_without_tingyun, :produce
+
+          def produce(*args, **options, &block)
+            begin
+              state = TingYun::Agent::TransactionState.tl_get
+              ip_and_hosts = @worker.producer.cluster.seed_brokers.map{|a| [a.host, a.port].join(':')}.join(',') rescue TingYun::Instrumentation::Kafka::UNKNOWN
+              metric_name = "Message Kafka/#{ip_and_hosts}%2FTopic%2F#{options[:topic]}/Produce"
+              summary_metrics = TingYun::Agent::Datastore::MetricHelper.metrics_for_message('Kafka', ip_and_hosts, 'Produce')
+              TingYun::Agent::Transaction.wrap(state, metric_name, :Kafka, {}, summary_metrics) do
+                TingYun::Agent.record_metric("#{metric_name}%2FByte",args[0].bytesize) if args[0]
+                produce_without_tingyun(*args, **options, &block)
+              end
+            rescue => e
+              TingYun::Agent.logger.error("Failed to kafka produce async : ", e)
+              produce_without_tingyun(*args, **options, &block)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ting_yun/instrumentation/memcached.rb

@@ -0,0 +1,135 @@
+# encoding: utf-8
+module TingYun
+  module Instrumentation
+    module Timings
+      def record_memcached_duration(duration)
+        state = TingYun::Agent::TransactionState.tl_get
+        if state
+          state.timings.mc_duration = state.timings.mc_duration + duration * 1000
+        end
+      end
+    end
+
+    module VersionSupport
+      require 'ting_yun/support/version_number'
+      module_function
+
+      VERSION1 = '2.6.4'.freeze
+
+      def new_version_support?
+        ::TingYun::Support::VersionNumber.new(Dalli::VERSION) >= ::TingYun::Support::VersionNumber.new(VERSION1)
+      end
+    end
+  end
+end
+
+
+TingYun::Support::LibraryDetection.defer do
+  named :memcached
+
+  depends_on do
+    defined?(::Memcached) || (defined?(::Dalli) && defined?(::Dalli::Client)) && false
+  end
+
+  depends_on do
+    !::TingYun::Agent.config[:disable_memcache]
+  end
+
+
+  executes do
+    TingYun::Agent.logger.info "Installing Memcached Instrumentation" if defined?(::Memcached)
+    TingYun::Agent.logger.info "Installing Dalli Instrumentation" if defined?(::Dalli::Client)
+    require 'ting_yun/agent/transaction/transaction_state'
+  end
+
+  executes do
+    require 'ting_yun/agent/datastore'
+
+    if defined?(::Memcached)
+      ::Memcached.class_eval do
+
+        include TingYun::Instrumentation::Timings
+
+        methods = [:set, :add, :increment, :decrement, :replace, :append, :prepend, :cas, :delete, :flush, :get, :exist,
+                   :get_from_last, :server_by_key, :stats, :set_servers]
+
+        methods.each do |method|
+          next unless public_method_defined? method
+
+          alias_method "#{method}_without_tingyun_trace".to_sym, method.to_sym
+
+          define_method method do |*args, &block|
+            TingYun::Agent::Datastore.wrap('Memcached', method.to_s, nil, nil, nil, nil, method(:record_memcached_duration)) do
+              send "#{method}_without_tingyun_trace", *args, &block
+            end
+          end
+        end
+
+        alias :incr :increment
+        alias :decr :decrement
+        alias :compare_and_swap :cas if public_method_defined? :compare_and_swap
+      end
+    end
+
+    if defined?(::Dalli::Server)
+      ::Dalli::Server.class_eval do
+
+        include TingYun::Instrumentation::Timings
+
+        connect_method = (private_method_defined? :connect) ? :connect : :connection
+        private
+        alias_method :connect_without_tingyun_trace, connect_method
+
+        define_method connect_method do |*args, &block|
+          if @sock
+            connect_without_tingyun_trace *args, &block
+          else
+            TingYun::Agent::Datastore.wrap('Memcached', 'connect', nil, hostname, port, nil, method(:record_memcached_duration)) do
+              connect_without_tingyun_trace *args, &block
+            end
+          end
+        end
+      end
+    end
+
+    if defined?(::Dalli::Client)
+      ::Dalli::Client.class_eval do
+
+        include TingYun::Instrumentation::Timings
+
+        private
+        alias_method :perform_without_tingyun_trace, :perform
+        def perform(*args, &block)
+          return block.call if block
+          op, key = args[0..1]
+          current_ring = self.class.private_method_defined?(:ring) ? ring : @ring
+          server = current_ring.server_for_key(validate_key(key.to_s)) rescue nil
+          if server
+            host = server.hostname
+            port = server.port
+          end
+          TingYun::Agent::Datastore.wrap('Memcached', op.to_s, nil, host, port, nil, method(:record_memcached_duration)) do
+            perform_without_tingyun_trace(*args, &block)
+          end
+        end
+
+        methods = [:flush, :stats, :reset_stats, :close]
+        methods += [:get_multi, :get_multi_cas] if TingYun::Instrumentation::VersionSupport.new_version_support?
+
+        methods.each do |method|
+          next unless public_method_defined? method
+          alias_method "#{method}_without_tingyun_trace".to_sym, method.to_sym
+
+          define_method method do |*args, &block|
+            TingYun::Agent::Datastore.wrap('Memcached', method.to_s, nil, nil, nil, nil, method(:record_memcached_duration)) do
+              send "#{method}_without_tingyun_trace", *args, &block
+            end
+          end
+        end
+
+        alias :flush_all :flush
+        alias :reset :close if public_method_defined? :reset
+      end
+    end
+  end
+end

data/lib/ting_yun/instrumentation/middleware_proxy.rb

@@ -14,10 +14,7 @@ module TingYun
       end
 
       def self.needs_wrapping?(target)
-        (
-        !target.respond_to?(:_nr_has_middleware_tracing) &&
-            !is_sinatra_app?(target)
-        )
+        !target.respond_to?(:_nr_has_middleware_tracing)
       end
 
       def self.wrap(target, is_app=false)

data/lib/ting_yun/instrumentation/middleware_tracing.rb

@@ -45,8 +45,13 @@ module TingYun
         end
       end
 
+      def sinatra_static?(env)
+        defined?(::Sinatra) && defined?(::Sinatra::Base) && env['REQUEST_URI'] && env['REQUEST_URI'] =~ /\.(css|js|html|png|jpg|jpeg|gif|bmp)\Z/i
+      end
 
       def call(env)
+        return target.call(env) if sinatra_static?(env)
+
         first_middleware = note_transaction_started(env)
         state = TingYun::Agent::TransactionState.tl_get
         begin
@@ -66,7 +71,6 @@ module TingYun
 
           result
         rescue Exception => e
-
           TingYun::Agent.notice_error(e)
           raise e
         ensure

data/lib/ting_yun/instrumentation/mongo.rb

@@ -23,7 +23,7 @@ module TingYun
 
       def hook_instrument_method(target_class)
         target_class.class_eval do
-          require 'ting_yun/agent/method_tracer'
+          require 'ting_yun/agent/method_tracer_helpers'
 
           def record_mongo_duration(duration)
             state = TingYun::Agent::TransactionState.tl_get
@@ -32,15 +32,21 @@ module TingYun
             end
           end
 
+          def tingyun_host_port
+           return @db.connection.host_port if self.instance_variable_defined? :@db
+           return @host_to_try if self.instance_variable_defined? :@host_to_try
+           return ['Unknown', 'Unknown']
+          end
+
           def tingyun_generate_metrics(operation, payload = nil)
             payload ||= { :collection => self.name, :database => self.db.name }
-            TingYun::Instrumentation::Support::MetricTranslator.metrics_for(operation, payload)
+            TingYun::Instrumentation::Support::MetricTranslator.metrics_for(operation, payload, tingyun_host_port)
           end
 
           def instrument_with_tingyun(name, payload = {}, &block)
-            metrics = tingyun_generate_metrics(name, payload)
+            klass_name, *metrics = tingyun_generate_metrics(name, payload)
 
-            TingYun::Agent::MethodTracer.trace_execution_scoped(metrics, payload, method(:record_mongo_duration)) do
+            TingYun::Agent::MethodTracerHelpers.trace_execution_scoped(metrics, payload, method(:record_mongo_duration), klass_name) do
               instrument_without_tingyun(name, payload, &block)
             end
           end
@@ -53,7 +59,8 @@ module TingYun
       def instrument
         ::Mongo::Collection.class_eval do
           def save_with_tingyun(doc, opts = {}, &block)
-            TingYun::Agent::MethodTracer.trace_execution_scoped(tingyun_generate_metrics(:save), opts, method(:record_mongo_duration)) do
+            klass_name, *metrics = tingyun_generate_metrics(:save)
+            TingYun::Agent::MethodTracerHelpers.trace_execution_scoped(metrics, opts, method(:record_mongo_duration), klass_name) do
               save_without_tingyun(doc, opts, &block)
             end
           end
@@ -62,7 +69,8 @@ module TingYun
           alias_method :save, :save_with_tingyun
 
           def ensure_index_with_tingyun(spec, opts = {}, &block)
-            TingYun::Agent::MethodTracer.trace_execution_scoped(tingyun_generate_metrics(:ensureIndex), opts, method(:record_mongo_duration)) do
+            klass_name, *metrics = tingyun_generate_metrics(:ensureIndex)
+            TingYun::Agent::MethodTracerHelpers.trace_execution_scoped(metrics, opts, method(:record_mongo_duration), klass_name) do
               ensure_index_without_tingyun(spec, opts, &block)
             end
           end
@@ -79,6 +87,10 @@ end
 TingYun::Support::LibraryDetection.defer do
   named :mongo
 
+  depends_on do
+    !::TingYun::Agent.config[:disable_mongo]
+  end
+
   depends_on do
     defined?(::Mongo)
   end

data/lib/ting_yun/instrumentation/mongo2.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 require 'ting_yun/agent'
-require 'ting_yun/agent/method_tracer'
+require 'ting_yun/instrumentation/support/method_instrumentation'
 
 module TingYun
   module Instrumentation
@@ -22,6 +22,10 @@ end
 TingYun::Support::LibraryDetection.defer do
   named :mongo2
 
+  depends_on do
+    !::TingYun::Agent.config[:disable_mongo]
+  end
+
   depends_on do
     require 'ting_yun/agent/datastore/mongo'
     defined?(::Mongo) && TingYun::Agent::Datastore::Mongo.unsupported_2x? && defined?(::Mongo::Monitoring::Global)

data/lib/ting_yun/instrumentation/mongo_command_log_subscriber.rb

@@ -30,12 +30,12 @@ module TingYun
           state.timings.mon_duration = state.timings.mon_duration +  event.duration * 1000
           started_event = operations.delete(event.operation_id)
 
-          base, *other_metrics = metrics(started_event)
+          klass_name, 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)
+          notice_nosql_statement(state, started_event, base, event.duration, klass_name)
         rescue Exception => e
           log_notification_error('completed', e)
         end
@@ -68,7 +68,7 @@ module TingYun
       end
 
       def metrics(event)
-        TingYun::Agent::Datastore::MetricHelper.metrics_for(MONGODB, TingYun::Agent::Datastore::Mongo.transform_operation(event.command_name), collection(event))
+        TingYun::Agent::Datastore::MetricHelper.metrics_for(MONGODB, TingYun::Agent::Datastore::Mongo.transform_operation(event.command_name), event.address.host, event.address.port, event.database_name, collection(event))
       end
 
       def generate_statement(event)
@@ -79,7 +79,7 @@ module TingYun
         )
       end
 
-      def notice_nosql_statement(state, event, metric, duration)
+      def notice_nosql_statement(state, event, metric, duration, klass_name)
         end_time = Time.now.to_f
 
         stack  = state.traced_method_stack
@@ -90,7 +90,7 @@ module TingYun
         transaction_sampler.notice_nosql_statement(generate_statement(event),duration*1000)
 
         # exit transaction trace node
-        stack.pop_frame(state, frame, metric, end_time)
+        stack.pop_frame(state, frame, metric, end_time, true, klass_name)
       end
 
       def transaction_sampler

data/lib/ting_yun/instrumentation/moped.rb

@@ -32,7 +32,8 @@ module TingYun
         operation = TingYun::Agent::Datastore::Mongo.transform_operation(operation_name)
 
         res = nil
-        TingYun::Agent::Datastore.wrap(MONGODB, operation, collection, method(:record_mongo_duration)) do
+        database = options["database"] || options[:database]
+        TingYun::Agent::Datastore.wrap(MONGODB, operation, collection, ip_address, port, database, method(:record_mongo_duration)) do
           res = log_without_tingyun_instrumentation(operations, &blk)
         end
 
@@ -61,7 +62,7 @@ module TingYun
         return operation_name, collection
       end
 
-      def record_mongo_duration(_1, _2, duration)
+      def record_mongo_duration(duration)
         state = TingYun::Agent::TransactionState.tl_get
         if state
           state.timings.mon_duration = state.timings.mon_duration +  duration * 1000
@@ -81,7 +82,7 @@ end
 TingYun::Support::LibraryDetection.defer do
   named :mongo_moped
   depends_on do
-    defined?(::Moped)
+    defined?(::Moped) && !::TingYun::Agent.config[:disable_mongo]
   end
 
   executes do

data/lib/ting_yun/instrumentation/net.rb

@@ -5,7 +5,7 @@ TingYun::Support::LibraryDetection.defer do
   named :net_http
 
   depends_on do
-    defined?(Net) && defined?(Net::HTTP)
+    defined?(Net) && defined?(Net::HTTP) && !::TingYun::Agent.config[:disable_net_http]
   end
 
   executes do
@@ -36,7 +36,7 @@ TingYun::Support::LibraryDetection.defer do
           begin
             get_response_without_tingyun(uri_or_host, path , port , &block)
           rescue => e
-            ::TingYun::Instrumentation::Support::ExternalError.handle_error(e, "External/#{uri_or_host.to_s.gsub('/','%2F')}/net%2Fhttp")
+            ::TingYun::Instrumentation::Support::ExternalError.handle_error(e, "External/#{uri_or_host.to_s.gsub(/\/\z/,'').gsub('/','%2F')}/net%2Fhttp")
             raise e
           end
         end
@@ -47,7 +47,7 @@ TingYun::Support::LibraryDetection.defer do
           begin
             start_without_tingyun(address, *arg, &block)
           rescue => e
-            ::TingYun::Instrumentation::Support::ExternalError.handle_error(e, "External/#{address.to_s.gsub('/','%2F')}/net%2Fhttp")
+            ::TingYun::Instrumentation::Support::ExternalError.handle_error(e, "External/#{address.to_s.gsub(/\/\z/,'').gsub('/','%2F')}/net%2Fhttp")
             raise e
           end
         end

data/lib/ting_yun/instrumentation/rails3/action_controller.rb

@@ -15,15 +15,15 @@ module TingYun
 
         def tingyun_metric_path(action_name_override = nil)
           if find_rule(request.request_method.upcase, request.path, request.env, request.filtered_parameters)
-            return "Rails3/#{namespace}/#{name(request.path.slice(1..-1), request.env, request.filtered_parameters, request.cookies)}"
+            return "Rails/#{namespace}/#{name(request.path.slice(1..-1), request.env, request.filtered_parameters, request.cookies)}"
           else
-            return  self.env["PATH_INFO"] unless TingYun::Agent.config[:'nbs.auto_action_naming']
+            return  "URL/#{self.env["PATH_INFO"][1..-1].gsub(/\//,'%2F')}" unless TingYun::Agent.config[:'nbs.auto_action_naming']
 
             action = action_name_override || action_name
             if action_name_override || self.class.action_methods.include?(action)
-              "Rails3/#{self.class.controller_path}%2F#{action}"
+              "Rails/#{self.class.controller_path}%2F#{action}"
             else
-              "Rails3/#{self.class.controller_path}%2F(other)"
+              "Rails/#{self.class.controller_path}%2F(other)"
             end
           end
         end
@@ -48,6 +48,10 @@ end
 TingYun::Support::LibraryDetection.defer do
   @name = :rails3_controller
 
+  depends_on do
+    !::TingYun::Agent.config[:disable_action_controller]
+  end
+
   depends_on do
     defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 3
   end