3scale_toolbox 0.19.2 → 0.19.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dee95ebde6b993418261f63857e80e18c8dd94bcfea9b92c6fa505cbbfdade99
-  data.tar.gz: ff8c3c97adb47ad141b2af12f8d4481330f9f25ce8819ecb5162666c6eedc521
+  metadata.gz: d2a44bdf128bf6f8d4d0a592a4eee49c82c34415017e03366ff2bcc241fe18c0
+  data.tar.gz: 0e94df4747331e9092ae0c961709cfcc334a553eb54209378941b8239307eceb
 SHA512:
-  metadata.gz: 41473b4f397a15743224e1848aecdd21abdf8a0246833522c2a3aadf6ed5c5cc58970e4761bb61801afa2e32b4326a33d15bf71db3f926c06a7620f7daa5e8b1
-  data.tar.gz: 6d1396f584b308ba1f978f02981605023d346c2ff39d806e1e3b265b7d16233f72beb4f7fc896e99a6d62d5b765878d5e9c71ee4eeb444db91101decc0a16bae
+  metadata.gz: 8dd7a6efc6567598d87e4ebbc18c486eba1ea9e6766ca6c0241f78e73a4287408d9e18ac838788e81a073c8f3a8fd93d299fac4ea9f21a42571e3cff68f2b0bb
+  data.tar.gz: c4ed75a0b46414606208a5fb6e1374e72d5fe06fbb5a237b3793bc2471d20667c489acace51cdf93d4971bfe59b42dc2919631b90074a8af72bac1668c663d01

data/lib/3scale_toolbox/commands/import_command/openapi/update_policies_step.rb

@@ -15,7 +15,7 @@ module ThreeScaleToolbox
             # do not update in-place, otherwise changes will not be detected
             policies_settings = source_policies_settings.dup
 
-            add_anonymous_access_policy(policies_settings)
+            reconcile_anonymous_access_policy(policies_settings)
             add_rh_sso_keycloak_role_check_policy(policies_settings)
             add_url_rewritting_policy(policies_settings)
 
@@ -31,15 +31,28 @@ module ThreeScaleToolbox
 
           private
 
-          def add_anonymous_access_policy(policies)
-            # only on 'open api' security req
-            return unless api_spec.security.nil?
-
-            return if policies.any? { |policy| policy['name'] == 'default_credentials' }
-
-            # Anonymous policy should be before apicast policy
-            # hence, adding as a first element
-            policies.insert(0, anonymous_policy)
+          def reconcile_anonymous_access_policy(policies)
+            idx = policies.find_index { |p| p['name'] == 'default_credentials' }
+
+            if api_spec.security.nil?
+              # only on 'open api' security req
+              # Update anonymous policy if exists
+              #
+              if idx.nil?
+                # Anonymous policy should be before apicast policy
+                # hence, adding as a first element
+                policies.insert(0, anonymous_policy)
+              else
+                # only update if different
+                if policies[idx].dig('configuration', 'user_key') != anonymous_policy.dig(:configuration, :user_key)
+                  policies[idx] = anonymous_policy
+                end
+              end
+            else
+              unless idx.nil?
+                policies.slice!(idx)
+              end
+            end
           end
 
           def anonymous_policy

data/lib/3scale_toolbox/commands/plans_command/export_command.rb

@@ -1,12 +1,3 @@
-require '3scale_toolbox/commands/plans_command/export/step'
-require '3scale_toolbox/commands/plans_command/export/read_app_plan_step'
-require '3scale_toolbox/commands/plans_command/export/read_plan_features_step'
-require '3scale_toolbox/commands/plans_command/export/read_plan_limits_step'
-require '3scale_toolbox/commands/plans_command/export/read_plan_pricing_rules_step'
-require '3scale_toolbox/commands/plans_command/export/read_plan_methods_step'
-require '3scale_toolbox/commands/plans_command/export/read_plan_metrics_step'
-require '3scale_toolbox/commands/plans_command/export/write_artifacts_file_step'
-
 module ThreeScaleToolbox
   module Commands
     module PlansCommand
@@ -31,32 +22,64 @@ module ThreeScaleToolbox
           end
 
           def run
