Class: Fluent::AnalyzeConfigFilter

Inherits:

Filter

• Object
• Filter
• Fluent::AnalyzeConfigFilter

Includes:

selfself::Constants, Config

Defined in:

lib/fluent/plugin/filter_analyze_config.rb

Overview

Fluentd filter plugin to analyze configuration usage.

For documentation on inspecting parsed configuration elements, see https://www.rubydoc.info/github/fluent/fluentd/Fluent/Config/Element

Defined Under Namespace

Modules: Constants

Instance Method Summary

• #configure(conf) ⇒ Object
• #custom_plugin_name(e) ⇒ Object

  Returns a name for identifying plugins not in our default config.

• #default_plugin_name(e) ⇒ Object

  Returns a name for identifying plugins we ship by default.

• #embedded_ruby?(e) ⇒ Boolean
• #filter(tag, time, record) ⇒ Object

  rubocop:disable Lint/UnusedMethodArgument.

• #parse_config(path) ⇒ Object
• #shutdown ⇒ Object
• #start ⇒ Object

  rubocop:enable Style/HashSyntax.

Instance Method Details

#configure(conf) ⇒ Object

# File 'lib/fluent/plugin/filter_analyze_config.rb', line 206

def configure(conf)
  super
  if File.file?(@google_fluentd_config_path) &&
     File.file?(@google_fluentd_baseline_config_path)
    @log.info(
      'google-fluentd configuration file found at' \
      " #{@google_fluentd_config_path}. " \
      'google-fluentd baseline configuration file found at' \
      " #{@google_fluentd_baseline_config_path}. " \
      'google-fluentd Analyzing configuration.')

    utils = Common::Utils.new(@log)
    platform = utils.detect_platform(true)
    project_id = utils.get_project_id(platform, nil)
    vm_id = utils.get_vm_id(platform, nil)
    zone = utils.get_location(platform, nil, true)

    # All metadata parameters must now be set.
    utils.check_required_metadata_variables(
      platform, project_id, zone, vm_id)

    # Retrieve monitored resource.
    # Fail over to retrieve monitored resource via the legacy path if we
    # fail to get it from Metadata Agent.
    resource = utils.determine_agent_level_monitored_resource_via_legacy(
      platform, nil, false, vm_id, zone)

    unless Monitoring::MonitoringRegistryFactory.supports_monitoring_type(
      @monitoring_type)
      @log.warn "monitoring_type '#{@monitoring_type}' is unknown; "\
                'there will be no metrics'
    end
    registry = Monitoring::MonitoringRegistryFactory.create(
      @monitoring_type, project_id, resource, @gcm_service_address)

    plugin_usage = registry.counter(
      :stackdriver_enabled_plugins,
      [:plugin_name, :is_default_plugin, :has_default_value],
      'Enabled plugins')
    config_usage = registry.counter(
      :stackdriver_config_usage,
      [:plugin_name, :param, :is_present, :has_default_value],
      'Parameter usage for Google Cloud plugins')
    config_bool_values = registry.counter(
      :stackdriver_config_bool_values,
      [:plugin_name, :param, :value],
      'Values for bool parameters in Google Cloud plugins')

    config = parse_config(@google_fluentd_config_path)
    baseline_config = parse_config(@google_fluentd_baseline_config_path)

    # Create hash of all baseline elements by their plugin names.
    baseline_elements = Hash[baseline_config.elements.collect do |e|
                               [default_plugin_name(e), e]
                             end]
    baseline_google_element = baseline_config.elements.find do |e|
      e['@type'] == 'google_cloud'
    end

    # Look at each top-level config element and see whether it
    # matches the baseline value.
    #
    # Note on custom configurations: If the plugin has a custom
    # value (e.g. if a tail plugin has pos_file
    # /var/lib/google-fluentd/pos/my-custom-value.pos), then the
    # default_plugin_name (e.g. source/tail/my-custom-value) won't
    # be a key in baseline_elements below, so it won't be
    # used.  Instead it will use the custom_plugin_name
    # (e.g. source/tail).
    config.elements.each do |e|
      plugin_name = default_plugin_name(e)
      if baseline_elements.key?(plugin_name)
        is_default_plugin = true
        has_default_value = (baseline_elements[plugin_name] == e)
      else
        plugin_name = custom_plugin_name(e)
        is_default_plugin = false
        has_default_value = false
      end
      plugin_usage.increment(
        labels: {
          plugin_name: plugin_name,
          is_default_plugin: is_default_plugin,
          has_default_value: has_default_value,
          has_ruby_snippet: embedded_ruby?(e)
        },
        by: 1)

      # Additional metric for Google plugins (google_cloud and
      # detect_exceptions).
      next unless GOOGLE_PLUGIN_PARAMS.key?(e['@type'])
      GOOGLE_PLUGIN_PARAMS[e['@type']].each do |p|
        config_usage.increment(
          labels: {
            plugin_name: e['@type'],
            param: p,
            is_present: e.key?(p),
            has_default_value: (e.key?(p) &&
                                baseline_google_element.key?(p) &&
                                e[p] == baseline_google_element[p])
          },
          by: 1)
        next unless e.key?(p) && %w(true false).include?(e[p])
        config_bool_values.increment(
          labels: {
            plugin_name: e['@type'],
            param: p,
            value: e[p] == 'true'
          },
          by: 1)
      end
    end
  else
    @log.info(
      'google-fluentd configuration file does not exist at' \
      " #{@google_fluentd_config_path} or " \
      'google-fluentd baseline configuration file does not exist at' \
      " #{@google_fluentd_baseline_config_path} or " \
      '. Skipping configuration analysis.')
  end
