tingyun_rpm 1.2.0 → 1.3.0

data/lib/ting_yun/instrumentation/{rails4 → support}/action_controller_subscriber.rb

@@ -9,7 +9,7 @@ require 'ting_yun/instrumentation/support/parameter_filtering'
 
 module TingYun
   module Instrumentation
-    module Rails4
+    module Rails
       class ActionControllerSubscriber < TingYun::Instrumentation::Support::EventedSubscriber
         def start(name, id, payload) #THREAD_LOCAL_ACCES
           state = TingYun::Agent::TransactionState.tl_get
@@ -17,8 +17,8 @@ module TingYun
           event = ControllerEvent.new(name, Time.now, nil, id, payload, request)
           push_event(event)
           # if state.execution_traced?
-            start_transaction(state, event)
-          # end
+          start_transaction(state, event)
+            # end
         rescue => e
           log_notification_error(e, name, 'start')
         end
@@ -80,7 +80,7 @@ module TingYun
             if TingYun::Agent.config[:'nbs.auto_action_naming']
               @metric_name ||= "WebAction/Rails/#{metric_path}%2F#{metric_action}"
             else
-              "WebAction/#{uri}"
+              "WebAction/URI/#{uri[1..-1].gsub(/\//,'%2F')}"
             end
           end
         end
@@ -90,7 +90,7 @@ module TingYun
         end
 
         def params
-           payload[:params]
+          payload[:params]
         end
 
         def metric_path
@@ -122,27 +122,3 @@ module TingYun
     end
   end
 end
-
-
-TingYun::Support::LibraryDetection.defer do
-  @name = :rails4_controller
-
-  depends_on do
-    defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 4
-  end
-
-  depends_on do
-    defined?(ActionController) && defined?(ActionController::Base)
-  end
-
-  executes do
-    ::TingYun::Agent.logger.info 'Installing Rails 4 Controller instrumentation'
-  end
-
-  executes do
-    ::TingYun::Instrumentation::Rails4::ActionControllerSubscriber \
-      .subscribe(/^process_action.action_controller$/)
-  end
-end
-
-

data/lib/ting_yun/instrumentation/{rails4 → support}/action_view_subscriber.rb

@@ -7,7 +7,7 @@ require 'ting_yun/agent'
 
 module TingYun
   module Instrumentation
-    module Rails4
+    module Rails
       class ActionViewSubscriber < TingYun::Instrumentation::Support::EventedSubscriber
 
         def start(name, id, payload) #THREAD_LOCAL_ACCESS
@@ -93,26 +93,4 @@ module TingYun
       end
     end
   end
-end
-
-TingYun::Support::LibraryDetection.defer do
-  @name = :rails4_view
-
-  depends_on do
-    defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 4
-  end
-
-  depends_on do
-    !TingYun::Agent.config[:disable_view_instrumentation] &&
-        !TingYun::Instrumentation::Rails4::ActionViewSubscriber.subscribed?
-  end
-
-  executes do
-    TingYun::Agent.logger.info 'Installing Rails 4 view instrumentation'
-  end
-
-  executes do
-    TingYun::Instrumentation::Rails4::ActionViewSubscriber.subscribe(/render_.+\.action_view$/)
-  end
-end
-#
+end

data/lib/ting_yun/instrumentation/support/active_record_helper.rb

@@ -12,6 +12,7 @@ module TingYun
 
 
         ACTIVE_RECORD = "ActiveRecord".freeze unless defined?(ACTIVE_RECORD)
+        DATA_MAPPER = "DataMapper".freeze
 
         # Used by both the AR 3.x and 4.x instrumentation
         def instrument_additional_methods
@@ -68,15 +69,29 @@ module TingYun
           end
         end
 
-        def metrics_for(name, sql, adapter_name)
-          product = map_product(adapter_name)
+        def metrics_for(name, sql, config)
+          config ||={}
+          product = map_product(config[:adapter])
           splits = split_name(name)
           model = model_from_splits(splits) || product
           operation = operation_from_splits(splits, sql)
 
-          TingYun::Agent::Datastore::MetricHelper.metrics_for(product, operation, model, ACTIVE_RECORD)
+          TingYun::Agent::Datastore::MetricHelper.metrics_for(product, operation, config[:host], config[:port], config[:database], model, ACTIVE_RECORD)
         end
 
