tingyun_rpm 1.0.6

data/lib/ting_yun/instrumentation/redis.rb

@@ -0,0 +1,70 @@
+# encoding: utf-8
+
+
+
+TingYun::Support::LibraryDetection.defer do
+  named :redis
+
+  depends_on do
+    defined?(::Redis)
+  end
+
+
+  executes do
+    TingYun::Agent.logger.info 'Installing Redis Instrumentation'
+    require 'ting_yun/agent/transaction/transaction_state'
+  end
+
+  executes do
+    require 'ting_yun/agent/datastore'
+
+    ::Redis::Client.class_eval do
+
+      def record_redis_duration(_1, _2, duration)
+        state = TingYun::Agent::TransactionState.tl_get
+        unless state.nil?
+          state.rds_duration += duration * 1000
+        end
+      end
+
+      call_method = ::Redis::Client.new.respond_to?(:call) ? :call : :raw_call_command
+
+      def call_with_tingyun_trace(*args, &blk)
+        operation = args[0].is_a?(Array) ? args[0][0] : args[0]
+
+        TingYun::Agent::Datastore.wrap("Redis", operation, nil, method(:record_redis_duration)) do
+          call_without_tingyun_trace(*args, &blk)
+        end
+      end
+
+      alias_method :call_without_tingyun_trace, call_method
+      alias_method call_method, :call_with_tingyun_trace
+
+
+      if public_method_defined? :call_pipelined
+        def call_pipelined_with_tingyun_trace(*args, &block)
+          pipeline = args[0]
+          operation = pipeline.is_a?(::Redis::Pipeline::Multi) ? 'multi' : 'pipeline'
+
+          TingYun::Agent::Datastore.wrap("Redis", operation, nil, method(:record_redis_duration)) do
+            call_pipelined_without_tingyun_trace(*args, &block)
+          end
+        end
+
+        alias_method :call_pipelined_without_tingyun_trace, :call_pipelined
+        alias_method :call_pipelined, :call_pipelined_with_tingyun_trace
+      end
+
+      if public_method_defined? :connect
+
+        alias_method :connect_without_tingyun, :connect
+
+        def connect(*args, &block)
+          TingYun::Agent::Datastore.wrap("Redis", "connect", nil, method(:record_redis_duration)) do
+            connect_without_tingyun(*args, &block)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,178 @@
+# encoding: utf-8
+
+
+require 'ting_yun/instrumentation/support/database'
+require 'ting_yun/agent/datastore/metric_helper'
+require 'ting_yun/agent'
+module TingYun
+  module Instrumentation
+    module Support
+      module ActiveRecordHelper
+        module_function
+
+
+        ACTIVE_RECORD = "ActiveRecord".freeze unless defined?(ACTIVE_RECORD)
+
+        # Used by both the AR 3.x and 4.x instrumentation
+        def instrument_additional_methods
+          instrument_save_methods
+          instrument_relation_methods
+        end
+
+        def instrument_save_methods
+          ::ActiveRecord::Base.class_eval do
+            alias_method :save_without_tingyun, :save
+
+            def save(*args, &blk)
+              ::TingYun::Agent.with_database_metric_name(self.class.name, nil, ACTIVE_RECORD) do
+                save_without_tingyun(*args, &blk)
+              end
+            end
+
+            alias_method :save_without_tingyun!, :save!
+
+            def save!(*args, &blk)
+              ::TingYun::Agent.with_database_metric_name(self.class.name, nil, ACTIVE_RECORD) do
+                save_without_tingyun!(*args, &blk)
+              end
+            end
+          end
+        end
+
+        def instrument_relation_methods
+
+          ::ActiveRecord::Relation.class_eval do
+            alias_method :update_all_without_tingyun, :update_all
+
+            def update_all(*args, &blk)
+              ::TingYun::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+                update_all_without_tingyun(*args, &blk)
+              end
+            end
+
+            alias_method :delete_all_without_tingyun, :delete_all
+
+            def delete_all(*args, &blk)
+              ::TingYun::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+                delete_all_without_tingyun(*args, &blk)
+              end
+            end
+
+            alias_method :destroy_all_without_tingyun, :destroy_all
+
+            def destroy_all(*args, &blk)
+              ::TingYun::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+                destroy_all_without_tingyun(*args, &blk)
+              end
+            end
+          end
+        end
+
+        def metrics_for(name, sql, adapter_name)
+          product = map_product(adapter_name)
+          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)
+        end
+
+
+        SPACE = ' '.freeze unless defined?(SPACE)
+        EMPTY = [].freeze unless defined?(EMPTY)
+
+        def split_name(name)
+          if name && name.respond_to?(:split)
+            name.split(SPACE)
+          else
+            EMPTY
+          end
+        end
+
+        def model_from_splits(splits)
+          if splits.length == 2
+            splits.first
+          else
+            nil
+          end
+        end
+
+        def operation_from_splits(splits, sql)
+          if splits.length == 2
+            map_operation(splits[1])
+          else
+            TingYun::Instrumentation::Support::Database.parse_operation_from_query(sql)
+          end
+        end
+
+        # These are used primarily to optimize and avoid allocation on well
+        # known operations coming in. Anything not matching the list is fine,
+        # it just needs to get downcased directly for use.
+        OPERATION_NAMES = {
+            'Find' => 'SELECT',
+            'Load' => 'SELECT',
+            'Count' => 'SELECT',
+            'Exists' => 'SELECT',
+            'Create' => 'INSERT',
+            'Columns' => 'SELECT',
+            'Indexes' => 'SELECT',
+            'Destroy' => 'DELETE',
+            'Update' => 'UPDATE',
+            'Save' => 'INSERT'
+        }.freeze unless defined?(OPERATION_NAMES)
+
+        def map_operation(raw_operation)
+          direct_op = OPERATION_NAMES[raw_operation]
+          return direct_op if direct_op
+
+          # raw_operation.upcase
+        end
+
+        PRODUCT_NAMES = {
+            "mysql" => "MySQL",
+            "mysql2" => "MySQL",
+
+            "postgresql" => "Postgres",
+
+            "sqlite3" => "SQLite",
+
+            # https://rubygems.org/gems/activerecord-jdbcpostgresql-adapter
+            "jdbcmysql" => "MySQL",
+
+            # https://rubygems.org/gems/activerecord-jdbcpostgresql-adapter
+            "jdbcpostgresql" => "Postgres",
+
+            # https://rubygems.org/gems/activerecord-jdbcsqlite3-adapter
+            "jdbcsqlite3" => "SQLite",
+
+            # https://rubygems.org/gems/activerecord-jdbcderby-adapter
+            "derby" => "Derby",
+            "jdbcderby" => "Derby",
+
+            # https://rubygems.org/gems/activerecord-jdbc-adapter
+            "jdbc" => "JDBC",
+
+            # https://rubygems.org/gems/activerecord-jdbcmssql-adapter
+            "jdbcmssql" => "MSSQL",
+            "mssql" => "MSSQL",
+
+            # https://rubygems.org/gems/activerecord-sqlserver-adapter
+            "sqlserver" => "MSSQL",
+
+            # https://rubygems.org/gems/activerecord-odbc-adapter
+            "odbc" => "ODBC",
+
+            # https://rubygems.org/gems/activerecord-oracle_enhanced-adapter
+            "oracle_enhanced" => "Oracle"
+        }.freeze unless defined?(PRODUCT_NAMES)
+
+        DEFAULT_PRODUCT_NAME = "Database".freeze unless defined?(DEFAULT_PRODUCT_NAME)
+
+        def map_product(adapter_name)
+          PRODUCT_NAMES.fetch(adapter_name, DEFAULT_PRODUCT_NAME)
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,54 @@
+# encoding: utf-8
+
+require 'ting_yun/agent/transaction/transaction_state'
+require 'ting_yun/instrumentation/support/transaction_namer'
+require 'ting_yun/agent/transaction'
+require 'ting_yun/agent'
+
+
+module TingYun
+  module Instrumentation
+    module Support
+      module ControllerInstrumentation
+
+        NR_DEFAULT_OPTIONS    = {}.freeze          unless defined?(NR_DEFAULT_OPTIONS   )
+
+        def perform_action_with_tingyun_trace (*args, &block)
+
+          state = TingYun::Agent::TransactionState.tl_get
+
+          state.request = self.request
+          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, state)
+
+          begin
+             txn = TingYun::Agent::Transaction.start(state, category, txn_options)
+            begin
+              yield
+            rescue => e
+              ::TingYun::Agent.notice_error(e)
+              raise
+            end
+          ensure
+            TingYun::Agent::Transaction.stop(state)
+          end
+        end
+
+        private
+
+        def create_transaction_options(trace_options, category, state)
+          txn_options = {}
+
+          txn_options[:request] ||= request if respond_to?(: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
+
+          txn_options
+        end
+      end
+    end
+  end
+
+end

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

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+require 'ting_yun/support/helper'
+
+module TingYun
+  module Instrumentation
+    module Support
+      module  Database
+        extend self
+
+        KNOWN_OPERATIONS = [
+            'SELECT',
+            'UPDATE',
+            'DELETE',
+            'INSERT',
+            'SHOW',
+            'CALL'
+        ]
+
+        SQL_COMMENT_REGEX = Regexp.new('/\*.*?\*/', Regexp::MULTILINE).freeze
+        EMPTY_STRING      = ''.freeze
+
+        def parse_operation_from_query(sql)
+          sql =TingYun::Helper.correctly_encoded(sql).gsub(SQL_COMMENT_REGEX, EMPTY_STRING)
+          if sql =~ /(\w+)/
+            op = $1.upcase
+            if KNOWN_OPERATIONS.include?(op)
+              return op
+            else
+              return "CALL"
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+module TingYun
+  module Instrumentation
+    module Support
+      module EventFormatter
+        def self.format(command_name, database_name, command)
+          result = {
+              :operation => command_name,
+              :database => database_name,
+              :collection => command.values.first,
+              :term => command.values.last
+          }
+          result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+
+module TingYun
+  module Instrumentation
+    module Support
+      class EventedSubscriber
+        def initialize
+          @queue_key = ['TingYun', self.class.name, object_id].join('-')
+        end
+
+        def self.subscribed?
+          # rather than digging through Listener ivars
+          ActiveSupport::Notifications.notifier.instance_variable_get(:@subscribers) \
+            .find{|s| s.instance_variable_get(:@delegate).class == self }
+        end
+
+        def self.subscribe(pattern)
+          unless subscribed?
+            ActiveSupport::Notifications.subscribe(pattern, new)
+          end
+        end
+
+        def start(name, id, payload)
+          event = ActiveSupport::Notifications::Event.new(name, Time.now, nil, id, payload)
+          push_event(event)
+          event
+        end
+
+        def finish(name, id, payload)
+          pop_event(id)
+        end
+
+        def log_notification_error(error, name, event_type)
+          # These are important enough failures that we want the backtraces
+          # logged at error level, hence the explicit log_exception call.
+          TingYun::Agent.logger.error("Error during #{event_type} callback for event '#{name}':")
+          TingYun::Agent.logger.log_exception(:error, error)
+        end
+
+        def push_event(event)
+          parent = event_stack[event.transaction_id].last
+          if parent && event.respond_to?(:parent=)
+            event.parent = parent
+            parent << event
+          end
+          event_stack[event.transaction_id].push event
+        end
+
+        def pop_event(transaction_id)
+          event = event_stack[transaction_id].pop
+          event.end = Time.now
+          event
+        end
+
+        def event_stack
+          Thread.current[@queue_key] ||= Hash.new {|h,id| h[id] = [] }
+        end
+      end
+
+      # Taken from ActiveSupport::Notifications::Event, pasted here
+      # with a couple minor additions so we don't have a hard
+      # dependency on ActiveSupport::Notifications.
+      #
+      # Represents an intrument event, provides timing and metric
+      # name information useful when recording metrics.
+      class Event
+        attr_reader :name, :time, :transaction_id, :payload, :children
+        attr_accessor :end, :parent, :frame
+
+        def initialize(name, start, ending, transaction_id, payload, _=nil)
+          @name           = name
+          @payload        = payload.dup
+          @time           = start
+          @transaction_id = transaction_id
+          @end            = ending
+          @children       = []
+        end
+
+        def metric_name
+          raise NotImplementedError
+        end
+
+        def duration
+          (self.end - time)*1000
+        end
+
+        def <<(event)
+          @children << event
+        end
+
+        def parent_of?(event)
+          @children.include? event
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,52 @@
+# encoding: utf-8
+require 'ting_yun/agent'
+require 'ting_yun/support/exception'
+
+module TingYun
+  module Instrumentation
+    module Support
+      module ExternalError
+
+
+        module_function
+
+        def capture_exception(response,request,type)
+          if !response.nil? && 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}"
+            e.instance_variable_set(:@tingyun_klass, klass)
+            e.instance_variable_set(:@tingyun_external, true)
+            e.instance_variable_set(:@tingyun_code, response.code)
+            e.instance_variable_set(:@tingyun_trace, caller.reject! { |t| t.include?('tingyun_rpm') })
+            TingYun::Agent.notice_error(e)
+          end
+        end
+
+        def handle_error(e,klass)
+
+          e.instance_variable_set(:@tingyun_klass, klass)
+          e.instance_variable_set(:@tingyun_external, true)
+          e.instance_variable_set(:@tingyun_trace, caller.reject! { |t| t.include?('tingyun_rpm') })
+
+          case e
+            when Errno::ECONNREFUSED
+              e.instance_variable_set(:@tingyun_code, 902)
+            when SocketError
+              e.instance_variable_set(:@tingyun_code, 901)
+            when OpenSSL::SSL::SSLError
+              e.instance_variable_set(:@tingyun_code, 908)
+            when Timeout::Error
+              e.instance_variable_set(:@tingyun_code, 903)
+            else
+              e.instance_variable_set(:@tingyun_code, 1000)
+          end
+
+          TingYun::Agent.notice_error(e)
+
+          raise e
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# encoding: utf-8
+require 'ting_yun/agent'
+require 'ting_yun/agent/datastore/metric_helper'
+require 'ting_yun/agent/datastore/mongo'
+
+module TingYun
+  module Instrumentation
+    module Support
+      module MetricTranslator
+
+        MONGODB = 'MongoDB'.freeze
+
+        def self.metrics_for(name, payload)
+          payload ||= {}
+
+          return nil  if collection_in_selector?(payload)
+
+          collection = payload[:collection]
+
+          if create_index?(name, payload)
+            collection = self.collection_name_from_index(payload)
+          elsif group?(name, payload)
+            collection = collection_name_from_group_selector(payload)
+          elsif rename_collection?(name, payload)
+            collection = collection_name_from_rename_selector(payload)
+          end
+
+          TingYun::Agent::Datastore::MetricHelper.metrics_for(MONGODB,
+                                                              TingYun::Agent::Datastore::Mongo.transform_operation(name),
+                                                              collection)
+        rescue => e
+          TingYun::Agent.logger.debug("Failure during Mongo metric generation", e)
+          nil
+        end
+
+
+        def self.collection_in_selector?(payload)
+          payload[:collection] == '$cmd'
+        end
+
+        def self.create_index?(name, payload)
+          name == :insert && payload[:collection] == "system.indexes"
+        end
+
+        def self.group?(name, payload)
+          name == :group
+        end
+
+        def self.rename_collection?(name, payload)
+          name == :renameCollection
+        end
+
+        def self.collection_name_from_index(payload)
+          if payload[:documents]
+            if payload[:documents].is_a?(Array)
+              # mongo gem versions pre 1.10.0
+              document = payload[:documents].first
+            else
+              # mongo gem versions 1.10.0 and later
+              document = payload[:documents]
+            end
+
+            if document && document[:ns]
+              return document[:ns].split('.').last
+            end
+          end
+
+          'system.indexes'
+        end
+
+        def self.collection_name_from_group_selector(payload)
+          payload[:selector]["group"]["ns"]
+        end
+
+        def self.collection_name_from_rename_selector(payload)
+          parts = payload[:selector][:renameCollection].split('.')
+          parts.shift
+          parts.join('.')
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+
+require 'ting_yun/agent/datastores/mongo/obfuscator'
+
+module TingYun
+  module Instrumentation
+    module Support
+      module MongoFormatter
+
+        PLAINTEXT_KEYS = [
+            :database,
+            :collection,
+            :operation,
+            :fields,
+            :skip,
+            :limit,
+            :order
+        ]
+
+        OBFUSCATE_KEYS = [
+            :selector
+        ]
+
+        def self.format(statement, operation)
+
+          result = {:operation => operation}
+
+          PLAINTEXT_KEYS.each do |key|
+            result[key] = statement[key] if statement.key?(key)
+          end
+
+          OBFUSCATE_KEYS.each do |key|
+            if statement.key?(key) && statement[key]
+              obfuscated = obfuscate(statement[key])
+              result[key] = obfuscated if obfuscated
+            end
+          end
+          result
+        end
+
+        def self.obfuscate(statement)
+          statement = Obfuscator.obfuscate_statement(statement)
+          statement
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+
+
+module TingYun
+  module Instrumentation
+    module Support
+      module ParameterFiltering
+
+        module_function
+
+        def filter_rails_request_parameters(params)
+          result = params.dup
+          result.delete("controller")
+          result.delete("action")
+          result
+        end
+      end
+    end
+  end
+end