fluent-plugin-google-cloud 0.6.3 → 0.6.4.pre.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a0d7c7c98a69f3fa2f2c40ad70020260bf55e8be
-  data.tar.gz: 539deff09173b3b13fe9c226eaee60f8bd3695c7
+  metadata.gz: f8b2b5d197dc8da098e69040d3c1e33cf1d13390
+  data.tar.gz: d01388ebf1188dcd27061bdc3466a65be62856e9
 SHA512:
-  metadata.gz: 9bd48380bc63a1863ddc846beaf10d47053b3c17013e5d4044bc6474383d5958cd331ed9195092b8ffbf27e9b18c8f61e98f7e3eaff23ec2ed8b3fbfdb30ac11
-  data.tar.gz: 7c0e134bbfa2c2b78b33727be8739c2e548f169f7b7c76a451bedea257babc82bf062c89e0020daf9426d8b47a1cf72542670e24ef73cc94782e8d9ecec86263
+  metadata.gz: b6720df5c417423746b423fd34cebbcb3d417cdbc1cdfe91307970841661cf8d18edd987e0f622680bcc51b4503b5e3458c3029774362396eea769f2a2378dc5
+  data.tar.gz: 0ebf298b06bc970370d4a7640096f2fd14a2646339c9db6e93f29dacbf640140e52d1016c89cc63811b8248c314e945e54f8e47088b58a4384cd6082da233d59

data/Gemfile.lock

@@ -1,7 +1,8 @@
 PATH
   remote: .
   specs:
-    fluent-plugin-google-cloud (0.6.3)
+    fluent-plugin-google-cloud (0.6.4.pre.1)
+      excon (~> 0.56.0)
       fluentd (~> 0.10)
       google-api-client (~> 0.9.0)
       google-cloud-logging (~> 0.23.2)
@@ -21,9 +22,10 @@ GEM
     cool.io (1.5.0)
     crack (0.4.3)
       safe_yaml (~> 1.0.0)
+    excon (0.56.0)
     faraday (0.12.1)
       multipart-post (>= 1.2, < 3)
-    fluentd (0.14.17)
+    fluentd (0.14.18)
       cool.io (>= 1.4.5, < 2.0.0)
       http_parser.rb (>= 0.5.1, < 0.7.0)
       msgpack (>= 0.7.0, < 2.0.0)
@@ -57,7 +59,7 @@ GEM
       googleauth (~> 0.5.1)
       grpc (~> 1.0)
       rly (~> 0.2.3)
-    google-protobuf (3.3.0-universal-darwin)
+    google-protobuf (3.3.0)
     googleapis-common-protos (1.3.5)
       google-protobuf (~> 3.2)
       grpc (~> 1.0)
@@ -69,7 +71,7 @@ GEM
       multi_json (~> 1.11)
       os (~> 0.9)
       signet (~> 0.7)
-    grpc (1.2.5-universal-darwin)
+    grpc (1.2.5)
       google-protobuf (~> 3.1)
       googleauth (~> 0.5.1)
     hashdiff (0.3.4)
@@ -82,7 +84,7 @@ GEM
     logging (2.2.2)
       little-plugger (~> 1.1)
       multi_json (~> 1.10)
-    memoist (0.15.0)
+    memoist (0.16.0)
     metaclass (0.0.4)
     mime-types (3.1)
       mime-types-data (~> 3.2015)
@@ -152,4 +154,4 @@ DEPENDENCIES
   webmock (~> 1.17)
 
 BUNDLED WITH
-   1.15.0
+   1.15.1

data/fluent-plugin-google-cloud.gemspec

@@ -10,7 +10,7 @@ eos
   gem.homepage      = \
     'https://github.com/GoogleCloudPlatform/fluent-plugin-google-cloud'
   gem.license       = 'Apache-2.0'
-  gem.version       = '0.6.3'
+  gem.version       = '0.6.4.pre.1'
   gem.authors       = ['Todd Derr', 'Alex Robinson']
   gem.email         = ['salty@google.com']
   gem.required_ruby_version = Gem::Requirement.new('>= 2.0')
@@ -19,6 +19,7 @@ eos
   gem.test_files    = gem.files.grep(/^(test)/)
   gem.require_paths = ['lib']
 
+  gem.add_runtime_dependency 'excon', '~> 0.56.0'
   gem.add_runtime_dependency 'fluentd', '~> 0.10'
   gem.add_runtime_dependency 'googleapis-common-protos', '~> 1.3'
   gem.add_runtime_dependency 'google-api-client', '~> 0.9.0'

data/lib/fluent/plugin/out_google_cloud.rb

@@ -11,9 +11,11 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+require 'excon'
 require 'grpc'
 require 'json'
 require 'open-uri'
+require 'rubygems'
 require 'socket'
 require 'time'
 require 'yaml'
@@ -36,8 +38,10 @@ end
 module Fluent
   # fluentd output plugin for the Stackdriver Logging API
   class GoogleCloudOutput < BufferedOutput
-    # Constants for service names and resource types.
+    # Constants.
     module Constants
+      # Service names and resource types.
+
       APPENGINE_CONSTANTS = {
         service: 'appengine.googleapis.com',
         resource_type: 'gae_app'
@@ -54,10 +58,18 @@ module Fluent
         service: 'container.googleapis.com',
         resource_type: 'container'
       }
+      DOCKER_CONSTANTS = {
+        service: 'dockercontainer.googleapis.com',
+        resource_type: 'docker_container'
+      }
       DATAFLOW_CONSTANTS = {
         service: 'dataflow.googleapis.com',
         resource_type: 'dataflow_step'
       }
+      DATAPROC_CONSTANTS = {
+        service: 'cluster.dataproc.googleapis.com',
+        resource_type: 'cloud_dataproc_cluster'
+      }
       EC2_CONSTANTS = {
         service: 'ec2.amazonaws.com',
         resource_type: 'aws_ec2_instance'
@@ -66,6 +78,15 @@ module Fluent
         service: 'ml.googleapis.com',
         resource_type: 'ml_job'
       }
+
+      # Metadata agent support.
+
+      # Use empty string as request path when locally-unique key of monitored
+      # resource can be implicitly inferred by Metadata Agent.
+      IMPLICIT_MONITORED_RESOURCE_UNIQUE_KEY = ''
+
+      # Docker container support.
+      DEFAULT_DOCKER_API_SOCKET_PATH = '/var/run/docker.sock'
     end
 
     include self::Constants
@@ -73,7 +94,7 @@ module Fluent
     Fluent::Plugin.register_output('google_cloud', self)
 
     PLUGIN_NAME = 'Fluentd Google Cloud Logging plugin'
-    PLUGIN_VERSION = '0.6.3'
+    PLUGIN_VERSION = '0.6.4.pre.1'
 
     # Name of the the Google cloud logging write scope.
     LOGGING_SCOPE = 'https://www.googleapis.com/auth/logging.write'