+        def metrics_for_data_mapper(name, sql, config, model=nil)
+          if config
+            product = map_product(config.query['adapter'])
+            operation = name || TingYun::Instrumentation::Support::Database.parse_operation_from_query(sql)
+            model ||= product
+            db = config.query['database'] || config.path.split('/').last
+            host = config.host
+            port = config.port
+            host = nil if config.host && config.host.empty?
+            port = nil if config.host && config.host.empty?
+            TingYun::Agent::Datastore::MetricHelper.metrics_for(product, operation, host, port, db, model, DATA_MAPPER)
+          end
+        end
 
         SPACE = ' '.freeze unless defined?(SPACE)
         EMPTY = [].freeze unless defined?(EMPTY)
@@ -132,7 +147,9 @@ module TingYun
             "mysql" => "MySQL",
             "mysql2" => "MySQL",
 
-            "postgresql" => "Postgres",
+            "postgresql" => "PostgreSQL",
+
+            "postgres" => 'PostgreSQL',
 
             "sqlite3" => "SQLite",
 
@@ -140,7 +157,7 @@ module TingYun
             "jdbcmysql" => "MySQL",
 
             # https://rubygems.org/gems/activerecord-jdbcpostgresql-adapter
-            "jdbcpostgresql" => "Postgres",
+            "jdbcpostgresql" => "PostgreSQL",
 
             # https://rubygems.org/gems/activerecord-jdbcsqlite3-adapter
             "jdbcsqlite3" => "SQLite",
@@ -157,7 +174,7 @@ module TingYun
             "mssql" => "MSSQL",
 
             # https://rubygems.org/gems/activerecord-sqlserver-adapter
-            "sqlserver" => "MSSQL",
+            "sqlserver" => "SQLServer",
 
             # https://rubygems.org/gems/activerecord-odbc-adapter
             "odbc" => "ODBC",

data/lib/ting_yun/instrumentation/{rails4 → support}/active_record_subscriber.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+
 require 'ting_yun/instrumentation/support/evented_subscriber'
 require 'ting_yun/agent/transaction/transaction_state'
 require 'ting_yun/instrumentation/support/active_record_helper'
@@ -9,7 +10,7 @@ require 'ting_yun/agent/database'
 
 module TingYun
   module Instrumentation
-    module Rails4
+    module Rails
       class ActiveRecordSubscriber < TingYun::Instrumentation::Support::EventedSubscriber
         CACHED_QUERY_NAME = 'CACHE'.freeze unless defined? CACHED_QUERY_NAME
 
@@ -37,37 +38,37 @@ module TingYun
           state = TingYun::Agent::TransactionState.tl_get
           event = pop_event(id)
           config = active_record_config_for_event(event)
-          base_metric = record_metrics(event, config)
-          notice_sql(state, event, config, base_metric)
+          base, metric = record_metrics(event, config)
+          notice_sql(state, event, config, base, metric)
         rescue Exception => e
           log_notification_error(e, name, 'finish')
         end
 
 
-        def notice_sql(state, event, config, metric)
+        def notice_sql(state, event, config, base, metric)
           stack  = state.traced_method_stack
           state.timings.sql_duration = state.timings.sql_duration + event.duration
           # enter transaction trace node
           frame = stack.push_frame(state, :active_record, event.time)
 
-          sql_sampler.notice_sql(event.payload[:sql], metric, config,
-                        TingYun::Helper.milliseconds_to_seconds(event.duration),
-                        state, @explainer, event.payload[:binds], event.payload[:name])
+          sql_sampler.notice_sql(event.payload[:sql], base, config,
+                                 TingYun::Helper.milliseconds_to_seconds(event.duration),
+                                 state, @explainer, event.payload[:binds], event.payload[:name])
 
           transaction_sampler.notice_sql(event.payload[:sql], config, event.duration,
-                        state, @explainer, event.payload[:binds], event.payload[:name])
+                                         state, @explainer, event.payload[:binds], event.payload[:name])
           # exit transaction trace node
