newrelic_rpm 5.7.0.350 → 9.0.0

data/lib/new_relic/agent/custom_event_aggregator.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 require 'new_relic/agent/event_aggregator'
 require 'new_relic/agent/attribute_processing'
@@ -10,9 +10,9 @@ module NewRelic
     class CustomEventAggregator < EventAggregator
       include NewRelic::Coerce
 
-      TYPE             = 'type'.freeze
-      TIMESTAMP        = 'timestamp'.freeze
-      PRIORITY         = 'priority'.freeze
+      TYPE = 'type'.freeze
+      TIMESTAMP = 'timestamp'.freeze
+      PRIORITY = 'priority'.freeze
       EVENT_TYPE_REGEX = /^[a-zA-Z0-9:_ ]+$/.freeze
 
       named :CustomEventAggregator
@@ -20,7 +20,7 @@ module NewRelic
       enabled_key :'custom_insights_events.enabled'
 
       def record(type, attributes)
-        unless attributes.is_a? Hash
+        unless attributes.is_a?(Hash)
           raise ArgumentError, "Expected Hash but got #{attributes.class}"
         end
 
@@ -46,9 +46,9 @@ module NewRelic
 
       def create_event(type, priority, attributes)
         [
-          { TYPE => type, TIMESTAMP => Time.now.to_i,
-            PRIORITY => priority
-          },
+          {TYPE => type,
+           TIMESTAMP => Process.clock_gettime(Process::CLOCK_REALTIME).to_i,
+           PRIORITY => priority},
           AttributeProcessing.flatten_and_coerce(attributes)
         ]
       end
@@ -57,23 +57,23 @@ module NewRelic
         @type_strings = Hash.new { |hash, key| hash[key] = key.to_s.freeze }
       end
 
-      def after_harvest metadata
+      def after_harvest(metadata)
         dropped_count = metadata[:seen] - metadata[:captured]
         note_dropped_events(metadata[:seen], dropped_count)
         record_supportability_metrics(metadata[:seen], metadata[:captured], dropped_count)
       end
 
-      def note_dropped_events total_count, dropped_count
+      def note_dropped_events(total_count, dropped_count)
         if dropped_count > 0
           NewRelic::Agent.logger.warn("Dropped #{dropped_count} custom events out of #{total_count}.")
         end
       end
 
-      def record_supportability_metrics total_count, captured_count, dropped_count
+      def record_supportability_metrics(total_count, captured_count, dropped_count)
         engine = NewRelic::Agent.instance.stats_engine
-        engine.tl_record_supportability_metric_count("Events/Customer/Seen"   ,    total_count)
-        engine.tl_record_supportability_metric_count("Events/Customer/Sent"   , captured_count)
-        engine.tl_record_supportability_metric_count("Events/Customer/Dropped",  dropped_count)
+        engine.tl_record_supportability_metric_count("Events/Customer/Seen", total_count)
+        engine.tl_record_supportability_metric_count("Events/Customer/Sent", captured_count)
+        engine.tl_record_supportability_metric_count("Events/Customer/Dropped", dropped_count)
       end
 
       def note_dropped_event(type)

data/lib/new_relic/agent/database/explain_plan_helpers.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 require 'new_relic/agent/database/obfuscator'
 require 'new_relic/agent/database/postgres_explain_obfuscator'
@@ -9,7 +9,6 @@ module NewRelic
   module Agent
     module Database
       module ExplainPlanHelpers
-
         SUPPORTED_ADAPTERS_FOR_EXPLAIN = [:postgres, :mysql2, :mysql, :sqlite]
         SELECT = 'select'.freeze
 
@@ -97,7 +96,7 @@ module NewRelic
 
         def process_explain_results_mysql(results)
           headers = []
-          values  = []
+          values = []
           if results.is_a?(Array)
             # We're probably using the jdbc-mysql gem for JRuby, which will give
             # us an array of hashes.
@@ -118,7 +117,7 @@ module NewRelic
 
         def process_explain_results_mysql2(results)
           headers = results.fields
-          values  = []
+          values = []
           results.each { |row| values << row }
           [headers, values]
         end