@@ -120,7 +141,7 @@ module Fluent
     config_param :require_valid_tags, :bool, :default => false
 
     # The regular expression to use on Kubernetes logs to extract some basic
-    # information about the log source. The regex must contain capture groups
+    # information about the log source. The regexp must contain capture groups
     # for pod_name, namespace_name, and container_name.
     config_param :kubernetes_tag_regexp, :string, :default =>
       '\.(?<pod_name>[^_]+)_(?<namespace_name>[^_]+)_(?<container_name>.+)$'
@@ -182,6 +203,18 @@ module Fluent
                  :default => nil,
                  :secret => true
 
+    # Whether to call metadata agent to retrieve monitored resource.
+    config_param :enable_metadata_agent, :bool, :default => false
+    config_param :metadata_agent_url, :string,
+                 :default => 'http://local-metadata-agent.stackdriver.com:8000'
+
+    # Whether to call Docker Remote API locally when Metadata Agent is not
+    # enabled or if the request fails.
+    config_param :call_docker_api_locally, :bool, :default => true
+    # Docker Remote API unix socket path.
+    config_param :docker_remote_api_socket_path, :string,
+                 :default => '/var/run/docker.sock'
+
     # rubocop:enable Style/HashSyntax
 
     # TODO: Add a log_name config option rather than just using the tag?
@@ -191,9 +224,6 @@ module Fluent
     attr_reader :project_id
     attr_reader :zone
     attr_reader :vm_id
-    attr_reader :running_on_managed_vm
-    attr_reader :gae_backend_name
-    attr_reader :gae_backend_version
     attr_reader :resource
     attr_reader :common_labels
 
@@ -203,6 +233,35 @@ module Fluent
       @log = $log # rubocop:disable Style/GlobalVars
     end
 
+    # Set up regex patterns used to parse tags and logs.
+    def setup_regex_patterns
+      @compiled_kubernetes_tag_regexp = nil
+      if @kubernetes_tag_regexp
+        @compiled_kubernetes_tag_regexp = Regexp.new(@kubernetes_tag_regexp)
+      end
+
+      @cloudfunctions_tag_regexp =
+        /\.(?<encoded_function_name>.+)\.\d+-[^-]+_default_worker$/
+      @cloudfunctions_log_regexp = /^
+        (?:\[(?<severity>.)\])?
+        \[(?<timestamp>.{24})\]
+        (?:\[(?<execution_id>[^\]]+)\])?
+        [ ](?<text>.*)$/x
+
+      # Docker container tag format:
+      # "container.<container_id>.<container_name>".
+      @dockercontainer_tag_regexp =
+        /^container\.(?<container_id>[a-zA-Z0-9]+)\.
+        (?<container_name>[a-zA-Z0-9_.-]+)$/x
+      # Docker container with application tag format:
+      # "application-container.<container_name>.<additional_tag>".
+      @dockercontainer_tag_with_application_regexp =
+        /^application-container\.(?<container_name>[a-zA-Z0-9_.-]+)\.
+        (?<additional_tag>.+)$/x
+
+      @http_latency_regexp = /^\s*(?<seconds>\d+)(?<decimal>\.\d+)?\s*s\s*$/
+    end
+
     def configure(conf)
       super
 
@@ -221,150 +280,57 @@ module Fluent
                extra.join(' ')
       end
 
-      # TODO: Send instance tags as labels as well?
-      @common_labels = {}
-      @common_labels.merge!(@labels) if @labels
-
-      # TODO: Construct Google::Api::MonitoredResource when @use_grpc is
-      # true after the protobuf map corruption issue is fixed.
-      @resource = Google::Apis::LoggingV2beta1::MonitoredResource.new(
-        labels: {})
-
-      @compiled_kubernetes_tag_regexp = nil
-      if @kubernetes_tag_regexp
-        @compiled_kubernetes_tag_regexp = Regexp.new(@kubernetes_tag_regexp)
-      end
-
-      @cloudfunctions_tag_regexp =
-        /\.(?<encoded_function_name>.+)\.\d+-[^-]+_default_worker$/
-      @cloudfunctions_log_regexp = /^
-        (?:\[(?<severity>.)\])?
-        \[(?<timestamp>.{24})\]
-        (?:\[(?<execution_id>[^\]]+)\])?
-        [ ](?<text>.*)$/x
-
-      @http_latency_regexp = /^\s*(?<seconds>\d+)(?<decimal>\.\d+)?\s*s\s*$/
+      setup_regex_patterns
 
-      # set attributes from metadata (unless overriden by static config)
-      @vm_name = Socket.gethostname if @vm_name.nil?
       @platform = detect_platform
-      case @platform
-      when Platform::GCE
-        if @project_id.nil?
-          @project_id = fetch_gce_metadata('project/project-id')
-        end
-        if @zone.nil?
-          # this returns "projects/<number>/zones/<zone>"; we only want
-          # the part after the final slash.
-          fully_qualified_zone = fetch_gce_metadata('instance/zone')
-          @zone = fully_qualified_zone.rpartition('/')[2]
-        end
-        @vm_id = fetch_gce_metadata('instance/id') if @vm_id.nil?
-      when Platform::EC2
-        metadata = fetch_ec2_metadata
-        if @zone.nil? && metadata.key?('availabilityZone')
-          @zone = 'aws:' + metadata['availabilityZone']
-        end
-        if @vm_id.nil? && metadata.key?('instanceId')
-          @vm_id = metadata['instanceId']
-        end
-        if metadata.key?('accountId')
-          @resource.labels['aws_account'] = metadata['accountId']
-        end
-      when Platform::OTHER
-        # do nothing
-      else
-        fail Fluent::ConfigError, 'Unknown platform ' + @platform
-      end
 
-      # If we still don't have a project ID, try to obtain it from the
-      # credentials.
-      if @project_id.nil?
-        @project_id = CredentialsInfo.project_id
-        @log.info 'Set Project ID from credentials: ', @project_id unless
-          @project_id.nil?
+      # Set agent-level monitored resource. This monitored resource is initiated
+      # as the logging agent starts up. It will be inherited by all log entries
+      # processed by this agent. First try to retrieve it via Metadata Agent.
+      if @enable_metadata_agent
+        # The locally-unique key for this should be the instance id. Since this
+        # can be implicitly inferred by Metadata Agent, we do not need to
+        # explicitly send the key.
+        @resource = call_metadata_agent_for_monitored_resource(
+          IMPLICIT_MONITORED_RESOURCE_UNIQUE_KEY)
       end
 