-          stack.pop_frame(state, frame, metric, event.end)
+          stack.pop_frame(state, frame, base, event.end, true, metric)
         end
 
         def record_metrics(event, config)
-          base, *other_metrics = TingYun::Instrumentation::Support::ActiveRecordHelper.metrics_for(event.payload[:name],
+          metric, base, *other_metrics = TingYun::Instrumentation::Support::ActiveRecordHelper.metrics_for(event.payload[:name],
                                                                                                    TingYun::Helper.correctly_encoded(event.payload[:sql]),
-                                                                                                   config && config[:adapter])
+                                                                                                   config)
 
           TingYun::Agent.agent.stats_engine.tl_record_scoped_and_unscoped_metrics(base, other_metrics, event.duration)
 
-          base
+          return base, metric
         end
 
 
@@ -98,29 +99,4 @@ module TingYun
       end
     end
   end
-end
-
-TingYun::Support::LibraryDetection.defer do
-  named :active_record_4
-
-
-  depends_on do
-    defined?(::ActiveRecord) && defined?(::ActiveRecord::Base) &&
-        defined?(::ActiveRecord::VERSION) &&
-        ::ActiveRecord::VERSION::MAJOR.to_i >= 4
-  end
-
-  depends_on do
-    !TingYun::Instrumentation::Rails4::ActiveRecordSubscriber.subscribed?
-  end
-
-  executes do
-    ::TingYun::Agent.logger.info 'Installing ActiveRecord 4 instrumentation'
-  end
-
-  executes do
-    ActiveSupport::Notifications.subscribe('sql.active_record',
-                                           TingYun::Instrumentation::Rails4::ActiveRecordSubscriber.new)
-    ::TingYun::Instrumentation::Support::ActiveRecordHelper.instrument_additional_methods
-  end
 end

data/lib/ting_yun/instrumentation/support/controller_instrumentation.rb

@@ -4,19 +4,221 @@ require 'ting_yun/agent/transaction/transaction_state'
 require 'ting_yun/instrumentation/support/transaction_namer'
 require 'ting_yun/agent/transaction'
 require 'ting_yun/agent'
-
+require 'ting_yun/support/helper'
 
 module TingYun
   module Instrumentation
     module Support
+
+      # This module can also be used to capture performance information for
+      # background tasks and other non-web transactions, including
+      # detailed transaction traces and traced errors.
       module ControllerInstrumentation
 