@@ -127,7 +126,7 @@ module NewRelic
 
         def process_explain_results_sqlite(results)
           headers = SQLITE_EXPLAIN_COLUMNS
-          values  = []
+          values = []
           results.each do |row|
             values << headers.map { |h| row[h] }
           end

data/lib/new_relic/agent/database/obfuscation_helpers.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 module NewRelic
   module Agent
@@ -11,7 +11,7 @@ module NewRelic
           :double_quotes => /"(?:[^"]|"")*?(?:\\".*|"(?!"))/,
           :dollar_quotes => /(\$(?!\d)[^$]*?\$).*?(?:\1|$)/,
           :uuids => /\{?(?:[0-9a-fA-F]\-*){32}\}?/,
-          :numeric_literals => /\b-?(?:[0-9]+\.)?[0-9]+([eE][+-]?[0-9]+)?\b/,
+          :numeric_literals => /-?\b(?:[0-9]+\.)?[0-9]+([eE][+-]?[0-9]+)?\b/,
           :boolean_literals => /\b(?:true|false|null)\b/i,
           :hexadecimal_literals => /0x[0-9a-fA-F]+/,
           :comments => /(?:#|--).*?(?=\r|\n|$)/i,
@@ -20,17 +20,17 @@ module NewRelic
         }
 
         DIALECT_COMPONENTS = {
-          :fallback   => COMPONENTS_REGEX_MAP.keys,
-          :mysql      => [:single_quotes, :double_quotes, :numeric_literals, :boolean_literals,
-                          :hexadecimal_literals, :comments, :multi_line_comments],
-          :postgres   => [:single_quotes, :dollar_quotes, :uuids, :numeric_literals,
-                          :boolean_literals, :comments, :multi_line_comments],
-          :sqlite     => [:single_quotes, :numeric_literals, :boolean_literals, :hexadecimal_literals,
-                          :comments, :multi_line_comments],
-          :oracle     => [:single_quotes, :oracle_quoted_strings, :numeric_literals, :comments,
-                          :multi_line_comments],
-          :cassandra  => [:single_quotes, :uuids, :numeric_literals, :boolean_literals,
-                          :hexadecimal_literals, :comments, :multi_line_comments]
+          :fallback => COMPONENTS_REGEX_MAP.keys,
+          :mysql => [:single_quotes, :double_quotes, :numeric_literals, :boolean_literals,
+            :hexadecimal_literals, :comments, :multi_line_comments],
+          :postgres => [:single_quotes, :dollar_quotes, :uuids, :numeric_literals,
+            :boolean_literals, :comments, :multi_line_comments],
+          :sqlite => [:single_quotes, :numeric_literals, :boolean_literals, :hexadecimal_literals,
+            :comments, :multi_line_comments],
+          :oracle => [:single_quotes, :oracle_quoted_strings, :numeric_literals, :comments,
+            :multi_line_comments],
+          :cassandra => [:single_quotes, :uuids, :numeric_literals, :boolean_literals,
+            :hexadecimal_literals, :comments, :multi_line_comments]
         }
 
         # We use these to check whether the query contains any quote characters
@@ -53,12 +53,13 @@ module NewRelic
 
         def obfuscate_single_quote_literals(sql)
           return sql unless sql =~ COMPONENTS_REGEX_MAP[:single_quotes]
+
           sql.gsub(COMPONENTS_REGEX_MAP[:single_quotes], PLACEHOLDER)
         end
 
         def self.generate_regex(dialect)
           components = DIALECT_COMPONENTS[dialect]
-          Regexp.union(components.map{|component| COMPONENTS_REGEX_MAP[component]})
+          Regexp.union(components.map { |component| COMPONENTS_REGEX_MAP[component] })
         end
 
         MYSQL_COMPONENTS_REGEX = self.generate_regex(:mysql)

data/lib/new_relic/agent/database/obfuscator.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 require 'new_relic/agent/database/obfuscation_helpers'
 
@@ -50,7 +50,7 @@ module NewRelic
         def default_sql_obfuscator(sql)
           stmt = sql.kind_of?(Statement) ? sql : Statement.new(sql)
 
-          if stmt.sql.end_with? ELLIPSIS
+          if stmt.sql.end_with?(ELLIPSIS)
             return QUERY_TOO_LARGE_MESSAGE
           end
 

data/lib/new_relic/agent/database/postgres_explain_obfuscator.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 module NewRelic
   module Agent
@@ -12,7 +12,7 @@ module NewRelic
         # Database::Obfuscator class because here we don't look for
         # backslash-escaped strings.
         QUOTED_STRINGS_REGEX = /'(?:[^']|'')*'|"(?:[^"]|"")*"/