-      # all metadata parameters must now be set
-      unless @project_id && @zone && @vm_id
-        missing = []
-        missing << 'project_id' unless @project_id
-        missing << 'zone' unless @zone
-        missing << 'vm_id' unless @vm_id
-        fail Fluent::ConfigError, 'Unable to obtain metadata parameters: ' +
-          missing.join(' ')
+      # Set required variables: @project_id, @vm_id, @vm_name and @zone.
+      # If any info above is included in the response from Metadata Agent, make
+      # use of that. Otherwise make some additional requests to metadata server.
+      #
+      # Note: Once we support metadata injection on the Logging API side, we
+      # might no longer need to require all these metadata in logging agent. But
+      # for now, they are still required.
+      set_required_metadata_variables
+
+      # Fail over to retrieve monitored resource via the legacy path if we fail
+      # to get it from Metadata Agent.
+      @resource ||= determine_agent_level_monitored_resource_via_legacy
+
+      # Set variables specific to CLoud Functions. This has to be called after
+      # we have determined the resource type. The purpose is to avoid repeated
+      # calls to metadata server.
+      @running_cloudfunctions = false
+      # We only support Cloud Functions logs for GKE right now.
+      if @resource.type == CONTAINER_CONSTANTS[:resource_type] &&
+         fetch_gce_metadata('instance/attributes/').split.include?('gcf_region')
+        # We are not setting resource type as Cloud Functions here because
+        # whether a log entry is truly coming from a Cloud Functions function
+        # depends on the log tag. Only when @running_cloudfunctions is true will
+        # we try to match log tags against Cloud Functions tag regexp when
+        # processing log entries.
+        @running_cloudfunctions = true
+        # Fetch this info and store it to avoid recurring metadata server calls.
+        @gcf_region = fetch_gce_metadata('instance/attributes/gcf_region')
       end
 
-      # Default this to false; it is only overwritten if we detect Managed VM.
-      @running_on_managed_vm = false
-
-      # Default this to false; it is only overwritten if we detect Cloud
-      # Functions.
-      @running_cloudfunctions = false
+      # Determine the common labels that should be added to all log entries
+      # processed by this logging agent.
+      @common_labels = determine_agent_level_common_labels
 
-      # Set up the MonitoredResource, labels, etc. based on the config.
-      case @platform
-      when Platform::GCE
-        @resource.type = COMPUTE_CONSTANTS[:resource_type]
-        # TODO: introduce a new MonitoredResource-centric configuration and
-        # deprecate subservice-name; for now, translate known uses.
-        if @subservice_name
-          # TODO: what should we do if we encounter an unknown value?
-          if @subservice_name == DATAFLOW_CONSTANTS[:service]
-            @resource.type = DATAFLOW_CONSTANTS[:resource_type]
-          elsif @subservice_name == ML_CONSTANTS[:service]
-            @resource.type = ML_CONSTANTS[:resource_type]
-          end
-        elsif @detect_subservice
-          # Check for specialized GCE environments.
-          # TODO: Add config options for these to allow for running outside GCE?
-          attributes = fetch_gce_metadata('instance/attributes/').split
-          # Do nothing, just don't populate other service's labels.
-          if attributes.include?('gae_backend_name') &&
-             attributes.include?('gae_backend_version')
-            # Managed VM
-            @running_on_managed_vm = true
-            @gae_backend_name =
-                fetch_gce_metadata('instance/attributes/gae_backend_name')
-            @gae_backend_version =
-                fetch_gce_metadata('instance/attributes/gae_backend_version')
-            @resource.type = APPENGINE_CONSTANTS[:resource_type]
-            @resource.labels['module_id'] = @gae_backend_name
-            @resource.labels['version_id'] = @gae_backend_version
-          elsif attributes.include?('kube-env')
-            # Kubernetes/Container Engine
-            @resource.type = CONTAINER_CONSTANTS[:resource_type]
-            @raw_kube_env = fetch_gce_metadata('instance/attributes/kube-env')
-            @kube_env = YAML.load(@raw_kube_env)
-            @resource.labels['cluster_name'] =
-              cluster_name_from_kube_env(@kube_env)
-            detect_cloudfunctions(attributes)
-          end
-        end
-        # Some services have the GCE instance_id and zone as MonitoredResource
-        # labels; for other services we send them as entry labels.
-        if @resource.type == COMPUTE_CONSTANTS[:resource_type] ||
-           @resource.type == CONTAINER_CONSTANTS[:resource_type]
-          @resource.labels['instance_id'] = @vm_id
-          @resource.labels['zone'] = @zone
-        else
-          common_labels["#{COMPUTE_CONSTANTS[:service]}/resource_id"] = @vm_id
-          common_labels["#{COMPUTE_CONSTANTS[:service]}/zone"] = @zone
-        end
-        common_labels["#{COMPUTE_CONSTANTS[:service]}/resource_name"] = @vm_name
-      when Platform::EC2
-        @resource.type = EC2_CONSTANTS[:resource_type]
-        @resource.labels['instance_id'] = @vm_id
-        @resource.labels['region'] = @zone
-        # the aws_account label is populated above.
-        common_labels["#{EC2_CONSTANTS[:service]}/resource_name"] = @vm_name
-      when Platform::OTHER
-        # Use GCE as the default environment.
-        @resource.type = COMPUTE_CONSTANTS[:resource_type]
-        @resource.labels['instance_id'] = @vm_id
-        @resource.labels['zone'] = @zone
-        common_labels["#{COMPUTE_CONSTANTS[:service]}/resource_name"] = @vm_name
-      end
+      # For each resource type, there is a list of labels that we want to report
+      # as monitored resource instead of metadata labels. Move them if present.
       @resource.labels.merge!(
         extract_resource_labels(@resource.type, common_labels))
 
@@ -376,7 +342,7 @@ module Fluent
 
       # 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}/",
+                "viewer?project=#{@project_id}&resource=#{@resource.type}/",
                 "instance_id/#{@vm_id}"
     end
 
@@ -391,130 +357,6 @@ module Fluent
       super
     end
 
