oneapm_rpm 1.3.7 → 1.4.0

data/lib/one_apm/agent/cross_app/cross_app_tracing_message.rb

@@ -0,0 +1,130 @@
+  # encoding: utf-8
+
+module OneApm
+  module Agent
+    module CrossAppTracingMessage
+
+      class Error < RuntimeError; end
+
+      OA_ID_MESSAGE_HEADER = 'BlueWareID'
+
+      OA_TXN_MESSAGE_HEADER = 'BlueWareTransaction'
+
+      OA_SYNTHETICS_MESSAGE_HEADER = 'BlueWareSynthetics'
+
+      ###############
+      module_function
+      ###############
+
+      def request_data(state)
+        rpc_request = {}
+        inject_rpc_request_headers(state, rpc_request) if cross_app_enabled?
+        json_rpc_request = OneApm::JSONWrapper.dump(rpc_request)
+        # OneApm::Manager.logger.debug "Thrift Header Message: #{json_rpc_request}"
+        obfuscator.obfuscate(json_rpc_request)
+      rescue OneApm::Agent::CrossAppTracingMessage::Error => err
+        OneApm::Manager.logger.debug "Not injecting x-process header", err
+      end
+
+      # TODO: just stub
+      def process_request message
+        OneApm::Manager.logger.debug "Thrift Process Message: #{message}"
+      end
+
+      def inject_rpc_request_headers state, rpc_request
+        txn_guid = state.request_guid
+        txn = state.current_transaction
+        if txn
+          trip_id   = txn.cat_trip_id(state)
+          path_hash = txn.cat_path_hash(state)
+          if txn.raw_synthetics_header
+            rpc_request[OA_SYNTHETICS_MESSAGE_HEADER] = txn.raw_synthetics_header
+          end
+        end
+        rpc_request[OA_ID_MESSAGE_HEADER]  = cross_app_id
+        rpc_request[OA_TXN_MESSAGE_HEADER] = [txn_guid, true, trip_id, path_hash, '']
+      rescue OneApm::Agent::CrossAppTracingMessage::Error => err #TODO
+        OneApm::Manager.logger.debug "Not injecting x-process header", err
+      end
+
+      def cross_app_id
+        OneApm::Manager.config[:cross_process_id] or
+          raise OneApm::Agent::CrossAppTracingMessage::Error, "no cross app ID configured"
+      end
+
+      def start_trace(state, t0, rpc_request)
+        state.is_cross_app_caller = true
+        stack = state.traced_method_stack
+        segment = stack.push_frame(state, :rpc_request, t0)
+        return segment
+      rescue => err
+        OneApm::Manager.logger.error "Uncaught exception while tracing RPC request", err
+        return nil
+      rescue Exception => e
+        OneApm::Manager.logger.debug "Unexpected exception raised while tracing RPC request", e
+        raise e
+      end
+
+      def finish_trace(state, t0, segment, request, metrics)
+        unless t0
+          OneApm::Manager.logger.error("RPC request trace finished without start time. This is probably an agent bug.")
+          return
+        end
+
+        t1 = Time.now
+        duration = t1.to_f - t0.to_f
+        begin
+          if request
+            scoped_metric, *other_metrics = metrics
+            OneApm::Manager.agent.stats_engine.record_scoped_and_unscoped_metrics(state, scoped_metric, nil, duration)
+            if segment
+              segment.name = scoped_metric
+            end
+          end
+        ensure
+          # If we have a segment, always pop the traced method stack to avoid
+          # an inconsistent state, which prevents tracing of whole transaction.
+          if segment
+            stack = state.traced_method_stack
+            stack.pop_frame(state, segment, scoped_metric, t1)
+          end
+        end
+      rescue OneApm::Agent::CrossAppTracingMessage::Error => err
+        OneApm::Manager.logger.debug "while cross app tracing", err
+      rescue => err
+        OneApm::Manager.logger.error "Uncaught exception while finishing an RPC request trace", err
+      end
+
+      # Return +true+ if cross app tracing is enabled in the config.
+      def cross_app_enabled?
+        valid_cross_process_id? &&
+          valid_encoding_key? &&
+          cross_application_tracer_enabled?
+      end
+
+      def valid_cross_process_id?
+        OneApm::Manager.config[:cross_process_id] && OneApm::Manager.config[:cross_process_id].length > 0
+      end
+
+      def valid_encoding_key?
+        OneApm::Manager.config[:encoding_key] && OneApm::Manager.config[:encoding_key].length > 0
+      end
+
+      def cross_application_tracer_enabled?
+        OneApm::Manager.config[:"cross_application_tracer.enabled"]
+      end
+
+      # Fetcher for the cross app encoding key. Raises a
+      # OneApm::Agent::CrossAppTracingMessage::Error if the key isn't configured.
+      def cross_app_encoding_key
+        OneApm::Manager.config[:encoding_key] or
+          raise OneApm::Agent::CrossAppTracingMessage::Error, "No encoding_key set."
+      end
+
+      def obfuscator
+        @obfuscator ||= OneApm::Agent::Obfuscator.new(cross_app_encoding_key)
+      end
+
+    end
+  end
+end