-        LABEL_LINE_REGEX     = /^([^:\n]*:\s+).*$/.freeze
+        LABEL_LINE_REGEX = /^([^:\n]*:\s+).*$/.freeze
 
         def obfuscate(explain)
           # First, we replace all single-quoted strings.
@@ -35,7 +35,7 @@ module NewRelic
           # All parts of the query that can appear in the explain output are
           # prefixed with "<label>: ", so we want to preserve the label, but
           # remove the rest of the line.
-          explain.gsub!(LABEL_LINE_REGEX,   '\1?')
+          explain.gsub!(LABEL_LINE_REGEX, '\1?')
           explain
         end
       end

data/lib/new_relic/agent/database.rb

@@ -1,26 +1,12 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 require 'singleton'
 require 'new_relic/agent/database/explain_plan_helpers'
 require 'new_relic/agent/database/obfuscator'
 
 module NewRelic
-  # columns for a mysql explain plan
-  MYSQL_EXPLAIN_COLUMNS = [
-                           "Id",
-                           "Select Type",
-                           "Table",
-                           "Type",
-                           "Possible Keys",
-                           "Key",
-                           "Key Length",
-                           "Ref",
-                           "Rows",
-                           "Extra"
-                          ].freeze
-
   module Agent
     module Database
       MAX_QUERY_LENGTH = 16384
@@ -32,6 +18,8 @@ module NewRelic
       # Take care not to the dup the query more than once as
       # correctly encoded may also dup the query.
       def capture_query(query)
+        return unless query
+
         id = query.object_id
         query = Helper.correctly_encoded(truncate_query(query))
         if query.object_id == id
@@ -42,6 +30,8 @@ module NewRelic
       end
 
       def truncate_query(query)
+        return unless query
+
         if query.length > (MAX_QUERY_LENGTH - 4)
           query[0..MAX_QUERY_LENGTH - 4] << ELLIPSIS
         else
@@ -57,7 +47,7 @@ module NewRelic
         Obfuscator.instance.set_sql_obfuscator(type, &block)
       end
 
-      def record_sql_method(config_section=:transaction_tracer)
+      def record_sql_method(config_section = :transaction_tracer)
         key = record_sql_method_key(config_section)
 
         case Agent.config[key].to_s
@@ -87,11 +77,11 @@ module NewRelic
 
       RECORD_FOR = [:raw, :obfuscated].freeze
 
-      def should_record_sql?(config_section=:transaction_tracer)
+      def should_record_sql?(config_section = :transaction_tracer)
         RECORD_FOR.include?(record_sql_method(config_section))
       end
 
-      def should_collect_explain_plans?(config_section=:transaction_tracer)
+      def should_collect_explain_plans?(config_section = :transaction_tracer)
         should_record_sql?(config_section) &&
           Agent.config["#{config_section}.explain_enabled".to_sym]
       end
@@ -114,33 +104,33 @@ module NewRelic
       # in a report period, selected for shipment to New Relic
       def explain_sql(statement)
         return nil unless statement.sql && statement.explainer && statement.config
+
         statement.sql = statement.sql.split(";\n")[0] # only explain the first
         return statement.explain || []
       end
 