-    def format(tag, time, record)
-      [tag, time, record].to_msgpack
-    end
-
-    # Given a tag, returns the corresponding valid tag if possible, or nil if
-    # the tag should be rejected. If 'require_valid_tags' is false, non-string
-    # tags are converted to strings, and invalid characters are sanitized;
-    # otherwise such tags are rejected.
-    def sanitize_tag(tag)
-      if @require_valid_tags &&
-         (!tag.is_a?(String) || tag == '' || convert_to_utf8(tag) != tag)
-        return nil
-      end
-      tag = convert_to_utf8(tag.to_s)
-      tag = '_' if tag == ''
-      tag
-    end
-
-    # Compute the monitored resource and common labels shared by a collection of
-    # entries.
-    def compute_group_resource_and_labels(tag)
-      # Note that we assume that labels added to group_common_labels below are
-      # not 'service' labels (i.e. we do not call extract_resource_labels
-      # again).
-      group_resource = @resource.dup
-      group_common_labels = @common_labels.dup
-
-      if @running_cloudfunctions
-        # If the current group of entries is coming from a Cloud Functions
-        # function, the function name can be extracted from the tag.
-        match_data = @cloudfunctions_tag_regexp.match(tag)
-        if match_data
-          # Resource type is set to Cloud Functions only for logs actually
-          # coming from a function, otherwise we leave it as Container.
-          group_resource.type = CLOUDFUNCTIONS_CONSTANTS[:resource_type]
-          group_resource.labels['region'] = @gcf_region
-          group_resource.labels['function_name'] =
-            decode_cloudfunctions_function_name(
-              match_data['encoded_function_name'])
-          # Move GKE container labels from the MonitoredResource to the
-          # LogEntry.
-          instance_id = group_resource.labels.delete('instance_id')
-          group_common_labels["#{CONTAINER_CONSTANTS[:service]}/cluster_name"] =
-            group_resource.labels.delete('cluster_name')
-          group_common_labels["#{CONTAINER_CONSTANTS[:service]}/instance_id"] =
-            instance_id
-          group_common_labels["#{COMPUTE_CONSTANTS[:service]}/resource_id"] =
-            instance_id
-          group_common_labels["#{COMPUTE_CONSTANTS[:service]}/zone"] =
-            group_resource.labels.delete('zone')
-        end
-      end
-      if group_resource.type == CONTAINER_CONSTANTS[:resource_type] &&
-         @compiled_kubernetes_tag_regexp
-        # Container logs in Kubernetes are tagged based on where they came
-        # from, so we can extract useful metadata from the tag.
-        # Do this here to avoid having to repeat it for each record.
-        match_data = @compiled_kubernetes_tag_regexp.match(tag)
-        if match_data
-          group_resource.labels['container_name'] = match_data['container_name']
-          group_resource.labels['namespace_id'] = match_data['namespace_name']
-          group_resource.labels['pod_id'] = match_data['pod_name']
-          %w(namespace_name pod_name).each do |field|
-            group_common_labels["#{CONTAINER_CONSTANTS[:service]}/#{field}"] =
-              match_data[field]
-          end
-        end
-      end
-
-      # Freeze the per-request state. Any further changes must be made on a
-      # per-entry basis.
-      group_resource.freeze
-      group_resource.labels.freeze
-      group_common_labels.freeze
-
-      [group_resource, group_common_labels]
-    end
-
-    # Extract entry resource and common labels that should be applied to
-    # individual entries from the group resource.
-    def extract_entry_labels(group_resource, record)
-      resource_labels = {}
-      common_labels = {}
-
-      if group_resource.type == CLOUDFUNCTIONS_CONSTANTS[:resource_type] &&
-         record.key?('log')
-        @cloudfunctions_log_match =
-          @cloudfunctions_log_regexp.match(record['log'])
-      end
-
-      if group_resource.type == CONTAINER_CONSTANTS[:resource_type]
-        # Move the stdout/stderr annotation from the record into a label
-        common_labels.merge!(
-          fields_to_labels(
-            record, 'stream' => "#{CONTAINER_CONSTANTS[:service]}/stream"))
-
-        # If the record has been annotated by the kubernetes_metadata_filter
-        # plugin, then use that metadata. Otherwise, rely on commonLabels
-        # populated at the grouped_entries level from the group's tag.
-        if record.key?('kubernetes')
-          extracted_resource_labels, extracted_common_labels = \
-            extract_container_metadata(record)
-          resource_labels.merge!(extracted_resource_labels)
-          common_labels.merge!(extracted_common_labels)
-        end
-      end
-
-      # If a field is present in the label_map, send its value as a label
-      # (mapping the field name to label name as specified in the config)
-      # and do not send that field as part of the payload.
-      common_labels.merge!(fields_to_labels(record, @label_map))
-
-      if group_resource.type == CLOUDFUNCTIONS_CONSTANTS[:resource_type] &&
-         @cloudfunctions_log_match &&
-         @cloudfunctions_log_match['execution_id']
-        common_labels['execution_id'] =
-          @cloudfunctions_log_match['execution_id']
-      end
-      resource_labels.merge!(
-        extract_resource_labels(group_resource.type, common_labels))
-
-      [resource_labels, common_labels]
-    end
-
     def write(chunk)
       # Group the entries since we have to make one call per tag.
       grouped_entries = {}
@@ -531,20 +373,21 @@ module Fluent
 
       grouped_entries.each do |tag, arr|
         entries = []
-        group_resource, group_common_labels = compute_group_resource_and_labels(
-          tag)
+        group_resource, group_common_labels =
+          determine_group_level_monitored_resource_and_labels(tag)
 
         arr.each do |time, record|
           next unless record.is_a?(Hash)
 
           extracted_resource_labels, extracted_common_labels = \
-            extract_entry_labels(group_resource, record)
+            determine_entry_level_labels(group_resource, record)
           entry_resource = group_resource.dup
           entry_resource.labels.merge!(extracted_resource_labels)
           entry_common_labels = \
             group_common_labels.merge(extracted_common_labels)
 
-          if entry_resource.type == CONTAINER_CONSTANTS[:resource_type]
+          if [CONTAINER_CONSTANTS[:resource_type],
+              DOCKER_CONSTANTS[:resource_type]].include?(entry_resource.type)
             # Save the timestamp if available, then clear it out to allow for
             # determining whether we should parse the log or message field.
             timestamp = record.key?('time') ? record['time'] : nil
@@ -777,7 +620,7 @@ module Fluent
           end
         end
       rescue StandardError => e
-        @log.debug 'Failed to access metadata service: ', error: e
+        @log.error 'Failed to access metadata service: ', error: e
       end
 
       @log.info 'Unable to determine platform'
@@ -792,15 +635,570 @@ module Fluent
            metadata_path, 'Metadata-Flavor' => 'Google', &:read)
     end
 