-            tasks = []
-            tasks << ReadAppPlanStep.new(context)
-            tasks << ReadPlanLimitsStep.new(context)
-            tasks << ReadPlanPricingRulesStep.new(context)
-            tasks << ReadPlanFeaturesStep.new(context)
-            tasks << ReadPlanMethods.new(context)
-            tasks << ReadPlanMetrics.new(context)
-            tasks << WriteArtifactsStep.new(context)
-
-            # run tasks
-            tasks.each(&:call)
+            select_output do |output|
+              plan_object = application_plan.to_hash.merge(
+                'created_at' => Time.now.utc.iso8601,
+                'toolbox_version' => ThreeScaleToolbox::VERSION
+              )
+              output.write(plan_object.to_yaml)
+            end
           end
 
           private
 
-          def context
-            @context ||= create_context
+          def remote
+            @remote ||= threescale_client(arguments[:remote])
+          end
+
+          def select_output
+            ios = if file
+                    File.open(file, 'w')
+                  else
+                    $stdout
+                  end
+            begin
+              yield(ios)
+            ensure
+              ios.close
+            end
+          end
+
+          def application_plan
+            @application_plan ||= find_application_plan
+          end
+
+          def find_application_plan
+            Entities::ApplicationPlan.find(service: product, ref: plan_system_name).tap do |p|
+              raise ThreeScaleToolbox::Error, "Application plan #{plan_system_name} does not exist" if p.nil?
+            end
+          end
+
+          def product
+            @product ||= find_product
+          end
+
+          def product_ref
+            arguments[:service_system_name]
+          end
+
+          def plan_system_name
+            arguments[:plan_system_name]
+          end
+
+          def find_product
+            Entities::Service.find(remote: remote, ref: product_ref).tap do |prd|
+              raise ThreeScaleToolbox::Error, "Product #{product_ref} does not exist" if prd.nil?
+            end
           end
 
-          def create_context
-            {
-              file: options[:file],
-              threescale_client: threescale_client(arguments[:remote]),
-              service_system_name: arguments[:service_system_name],
-              plan_system_name: arguments[:plan_system_name],
-            }
+          def file
+            options[:file]
           end
         end
       end

data/lib/3scale_toolbox/commands/plans_command/import/import_backend_metrics_step.rb

@@ -0,0 +1,37 @@
+module ThreeScaleToolbox
+  module Commands
+    module PlansCommand
+      module Import
+        class ImportBackendMetricsStep
+          include Step
+          ##
+          # Writes Plan metrics and methods
+          def call
+            resource_backend_metrics.each(&method(:create_metric))
+            resource_backend_methods.each(&method(:create_method))
+          end
+
+          private
+
+          def create_metric(metric_attrs)
+            backend = find_backend(metric_attrs.fetch('backend_system_name'))
+
+            unless backend.metrics.any? { |m| m.system_name == metric_attrs.fetch('system_name') }
+              Entities::BackendMetric.create(backend: backend, attrs: metric_attrs)
+              puts "Created backend metric: #{metric_attrs.fetch('system_name')}; backend: #{backend.system_name}"
+            end
+          end
+
+          def create_method(method_attrs)
+            backend = find_backend(method_attrs.fetch('backend_system_name'))
+
+            unless backend.methods.any? { |m| m.system_name == method_attrs.fetch('system_name') }
+              Entities::BackendMethod.create(backend: backend, attrs: method_attrs)
+              puts "Created backend method: #{method_attrs.fetch('system_name')}; backend: #{backend.system_name}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/commands/plans_command/import/import_plan_limits_step.rb

@@ -2,7 +2,7 @@ module ThreeScaleToolbox
   module Commands
     module PlansCommand
       module Import
-        class ImportMetricLimitsStep
+        class ImportLimitsStep
           include Step
           ##
           # Writes Plan limits
@@ -26,9 +26,18 @@ module ThreeScaleToolbox
 
           def resource_limits_processed
             resource_limits.map do |limit|
-              metric = find_metric_by_system_name(limit.delete('metric_system_name'))
+              metric_system_name = limit.delete('metric_system_name')
+              backend_system_name = limit.delete('metric_backend_system_name')
+              metric_owner = if backend_system_name.nil?
+                               service
+                             else
+                               find_backend(backend_system_name)
+                             end
+              metric = metric_owner.find_metric_or_method(metric_system_name)
               # this ImportMetricLimitsStep step is assuming all metrics/methods have been created
               # in previous step, so finding metric should always succeed.
