oneapm_rpm 1.3.7 → 1.4.0

data/lib/one_apm/inst/nosql/memcache.rb

@@ -30,9 +30,28 @@ module OneApm
             client_class.class_eval do
               alias_method method_name_without, method_name
 
+              if defined?(::MemCache)
+                 def oneapm_product 
+                   @product ||= begin 
+                     s = Array(servers)
+                     host, port = s.first.host, s.first.port if s.first rescue nil
+                     OneApm::Agent::Datastore.oneapm_product("Memcached", host,  port)
+                   end
+                 end
+                 private :oneapm_product
+              else
+                 def oneapm_product 
+                    @product ||= begin 
+                      s = Array(@servers || servers)
+                      host, port, weight = s.first.split(":") if s.first && s.first.to_s.include?(':') rescue nil
+                      OneApm::Agent::Datastore.oneapm_product("Memcached", host,  port)
+                    end
+                 end
+                 private :oneapm_product
+              end
+              
               define_method method_name do |*args, &block|
-                metrics = Datastore::MetricHelper.metrics_for("Memcached", method_name)
-
+                metrics = Datastore::MetricHelper.metrics_for(oneapm_product, method_name)
                 OneApm::Support::MethodTracer.trace_execution_scoped(metrics) do
                   t0 = Time.now
                   begin

data/lib/one_apm/inst/nosql/mongo2.rb

@@ -33,10 +33,13 @@ module OneApm
           @operations ||= {}
         end
 
-        def mertircs(event)
-          OneApm::Agent::Datastore::MetricHelper.metrics_for(
-            OA_MONGODB, event.command_name, event.command.values.first
-          )
+        def generate_metrics(event)
+          @product ||= begin
+            host = event.address.host rescue nil
+            port = event.address.port rescue nil
+            OneApm::Agent::Datastore.oneapm_product(OA_MONGODB, host, port)
+          end
+          OneApm::Agent::Datastore::MetricHelper.metrics_for(@product, event.command_name, event.command.values.first)
         end
 
         def operator(operator_type, event)
@@ -44,7 +47,7 @@ module OneApm
             state = OneApm::TransactionState.tl_get
             return unless state.is_execution_traced?
             stared_event = operations.delete(event.operation_id)
-            one_apm_generate_metrics(stared_event, event.duration)
+            one_apm_record_metrics(stared_event, event.duration)
             one_apm_notice_statement(stared_event, operator_type, event.duration)
             one_apm_notice_sql(state, stared_event, operator_type, event.duration)
           rescue => e
@@ -52,8 +55,8 @@ module OneApm
           end
         end
 
-        def one_apm_generate_metrics(event, duration)         
-          base, *other_metrics = mertircs(event)
+        def one_apm_record_metrics(event, duration)         
+          base, *other_metrics = generate_metrics(event)
           OneApm::Manager.agent.stats_engine.tl_record_scoped_and_unscoped_metrics(
             base, other_metrics, duration
           )
@@ -61,7 +64,7 @@ module OneApm
 
         def one_apm_notice_sql(state, event, status, duration)
           stack = state.traced_method_stack
-          base, *other_metrics = mertircs(event)
+          base, *other_metrics = generate_metrics(event)
 
           started_time = Time.now.to_f
           frame = stack.push_frame(state, :mongo_tracer, started_time - duration)

data/lib/one_apm/inst/nosql/redis.rb

@@ -21,6 +21,11 @@ LibraryDetection.defer do
       # +raw_call_command+.
 
       call_method = ::Redis::Client.new.respond_to?(:call) ? :call : :raw_call_command
+
+      def oneapm_product 
+        @product ||= OneApm::Agent::Datastore.oneapm_product("Redis", host,  port)
+      end
+      private :oneapm_product
     
       def call_with_oneapm_trace(*args, &blk)
         method_name = args[0].is_a?(Array) ? args[0][0] : args[0]
@@ -28,7 +33,7 @@ LibraryDetection.defer do
         callback = proc do |result, metric, elapsed|
           _send_to_one_apm(args, elapsed)
         end
-        OneApm::Agent::Datastore.wrap("Redis", filtered_command, nil, callback) do
+        OneApm::Agent::Datastore.wrap(oneapm_product, filtered_command, nil, callback) do
           call_without_oneapm_trace(*args, &blk)
         end
       end
