Method: Fluent::GoogleCloudOutput#configure

Defined in:

lib/fluent/plugin/out_google_cloud.rb

#configure(conf) ⇒ Object

# File 'lib/fluent/plugin/out_google_cloud.rb', line 453

def configure(conf)
  super

  # TODO(qingling128): Remove this warning after the support is added. Also
  # remove the comment in the description of this configuration.
  unless @logging_api_url == DEFAULT_LOGGING_API_URL || @use_grpc
    @log.warn 'Detected customized logging_api_url while use_grpc is not' \
              ' enabled. Customized logging_api_url for the non-gRPC path' \
              ' is not supported. The logging_api_url option will be' \
              ' ignored.'
  end

  # Alert on old authentication configuration.
  unless @auth_method.nil? && @private_key_email.nil? &&
         @private_key_path.nil? && @private_key_passphrase.nil?
    extra = []
    extra << 'auth_method' unless @auth_method.nil?
    extra << 'private_key_email' unless @private_key_email.nil?
    extra << 'private_key_path' unless @private_key_path.nil?
    extra << 'private_key_passphrase' unless @private_key_passphrase.nil?

    raise Fluent::ConfigError,
          "#{PLUGIN_NAME} no longer supports auth_method.\n" \
          "Please remove configuration parameters: #{extra.join(' ')}"
  end

  set_regexp_patterns

  @utils = Common::Utils.new(@log)

  @platform = @utils.detect_platform(@use_metadata_service)

  # Treat an empty setting of the credentials file path environment variable
  # as unset. This way the googleauth lib could fetch the credentials
  # following the fallback path.
  ENV.delete(CREDENTIALS_PATH_ENV_VAR) if
    ENV[CREDENTIALS_PATH_ENV_VAR] == ''

  # Set required variables: @project_id, @vm_id, @vm_name and @zone.
  @project_id = @utils.get_project_id(@platform, @project_id)
  @vm_id = @utils.get_vm_id(@platform, @vm_id)
  @vm_name = @utils.get_vm_name(@vm_name)
  @zone = @utils.get_location(@platform, @zone, @use_aws_availability_zone)

  # 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, @subservice_name, @detect_subservice, @vm_id, @zone)

  if @metrics_resource
    unless @metrics_resource[:type].is_a?(String)
      raise Fluent::ConfigError,
            'metrics_resource.type must be a string:' \
            " #{@metrics_resource}."
    end
    if @metrics_resource.key?(:labels)
      unless @metrics_resource[:labels].is_a?(Hash)
        raise Fluent::ConfigError,
              'metrics_resource.labels must be a hash:' \
              " #{@metrics_resource}."
      end
      extra_keys = @metrics_resource.reject do |k, _|
        k == :type || k == :labels
      end
      unless extra_keys.empty?
        raise Fluent::ConfigError,
              "metrics_resource has unrecognized keys: #{extra_keys.keys}."
      end
    else
      extra_keys = @metrics_resource.reject do |k, _|
        k == :type || k.to_s.start_with?('labels.')
      end
      unless extra_keys.empty?
        raise Fluent::ConfigError,
              "metrics_resource has unrecognized keys: #{extra_keys.keys}."
      end
      # Transform the Hash form of the metrics_resource config if necessary.
      resource_type = @metrics_resource[:type]
      resource_labels = @metrics_resource.each_with_object({}) \
        do |(k, v), h|
          h[k.to_s.sub('labels.', '')] = v if k.to_s.start_with? 'labels.'
        end
      @metrics_resource = { type: resource_type, labels: resource_labels }
    end
  end

  # If monitoring is enabled, register metrics in the default registry
  # and store metric objects for future use.
  if @enable_monitoring
    unless Monitoring::MonitoringRegistryFactory.supports_monitoring_type(
      @monitoring_type)
      @log.warn "monitoring_type '#{@monitoring_type}' is unknown; "\
                'there will be no metrics'
    end
    if @metrics_resource
      @monitoring_resource = @utils.create_monitored_resource(
        @metrics_resource[:type], @metrics_resource[:labels])
    else
      @monitoring_resource = @resource
    end
    @registry = Monitoring::MonitoringRegistryFactory
                .create(@monitoring_type, @project_id,
                        @monitoring_resource, @gcm_service_address)
    # Export metrics every 60 seconds.
    timer_execute(:export_metrics, 60) { @registry.export }
    # Uptime should be a gauge, but the metric definition is a counter and
    # we can't change it.
    @uptime_metric = @registry.counter(
      :uptime, [:version], 'Uptime of Logging agent',
      'agent.googleapis.com/agent', 'CUMULATIVE')
    update_uptime
    timer_execute(:update_uptime, 1) { update_uptime }
    @successful_requests_count = @registry.counter(
      :stackdriver_successful_requests_count,
      [:grpc, :code],
      'A number of successful requests to the Stackdriver Logging API',
      'agent.googleapis.com/agent', 'CUMULATIVE')
    @failed_requests_count = @registry.counter(
      :stackdriver_failed_requests_count,
      [:grpc, :code],
      'A number of failed requests to the Stackdriver Logging '\
      'API, broken down by the error code',
      'agent.googleapis.com/agent', 'CUMULATIVE')
    @ingested_entries_count = @registry.counter(
      :stackdriver_ingested_entries_count,
      [:grpc, :code],
      'A number of log entries ingested by Stackdriver Logging',
      'agent.googleapis.com/agent', 'CUMULATIVE')
    @dropped_entries_count = @registry.counter(
      :stackdriver_dropped_entries_count,
      [:grpc, :code],
      'A number of log entries dropped by the Stackdriver output plugin',
      'agent.googleapis.com/agent', 'CUMULATIVE')
    @retried_entries_count = @registry.counter(
      :stackdriver_retried_entries_count,
      [:grpc, :code],
      'The number of log entries that failed to be ingested by '\
      'the Stackdriver output plugin due to a transient error '\
      'and were retried',
      'agent.googleapis.com/agent', 'CUMULATIVE')
    @ok_code = @use_grpc ? GRPC::Core::StatusCodes::OK : 200
  end

  # Set regexp that we should match tags against later on. Using a list
  # instead of a map to ensure order.
  @tag_regexp_list = []
  if @resource.type == GKE_CONSTANTS[:resource_type]
    @tag_regexp_list << [
      GKE_CONSTANTS[:resource_type], @compiled_kubernetes_tag_regexp
    ]
  end

  # Determine the common labels that should be added to all log entries
  # processed by this logging agent.
  @common_labels = determine_agent_level_common_labels(@resource)

  # The resource and labels are now set up; ensure they can't be modified
  # without first duping them.
  @resource.freeze
  @resource.labels.freeze
  @common_labels.freeze

  if @use_grpc
    @construct_log_entry = method(:construct_log_entry_in_grpc_format)
    @write_request = method(:write_request_via_grpc)
  else
    @construct_log_entry = method(:construct_log_entry_in_rest_format)
    @write_request = method(:write_request_via_rest)
  end

  if [Common::Platform::GCE, Common::Platform::EC2].include?(@platform)
    # Log an informational message containing the Logs viewer URL
    @log.info 'Logs viewer address: https://console.cloud.google.com/logs/',
              "viewer?project=#{@project_id}&resource=#{@resource.type}/",
              "instance_id/#{@vm_id}"
  end
end