+              raise ThreeScaleToolbox::Error, "metric [#{metric_system_name}, #{backend_system_name}] not found" if metric.nil?
+
               limit.merge('metric_id' => metric.id)
             end
           end

data/lib/3scale_toolbox/commands/plans_command/import/import_plan_metrics_step.rb

@@ -14,13 +14,13 @@ module ThreeScaleToolbox
           private
 
           def missing_metrics
-            ThreeScaleToolbox::Helper.array_difference(resource_metrics, service.metrics) do |a, b|
+            ThreeScaleToolbox::Helper.array_difference(resource_product_metrics, service.metrics) do |a, b|
               a['system_name'] == b.system_name
             end
           end
 
           def missing_methods
-            ThreeScaleToolbox::Helper.array_difference(resource_methods, service.methods) do |a, b|
+            ThreeScaleToolbox::Helper.array_difference(resource_product_methods, service.methods) do |a, b|
               a['system_name'] == b.system_name
             end
           end

data/lib/3scale_toolbox/commands/plans_command/import/import_plan_pricing_rules_step.rb

@@ -26,7 +26,18 @@ module ThreeScaleToolbox
 
           def resource_pr_processed
             resource_pricing_rules.map do |pr|
-              metric = find_metric_by_system_name(pr.delete('metric_system_name'))
+              metric_system_name = pr.delete('metric_system_name')
+              backend_system_name = pr.delete('metric_backend_system_name')
+              metric_owner = if backend_system_name.nil?
+                               service
+                             else
+                               find_backend(backend_system_name)
+                             end
+              metric = metric_owner.find_metric_or_method(metric_system_name)
+              # this ImportMetricLimitsStep step is assuming all metrics/methods have been created
+              # in previous step, so finding metric should always succeed.
+              raise ThreeScaleToolbox::Error, "metric [#{metric_system_name}, #{backend_system_name}] not found" if metric.nil?
+
               pr.merge('metric_id' => metric.id,
                        'cost_per_unit' => pr.fetch('cost_per_unit').to_f)
             end

data/lib/3scale_toolbox/commands/plans_command/import/step.rb

@@ -53,6 +53,22 @@ module ThreeScaleToolbox
             artifacts_resource['methods'] || []
           end
 
+          def resource_product_metrics
+            resource_metrics.reject{ |m| m.has_key? 'backend_system_name' }
+          end
+
+          def resource_product_methods
+            resource_methods.reject{ |mth| mth.has_key? 'backend_system_name' }
+          end
+
+          def resource_backend_metrics
+            resource_metrics.select{ |m| m.has_key? 'backend_system_name' }
+          end
+
+          def resource_backend_methods
+            resource_methods.select{ |mth| mth.has_key? 'backend_system_name' }
+          end
+
           def resource_limits
             artifacts_resource['limits'] || []
           end
@@ -65,10 +81,6 @@ module ThreeScaleToolbox
             artifacts_resource['plan_features'] || []
           end
 
-          def service_metrics_and_methods
-            service.metrics + service.methods
-          end
-
           def service_features
             context[:service_features] ||= service.features
           end
@@ -82,10 +94,6 @@ module ThreeScaleToolbox
             service_features.find { |feature| feature['system_name'] == system_name }
           end
 
-          def find_metric_by_system_name(system_name)
-            service_metrics_and_methods.find { |metric| metric.system_name == system_name }
-          end
-
           private
 
           def find_service
@@ -100,6 +108,13 @@ module ThreeScaleToolbox
               raise ThreeScaleToolbox::Error, "Application plan #{plan_system_name} does not exist" if p.nil?
             end
           end
+
+          def find_backend(backend_system_name)
+            Entities::Backend.find_by_system_name(remote: threescale_client,
+                                                  system_name: backend_system_name).tap do |backend|
+              raise ThreeScaleToolbox::Error, "Backend #{backend_system_name} does not exist" if backend.nil?
+            end
+          end
         end
       end
     end

data/lib/3scale_toolbox/commands/plans_command/import/validate_plan_step.rb