-    def fetch_ec2_metadata
-      fail "Called fetch_ec2_metadata with platform=#{@platform}" unless
+    # EC2 Metadata server returns everything in one call. Store it after the
+    # first fetch to avoid making multiple calls.
+    def ec2_metadata
+      fail "Called ec2_metadata with platform=#{@platform}" unless
+        @platform == Platform::EC2
+      unless @ec2_metadata
+        # See http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html
+        open('http://' + METADATA_SERVICE_ADDR +
+             '/latest/dynamic/instance-identity/document') do |f|
+          contents = f.read
+          @ec2_metadata = JSON.parse(contents)
+        end
+      end
+
+      @ec2_metadata
+    end
+
+    # Set regexp patterns to parse tags and logs.
+    def set_regexp_patterns
+      @compiled_kubernetes_tag_regexp = nil
+      if @kubernetes_tag_regexp
+        @compiled_kubernetes_tag_regexp = Regexp.new(@kubernetes_tag_regexp)
+      end
+
+      @cloudfunctions_tag_regexp =
+        /\.(?<encoded_function_name>.+)\.\d+-[^-]+_default_worker$/
+      @cloudfunctions_log_regexp = /^
+        (?:\[(?<severity>.)\])?
+        \[(?<timestamp>.{24})\]
+        (?:\[(?<execution_id>[^\]]+)\])?
+        [ ](?<text>.*)$/x
+
+      @http_latency_regexp = /^\s*(?<seconds>\d+)(?<decimal>\.\d+)?\s*s\s*$/
+    end
+
+    # Set required variables like @project_id, @vm_id, @vm_name and @zone.
+    def set_required_metadata_variables
+      set_project_id
+      set_vm_id
+      set_vm_name
+      set_location
+
+      # All metadata parameters must now be set.
+      return if @project_id && @zone && @vm_id
+      missing = []
+      missing << 'project_id' unless @project_id
+      missing << 'zone' unless @zone
+      missing << 'vm_id' unless @vm_id
+      fail Fluent::ConfigError, 'Unable to obtain metadata parameters: ' +
+        missing.join(' ')
+    end
+
+    # 1. Return the value if it is explicitly set in the config already.
+    # 2. If not, try to retrieve it by calling metadata server directly.
+    # 3. If still not set, try to obtain it from the credentials.
+    def set_project_id
+      @project_id ||= fetch_gce_metadata('project/project-id') if
+        @platform == Platform::GCE
+      @project_id ||= CredentialsInfo.project_id
+    rescue StandardError => e
+      @log.error 'Failed to obtain project id: ', error: e
+    end
+
+    # 1. Return the value if it is explicitly set in the config already.
+    # 2. If not, check if the response from Metadata Agent includes this info.
+    # 3. If not, try to retrieve it by calling metadata servers directly.
+    def set_vm_id
+      @vm_id ||= @resource.labels['instance_id'] if
+        !@resource.nil? && @resource.labels.key?('instance_id')
+      @vm_id ||= fetch_gce_metadata('instance/id') if @platform == Platform::GCE
+      @vm_id ||= ec2_metadata['instanceId'] if @platform == Platform::EC2
+    rescue StandardError => e
+      @log.error 'Failed to obtain vm_id: ', error: e
+    end
+
+    # 1. Return the value if it is explicitly set in the config already.
+    # 2. If not, check if the response from Metadata Agent includes this info.
+    # 3. If not, try to retrieve it locally.
+    def set_vm_name
+      @vm_name ||= @resource.labels['instance_name'] if
+        !@resource.nil? && @resource.labels.key?('instance_name')
+      @vm_name ||= Socket.gethostname
+    rescue StandardError => e
+      @log.error 'Failed to obtain vm name: ', error: e
+    end
+
+    # 1. Return the value if it is explicitly set in the config already.
+    # 2. If not, check if the response from Metadata Agent includes this info.
+    # 3. If not, try to retrieve it locally.
+    def set_location
+      unless @resource.nil?
+        @zone ||= @resource.labels['location'] if
+          @resource.type == DOCKER_CONSTANTS[:resource_type] &&
+          @resource.labels.key?('location')
+        @zone ||= @resource.labels['zone'] if
+          @platform == Platform::GCE && @resource.labels.key?('zone')
+        @zone ||= @resource.labels['region'] if
+          @platform == Platform::EC2 && @resource.labels.key?('region')
+      end
+      # Response format: "projects/<number>/zones/<zone>"
+      @zone ||= fetch_gce_metadata('instance/zone').rpartition('/')[2] if
+        @platform == Platform::GCE
+      @zone ||= 'aws:' + ec2_metadata['availabilityZone'] if
+        @platform == Platform::EC2 && ec2_metadata.key?('availabilityZone')
+    rescue StandardError => e
+      @log.error 'Failed to obtain location: ', error: e
+    end
+
+    # Retrieve monitored resource via the legacy way.
+    #
+    # Note: This is just a failover plan if we fail to get metadata from
+    # Metadata agent. Thus it should be equivalent to what Metadata Agent
+    # returns.
+    def determine_agent_level_monitored_resource_via_legacy
+      resource = Google::Apis::LoggingV2beta1::MonitoredResource.new(
+        labels: {})
+      resource.type = determine_agent_level_monitored_resource_type
+      resource.labels = determine_agent_level_monitored_resource_labels(
+        resource.type)
+      resource
+    end
+
+    # Determine agent level monitored resource type.
+    def determine_agent_level_monitored_resource_type
+      # EC2 instance.
+      return EC2_CONSTANTS[:resource_type] if
         @platform == Platform::EC2