@@ -45,7 +50,7 @@ LibraryDetection.defer do
           # user can at least see what all the commands were.
           additional = commands.map do |c|
             name = c.kind_of?(Array) ? c[0] : c
-            "Datastore/operation/Redis/#{name.to_s.downcase}_pipelined"
+            "Datastore/operation/#{oneapm_product}/#{name.to_s.downcase}_pipelined"
           end
 
           callback = proc do |result, metric, elapsed|
@@ -57,7 +62,7 @@ LibraryDetection.defer do
             end
           end
 
-          OneApm::Agent::Datastore.wrap("Redis", "pipelined", nil, callback) do
+          OneApm::Agent::Datastore.wrap(oneapm_product, 'pipelined', nil, callback) do
             call_pipelined_without_oneapm_trace commands, *rest
           end
         end

data/lib/one_apm/inst/orm/active_record.rb

@@ -32,6 +32,12 @@ module OneApm
           end
         end
 
+        def generate_metrics(operation, name)
+          @product ||= ActiveRecordHelper.database_info(@config)
+          model_name = ActiveRecordHelper.model_for_name(name)
+          ActiveRecordHelper.metric_for(@product, operation, model_name).compact
+        end
+
         def log_with_oneapm_instrumentation(*args, &block)
           state = OneApm::TransactionState.tl_get
 
@@ -40,21 +46,21 @@ module OneApm
           end
 
           sql, name, _ = args
-          metric = ActiveRecordHelper.metric_for_name(OneApm::Helper.correctly_encoded(name)) ||
-                   ActiveRecordHelper.metric_for_sql(OneApm::Helper.correctly_encoded(sql))
-
-          if !metric
+          operation = ActiveRecordHelper.operator_for_name(OneApm::Helper.correctly_encoded(name)) ||
+                   ActiveRecordHelper.operator_for_sql(OneApm::Helper.correctly_encoded(sql))
+                   
+          if !operation
             log_without_oneapm_instrumentation(*args, &block)
           else
-            metrics = [metric, remote_service_metric].compact
-            metrics += ActiveRecordHelper.rollup_metrics_for(metric)
+           
+            metrics = generate_metrics(operation, name)
             self.class.trace_execution_scoped(metrics) do
               t0 = Time.now
               begin
                 log_without_oneapm_instrumentation(*args, &block)
               ensure
                 elapsed_time = (Time.now - t0).to_f
-                OneApm::Manager.notice_sql(sql, metric, @config, elapsed_time, state, &OA_EXPLAINER)
+                OneApm::Manager.notice_sql(sql, metrics.first, @config, elapsed_time, state, &OA_EXPLAINER)
               end
             end
           end

data/lib/one_apm/inst/rails4/active_record_subscriber.rb

@@ -43,7 +43,8 @@ module OneApm
         def notice_sql(state, event)
           stack  = state.traced_method_stack
           config = active_record_config_for_event(event)
-          metric = base_metric(event)
+
+          base, *other_metrics = generate_metrics(event)
 
           # enter transaction trace segment
           frame = stack.push_frame(state, :active_record, event.time)
@@ -54,22 +55,24 @@ module OneApm
                         state, &method(:get_explain_plan))
 
           OneApm::Manager.agent.sql_sampler \