@@ -0,0 +1,126 @@
+module ThreeScaleToolbox
+  module Commands
+    module PlansCommand
+      module Import
+        class ValidatePlanStep
+          include Step
+          ##
+          # Creates if it does not exist, updates otherwise
+          def call
+            validate_product_metric_method_uniqueness!
+
+            validate_backend_metric_method_uniqueness!
+
+            validate_product_backend_usage_references!
+
+            validate_limit_backend_references!
+
+            validate_limit_product_references!
+
+            validate_pricingrule_backend_references!
+
+            validate_pricingrule_product_references!
+          end
+
+          private
+
+          def validate_product_metric_method_uniqueness!
+            system_name_list = (resource_product_metrics + resource_product_methods).map do |m|
+              m.fetch('system_name')
+            end
+            if system_name_list.length != system_name_list.uniq.length
+              raise ThreeScaleToolbox::Error, "Invalid content. " \
+                "Product metrics and method system names must be unique."
+            end
+          end
+
+          def validate_backend_metric_method_uniqueness!
+            metric_list = resource_backend_metrics + resource_backend_methods
+            backend_list = metric_list.map { |m| m.fetch('backend_system_name') }.uniq
+            backend_list.each do |backend_system_name|
+              backend_metric_list = metric_list.select do |m|
+                m.fetch('backend_system_name') == backend_system_name
+              end.map { |m| m.fetch('system_name') }
+
+              if backend_metric_list.length != backend_metric_list.uniq.length
+                raise ThreeScaleToolbox::Error, "Invalid content. " \
+                  "Backend #{backend_system_name} contains metrics and method system names that are not unique"
+              end
+            end
+          end
+
+          def validate_product_backend_usage_references!
+            metric_list = resource_backend_metrics + resource_backend_methods
+            backend_list = metric_list.map { |m| m.fetch('backend_system_name') }.uniq
+            backend_usages_list = service.backend_usage_list.map(&:backend).map(&:system_name)
+
+            backend_list.each do |backend_system_name|
+              unless backend_usages_list.include?(backend_system_name)
+                raise ThreeScaleToolbox::Error, "Invalid content. " \
+                  "Backend usage reference to backend #{backend_system_name} has not been found"
+              end
+            end
+          end
+
+          def validate_limit_backend_references!
+            metric_list = resource_backend_metrics + resource_backend_methods
+            limits_with_backend_ref = resource_limits.select{ |limit| limit.has_key? 'metric_backend_system_name'}
+            limits_with_backend_ref.each do |limit|
+              none = metric_list.none? do |m|
+                m.fetch('system_name') == limit.fetch('metric_system_name') &&
+                m.fetch('backend_system_name') == limit.fetch('metric_backend_system_name')
+              end
+
+              if none
+                raise ThreeScaleToolbox::Error, "Invalid content. " \
+                  "Limit with backend metric [#{limit.fetch('metric_system_name')}, #{limit.fetch('metric_backend_system_name')}] " \
+                  "has not been found in metric or method list"
+              end
+            end
+          end
+
+          def validate_limit_product_references!
+            metric_list = resource_product_metrics + resource_product_methods
+            limits = resource_limits.reject { |limit| limit.has_key? 'metric_backend_system_name'}
+            limits.each do |limit|
+              if metric_list.none? { |m| m.fetch('system_name') == limit.fetch('metric_system_name') }
+                raise ThreeScaleToolbox::Error, "Invalid content. " \
+                  "Limit with product metric [#{limit.fetch('metric_system_name')}] " \
+                  "has not been found in metric or method list"
+              end
+            end
+          end
+
+          def validate_pricingrule_backend_references!
+            metric_list = resource_backend_metrics + resource_backend_methods
+            pr_with_backend_ref = resource_pricing_rules.select{ |pr| pr.has_key? 'metric_backend_system_name'}
+            pr_with_backend_ref.each do |pr|
+              none = metric_list.none? do |m|
+                m.fetch('system_name') == pr.fetch('metric_system_name') &&
+                m.fetch('backend_system_name') == pr.fetch('metric_backend_system_name')
+              end
+
+              if none
+                raise ThreeScaleToolbox::Error, "Invalid content. " \
+                  "PricingRule with backend metric [#{pr.fetch('metric_system_name')}, #{pr.fetch('metric_backend_system_name')}] " \
+                  "has not been found in metric or method list"
+              end
+            end
+          end
+
+          def validate_pricingrule_product_references!
+            metric_list = resource_product_metrics + resource_product_methods
+            prs = resource_pricing_rules.reject { |pr| pr.has_key? 'metric_backend_system_name'}
+            prs.each do |pr|
+              if metric_list.none? { |m| m.fetch('system_name') == pr.fetch('metric_system_name') }
+                raise ThreeScaleToolbox::Error, "Invalid content. " \
+                  "PricingRule with product metric [#{pr.fetch('metric_system_name')}] " \
+                  "has not been found in metric or method list"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/commands/plans_command/import_command.rb