data/lib/one_apm/agent/database/active_record_helper.rb

@@ -6,72 +6,126 @@ module OneApm
       module ActiveRecordHelper
         module_function
 
-        def metric_for_name(name)
-          return unless name && name.respond_to?(:split)
+        DATABASE = "Database".freeze
+        STATEMENT = "statement".freeze
+        ALL = "Database/all".freeze
+        ALLWEB = "Database/allWeb".freeze
+        ALLOTHER  = "Database/allOther".freeze
+
+        def operation_metric_for(product, operation, model_name)
+          met_info = [ DATABASE, STATEMENT]
+          met_info << product
+          met_info << model_name
+          met_info << operation
+          met_info.compact.join("/")
+        end
+
+        def operation_all_metric_for(product, operation)
+          met_info = [ DATABASE, STATEMENT]
+          #without data_base_name
+          met_info << without_database_name(product)
+          met_info << operation
+          met_info.compact.join("/")
+        end
+
+        def product_rollup(product)
+          "Database/#{STATEMENT}/#{without_database_name(product)}/all"
+        end
+
+        def rollup_metrics_for
+          return ALLWEB if OneApm::Transaction.recording_web_transaction?
+          return ALLOTHER
+        end
+
+        #Database/statement/SqlType:10.128.6.33:3306/all
+        def all(product)
+          met_info = [ DATABASE, STATEMENT]
+          met_info << database_type(product)
+          met_info.compact.join("/")
+        end
+
+        def metric_for(product, operation, model_name = nil)
+          metrics = [
+            operation_metric_for(product, operation, model_name),
+            operation_all_metric_for(product, operation),
+            product_rollup(product),
+            rollup_metrics_for,
+            all(product)
+          ]
+          metrics
+        end
+
+        def model_for_name(name)
+          return 'SQL' unless name && name.respond_to?(:split)
           parts = name.split(' ')
-          if parts.size == 2
-            model = parts.first
-            operation = parts.last.downcase
-            case operation
-            when 'find', 'load', 'count', 'exists'
-              op_name = 'select'
-            when 'destroy'
-              op_name = 'delete'
-            when 'create'
-              op_name = 'insert'
+           if parts.size == 2
+              parts.first
+           else
+             'SQL'
+           end
+        end
+
+        def operator_for_name(name)
+          return unless name && name.include?(' ')
+          parts = name.split(' ')
+          return rename_for(parts.last.downcase) if parts.size == 2
+        end
+
+        def rename_for operation
+          op_name = case operation.to_s
+            when 'find', 'load', 'count', 'exists', 'all', 'get', 'select'
+              'select'
+            when 'destroy', 'delete'
+              'delete'
+            when 'create', 'insert'
+              'insert'
             when 'update', 'save'
-              op_name = 'update'
+              'update'
+            when 'other'
+              'other'
             else
-              op_name = nil
+              nil
             end
-            "Database/#{model}/#{op_name}" if op_name
-          end
+          op_name
         end
 
-        def metric_for_sql(sql)
+        def operator_for_sql(sql)
           txn = OneApm::Transaction.tl_current
           metric = txn && txn.database_metric_name
+          operation = ""
           if metric.nil?
             operation = OneApm::Agent::Database.parse_operation_from_query(sql)
-            if operation
-              # Could not determine the model/operation so use a fallback metric
-              metric = "Database/SQL/#{operation}"
-            else
-              metric = "Database/SQL/other"
-            end
           end
-          metric
+          operation || "other"
+        end
+        
+        def database_info config = {}
+          info = []
+          db_type, default_port = type_and_default_port_for_db config.fetch(:adapter, "SQL")
+          info << db_type
+          info << config.fetch(:host, '127.0.0.1')
+          info << config.fetch(:port, default_port)
+          #database need join with '/'
+          "#{info.compact.uniq.join(":")}/#{config.fetch(:database, 'unknown')}"
         end
 