-      KNOWN_OPERATIONS = [
-        'alter',
-        'select',
-        'update',
-        'delete',
-        'insert',
-        'create',
-        'show',
-        'set',
-        'exec',
-        'execute',
-        'call'
+      KNOWN_OPERATIONS = %w[
+        alter
+        select
+        update
+        delete
+        insert
+        create
+        show
+        set
+        exec
+        execute
+        call
       ]
-
+      OTHER_OPERATION = 'other'.freeze
       SQL_COMMENT_REGEX = Regexp.new('/\*.*?\*/', Regexp::MULTILINE).freeze
-      EMPTY_STRING      = ''.freeze
 
       def parse_operation_from_query(sql)
-        sql = Helper.correctly_encoded(sql).gsub(SQL_COMMENT_REGEX, EMPTY_STRING)
-        if sql =~ /(\w+)/
-          op = $1.downcase
-          return op if KNOWN_OPERATIONS.include?(op)
-        end
+        sql = Helper.correctly_encoded(sql).gsub(SQL_COMMENT_REGEX, NewRelic::EMPTY_STR)
+        return unless sql =~ /(\w+)/
+
+        op = Regexp.last_match(1).downcase
+        KNOWN_OPERATIONS.include?(op) ? op : OTHER_OPERATION
       end
 
       class ConnectionManager
@@ -158,7 +148,7 @@ module NewRelic
           return connection if connection
 
           begin
-            @connections[config] = connector.call(config)
+            @connections[config] = yield(config)
           rescue => e
             ::NewRelic::Agent.logger.error("Caught exception trying to get connection to DB for explain.", e)
             nil
@@ -186,7 +176,7 @@ module NewRelic
 
         DEFAULT_QUERY_NAME = "SQL".freeze
 
-        def initialize(sql, config={}, explainer=nil, binds=nil, name=DEFAULT_QUERY_NAME, host=nil, port_path_or_id=nil, database_name=nil)
+        def initialize(sql, config = {}, explainer = nil, binds = nil, name = DEFAULT_QUERY_NAME, host = nil, port_path_or_id = nil, database_name = nil)
           @sql = Database.capture_query(sql)
           @config = config
           @explainer = explainer
@@ -206,9 +196,7 @@ module NewRelic
               Database.obfuscate_sql(self)
             when :raw
               sql.to_s
-            else
-              nil
-            end
+          end
         end
 
         # This takes a connection config hash from ActiveRecord or Sequel and
@@ -221,35 +209,38 @@ module NewRelic
           elsif @config[:uri] && @config[:uri].to_s =~ /^jdbc:([^:]+):/
             # This case is for Sequel with the jdbc-mysql, jdbc-postgres, or jdbc-sqlite3 gems.
             symbolized_adapter($1)
-          else
-            nil
           end
         end
 
         def explain
           return unless explainable?
+
           handle_exception_in_explain do
-            start = Time.now
+            start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
             plan = @explainer.call(self)
-            ::NewRelic::Agent.record_metric("Supportability/Database/execute_explain_plan", Time.now - start)
+            ::NewRelic::Agent.record_metric(
+              "Supportability/Database/execute_explain_plan",
+              Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+            )
             return process_resultset(plan, adapter) if plan
           end
         end
 
         NEWLINE = "\n".freeze
 
-        def append_sql new_sql
+        def append_sql(new_sql)
           return if new_sql.empty?
+
           @sql = Database.truncate_query(@sql << NEWLINE << new_sql)
         end
 
         private
 
-        POSTGIS_PREFIX  = 'postgis'.freeze
+        POSTGIS_PREFIX = 'postgis'.freeze
         POSTGRES_PREFIX = 'postgres'.freeze
-        MYSQL_PREFIX    = 'mysql'.freeze
-        MYSQL2_PREFIX   = 'mysql2'.freeze
-        SQLITE_PREFIX   = 'sqlite'.freeze
+        MYSQL_PREFIX = 'mysql'.freeze
+        MYSQL2_PREFIX = 'mysql2'.freeze
+        SQLITE_PREFIX = 'sqlite'.freeze
 
         def symbolized_adapter(adapter)
           if adapter.start_with?(POSTGRES_PREFIX) || adapter == POSTGIS_PREFIX
@@ -260,7 +251,7 @@ module NewRelic
           # between usage of mysql and mysql2. Obfuscation is the same, though.
           elsif adapter == MYSQL2_PREFIX
             :mysql2
-          elsif adapter.start_with? SQLITE_PREFIX
+          elsif adapter.start_with?(SQLITE_PREFIX)
             :sqlite
           else
             adapter.to_sym

data/lib/new_relic/agent/database_adapter.rb

@@ -0,0 +1,35 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+module NewRelic
+  module Agent
+    class DatabaseAdapter
+      VERSIONS = {
+        '6.1.0' => proc { ActiveRecord::Base.connection_db_config.configuration_hash[:adapter] },
+        '4.0.0' => proc { ActiveRecord::Base.connection_config[:adapter] },
+        '3.0.0' => proc { |env| ActiveRecord::Base.configurations[env]['adapter'] }
+      }
+
+      def self.value
+        return unless defined? ActiveRecord::Base
+
+        new(::NewRelic::Control.instance.env, ActiveRecord::VERSION::STRING).value
+      end
+
+      attr_reader :env, :version
+
+      def initialize(env, version)
+        @env = env
+        @version = Gem::Version.new(version)
+      end
+
+      def value
+        match = VERSIONS.keys.find { |key| version >= Gem::Version.new(key) }
+        return unless match
+
+        VERSIONS[match].call(env)
+      end
+    end
+  end
+end

data/lib/new_relic/agent/datastores/metric_helper.rb

@@ -1,15 +1,12 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 module NewRelic
   module Agent
     module Datastores
       module MetricHelper
-        ROLLUP_METRIC        = "Datastore/all".freeze
-        WEB_ROLLUP_METRIC    = "Datastore/allWeb".freeze
-        OTHER_ROLLUP_METRIC  = "Datastore/allOther".freeze
-        DEFAULT_PRODUCT_NAME = "ActiveRecord".freeze
+        ROLLUP_METRIC = "Datastore/all".freeze
         OTHER = "Other".freeze
 
         ALL = "all".freeze
@@ -48,15 +45,15 @@ module NewRelic
           end
         end
 
-        def self.scoped_metric_for product, operation, collection=nil
+        def self.scoped_metric_for(product, operation, collection = nil)
           if collection
-            statement_metric_for product, collection, operation
+            statement_metric_for(product, collection, operation)
           else
-            operation_metric_for product, operation
+            operation_metric_for(product, operation)
           end
         end
 
-        def self.unscoped_metrics_for product, operation, collection=nil, host=nil, port_path_or_id=nil
+        def self.unscoped_metrics_for(product, operation, collection = nil, host = nil, port_path_or_id = nil)
           suffix = all_suffix
 
           metrics = [
@@ -67,30 +64,30 @@ module NewRelic
           ]
 
           if NewRelic::Agent.config[:'datastore_tracer.instance_reporting.enabled'] && host && port_path_or_id
-            metrics.unshift instance_metric_for(product, host, port_path_or_id)
+            metrics.unshift(instance_metric_for(product, host, port_path_or_id))
           end
-          metrics.unshift operation_metric_for(product, operation) if collection
+          metrics.unshift(operation_metric_for(product, operation)) if collection
 
           metrics
         end
 
-        def self.product_operation_collection_for product, operation, collection=nil, generic_product = nil
+        def self.product_operation_collection_for(product, operation, collection = nil, generic_product = nil)
           if overrides = overridden_operation_and_collection
             if should_override?(overrides, product, generic_product)
-              operation  = overrides[0] || operation
+              operation = overrides[0] || operation
               collection = overrides[1] || collection
             end
           end
           [product, operation, collection]
         end
 
-        def self.metrics_for(product, operation, collection = nil, generic_product = nil, host=nil, port_path_or_id=nil)
+        def self.metrics_for(product, operation, collection = nil, generic_product = nil, host = nil, port_path_or_id = nil)
           product, operation, collection = product_operation_collection_for(product, operation, collection, generic_product)
 
           # Order of these metrics matters--the first metric in the list will
           # be treated as the scoped metric in a bunch of different cases.
           metrics = unscoped_metrics_for(product, operation, collection, host, port_path_or_id)
-          metrics.unshift scoped_metric_for(product, operation, collection)
+          metrics.unshift(scoped_metric_for(product, operation, collection))
 
           metrics
         end
@@ -101,14 +98,15 @@ module NewRelic
         end
 
         def self.operation_from_sql(sql)
-          NewRelic::Agent::Database.parse_operation_from_query(sql) || OTHER
+          operation = NewRelic::Agent::Database.parse_operation_from_query(sql)
+          operation = OTHER if operation.eql?(NewRelic::Agent::Database::OTHER_OPERATION)
+          operation
         end
 
         # Allow Transaction#with_database_metric_name to override our
         # collection and operation
-        def self.overridden_operation_and_collection #THREAD_LOCAL_ACCESS
-          state = NewRelic::Agent::TransactionState.tl_get
-          txn   = state.current_transaction
+        def self.overridden_operation_and_collection # THREAD_LOCAL_ACCESS
+          txn = Tracer.current_transaction
           txn ? txn.instrumentation_state[:datastore_override] : nil
         end
 

data/lib/new_relic/agent/datastores/mongo/event_formatter.rb

@@ -1,19 +1,19 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-require 'new_relic/agent/datastores/mongo/obfuscator'
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+require_relative '../nosql_obfuscator'
 
 module NewRelic
   module Agent
     module Datastores
       module Mongo
         module EventFormatter
-
           # Keys that will get their values replaced with '?'.
-          OBFUSCATE_KEYS = [ 'filter', 'query', 'pipeline' ].freeze
+          OBFUSCATE_KEYS = %w[filter query pipeline].freeze
 
           # Keys that will get completely removed from the statement.
-          BLACKLISTED_KEYS = [ 'deletes', 'documents', 'updates' ].freeze
+          DENYLISTED_KEYS = %w[deletes documents updates].freeze
 
           def self.format(command_name, database_name, command)
             return nil unless NewRelic::Agent.config[:'mongo.capture_queries']
@@ -25,7 +25,8 @@ module NewRelic
             }
 
             command.each do |key, value|