-      # See http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html
-      open('http://' + METADATA_SERVICE_ADDR +
-           '/latest/dynamic/instance-identity/document') do |f|
-        contents = f.read
-        return JSON.parse(contents)
+
+      # Unknown platform will be defaulted to GCE instance..
+      return COMPUTE_CONSTANTS[:resource_type] if
+        @platform == Platform::OTHER
+
+      # Resource types determined by @subservice_name config.
+      # Cloud Dataflow.
+      return DATAFLOW_CONSTANTS[:resource_type] if
+        @subservice_name == DATAFLOW_CONSTANTS[:service]
+      # Cloud ML.
+      return ML_CONSTANTS[:resource_type] if
+        @subservice_name == ML_CONSTANTS[:service]
+      # Default back to GCE if invalid value is detected.
+      return COMPUTE_CONSTANTS[:resource_type] if
+        @subservice_name
+
+      # Resource types determined by @detect_subservice config.
+      if @detect_subservice
+        begin
+          attributes = fetch_gce_metadata('instance/attributes/').split
+        rescue StandardError => e
+          @log.error 'Failed to detect subservice: ', error: e
+        end
+        # GAE app.
+        return APPENGINE_CONSTANTS[:resource_type] if
+          attributes.include?('gae_backend_name') &&
+          attributes.include?('gae_backend_version')
+        # GKE container.
+        return CONTAINER_CONSTANTS[:resource_type] if
+          attributes.include?('kube-env')
+        # Cloud Dataproc.
+        return DATAPROC_CONSTANTS[:resource_type] if
+          attributes.include?('dataproc-cluster-uuid') &&
+          attributes.include?('dataproc-cluster-name')
+      end
+      # GCE instance.
+      COMPUTE_CONSTANTS[:resource_type]
+    end
+
+    # Determine agent level monitored resource labels based on the resource
+    # type. Each resource type has its own labels that need to be filled in.
+    def determine_agent_level_monitored_resource_labels(type)
+      labels = {}
+
+      case type
+
+      # GAE app.
+      when APPENGINE_CONSTANTS[:resource_type]
+        begin
+          labels['module_id'] = fetch_gce_metadata(
+            'instance/attributes/gae_backend_name')
+          labels['version_id'] = fetch_gce_metadata(
+            'instance/attributes/gae_backend_version')
+        rescue StandardError => e
+          @log.error 'Failed to set monitored resource labels for GAE: ',
+                     error: e
+        end
+
+      # GCE.
+      when COMPUTE_CONSTANTS[:resource_type]
+        labels['instance_id'] = @vm_id
+        labels['zone'] = @zone
+
+      # GKE container.
+      when CONTAINER_CONSTANTS[:resource_type]
+        labels['instance_id'] = @vm_id
+        labels['zone'] = @zone
+        begin
+          raw_kube_env = fetch_gce_metadata('instance/attributes/kube-env')
+          kube_env = YAML.load(raw_kube_env)
+          labels['cluster_name'] =
+            cluster_name_from_kube_env(kube_env)
+        rescue StandardError => e
+          @log.error 'Failed to set monitored resource labels for GKE: ',
+                     error: e
+        end
+
+      # Cloud Dataproc.
+      when DATAPROC_CONSTANTS[:resource_type]
+        begin
+          labels['cluster_uuid'] =
+            fetch_gce_metadata('instance/attributes/dataproc-cluster-uuid')
+          labels['cluster_name'] =
+            fetch_gce_metadata('instance/attributes/dataproc-cluster-name')
+          labels['region'] =
+            fetch_gce_metadata('instance/attributes/dataproc-region')
+        rescue StandardError => e
+          @log.error 'Failed to set monitored resource labels for Cloud ' \
+                     'Dataproc: ', error: e
+        end
+
+      # EC2.
+      when EC2_CONSTANTS[:resource_type]
+        labels['instance_id'] = @vm_id
+        labels['region'] = @zone
+        labels['aws_account'] = ec2_metadata['accountId'] if
+          ec2_metadata.key?('accountId')
+      end
+      labels
+    end
+
+    # Determine the common labels that should be added to all log entries
+    # processed by this logging agent.
+    def determine_agent_level_common_labels
+      labels = {}
+      # User can specify labels via config. We want to capture those as well.
+      # TODO: Send instance tags as labels as well?
+      labels.merge!(@labels) if @labels
+
+      case @resource.type
+
+      # GAE app.
+      when APPENGINE_CONSTANTS[:resource_type]
+        labels["#{COMPUTE_CONSTANTS[:service]}/resource_id"] = @vm_id
+        labels["#{COMPUTE_CONSTANTS[:service]}/resource_name"] = @vm_name
+        labels["#{COMPUTE_CONSTANTS[:service]}/zone"] = @zone
+
+      # GCE.
+      when COMPUTE_CONSTANTS[:resource_type]
+        labels["#{COMPUTE_CONSTANTS[:service]}/resource_name"] = @vm_name
+
+      # GKE container.
+      when CONTAINER_CONSTANTS[:resource_type]
+        labels["#{COMPUTE_CONSTANTS[:service]}/resource_name"] = @vm_name
+
+      # Cloud Dataflow and Cloud Dataproc.
+      when DATAFLOW_CONSTANTS[:resource_type],
+           DATAPROC_CONSTANTS[:resource_type]
+        labels["#{COMPUTE_CONSTANTS[:service]}/resource_id"] = @vm_id
+        labels["#{COMPUTE_CONSTANTS[:service]}/resource_name"] = @vm_name
+        labels["#{COMPUTE_CONSTANTS[:service]}/zone"] = @zone
+
+      # EC2.
+      when EC2_CONSTANTS[:resource_type]
+        labels["#{EC2_CONSTANTS[:service]}/resource_name"] = @vm_name
+
+      # Cloud ML.
+      when ML_CONSTANTS[:resource_type]
+        labels["#{COMPUTE_CONSTANTS[:service]}/resource_id"] = @vm_id
+        labels["#{COMPUTE_CONSTANTS[:service]}/resource_name"] = @vm_name
+        labels["#{COMPUTE_CONSTANTS[:service]}/zone"] = @zone
+      end
+      labels
+    end
+
+    # Determine the group level monitored resource and common labels shared by a
+    # collection of entries.
+    def determine_group_level_monitored_resource_and_labels(tag)
+      # Determine group level monitored resource type. For certain types,
+      # extract useful info from the tag and store those in
+      # matched_regexp_group.
+      group_resource_type, matched_regexp_group =
+        determine_group_level_monitored_resource_type(tag)
+
+      # Determine group level monitored resource labels and common labels.
+      group_resource_type, group_resource_labels, group_common_labels = \
+        determine_group_level_labels_and_adjust_type(
+          group_resource_type, matched_regexp_group)
+
+      group_resource = Google::Apis::LoggingV2beta1::MonitoredResource.new(
+        type: group_resource_type,
+        labels: group_resource_labels.to_h
+      )
+
+      # Freeze the per-request state. Any further changes must be made on a
+      # per-entry basis.
+      group_resource.freeze
+      group_resource.labels.freeze
+      group_common_labels.freeze
+
+      [group_resource, group_common_labels]
+    end
+
+    # Determine group level monitored resource type shared by a collection of
+    # entries.
+    # Returns the resource type and tag regexp matched groups. The matched
+    # groups only apply to some resource types. Return nil if not applicable or
+    # if there is no match.
+    def determine_group_level_monitored_resource_type(tag)
+      # Match tag against Cloud Functions format.
+      if @running_cloudfunctions
+        matched_regexp_group = @cloudfunctions_tag_regexp.match(tag)
+        return [CLOUDFUNCTIONS_CONSTANTS[:resource_type],
+                matched_regexp_group] if matched_regexp_group
+      end
+
+      # Match tag against Docker container stderr / stdout log format and
+      # Docker container application log format.
+      matched_regexp_group =
+        # Format: "container.<container_id>.<container_name>"
+        @dockercontainer_tag_regexp.match(tag) ||
+        # Format: "application-container.<container_name>.<additional_tag>"
+        @dockercontainer_tag_with_application_regexp.match(tag)
+      return [DOCKER_CONSTANTS[:resource_type], matched_regexp_group] if
+        matched_regexp_group
+
+      # Match tag against GKE Container format.
+      if @resource.type == CONTAINER_CONSTANTS[:resource_type] &&
+         @compiled_kubernetes_tag_regexp
+        # Container logs in Kubernetes are tagged based on where they came from,
+        # so we can extract useful metadata from the tag. Do this here to avoid
+        # having to repeat it for each record.
+        matched_regexp_group = @compiled_kubernetes_tag_regexp.match(tag)
+        return [@resource.type, matched_regexp_group] if matched_regexp_group
+      end
+
+      # Otherwise, return the original type.
+      [@resource.type, nil]
+    end
+
+    # Determine group level monitored resource labels and common labels. These
+    # labels will be shared by a collection of entries. In certain cases, we
+    # might also adjust the resource type.
+    def determine_group_level_labels_and_adjust_type(group_resource_type,
+                                                     matched_regexp_group)
+      group_resource_labels = @resource.labels.dup
+      group_common_labels = @common_labels.dup
+
+      case group_resource_type
+
+      # Cloud Functions.
+      when CLOUDFUNCTIONS_CONSTANTS[:resource_type]
+        group_resource_labels['region'] = @gcf_region
+        group_resource_labels['function_name'] =
+          decode_cloudfunctions_function_name(
+            matched_regexp_group['encoded_function_name'])
+        instance_id = group_resource_labels.delete('instance_id')
+        group_common_labels["#{CONTAINER_CONSTANTS[:service]}/cluster_name"] =
+          group_resource_labels.delete('cluster_name')
+        group_common_labels["#{CONTAINER_CONSTANTS[:service]}/instance_id"] =
+          instance_id
+        group_common_labels["#{COMPUTE_CONSTANTS[:service]}/resource_id"] =
+          instance_id
+        group_common_labels["#{COMPUTE_CONSTANTS[:service]}/zone"] =
+          group_resource_labels.delete('zone')
+
+      # GKE container.
+      when CONTAINER_CONSTANTS[:resource_type]
+        if matched_regexp_group
+          group_resource_labels['container_name'] =
+            matched_regexp_group['container_name']
+          group_resource_labels['namespace_id'] =
+            matched_regexp_group['namespace_name']
+          group_resource_labels['pod_id'] =
+            matched_regexp_group['pod_name']
+          %w(namespace_name pod_name).each do |field|
+            group_common_labels["#{CONTAINER_CONSTANTS[:service]}/#{field}"] =
+              matched_regexp_group[field]
+          end
+        end
+
+      # Docker container.
+      when DOCKER_CONSTANTS[:resource_type]
+        # For Docker container stderr / stdout logs generated by Docker Fluentd
+        # Logging Driver, tags are in the format of "container.<container_id>.
+        # <container_name>", thus they include 'container_id' info.
+        # For logs generated by applications running in Docker containers,
+        # tags are in the format of "application-container.<container_name>.
+        # <additional_tag>", thus 'container_id' info is unknown yet.
+        # 'container_name' info on the other hand is always available.
+        container_id = matched_regexp_group['container_id'] if
+          matched_regexp_group.names.include? 'container_id'
+        container_name = matched_regexp_group['container_name']
+
+        if @enable_metadata_agent
+          # Call Metadata Agent with "container.<container_id>" or
+          # "application-container.<container_name>" as the locally-unique key
+          # to retrieve monitored resource. This should be different from the
+          # original @resource value that got initiated when the agent starts up
+          # because that one is always at the VM level.
+          if container_id
+            locally_unique_id = "container.#{container_id}"
+          else
+            locally_unique_id = "containerName.#{container_name}"
+          end
+          retrieved_resource = call_metadata_agent_for_monitored_resource(
+            locally_unique_id)
+        end
+
+        if @enable_metadata_agent && !retrieved_resource.nil?
+          # If we successfully get a monitored resource from Metadata Agent,
+          # use this one instead of the original VM-level monitored resource.
+          group_resource_labels = retrieved_resource.labels.dup
+          @log.debug 'Retrieved monitored resource from Metadata Agent: ' \
+                     "#{retrieved_resource.inspect}."
+        else
+          # If Metadata Agent is not enabled, or we failed to get a monitored
+          # resource, we need to have some backup plan.
+          @log.debug 'Metadata agent not enabled or failed to retrieve ' \
+                     'docker container monitored resource from Metadata ' \
+                     'Agent.'
+
+          # 1. Check if 'container_id' is set already. It should be available
+          #    for stdout / stderr). If so, use that.
+          # 2. If not, call Docker Remote API to calculate container id from
+          #    container name, but only if @call_docker_api_locally is true.
+          container_id ||= retrieve_container_id_by_name_locally(
+            container_name) if @call_docker_api_locally
+          unless container_id
+            @log.debug 'No docker container id retrieved. Falling back to
+                        instance monitored resource.'
+            # If a container id is not available, fall back to the instance
+            # monitored resource.
+            return [COMPUTE_CONSTANTS[:resource_type], group_resource_labels,
+                    group_common_labels]
+          end
+          group_resource_labels['container_id'] = container_id
+          # 'zone' for GCP and 'region' for EC2 must have been set at this
+          # point. Rename them to 'location'.
+          group_resource_labels['location'] = @zone
+          if @platform == Platform::EC2
+            group_resource_labels.delete('region')
+          else
+            group_resource_labels.delete('zone')
+          end
+          # vm id info should be reported as a metadata label instead.
+          group_resource_labels.delete('instance_id')
+
+        end
+        # Set metadata labels.
+        group_common_labels["#{DOCKER_CONSTANTS[:service]}/container_name"] =
+          matched_regexp_group['container_name']
+        group_common_labels["#{COMPUTE_CONSTANTS[:service]}/resource_id"] =
+          @vm_id
+      end
+
+      [group_resource_type, group_resource_labels, group_common_labels]
+    end
+
+    # Extract entry resource and common labels that should be applied to
+    # individual entries from the group resource.
+    def determine_entry_level_labels(group_resource, record)
+      resource_labels = {}
+      common_labels = {}
+
+      # Cloud Functions.
+      if group_resource.type == CLOUDFUNCTIONS_CONSTANTS[:resource_type] &&
+         record.key?('log')
+        @cloudfunctions_log_match =
+          @cloudfunctions_log_regexp.match(record['log'])
+        common_labels['execution_id'] =
+          @cloudfunctions_log_match['execution_id'] if \
+            @cloudfunctions_log_match &&
+            @cloudfunctions_log_match['execution_id']
+      end
+
+      # GKE containers.
+      if group_resource.type == CONTAINER_CONSTANTS[:resource_type]
+        # Move the stdout/stderr annotation from the record into a label.
+        common_labels.merge!(
+          fields_to_labels(
+            record, 'stream' => "#{CONTAINER_CONSTANTS[:service]}/stream"))
+
+        # If the record has been annotated by the kubernetes_metadata_filter
+        # plugin, then use that metadata. Otherwise, rely on commonLabels
+        # populated at the grouped_entries level from the group's tag.
+        if record.key?('kubernetes')
+          extracted_resource_labels, extracted_common_labels = \
+            extract_container_metadata(record)
+          resource_labels.merge!(extracted_resource_labels)
+          common_labels.merge!(extracted_common_labels)
+        end
+      end
+
+      # Docker containers.
+      if group_resource.type == DOCKER_CONSTANTS[:resource_type]
+        # For logs coming from Docker Fluentd Logging Driver, the log record
+        # has 4 fields: 'container_id', 'container_name', 'source' and 'log'.
+        # Extract 'container_id', 'container_name' and 'source' from json
+        # record, set corresponding labels, and remove these fields from record.
+        {
+          'container_name' => 'container_name',
+          'source' => 'stream'
+        }.each do |field_name, label_name|
+          common_labels.merge!(
+            fields_to_labels(
+              record,
+              field_name => "#{DOCKER_CONSTANTS[:service]}/#{label_name}"
+            )
+          )
+        end
+        resource_labels.merge!(
+          fields_to_labels(record, 'container_id' => 'container_id'))
+      end
+
+      # If the name of a field in the record is present in the @label_map
+      # configured by users, report its value as a label and do not send that
+      # field as part of the payload.
+      common_labels.merge!(fields_to_labels(record, @label_map))
+
+      resource_labels.merge!(
+        extract_resource_labels(group_resource.type, common_labels))
+
+      [resource_labels, common_labels]
+    end
+
+    # Call Metadata Agent to get monitored resource information and parse
+    # response to Google::Api::MonitoredResource.
+    def call_metadata_agent_for_monitored_resource(unique_key)
+      response = call_metadata_agent("monitoredResource/#{unique_key}")
+      return nil if response.nil?
+      begin
+        resource = Google::Api::MonitoredResource.decode_json(response.to_json)
+      rescue Google::Protobuf::ParseError, ArgumentError => e
+        @log.error 'Error paring monitored resource from Metadata Agent. ' \
+                   "response: #{response.inspect}", error: e
+        return nil
+      end
+
+      # TODO(lingshi): Use Google::Api::MonitoredResource directly after we
+      # upgrade gRPC version to include the fix for the protobuf map
+      # corruption issue.
+      Google::Apis::LoggingV2beta1::MonitoredResource.new(
+        type: resource.type,
+        labels: resource.labels.to_h
+      )
+    end
+
+    # Call Metadata Agent and parse response to json. Return nil in case of any
+    # error / failure.
+    def call_metadata_agent(path)
+      url = "#{@metadata_agent_url}/#{path}"
+      @log.debug("Calling Metadata Agent: #{url}")
+      open(url) do |f|
+        response = f.read
+        parsed_hash = parse_json_or_nil(response)
+        if parsed_hash.nil?
+          @log.error 'Response from Metadata Agent is not in valid json ' \
+                     "format: '#{response.inspect}'."
+          return nil
+        end
+        @log.debug "Response from Metadata Agent: #{parsed_hash}"
+        return parsed_hash
       end