+        extend self
+
+        def self.included klass
+          klass.extend ClassMethods
+        end
+
+        def self.extended klass
+          klass.extend ClassMethods
+        end
+
+
+        module ClassMethods
+          # Add transaction tracing to the given method.  This will treat
+          # the given method as a main entrypoint for instrumentation, just
+          # like controller actions are treated by default.  Useful especially
+          # for background tasks.
+          # Example for background job:
+          #   class Job
+          #     include TingYun::Instrumentation::Support::ControllerInstrumentation
+          #     def run(task)
+          #        ...
+          #     end
+          #     # Instrument run so tasks show up under task.name.  Note single
+          #     # quoting to defer eval to runtime.
+          #     add_transaction_tracer :run, :name => '#{args[0].name}'
+          #   end
+          #
+          # Here's an example of a controller that uses a dispatcher
+          # action to invoke operations which you want treated as top
+          # level actions, so they aren't all lumped into the invoker
+          # action.
+          #
+          #   MyController < ActionController::Base
+          #     include TingYun::Instrumentation::Support::ControllerInstrumentation
+          #     # dispatch the given op to the method given by the service parameter.
+          #     def invoke_operation
+          #       op = params['operation']
+          #       send op
+          #     end
+          #     # Ignore the invoker to avoid double counting
+          #     tingyun_ignore :only => 'invoke_operation'
+          #     # Instrument the operations:
+          #     add_transaction_tracer :print
+          #     add_transaction_tracer :show
+          #     add_transaction_tracer :forward
+          #   end
+          #
+          # Here's an example of how to pass contextual information into the transaction
+          # so it will appear in transaction traces:
+          #
+          #   class Job
+          #    include TingYun::Instrumentation::Support::ControllerInstrumentation
+          #     def process(account)
+          #        ...
+          #     end
+          #     # Include the account name in the transaction details.  Note the single
+          #     # quotes to defer eval until call time.
+          #     add_transaction_tracer :process, :params => '{ :account_name => args[0].name }'
+          #   end
+          #``
+          #
+          # @api public
+          #
+          def add_transaction_tracer(method, options={})
+            options[:name] ||= method.to_s
+            argument_list = generate_argument_list(options)
+            traced_method, punctuation = parse_punctuation(method)
+            with_method_name, without_method_name = build_method_names(traced_method, punctuation)
+
+            if already_added_transaction_tracer?(self, with_method_name)
+              ::TingYun::Agent.logger.warn("Transaction tracer already in place for class = #{self.name}, method = #{method.to_s}, skipping")
+              return
+            end
+
+            class_eval <<-EOC
+            def #{with_method_name}(*args,&block)
+              perform_action_with_tingyun_trace(#{argument_list.join(',')}) do
+                #{without_method_name}(*args, &block)
+              end
+            end
+            EOC
+
+            visibility = TingYun::Helper.instance_method_visibility self, method
+
+            alias_method without_method_name, method.to_s
+            alias_method method.to_s, with_method_name
+            send visibility, method
+            send visibility, with_method_name
+            ::TingYun::Agent.logger.debug("Traced transaction: class = #{self.name}, method = #{method.to_s}, options = #{options.inspect}")
+          end
+
+          def already_added_transaction_tracer?(target, with_method_name)
+            if TingYun::Helper.instance_methods_include?(target, with_method_name)
+              true
+            else
+              false
+            end
+          end
+
+          def parse_punctuation(method)
+            [method.to_s.sub(/([?!=])$/, ''), $1]
+          end
+
+          def build_method_names(traced_method, punctuation)
+            [ "#{traced_method.to_s}_with_tingyun_transaction_trace#{punctuation}",
+              "#{traced_method.to_s}_without_tingyun_transaction_trace#{punctuation}" ]
+          end
+
+          def generate_argument_list(options)
+            options.map do |key, value|
+              value = if value.is_a?(Symbol)
+                        value.inspect
+                      elsif key == :params
+                        value.to_s
+                      else
+                        %Q["#{value.to_s}"]
+                      end
+
+              %Q[:#{key} => #{value}]
+            end
+          end
+
+
+
+        end
+
+
+
+        # Yield to the given block with TingYun tracing.  Used by
+        # default instrumentation on controller actions in Rails and Merb.
+        # But it can also be used in custom instrumentation of controller
+        # methods and background tasks.
+
+        # This is the method invoked by instrumentation added by the
+        # <tt>ClassMethods#add_transaction_tracer</tt>.
+
+        # Below is a controller with an +invoke_operation+ action which
+        # dispatches to more specific operation methods based on a
+        # parameter (very dangerous, btw!).  With this instrumentation,
+        # the +invoke_operation+ action is ignored but the operation
+        # methods show up in TingYun as if they were first class controller
+        # actions
+        #
+        #   MyController < ActionController::Base
+        #     include TingYun::Instrumentation::Support::ControllerInstrumentation
+        #     # dispatch the given op to the method given by the service parameter.
+        #     def invoke_operation
+        #       op = params['operation']
+        #       perform_action_with_tingyun_trace(:name => op) do
+        #         send op, params['message']
+        #       end
+        #     end
+        #     # Ignore the invoker to avoid double counting
+        #     tingyun_ignore :only => 'invoke_operation'
+        #   end
+        #
+        # When invoking this method explicitly as in the example above, pass in a
+        # block to measure with some combination of options:
+        #
+        # * <tt>:category => :controller</tt> indicates that this is a
+        #   controller action and will appear with all the other actions.  This
+        #   is the default.
+        # * <tt>:category => :task</tt> indicates that this is a
+        #   background task and will show up in Ting Yun with other background
+        #   tasks instead of in the controllers list
+        # * <tt>:category => :middleware</tt> if you are instrumenting a rack
+        #   middleware call.  The <tt>:name</tt> is optional, useful if you
+        #   have more than one potential transaction in the #call.
+        # * <tt>:category => :uri</tt> indicates that this is a
+        #   web transaction whose name is a normalized URI, where  'normalized'
+        #   means the URI does not have any elements with data in them such
+        #   as in many REST URIs.
+        # * <tt>:name => action_name</tt> is used to specify the action
+        #   name used as part of the metric name
+        # * <tt>:params => {...}</tt> to provide information about the context
+        #   of the call, used in transaction trace display, for example:
+        #   <tt>:params => { :account => @account.name, :file => file.name }</tt>
+        #   These are treated similarly to request parameters in web transactions.
+        #
+        # Seldomly used options:
+        #
+        # * <tt>:class_name => aClass.name</tt> is used to override the name
+        #   of the class when used inside the metric name.  Default is the
+        #   current class.
+        # * <tt>:path => metric_path</tt> is *deprecated* in the public API.  It
+        #   allows you to set the entire metric after the category part.  Overrides
+        #   all the other options.
+        # * <tt>:request => Rack::Request#new(env)</tt> is used to pass in a
+        #   request object that may respond to path and referer.
+        #
+        # @api public
+        #
         NR_DEFAULT_OPTIONS    = {}.freeze          unless defined?(NR_DEFAULT_OPTIONS   )
 
         def perform_action_with_tingyun_trace (*args, &block)
 
           state = TingYun::Agent::TransactionState.tl_get
 
+          skip_tracing = !state.execution_traced?
+
+          if skip_tracing
+            state.current_transaction.ignore! if state.current_transaction
+            TingYun::Agent.disable_all_tracing { return yield }
+          end
           trace_options = args.last.is_a?(Hash) ? args.last : NR_DEFAULT_OPTIONS
           category = trace_options[:category] || :controller
           txn_options = create_transaction_options(trace_options, category)
@@ -40,6 +242,7 @@ module TingYun
           txn_options = {}
 
           txn_options[:request] ||= request if respond_to?(:request)
+          txn_options[:request] ||= trace_options[:request] if trace_options[:request]
           txn_options[:filtered_params] = trace_options[:params]
           txn_options[:transaction_name] = TingYun::Instrumentation::Support::TransactionNamer.name_for(nil, self, category, trace_options)
           txn_options[:apdex_start_time] = Time.now

data/lib/ting_yun/instrumentation/support/database.rb

@@ -14,7 +14,8 @@ module TingYun
             'DELETE',
             'INSERT',
             'SHOW',
-            'CALL'
+            'CALL',
+            'PRAGMA'
         ]
 
         SQL_COMMENT_REGEX = Regexp.new('/\*.*?\*/', Regexp::MULTILINE).freeze

data/lib/ting_yun/instrumentation/support/external_error.rb

@@ -13,10 +13,10 @@ module TingYun
 
         module_function
 
-        def capture_exception(response,request,type)
+        def capture_exception(response,request)
           if response && response.code =~ /^[4,5][0-9][0-9]$/ && response.code!='401'
             e = TingYun::Support::Exception::InternalServerError.new("#{response.code}: #{response.message}")
-            klass = "External/#{request.uri.to_s.gsub('/','%2F')}/#{type}"
+            klass = "External/#{request.uri.to_s.gsub('/','%2F')}/#{request.from}"
             set_attributes(e, klass, response.code)
 
             TingYun::Agent.notice_error(e)

data/lib/ting_yun/instrumentation/support/external_helper.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+
+module TingYun
+  module Instrumentation
+    module Support
+      module ExternalHelper
+        def create_tingyun_id(protocol)
+          state = TingYun::Agent::TransactionState.tl_get
+          externel_guid = tingyun_externel_guid
+          state.transaction_sample_builder.current_node["externalId"] = externel_guid
+          cross_app_id  = TingYun::Agent.config[:tingyunIdSecret] or
+              raise TingYun::Agent::CrossAppTracing::Error, "no tingyunIdSecret configured"
+          "#{cross_app_id};c=1;x=#{state.request_guid};e=#{externel_guid};s=#{TingYun::Helper.time_to_millis(Time.now)};p=#{protocol}"
+        end
+
+        # generate a random 64 bit uuid
+        def tingyun_externel_guid
+          guid = ''
+          16.times do
+            guid << (0..15).map{|i| i.to_s(16)}[rand(16)]
+          end
+          guid
+        end
+      end
+    end
+  end
+end
+
+