-            .notice_sql(event.payload[:sql], metric, config,
+            .notice_sql(event.payload[:sql], base, config,
                         Helper.milliseconds_to_seconds(event.duration),
                         state, &method(:get_explain_plan))
 
           # exit transaction trace segment
-          stack.pop_frame(state, frame, metric, event.end)
+          stack.pop_frame(state, frame, base, event.end)
         end
 
-        def record_metrics(event)
-          base = base_metric(event)
+        def generate_metrics(event)
+          @config  ||= active_record_config_for_event(event)
+          @product ||= ActiveRecordHelper.database_info(@config)
+          operation = operation(event)
+          model_name = ActiveRecordHelper.model_for_name(event.payload[:name])
+          ActiveRecordHelper.metric_for(@product, operation, model_name)
+        end
 
-          other_metrics = ActiveRecordHelper.rollup_metrics_for(base)
-          if config = active_record_config_for_event(event)
-            other_metrics << ActiveRecordHelper.remote_service_metric(config[:adapter], config[:host])
-          end
-          other_metrics.compact!
+        def record_metrics(event)
+          base, *other_metrics = generate_metrics(event)
 
           OneApm::Manager.agent.stats_engine.tl_record_scoped_and_unscoped_metrics(
             base, other_metrics,
@@ -77,9 +80,9 @@ module OneApm
           )
         end
 
-        def base_metric(event)
-          ActiveRecordHelper.metric_for_name(event.payload[:name]) ||
-            ActiveRecordHelper.metric_for_sql(OneApm::Helper.correctly_encoded(event.payload[:sql]))
+        def operation(event)
+          ActiveRecordHelper.operator_for_name(event.payload[:name]) ||
+            ActiveRecordHelper.operator_for_sql(OneApm::Helper.correctly_encoded(event.payload[:sql]))
         end
 
         def active_record_config_for_event(event)

data/lib/one_apm/inst/transaction_base.rb

@@ -300,7 +300,6 @@ module OneApm
           trace_options = args.last.is_a?(Hash) ? args.last : OA_DEFAULT_OPTIONS
           category      = trace_options[:category] || :controller
           txn_options   = create_transaction_options(trace_options, category, state)
-
           begin
             txn = Transaction.start(state, category, txn_options)
 

data/lib/one_apm/logger/audit_logger.rb

@@ -30,8 +30,25 @@ module OneApm
           else
             marshaller.prepare(data, :encoder => @encoder).inspect
           end
-          @log.info("REQUEST: #{uri}")
-          @log.info("REQUEST BODY: #{request_body}")
+          if uri =~ /analytic_event_data/
+            @log.info("REQUEST: #{uri}")
+            @log.info("REQUEST BODY: #{request_body}")
+          else
+            @log.info("REQUEST: #{uri}")
+            @log.info("REQUEST BODY: #{request_body}")
+          end
+        end
+      rescue StandardError, SystemStackError, SystemCallError => e
+        OneApm::Manager.logger.warn("Failed writing to audit log", e)
+      rescue Exception => e
+        OneApm::Manager.logger.warn("Failed writing to audit log with exception. Re-raising in case of interupt.", e)
+        raise
+      end
+
+      def log_response(response)
+        if enabled?
+          setup_logger unless setup?
+          @log.info("RESPONSE: #{response.inspect}")
         end
       rescue StandardError, SystemStackError, SystemCallError => e
         OneApm::Manager.logger.warn("Failed writing to audit log", e)

data/lib/one_apm/manager.rb

@@ -7,6 +7,7 @@ require 'one_apm/support/timer_lib'
 require 'one_apm/support/json_wrapper'
 require 'one_apm/support/chained_call'
 require 'one_apm/support/rules_engine'
+require 'one_apm/support/rename_rules_engine'
 require 'one_apm/support/http_clients/uri_util'
 require 'one_apm/support/system_info'
 

data/lib/one_apm/probe/instance_methods.rb

@@ -52,7 +52,6 @@ module OneApm
       def configure_agent(env, options)
         manual = OneApm::Configuration::ManualSource.new(options)
         OneApm::Manager.config.replace_or_add_config(manual)
-
         config_file_path = @config_file_override || OneApm::Manager.config[:config_path]
         OneApm::Manager.config.replace_or_add_config(OneApm::Configuration::YamlSource.new(config_file_path, env))
 

data/lib/one_apm/rack/middleware_tracing.rb

@@ -61,6 +61,7 @@ module OneApm
           options = build_transaction_options(env, first_middleware)
 
           current_transaction = OneApm::Transaction.start(state, category, options)
+
           current_transaction.ignore_frames << options[:transaction_name] if respond_to?(:middleware_ignore?) && middleware_ignore?
 
           events.notify(:before_call, env) if first_middleware

data/lib/one_apm/support/event_buffer/sampled_buffer.rb

@@ -2,12 +2,15 @@
 
 # http://xlinux.nist.gov/dads/HTML/reservoirSampling.html
 
+require 'forwardable'
 require 'one_apm/support/event_buffer'
 
 module OneApm
   module Agent
     class SampledBuffer < EventBuffer
+      extend Forwardable
       attr_reader :seen_lifetime, :captured_lifetime
+      def_delegators :@items, :select
 
       def initialize(capacity)
         super
@@ -37,6 +40,7 @@ module OneApm
         end
       end
 
+
       def sample_rate_lifetime
         @captured_lifetime > 0 ? (@captured_lifetime.to_f / @seen_lifetime) : 0.0
       end

data/lib/one_apm/support/helper.rb

@@ -45,5 +45,21 @@ module OneApm
     def milliseconds_to_seconds(milliseconds)
       milliseconds / 1000.0
     end
+
+    HEX_DIGITS = (0..15).map{|i| i.to_s(16)}
+    GUID_LENGTH = 16
+
+    # generate a random 16 length uuid
+    def generate_guid
+      guid = ''
+      GUID_LENGTH.times do |a|
+        guid << HEX_DIGITS[rand(16)]
+      end
+      guid
+    end
+
+    def obfuscator
+      @obfuscator ||= OneApm::Agent::Obfuscator.new(OneApm::Manager.config[:encoding_key])
+    end
   end
 end

data/lib/one_apm/support/http_clients/curb_wrappers.rb

@@ -17,6 +17,10 @@ module OneApm
           self["host"] || self["Host"] || self.uri.host
         end
 
+        def port
+          self["port"] || self["port"] || self.uri.port
+        end
+
         def method
           @curlobj._oa_http_verb
         end
@@ -32,6 +36,22 @@ module OneApm
         def uri
           @uri ||= OneApm::Support::HTTPClients::URIUtil.parse_url(@curlobj.url)
         end
+
+        def query
+          @uri.query.nil?? {} : CGI.parse(@uri.query)
+        end
+
+        def body
+          @curlobj._oa_http_params
+        end
+
+        def post_params
+          body.nil?? {} :  CGI.parse(body)
+        end
+
+        def params
+          post_params.merge(query)
+        end
       end
 
 

data/lib/one_apm/support/http_clients/excon_wrappers.rb

@@ -41,6 +41,15 @@ module OneApm
           end
         end
 
+        def port
+          if hostname = (self['host'] || self['Host'])
+            hostname.split(':').last
+          else
+            @datum[:port]
+          end
+        end
+
+
         def method
           @datum[:method].to_s.upcase
         end
@@ -57,6 +66,22 @@ module OneApm
         def uri
           URI.parse("#{@datum[:scheme]}://#{@datum[:host]}:#{@datum[:port]}#{@datum[:path]}")
         end
+
+        def query
+          uri.query.nil?? {} : CGI.parse(uri.query)
+        end
+
+        def body
+          @datum[:body]
+        end
+
+        def post_params
+          body.nil?? {} :  CGI.parse(body)
+        end
+
+        def params
+          post_params.merge(query)
+        end
       end
     end
   end

data/lib/one_apm/support/http_clients/httpclient_wrappers.rb

@@ -48,6 +48,10 @@ module OneApm
           end
         end
 
+        def port
+          uri.port
+        end
+
         def [](key)
           request.headers[key]
         end
@@ -55,6 +59,22 @@ module OneApm
         def []=(key, value)
           request.http_header[key] = value
         end
+
+        def query
+          @uri.query.nil?? {} : CGI.parse(@uri.query)
+        end
+
+        def body
+          request.http_body.instance_values['body']
+        end
+
+        def post_params
+          body.nil?? {} :  CGI.parse(body)
+        end
+
+        def params
+          post_params.merge(query)
+        end
       end
     end
   end

data/lib/one_apm/support/http_clients/net_http_wrappers.rb

@@ -21,6 +21,10 @@ module OneApm
           end
         end
 
+        def port
+          @connection.port
+        end
+
         def method
           @request.method
         end
@@ -42,6 +46,22 @@ module OneApm
             URI("#{scheme}://#{@connection.address}:#{@connection.port}#{@request.path}")
           end
         end
+
+        def query
+          uri.query.nil?? {} : CGI.parse(uri.query)
+        end
+
+        def body
+          @request.body
+        end
+
+        def post_params
+          body.nil?? {} :  CGI.parse(body)
+        end
+
+        def params
+          post_params.merge(query)
+        end
       end
     end
   end