-              next if BLACKLISTED_KEYS.include?(key)
+              next if DENYLISTED_KEYS.include?(key)
+
               if OBFUSCATE_KEYS.include?(key)
                 obfuscated = obfuscate(value)
                 result[key] = obfuscated if obfuscated
@@ -38,7 +39,7 @@ module NewRelic
 
           def self.obfuscate(statement)
             if NewRelic::Agent.config[:'mongo.obfuscate_queries']
-              statement = Obfuscator.obfuscate_statement(statement)
+              statement = NewRelic::Agent::Datastores::NosqlObfuscator.obfuscate_statement(statement)
             end
             statement
           end

data/lib/new_relic/agent/datastores/mongo/metric_translator.rb

@@ -1,8 +1,8 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
-require 'new_relic/agent/datastores/mongo/obfuscator'
+require 'new_relic/agent/datastores/nosql_obfuscator'
 require 'new_relic/agent/datastores/metric_helper'
 
 module NewRelic
@@ -15,8 +15,8 @@ module NewRelic
 
             if collection_in_selector?(payload)
               command_key = command_key_from_selector(payload)
-              name        = get_name_from_selector(command_key, payload)
-              collection  = get_collection_from_selector(command_key, payload)
+              name = get_name_from_selector(command_key, payload)
+              collection = get_collection_from_selector(command_key, payload)
             else
               collection = payload[:collection]
             end
@@ -57,8 +57,6 @@ module NewRelic
             nil
           end
 
-          MONGO_PRODUCT_NAME = "MongoDB".freeze
-
           def self.collection_in_selector?(payload)
             payload[:collection] == '$cmd' && payload[:selector]
           end
@@ -79,7 +77,7 @@ module NewRelic
 
             :collstats,
             :renameCollection,
-            :drop,
+            :drop
           ]
 
           def self.command_key_from_selector(payload)
@@ -121,7 +119,7 @@ module NewRelic
             name == :findandmodify && payload[:selector] && payload[:selector][:remove]
           end
 
-          def self.create_indexes?(name, paylod)
+          def self.create_indexes?(name, _payload)
             name == :createIndexes
           end
 
@@ -176,9 +174,7 @@ module NewRelic
             parts.shift
             parts.join('.')
           end
-
         end
-
       end
     end
   end