+    rescue StandardError => e
+      @log.error 'Error calling Metadata Agent.', error: e
+      return nil
     end
 
     # TODO: This functionality should eventually be available in another
@@ -838,11 +1236,28 @@ module Fluent
       end
     end
 
-    def detect_cloudfunctions(attributes)
-      return unless attributes.include?('gcf_region')
-      # Cloud Functions detected
-      @running_cloudfunctions = true
-      @gcf_region = fetch_gce_metadata('instance/attributes/gcf_region')
+    # Calling Docker Remote API to get container id by name.
+    def retrieve_container_id_by_name_locally(container_name)
+      response = Excon.get(
+        "unix:///containers/#{container_name}/json",
+        socket: @docker_remote_api_socket_path)
+      @log.debug "Response from Docker API with name '#{container_name}': " \
+                 "#{response.inspect}."
+      return parse_container_id_from_docker_api_response(response)
+    rescue StandardError => e
+      @log.error 'Error calling Docker API to get container id.', error: e
+      return nil
+    end
+
+    # Parse the container id from Docker Remote API response.
+    # TODO(qingling128) Add a config for Docker API version to support parsing
+    # different versions of Docker Remote API when the format varies.
+    def parse_container_id_from_docker_api_response(response)
+      JSON.parse(response.data[:body])['Id']
+    rescue StandardError => e
+      @log.error 'Error parsing Docker API response to get container id.',
+                 error: e
+      return nil
     end
 
     def cluster_name_from_kube_env(kube_env)