rescue => e
  # Do not crash the agent due to configuration analysis failures.
  @log.warn(
    'Failed to optionally analyze the google-fluentd configuration' \
    " file. Proceeding anyway. Error: #{e}")
end

#custom_plugin_name(e) ⇒ Object

Returns a name for identifying plugins not in our default config. This should not contain arbitrary user-supplied data.

# File 'lib/fluent/plugin/filter_analyze_config.rb', line 191

def custom_plugin_name(e)
  if KNOWN_PLUGINS.key?(e.name) &&
     KNOWN_PLUGINS[e.name].include?(e['@type'])
    "#{e.name}/#{e['@type']}"
  else
    e.name.to_s
  end
end

#default_plugin_name(e) ⇒ Object

Returns a name for identifying plugins we ship by default.

# File 'lib/fluent/plugin/filter_analyze_config.rb', line 178

def default_plugin_name(e)
  case e['@type']
  when 'syslog'
    "#{e.name}/syslog/#{e['protocol_type']}"
  when 'tail'
    "#{e.name}/tail/#{File.basename(e['pos_file'], '.pos')}"
  else
    "#{e.name}/#{e['@type']}"
  end
end

#embedded_ruby?(e) ⇒ Boolean

Returns:

• (Boolean)

# File 'lib/fluent/plugin/filter_analyze_config.rb', line 200

def embedded_ruby?(e)
  (e.arg.include?('#{') ||
   e.any? { |_, v| v.include?('#{') } ||
   e.elements.any? { |ee| embedded_ruby?(ee) })
end

#filter(tag, time, record) ⇒ Object

rubocop:disable Lint/UnusedMethodArgument

# File 'lib/fluent/plugin/filter_analyze_config.rb', line 338

def filter(tag, time, record)
  # Skip the actual filtering process.
  record
end

#parse_config(path) ⇒ Object

# File 'lib/fluent/plugin/filter_analyze_config.rb', line 162

def parse_config(path)
  data = File.open(path, 'r', &:read)
  fname = File.basename(path)
  basepath = File.dirname(path)
  eval_context = Kernel.binding
  # Override instance_eval so that LiteralParser does not actually
  # evaluate the embedded Ruby, but instead just returns the
  # source string.  See
  # https://github.com/fluent/fluentd/blob/master/lib/fluent/config/literal_parser.rb
  def eval_context.instance_eval(code)
    code
  end
  Fluent::Config::V1Parser.parse(data, fname, basepath, eval_context)
end

#shutdown ⇒ Object

# File 'lib/fluent/plugin/filter_analyze_config.rb', line 333

def shutdown
  super
end

#start ⇒ Object

rubocop:enable Style/HashSyntax

# File 'lib/fluent/plugin/filter_analyze_config.rb', line 154

def start
  super
  @log = $log # rubocop:disable Style/GlobalVars

  # Initialize the insertID.
  @log.info 'Started the analyze_config plugin to analyze configuration.'
end