@@ -1,9 +1,11 @@
 require '3scale_toolbox/commands/plans_command/import/step'
+require '3scale_toolbox/commands/plans_command/import/validate_plan_step'
 require '3scale_toolbox/commands/plans_command/import/create_or_update_app_plan_step'
 require '3scale_toolbox/commands/plans_command/import/import_plan_features_step'
 require '3scale_toolbox/commands/plans_command/import/import_plan_metrics_step'
 require '3scale_toolbox/commands/plans_command/import/import_plan_limits_step'
 require '3scale_toolbox/commands/plans_command/import/import_plan_pricing_rules_step'
+require '3scale_toolbox/commands/plans_command/import/import_backend_metrics_step'
 
 module ThreeScaleToolbox
   module Commands
@@ -31,9 +33,11 @@ module ThreeScaleToolbox
 
           def run
             tasks = []
+            tasks << ValidatePlanStep.new(context)
             tasks << CreateOrUpdateAppPlanStep.new(context)
             tasks << ImportMetricsStep.new(context)
-            tasks << ImportMetricLimitsStep.new(context)
+            tasks << ImportBackendMetricsStep.new(context)
+            tasks << ImportLimitsStep.new(context)
             tasks << ImportPricingRulesStep.new(context)
             tasks << ImportPlanFeaturesStep.new(context)
 

data/lib/3scale_toolbox/crds/limit_dump.rb

@@ -18,7 +18,7 @@ module ThreeScaleToolbox
           { 'systemName' => method.system_name }
         elsif (metric = plan.service.metrics.find { |m| m.id == metric_id })
           { 'systemName' => metric.system_name }
-        elsif (backend = backend_from_metric)
+        elsif (backend = backend_from_metric_link)
           if (backend_metric = backend.metrics.find { |m| m.id == metric_id })
             { 'systemName' => backend_metric.system_name, 'backend' => backend.system_name }
           elsif (backend_method = backend.methods.find { |m| m.id == metric_id })

data/lib/3scale_toolbox/crds/pricing_rule_dump.rb

@@ -19,7 +19,7 @@ module ThreeScaleToolbox
           { 'systemName' => method.system_name }
         elsif (metric = plan.service.metrics.find { |m| m.id == metric_id })
           { 'systemName' => metric.system_name }
-        elsif (backend = backend_from_metric)
+        elsif (backend = backend_from_metric_link)
           if (backend_metric = backend.metrics.find { |m| m.id == metric_id })
             { 'systemName' => backend_metric.system_name, 'backend' => backend.system_name }
           elsif (backend_method = backend.methods.find { |m| m.id == metric_id })

data/lib/3scale_toolbox/entities/application_plan.rb

@@ -3,6 +3,9 @@ module ThreeScaleToolbox
     class ApplicationPlan
       include CRD::ApplicationPlanSerializer
 
+      APP_PLANS_BLACKLIST = %w[id links default custom created_at updated_at].freeze
+      PLAN_FEATURE_BLACKLIST = %w[id links created_at updated_at].freeze
+
       class << self
         def create(service:, plan_attrs:)
           plan = service.remote.create_application_plan service.id, create_plan_attrs(plan_attrs)
@@ -209,8 +212,69 @@ module ThreeScaleToolbox
         attrs.fetch('cost_per_month', 0.0)
       end
 
+      def to_hash
+        {
+          'plan' => attrs.reject { |key, _| APP_PLANS_BLACKLIST.include? key },
+          'limits' => limits.map(&:to_hash),
+          'pricingrules' => pricing_rules.map(&:to_hash),
+          'plan_features' => features.map do |feature|
+              feature.reject { |key, _| PLAN_FEATURE_BLACKLIST.include? key }
+          end,
+          'metrics' => uniq_metrics_to_hash,
+          'methods' => uniq_methods_to_hash,
+        }
+      end
+
       private
 