-        # Given a metric name such as "Database/model/action" this
-        # returns an array of rollup metrics:
-        # [ "Database/all", "Database/all", "Database/action" ]
-        # If the metric name is in the form of "Database/action"
-        # this returns merely: [ "Database/all", "Database/all" ]
-        def rollup_metrics_for(metric)
-          metrics = ["Database/all"]
-
-          # If we're outside of a web transaction, don't record any rollup
-          # database metrics. This is to prevent metrics from background tasks
-          # from polluting the metrics used to drive overview graphs.
-          if OneApm::Transaction.recording_web_transaction?
-            metrics << "Database/allWeb"
-          else
-            metrics << "Database/allOther"
-          end
-          metrics << "Database/#{$1}" if metric =~ /Database\/[\w|\:]+\/(\w+)/
+        def without_database_name(product)
+          product.split('/')[0..-2].join('/')
+        end
 
-          metrics
+        def database_type(product)
+          product.split(':')[0]
         end
 
-        # Given a database adapter name and a database server host
-        # this returns a metric name in the form:
-        # "RemoteService/sql/adapter/host"
-        # Host defaults to "localhost".
-        def remote_service_metric(adapter, host)
-          host ||= 'localhost'
-          type = adapter.to_s.sub(/\d*/, '')
-          "RemoteService/sql/#{type}/#{host}"
+
+        def type_and_default_port_for_db adapter
+          type, port = case adapter
+          when /mysql/      then [:MySQL, 3306]
+          when /postgresql/ then [:PostgreSQL, 5432]
+          when /oracle/     then [:Oracle, 1521]
+          when /sqlserver/  then [:SQLSever, 1433]
+          else [:Other, -1]
+          end
         end
       end
     end

data/lib/one_apm/agent/datastore.rb

@@ -6,6 +6,14 @@ module OneApm
   module Agent
     module Datastore
 
+      LOCALHOST = 'localhost'.freeze
+      LOCAL_127 = '127.0.0.1'.freeze
+
+      def self.oneapm_product *product
+        return product[0] if product[1].nil?
+        product.compact.join(":").gsub(LOCALHOST, LOCAL_127)
+      end
+
       def self.trace(clazz, method_name, product, operation = method_name)
         clazz.class_eval do
           method_name_without_oneapm = "#{method_name}_without_oneapm"

data/lib/one_apm/agent/datastore/metric_helper.rb

@@ -14,26 +14,53 @@ module OneApm
         OA_ALL_WEB = "allWeb".freeze
         OA_ALL_OTHER = "allOther".freeze
 
-        def self.statement_metric_for(product, collection, operation)
-          "Datastore/statement/#{product}/#{collection}/#{operation}"
-        end
-
+        # Datastore/operation/NoSqlType:10.128.6.240:27017/update
         def self.operation_metric_for(product, operation)
           "Datastore/operation/#{product}/#{operation}"
         end
 
+        #Datastore/operation/NoSqlType:10.128.6.240:27017/all
+        def self.operation_product_rollup(product)
+          "Datastore/operation/#{product}/all"
+        end
+
+        #Datastore/operation/NoSqlType
+        def self.operation_all(product)
+          "Datastore/operation/#{product.split(':')[0]}"
+        end
+
         def self.product_suffixed_rollup(product, suffix)
           "Datastore/#{product}/#{suffix}"
         end
 
         def self.product_rollup(product)
-          "Datastore/#{product}/all"
+          "Datastore//#{product}/all"
         end
 
         def self.suffixed_rollup(suffix)
           "Datastore/#{suffix}"
         end
 
+        #Datastore/statement/NoSqlType:10.128.6.240:27017/book/insert
+        def self.statement_metric_for(product, collection, operation)
+          "Datastore/statement/#{product}/#{collection}/#{operation}"
+        end
+
+        #Datastore/statement/NoSqlType:10.128.6.240:27017/book/insert
+        def self.statement_action_metric_for(product, operation)
+          "Datastore/statement/#{product}/#{operation}"
+        end
+
+        #Datastore/statement/NoSqlType:10.128.6.240:27017/all
+        def self.statement_all_metric_for(product)
+          "Datastore/statement/#{product}/all"
+        end
+
+        #Datastore/statement/NoSqlType
+        def self.statement_all(product)
+          "Datastore/statement/#{product.split(':')[0]}"
+        end
+
         def self.all_suffix
           if OneApm::Transaction.recording_web_transaction?
             OA_ALL_WEB
@@ -53,6 +80,8 @@ module OneApm
           # be treated as the scoped metric in a bunch of different cases.
           metrics = [
             operation_metric_for(product, operation),
+            operation_product_rollup(product),
+            operation_all(product),
             product_suffixed_rollup(product, suffix),
             product_rollup(product),
             suffixed_rollup(suffix),
@@ -60,7 +89,9 @@ module OneApm
           ]
 
           metrics.unshift statement_metric_for(product, collection, operation) if collection