@@ -915,9 +1330,14 @@ module Fluent
         end
       elsif record.key?('severity')
         return parse_severity(record.delete('severity'))
-      elsif resource_type == CONTAINER_CONSTANTS[:resource_type] &&
-            entry_common_labels.key?("#{CONTAINER_CONSTANTS[:service]}/stream")
-        stream = entry_common_labels["#{CONTAINER_CONSTANTS[:service]}/stream"]
+      elsif [CONTAINER_CONSTANTS[:resource_type],
+             DOCKER_CONSTANTS[:resource_type]].include?(resource_type)
+        stream = entry_common_labels[
+          "#{CONTAINER_CONSTANTS[:service]}/stream"] if
+           resource_type == CONTAINER_CONSTANTS[:resource_type]
+        stream = entry_common_labels[
+          "#{DOCKER_CONSTANTS[:service]}/stream"] if
+           resource_type == DOCKER_CONSTANTS[:resource_type]
         if stream == 'stdout'
           return 'INFO'
         elsif stream == 'stderr'
@@ -1125,6 +1545,24 @@ module Fluent
       [resource_labels, common_labels]
     end
 
+    def format(tag, time, record)
+      [tag, time, record].to_msgpack
+    end
+
+    # Given a tag, returns the corresponding valid tag if possible, or nil if
+    # the tag should be rejected. If 'require_valid_tags' is false, non-string
+    # tags are converted to strings, and invalid characters are sanitized;
+    # otherwise such tags are rejected.
+    def sanitize_tag(tag)
+      if @require_valid_tags &&
+         (!tag.is_a?(String) || tag == '' || convert_to_utf8(tag) != tag)
+        return nil
+      end
+      tag = convert_to_utf8(tag.to_s)
+      tag = '_' if tag == ''
+      tag
+    end
+
     # For every original_label => new_label pair in the label_map, delete the
     # original_label from the record if it exists, and extract the value to form
     # a map with the new_label as the key.
@@ -1152,7 +1590,8 @@ module Fluent
         entry.text_payload = record['log']
       elsif is_json
         entry.json_payload = record
-      elsif resource_type == CONTAINER_CONSTANTS[:resource_type] &&
+      elsif [CONTAINER_CONSTANTS[:resource_type],
+             DOCKER_CONSTANTS[:resource_type]].include?(resource_type) &&
             record.key?('log')
         entry.text_payload = record['log']
       elsif record.size == 1 && record.key?('message')
@@ -1222,7 +1661,8 @@ module Fluent
         entry.text_payload = convert_to_utf8(record['log'])
       elsif is_json
         entry.json_payload = struct_from_ruby(record)
-      elsif resource_type == CONTAINER_CONSTANTS[:resource_type] &&
+      elsif [CONTAINER_CONSTANTS[:resource_type],
+             DOCKER_CONSTANTS[:resource_type]].include?(resource_type) &&
             record.key?('log')
         entry.text_payload = convert_to_utf8(record['log'])
       elsif record.size == 1 && record.key?('message')
@@ -1235,7 +1675,7 @@ module Fluent
     def log_name(tag, resource)
       if resource.type == CLOUDFUNCTIONS_CONSTANTS[:resource_type]
         tag = 'cloud-functions'
-      elsif @running_on_managed_vm
+      elsif resource.type == APPENGINE_CONSTANTS[:resource_type]
         # Add a prefix to Managed VM logs to prevent namespace collisions.
         tag = "#{APPENGINE_CONSTANTS[:service]}/#{tag}"
       elsif resource.type == CONTAINER_CONSTANTS[:resource_type]
@@ -1265,6 +1705,9 @@ module Fluent
       elsif resource_type == ML_CONSTANTS[:resource_type]
         label_prefix = ML_CONSTANTS[:service]
         labels_to_extract = %w(job_id task_name)
+      elsif resource_type == DOCKER_CONSTANTS[:resource_type]
+        label_prefix = DOCKER_CONSTANTS[:service]
+        labels_to_extract = %w(container_id)
       else
         return extracted_labels
       end