+      def uniq_metrics_to_hash
+        limit_metrics = limits.flat_map do |limit|
+          # one of them (or both) could be nil
+          [
+            limit.product_metric, limit.backend_metric
+          ]
+        end.compact
+
+        pr_metrics = pricing_rules.flat_map do |pr|
+          # one of them (or both) could be nil
+          [
+            pr.product_metric, pr.backend_metric
+          ]
+        end.compact
+
+        # multiple limits can reference the same metric
+        # multiple pricing rules can reference the same metric
+        uniq_metrics = limit_metrics.concat(pr_metrics).each_with_object({}) do |metric, acc|
+          acc[metric.enriched_key] = metric
+        end.values
+
+        uniq_metrics.map { |metric| metric.to_hash }
+      end
+
+      def uniq_methods_to_hash
+        limit_methods = limits.flat_map do |limit|
+          # one of them (or both) could be nil
+          [
+            limit.product_method, limit.backend_method
+          ]
+        end.compact
+
+        pr_methods = pricing_rules.flat_map do |pr|
+          # one of them (or both) could be nil
+          [
+            pr.product_method, pr.backend_method
+          ]
+        end.compact
+
+        # multiple limits can reference the same method
+        # multiple pricing rules can reference the same method
+        uniq_methods = limit_methods.concat(pr_methods).each_with_object({}) do |method, acc|
+          acc[method.enriched_key] = method
+        end.values
+
+        uniq_methods.map { |method| method.to_hash }
+      end
+
       def read_plan_attrs
         raise ThreeScaleToolbox::InvalidIdError if id.zero?
 

data/lib/3scale_toolbox/entities/backend.rb

@@ -161,6 +161,10 @@ module ThreeScaleToolbox
         remote.http_client.endpoint == other.remote.http_client.endpoint && id == other.id
       end
 
+      def find_metric_or_method(system_name)
+        (metrics + methods).find { |m| m.system_name == system_name }
+      end
+
       private
 
       def metrics_and_methods

data/lib/3scale_toolbox/entities/backend_method.rb

@@ -6,6 +6,8 @@ module ThreeScaleToolbox
       VALID_PARAMS = %w[friendly_name system_name description].freeze
       public_constant :VALID_PARAMS
 
+      METHOD_BLACKLIST = %w[id links created_at updated_at parent_id].freeze
+
       class << self
         def create(backend:, attrs:)
           method = backend.remote.create_backend_method(backend.id, backend.hits.id,
@@ -71,6 +73,20 @@ module ThreeScaleToolbox
         remote.delete_backend_method backend.id, hits_id, id
       end
 
+      # enriched_key returns a metric key that will be unique for all
+      # metrics/methods from products and backends
+      def enriched_key
+        "backend.#{backend.id}.#{id}"
+      end
+
+      def to_hash
+        extra_attrs = {
+          'backend_system_name' => backend.system_name
+        }
+
+        attrs.merge(extra_attrs).reject { |key, _| METHOD_BLACKLIST.include? key }
+      end
+
       private
 
       def hits_id

data/lib/3scale_toolbox/entities/backend_metric.rb

@@ -6,6 +6,8 @@ module ThreeScaleToolbox
       VALID_PARAMS = %w[friendly_name system_name unit description].freeze
       public_constant :VALID_PARAMS
 
+      METRIC_BLACKLIST = %w[id links created_at updated_at].freeze
+
       class << self
         def create(backend:, attrs:)
           metric = backend.remote.create_backend_metric(backend.id,
@@ -74,6 +76,20 @@ module ThreeScaleToolbox
         remote.delete_backend_metric backend.id, id
       end
 
+      # enriched_key returns a metric key that will be unique for all
+      # metrics from products and backends
+      def enriched_key
+        "backend.#{backend.id}.#{id}"
+      end
+
+      def to_hash
+        extra_attrs = {
+          'backend_system_name' => backend.system_name
+        }
+
+        attrs.merge(extra_attrs).reject { |key, _| METRIC_BLACKLIST.include? key }
+      end
+
       private
 
       def process_attrs(metric_attrs)