-
+          metrics.unshift statement_action_metric_for(product,operation)
+          metrics.unshift statement_all_metric_for(product)
+          metrics.unshift statement_all(product)
           metrics
         end
 

data/lib/one_apm/agent/synthetics_monitor.rb

@@ -5,7 +5,7 @@ require 'one_apm/agent/inbound_request_monitor'
 module OneApm
   module Agent
     class SyntheticsMonitor < InboundRequestMonitor
-      OA_SYNTHETICS_HEADER_KEY  = 'HTTP_X_ONEAPM_SYNTHETICS'.freeze
+      OA_SYNTHETICS_HEADER_KEY  = 'HTTP_X_BLUEWARE_SYNTHETICS'.freeze
 
       OA_SUPPORTED_VERSION = 1
       OA_EXPECTED_PAYLOAD_LENGTH = 5

data/lib/one_apm/collector/collector/helper.rb

@@ -90,6 +90,8 @@ module OneApm
         # It also handles translating metric names to IDs using our metric ID cache.
         def build_metric_data_array(stats_hash)
           metric_data_array = []
+
+          # OneApm::Manager.logger.info "---metric_id_cache--#{metric_id_cache.inspect}"
           stats_hash.each do |metric_spec, stats|
             # Omit empty stats as an optimization
             unless stats.is_reset?
@@ -99,9 +101,11 @@ module OneApm
               else
                 OneApm::MetricData.new(metric_spec, stats, nil)
               end
-              metric_data_array << metric_data
+              
+              metric_data_array << metric_data #unless metric_spec.name =~ /^Nested/
             end
           end
+          # OneApm::Manager.logger.info "--metric_data_array---#{metric_data_array}"
           metric_data_array
         end
 

data/lib/one_apm/collector/collector/http_connection.rb

@@ -6,8 +6,9 @@ module OneApm
         # These include Errno connection errors, and all indicate that the
         # underlying TCP connection may be in a bad state.
         OA_CONNECTION_ERRORS = [Timeout::Error, EOFError, SystemCallError, SocketError].freeze
+        OA_API_VERSION = '1.0'.freeze
 
-        def invoke_remote(method, payload = [], options = {})
+        def invoke_remote(method, payload = [], options = {},query_params={})
           start_ts = Time.now
 
           data = nil
@@ -21,7 +22,7 @@ module OneApm
           data, encoding = compress_request(data)
           size = data.size
 
-          uri = remote_method_uri(method, @marshaller.format)
+          uri = remote_method_uri(method, @marshaller.format,query_params)
           full_uri = "#{@collector}#{uri}"
 
           @audit_logger.log_request(full_uri, payload, @marshaller)
@@ -29,7 +30,9 @@ module OneApm
                                   :uri       => uri,
                                   :encoding  => encoding,
                                   :collector => @collector)
-          @marshaller.load(decompress_response(response))
+          response =  @marshaller.load(decompress_response(response))
+          @audit_logger.log_response(response)
+          response
         ensure
           record_timing_supportability_metrics(method, start_ts, serialize_finish_ts)
           if size
@@ -38,8 +41,8 @@ module OneApm
         end
 
         # The path on the server that we should post our data to
-        def remote_method_uri(method, format)
-          params = {'run_id' => @agent_id, 'marshal_format' => format}
+        def remote_method_uri(method, format, query_params={})
+          params = {'run_id' => @agent_id, 'marshal_format' => format}.merge(query_params)
           uri = "/tpm/agent.do?PROTOCOL_VERSION=#{OA_PROTOCOL_VERSION}&license_key=#{@license_key}&method=#{method}"
           uri << '&' + params.map do |k,v|
             next unless v
@@ -59,11 +62,16 @@ module OneApm
         #                    contact
         #  - :data => the data to send as the body of the request
         def send_request(opts)
-          request = Net::HTTP::Post.new(opts[:uri], 'CONTENT-ENCODING' => opts[:encoding], 'HOST' => opts[:collector].name)
+          request = Net::HTTP::Post.new(opts[:uri],
+                                        'CONTENT-ENCODING' => opts[:encoding],
+                                        'HOST'             => opts[:collector].name,
+                                        'API-VERSION'      => OA_API_VERSION)
           request['user-agent'] = user_agent
+          request['_SKIP_CAT_'] = true
           request.body = opts[:data]
-          request.content_type = "multipart/form-data; boundary=-oneapm-#{request.object_id}-"
-
+          #see http://jira.oneapm.me/browse/AI-3227
+          #old content_type is  "multipart/form-data; boundary=-oneapm-#{request.object_id}-"
+          request.content_type = 'application/json'
           response     = nil
           attempts     = 0
           max_attempts = 2