google-api-client 0.9.8 → 0.9.20

data/generated/google/apis/logging_v2beta1/classes.rb

@@ -22,70 +22,84 @@ module Google
   module Apis
     module LoggingV2beta1
       
-      # A generic empty message that you can re-use to avoid defining duplicated empty
-      # messages in your APIs. A typical example is to use it as the request or the
-      # response type of an API method. For instance: service Foo ` rpc Bar(google.
-      # protobuf.Empty) returns (google.protobuf.Empty); ` The JSON representation for
-      # `Empty` is empty JSON object ````.
-      class Empty
+      # Result returned from `ListLogEntries`.
+      class ListLogEntriesResponse
         include Google::Apis::Core::Hashable
       
+        # A list of log entries.
+        # Corresponds to the JSON property `entries`
+        # @return [Array<Google::Apis::LoggingV2beta1::LogEntry>]
+        attr_accessor :entries
+      
+        # If there might be more results than appear in this response, then
+        # `nextPageToken` is included.  To get the next set of results, call this
+        # method again using the value of `nextPageToken` as `pageToken`.
+        # Corresponds to the JSON property `nextPageToken`
+        # @return [String]
+        attr_accessor :next_page_token
+      
         def initialize(**args)
            update!(**args)
         end
       
         # Update properties of this object
         def update!(**args)
+          @entries = args[:entries] if args.key?(:entries)
+          @next_page_token = args[:next_page_token] if args.key?(:next_page_token)
         end
       end
       
-      # The parameters to WriteLogEntries.
-      class WriteLogEntriesRequest
+      # Result returned from `ListSinks`.
+      class ListSinksResponse
         include Google::Apis::Core::Hashable
       
-        # Optional. A default log resource name for those log entries in `entries` that
-        # do not specify their own `logName`. Example: `"projects/my-project/logs/syslog"
-        # `. See LogEntry.
-        # Corresponds to the JSON property `logName`
+        # If there might be more results than appear in this response, then
+        # `nextPageToken` is included.  To get the next set of results, call the same
+        # method again using the value of `nextPageToken` as `pageToken`.
+        # Corresponds to the JSON property `nextPageToken`
         # @return [String]
-        attr_accessor :log_name
+        attr_accessor :next_page_token
       
-        # An object representing a resource that can be used for monitoring, logging,
-        # billing, or other purposes. Examples include virtual machine instances,
-        # databases, and storage devices such as disks. The `type` field identifies a
-        # MonitoredResourceDescriptor object that describes the resource's schema.
-        # Information in the `labels` field identifies the actual resource and its
-        # attributes according to the schema. For example, a particular Compute Engine
-        # VM instance could be represented by the following object, because the
-        # MonitoredResourceDescriptor for `"gce_instance"` has labels `"instance_id"`
-        # and `"zone"`: ` "type": "gce_instance", "labels": ` "instance_id": "my-
-        # instance", "zone": "us-central1-a" ``
-        # Corresponds to the JSON property `resource`
-        # @return [Google::Apis::LoggingV2beta1::MonitoredResource]
-        attr_accessor :resource
+        # A list of sinks.
+        # Corresponds to the JSON property `sinks`
+        # @return [Array<Google::Apis::LoggingV2beta1::LogSink>]
+        attr_accessor :sinks
       
-        # Optional. User-defined `key:value` items that are added to the `labels` field
-        # of each log entry in `entries`, except when a log entry specifies its own `key:
-        # value` item with the same key. Example: `` "size": "large", "color":"red" ``
-        # Corresponds to the JSON property `labels`
-        # @return [Hash<String,String>]
-        attr_accessor :labels
+        def initialize(**args)
+           update!(**args)
+        end
       
-        # Required. The log entries to write. The log entries must have values for all
-        # required fields.
-        # Corresponds to the JSON property `entries`
-        # @return [Array<Google::Apis::LoggingV2beta1::LogEntry>]
-        attr_accessor :entries
+        # Update properties of this object
+        def update!(**args)
+          @next_page_token = args[:next_page_token] if args.key?(:next_page_token)
+          @sinks = args[:sinks] if args.key?(:sinks)
+        end
+      end
       
-        # Optional. Whether valid entries should be written even if some other entries
-        # fail due to INVALID_ARGUMENT or PERMISSION_DENIED errors. If any entry is not
-        # written, the response status will be the error associated with one of the
-        # failed entries and include error details in the form of
-        # WriteLogEntriesPartialErrors.
-        # Corresponds to the JSON property `partialSuccess`
-        # @return [Boolean]
-        attr_accessor :partial_success
-        alias_method :partial_success?, :partial_success
+      # Specifies a location in a source code file.
+      class SourceLocation
+        include Google::Apis::Core::Hashable
+      
+        # Source file name. Depending on the runtime environment, this might be a
+        # simple name or a fully-qualified name.
+        # Corresponds to the JSON property `file`
+        # @return [String]
+        attr_accessor :file
+      
+        # Human-readable name of the function or method being invoked, with optional
+        # context such as the class or package name. This information is used in
+        # contexts such as the logs viewer, where a file and line number are less
+        # meaningful. The format can vary by language. For example:
+        # `qual.if.ied.Class.method` (Java), `dir/package.func` (Go), `function`
+        # (Python).
+        # Corresponds to the JSON property `functionName`
+        # @return [String]
+        attr_accessor :function_name
+      
+        # Line within the source file.
+        # Corresponds to the JSON property `line`
+        # @return [String]
+        attr_accessor :line
       
         def initialize(**args)
            update!(**args)
@@ -93,40 +107,81 @@ module Google
       
         # Update properties of this object
         def update!(**args)
-          @log_name = args[:log_name] if args.key?(:log_name)
-          @resource = args[:resource] if args.key?(:resource)
-          @labels = args[:labels] if args.key?(:labels)
-          @entries = args[:entries] if args.key?(:entries)
-          @partial_success = args[:partial_success] if args.key?(:partial_success)
+          @file = args[:file] if args.key?(:file)
+          @function_name = args[:function_name] if args.key?(:function_name)
+          @line = args[:line] if args.key?(:line)
         end
       end
       
-      # An object representing a resource that can be used for monitoring, logging,
-      # billing, or other purposes. Examples include virtual machine instances,
-      # databases, and storage devices such as disks. The `type` field identifies a
-      # MonitoredResourceDescriptor object that describes the resource's schema.
-      # Information in the `labels` field identifies the actual resource and its
-      # attributes according to the schema. For example, a particular Compute Engine
-      # VM instance could be represented by the following object, because the
-      # MonitoredResourceDescriptor for `"gce_instance"` has labels `"instance_id"`
-      # and `"zone"`: ` "type": "gce_instance", "labels": ` "instance_id": "my-
-      # instance", "zone": "us-central1-a" ``
-      class MonitoredResource
+      # Describes a sink used to export log entries outside of Stackdriver Logging.
+      # A logs filter controls which log entries are exported.  Sinks can have a
+      # start time and an end time; these can be used to place log entries from an
+      # exact time range into a particular destination.  If both `start_time` and
+      # `end_time` are present, then `start_time` must be less than `end_time`.
+      class LogSink
         include Google::Apis::Core::Hashable
       
-        # Required. The monitored resource type. This field must match the `type` field
-        # of a MonitoredResourceDescriptor object. For example, the type of a Cloud SQL
-        # database is `"cloudsql_database"`.
-        # Corresponds to the JSON property `type`
+        # Required. The export destination. See
+        # [Exporting Logs With Sinks](/logging/docs/api/tasks/exporting-logs).
+        # Examples:
+        # "storage.googleapis.com/my-gcs-bucket"
+        # "bigquery.googleapis.com/projects/my-project-id/datasets/my-dataset"
+        # "pubsub.googleapis.com/projects/my-project/topics/my-topic"
+        # Corresponds to the JSON property `destination`
         # @return [String]
-        attr_accessor :type
+        attr_accessor :destination
       
-        # Required. Values for all of the labels listed in the associated monitored
-        # resource descriptor. For example, Cloud SQL databases use the labels `"
-        # database_id"` and `"zone"`.
-        # Corresponds to the JSON property `labels`
-        # @return [Hash<String,String>]
-        attr_accessor :labels
+        # Optional. An [advanced logs filter](/logging/docs/view/advanced_filters).
+        # Only log entries matching the filter are exported. The filter
+        # must be consistent with the log entry format specified by the
+        # `outputVersionFormat` parameter, regardless of the format of the
+        # log entry that was originally written to Stackdriver Logging.
+        # Example filter (V2 format):
+        # logName=projects/my-projectid/logs/syslog AND severity>=ERROR
+        # The maximum length of the filter is 20000 characters.
+        # Corresponds to the JSON property `filter`
+        # @return [String]
+        attr_accessor :filter
+      
+        # Optional. Time at which this sink will stop exporting log entries.  If this
+        # value is present, then log entries are exported only if `entry.timestamp` <
+        # `end_time`.
+        # Corresponds to the JSON property `endTime`
+        # @return [String]
+        attr_accessor :end_time
+      
+        # Required. The client-assigned sink identifier, unique within the
+        # project. Example: `"my-syslog-errors-to-pubsub"`.  Sink identifiers are
+        # limited to 1000 characters and can include only the following characters:
+        # `A-Z`, `a-z`, `0-9`, and the special characters `_-.`.  The maximum length
+        # of the name is 100 characters.
+        # Corresponds to the JSON property `name`
+        # @return [String]
+        attr_accessor :name
+      
+        # Optional. The time at which this sink will begin exporting log entries.  If
+        # this value is present, then log entries are exported only if `start_time`
+        # <=`entry.timestamp`.
+        # Corresponds to the JSON property `startTime`
+        # @return [String]
+        attr_accessor :start_time
+      
+        # Optional. The log entry version to use for this sink's exported log
+        # entries.  This version does not have to correspond to the version of the
+        # log entry that was written to Stackdriver Logging. If omitted, the
+        # v2 format is used.
+        # Corresponds to the JSON property `outputVersionFormat`
+        # @return [String]
+        attr_accessor :output_version_format
+      
+        # Output only. An IAM identity&mdash;a service account or group&mdash;that
+        # will write exported log entries to the destination on behalf of Stackdriver
+        # Logging. You must grant this identity write-access to the destination.
+        # Consult the destination service's documentation to determine the exact role
+        # that must be granted.
+        # Corresponds to the JSON property `writerIdentity`
+        # @return [String]
+        attr_accessor :writer_identity
       
         def initialize(**args)
            update!(**args)
@@ -134,8 +189,62 @@ module Google
       
         # Update properties of this object
         def update!(**args)
-          @type = args[:type] if args.key?(:type)
-          @labels = args[:labels] if args.key?(:labels)
+          @destination = args[:destination] if args.key?(:destination)
+          @filter = args[:filter] if args.key?(:filter)
+          @end_time = args[:end_time] if args.key?(:end_time)
+          @name = args[:name] if args.key?(:name)
+          @start_time = args[:start_time] if args.key?(:start_time)
+          @output_version_format = args[:output_version_format] if args.key?(:output_version_format)
+          @writer_identity = args[:writer_identity] if args.key?(:writer_identity)
+        end
+      end
+      
+      # Describes a logs-based metric.  The value of the metric is the
+      # number of log entries that match a logs filter.
+      class LogMetric
+        include Google::Apis::Core::Hashable
+      
+        # Optional. A description of this metric, which is used in documentation.
+        # Corresponds to the JSON property `description`
+        # @return [String]
+        attr_accessor :description
+      
+        # Required. An [advanced logs filter](/logging/docs/view/advanced_filters).
+        # Example: `"resource.type=gae_app AND severity>=ERROR"`.
+        # The maximum length of the filter is 20000 characters.
+        # Corresponds to the JSON property `filter`
+        # @return [String]
+        attr_accessor :filter
+      
+        # Required. The client-assigned metric identifier. Example:
+        # `"severe_errors"`.  Metric identifiers are limited to 100
+        # characters and can include only the following characters: `A-Z`,
+        # `a-z`, `0-9`, and the special characters `_-.,+!*',()%/`.  The
+        # forward-slash character (`/`) denotes a hierarchy of name pieces,
+        # and it cannot be the first character of the name.  The '%' character
+        # is used to URL encode unsafe and reserved characters and must be
+        # followed by two hexadecimal digits according to RFC 1738.
+        # Corresponds to the JSON property `name`
+        # @return [String]
+        attr_accessor :name
+      
+        # Output only. The API version that created or updated this metric.
+        # The version also dictates the syntax of the filter expression. When a value
+        # for this field is missing, the default value of V2 should be assumed.
+        # Corresponds to the JSON property `version`
+        # @return [String]
+        attr_accessor :version
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @description = args[:description] if args.key?(:description)
+          @filter = args[:filter] if args.key?(:filter)
+          @name = args[:name] if args.key?(:name)
+          @version = args[:version] if args.key?(:version)
         end
       end
       
@@ -143,82 +252,90 @@ module Google
       class LogEntry
         include Google::Apis::Core::Hashable
       
-        # Required. The resource name of the log to which this log entry belongs. The
-        # format of the name is `"projects/
-        # /logs/"`. Examples: `"projects/my-projectid/logs/syslog"`, `"projects/
-        # 1234567890/logs/library.googleapis.com%2Fbook_log"`. The log ID part of
-        # resource name must be less than 512 characters long and can only include the
-        # following characters: upper and lower case alphanumeric characters: [A-Za-z0-9]
-        # ; and punctuation characters: forward-slash, underscore, hyphen, and period.
+        # The log entry payload, represented as a Unicode string (UTF-8).
+        # Corresponds to the JSON property `textPayload`
+        # @return [String]
+        attr_accessor :text_payload
+      
+        # A common proto for logging HTTP requests. Only contains semantics
+        # defined by the HTTP specification. Product-specific logging
+        # information MUST be defined in a separate message.
+        # Corresponds to the JSON property `httpRequest`
+        # @return [Google::Apis::LoggingV2beta1::HttpRequest]
+        attr_accessor :http_request
+      
+        # The log entry payload, represented as a structure that
+        # is expressed as a JSON object.
+        # Corresponds to the JSON property `jsonPayload`
+        # @return [Hash<String,Object>]
+        attr_accessor :json_payload
+      
+        # Optional. A set of user-defined (key, value) data that provides additional
+        # information about the log entry.
+        # Corresponds to the JSON property `labels`
+        # @return [Hash<String,String>]
+        attr_accessor :labels
+      
+        # Required. The resource name of the log to which this log entry
+        # belongs. The format of the name is
+        # `"projects/<project-id>/logs/<log-id>"`.  Examples:
+        # `"projects/my-projectid/logs/syslog"`,
+        # `"projects/my-projectid/logs/library.googleapis.com%2Fbook_log"`.
+        # The log ID part of resource name must be less than 512 characters
+        # long and can only include the following characters: upper and
+        # lower case alphanumeric characters: [A-Za-z0-9]; and punctuation
+        # characters: forward-slash, underscore, hyphen, and period.
         # Forward-slash (`/`) characters in the log ID must be URL-encoded.
         # Corresponds to the JSON property `logName`
         # @return [String]
         attr_accessor :log_name
       
+        # Optional. The severity of the log entry. The default value is
+        # `LogSeverity.DEFAULT`.
+        # Corresponds to the JSON property `severity`
+        # @return [String]
+        attr_accessor :severity
+      
         # An object representing a resource that can be used for monitoring, logging,
         # billing, or other purposes. Examples include virtual machine instances,
         # databases, and storage devices such as disks. The `type` field identifies a
-        # MonitoredResourceDescriptor object that describes the resource's schema.
-        # Information in the `labels` field identifies the actual resource and its
-        # attributes according to the schema. For example, a particular Compute Engine
-        # VM instance could be represented by the following object, because the
-        # MonitoredResourceDescriptor for `"gce_instance"` has labels `"instance_id"`
-        # and `"zone"`: ` "type": "gce_instance", "labels": ` "instance_id": "my-
-        # instance", "zone": "us-central1-a" ``
+        # MonitoredResourceDescriptor object that describes the resource's
+        # schema. Information in the `labels` field identifies the actual resource and
+        # its attributes according to the schema. For example, a particular Compute
+        # Engine VM instance could be represented by the following object, because the
+        # MonitoredResourceDescriptor for `"gce_instance"` has labels
+        # `"instance_id"` and `"zone"`:
+        # ` "type": "gce_instance",
+        # "labels": ` "instance_id": "12345678901234",
+        # "zone": "us-central1-a" ``
         # Corresponds to the JSON property `resource`
         # @return [Google::Apis::LoggingV2beta1::MonitoredResource]
         attr_accessor :resource
       
-        # The log entry payload, represented as a protocol buffer. You can only use `
-        # protoPayload` values that belong to a set of approved types.
+        # The log entry payload, represented as a protocol buffer.  Some
+        # Google Cloud Platform services use this field for their log
+        # entry payloads.
         # Corresponds to the JSON property `protoPayload`
         # @return [Hash<String,Object>]
         attr_accessor :proto_payload
       
-        # The log entry payload, represented as a Unicode string (UTF-8).
-        # Corresponds to the JSON property `textPayload`
-        # @return [String]
-        attr_accessor :text_payload
-      
-        # The log entry payload, represented as a structure that is expressed as a JSON
-        # object.
-        # Corresponds to the JSON property `jsonPayload`
-        # @return [Hash<String,Object>]
-        attr_accessor :json_payload
-      
-        # Optional. The time the event described by the log entry occurred. If omitted,
-        # Cloud Logging will use the time the log entry is written.
+        # Optional. The time the event described by the log entry occurred.  If
+        # omitted, Stackdriver Logging will use the time the log entry is received.
         # Corresponds to the JSON property `timestamp`
         # @return [String]
         attr_accessor :timestamp
       
-        # Optional. The severity of the log entry. The default value is `LogSeverity.
-        # DEFAULT`.
-        # Corresponds to the JSON property `severity`
-        # @return [String]
-        attr_accessor :severity
-      
-        # Optional. A unique ID for the log entry. If you provide this field, the
-        # logging service considers other log entries in the same log with the same ID
-        # as duplicates which can be removed. If omitted, Cloud Logging will generate a
-        # unique ID for this log entry.
+        # Optional. A unique ID for the log entry. If you provide this
+        # field, the logging service considers other log entries in the
+        # same project with the same ID as duplicates which can be removed.  If
+        # omitted, Stackdriver Logging will generate a unique ID for this
+        # log entry.
         # Corresponds to the JSON property `insertId`
         # @return [String]
         attr_accessor :insert_id
       
-        # A common proto for logging HTTP requests.
-        # Corresponds to the JSON property `httpRequest`
-        # @return [Google::Apis::LoggingV2beta1::HttpRequest]
-        attr_accessor :http_request
-      
-        # Optional. A set of user-defined (key, value) data that provides additional
-        # information about the log entry.
-        # Corresponds to the JSON property `labels`
-        # @return [Hash<String,String>]
-        attr_accessor :labels
-      
-        # Additional information about a potentially long-running operation with which a
-        # log entry is associated.
+        # Additional information about a potentially long-running operation with which
+        # a log entry is associated.
         # Corresponds to the JSON property `operation`
         # @return [Google::Apis::LoggingV2beta1::LogEntryOperation]
         attr_accessor :operation
@@ -229,94 +346,73 @@ module Google
       
         # Update properties of this object
         def update!(**args)
+          @text_payload = args[:text_payload] if args.key?(:text_payload)
+          @http_request = args[:http_request] if args.key?(:http_request)
+          @json_payload = args[:json_payload] if args.key?(:json_payload)
+          @labels = args[:labels] if args.key?(:labels)
           @log_name = args[:log_name] if args.key?(:log_name)
+          @severity = args[:severity] if args.key?(:severity)
           @resource = args[:resource] if args.key?(:resource)
           @proto_payload = args[:proto_payload] if args.key?(:proto_payload)
-          @text_payload = args[:text_payload] if args.key?(:text_payload)
-          @json_payload = args[:json_payload] if args.key?(:json_payload)
           @timestamp = args[:timestamp] if args.key?(:timestamp)
-          @severity = args[:severity] if args.key?(:severity)
           @insert_id = args[:insert_id] if args.key?(:insert_id)
-          @http_request = args[:http_request] if args.key?(:http_request)
-          @labels = args[:labels] if args.key?(:labels)
           @operation = args[:operation] if args.key?(:operation)
         end
       end
       
-      # A common proto for logging HTTP requests.
-      class HttpRequest
+      # Application log line emitted while processing a request.
+      class LogLine
         include Google::Apis::Core::Hashable
       
-        # The request method. Examples: `"GET"`, `"HEAD"`, `"PUT"`, `"POST"`.
-        # Corresponds to the JSON property `requestMethod`
-        # @return [String]
-        attr_accessor :request_method
-      
-        # The scheme (http, https), the host name, the path and the query portion of the
-        # URL that was requested. Example: `"http://example.com/some/info?color=red"`.
-        # Corresponds to the JSON property `requestUrl`
+        # Approximate time when this log entry was made.
+        # Corresponds to the JSON property `time`
         # @return [String]
-        attr_accessor :request_url
+        attr_accessor :time
       
-        # The size of the HTTP request message in bytes, including the request headers
-        # and the request body.
-        # Corresponds to the JSON property `requestSize`
+        # Severity of this log entry.
+        # Corresponds to the JSON property `severity`
         # @return [String]
-        attr_accessor :request_size
+        attr_accessor :severity
       
-        # The response code indicating the status of response. Examples: 200, 404.
-        # Corresponds to the JSON property `status`
-        # @return [Fixnum]
-        attr_accessor :status
+        # Specifies a location in a source code file.
+        # Corresponds to the JSON property `sourceLocation`
+        # @return [Google::Apis::LoggingV2beta1::SourceLocation]
+        attr_accessor :source_location
       
-        # The size of the HTTP response message sent back to the client, in bytes,
-        # including the response headers and the response body.
-        # Corresponds to the JSON property `responseSize`
+        # App-provided log message.
+        # Corresponds to the JSON property `logMessage`
         # @return [String]
-        attr_accessor :response_size
+        attr_accessor :log_message
       
-        # The user agent sent by the client. Example: `"Mozilla/4.0 (compatible; MSIE 6.
-        # 0; Windows 98; Q312461; .NET CLR 1.0.3705)"`.
-        # Corresponds to the JSON property `userAgent`
-        # @return [String]
-        attr_accessor :user_agent
+        def initialize(**args)
+           update!(**args)
+        end
       
-        # The IP address (IPv4 or IPv6) of the client that issued the HTTP request.
-        # Examples: `"192.168.1.1"`, `"FE80::0202:B3FF:FE1E:8329"`.
-        # Corresponds to the JSON property `remoteIp`
-        # @return [String]
-        attr_accessor :remote_ip
+        # Update properties of this object
+        def update!(**args)
+          @time = args[:time] if args.key?(:time)
+          @severity = args[:severity] if args.key?(:severity)
+          @source_location = args[:source_location] if args.key?(:source_location)
+          @log_message = args[:log_message] if args.key?(:log_message)
+        end
+      end
       
-        # The referer URL of the request, as defined in [HTTP/1.1 Header Field
-        # Definitions](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html).
-        # Corresponds to the JSON property `referer`
-        # @return [String]
-        attr_accessor :referer
-      
-        # Whether or not a cache lookup was attempted.
-        # Corresponds to the JSON property `cacheLookup`
-        # @return [Boolean]
-        attr_accessor :cache_lookup
-        alias_method :cache_lookup?, :cache_lookup
-      
-        # Whether or not an entity was served from cache (with or without validation).
-        # Corresponds to the JSON property `cacheHit`
-        # @return [Boolean]
-        attr_accessor :cache_hit
-        alias_method :cache_hit?, :cache_hit
+      # A reference to a particular snapshot of the source tree used to build and
+      # deploy an application.
+      class SourceReference
+        include Google::Apis::Core::Hashable
       
-        # Whether or not the response was validated with the origin server before being
-        # served from cache. This field is only meaningful if `cache_hit` is True.
-        # Corresponds to the JSON property `cacheValidatedWithOriginServer`
-        # @return [Boolean]
-        attr_accessor :cache_validated_with_origin_server
-        alias_method :cache_validated_with_origin_server?, :cache_validated_with_origin_server
+        # Optional. A URI string identifying the repository.
+        # Example: "https://github.com/GoogleCloudPlatform/kubernetes.git"
+        # Corresponds to the JSON property `repository`
+        # @return [String]
+        attr_accessor :repository
       
-        # The number of HTTP response bytes inserted into cache. Set only when a cache
-        # fill was attempted.
-        # Corresponds to the JSON property `cacheFillBytes`
+        # The canonical and persistent identifier of the deployed revision.
+        # Example (git): "0035781c50ec7aa23385dc841529ce8a4b70db1b"
+        # Corresponds to the JSON property `revisionId`
         # @return [String]
-        attr_accessor :cache_fill_bytes
+        attr_accessor :revision_id
       
         def initialize(**args)
            update!(**args)
@@ -324,67 +420,39 @@ module Google
       
         # Update properties of this object
         def update!(**args)
-          @request_method = args[:request_method] if args.key?(:request_method)
-          @request_url = args[:request_url] if args.key?(:request_url)
-          @request_size = args[:request_size] if args.key?(:request_size)
-          @status = args[:status] if args.key?(:status)
-          @response_size = args[:response_size] if args.key?(:response_size)
-          @user_agent = args[:user_agent] if args.key?(:user_agent)
-          @remote_ip = args[:remote_ip] if args.key?(:remote_ip)
-          @referer = args[:referer] if args.key?(:referer)
-          @cache_lookup = args[:cache_lookup] if args.key?(:cache_lookup)
-          @cache_hit = args[:cache_hit] if args.key?(:cache_hit)
-          @cache_validated_with_origin_server = args[:cache_validated_with_origin_server] if args.key?(:cache_validated_with_origin_server)
-          @cache_fill_bytes = args[:cache_fill_bytes] if args.key?(:cache_fill_bytes)
+          @repository = args[:repository] if args.key?(:repository)
+          @revision_id = args[:revision_id] if args.key?(:revision_id)
         end
       end
       
-      # Additional information about a potentially long-running operation with which a
-      # log entry is associated.
-      class LogEntryOperation
+      # An object representing a resource that can be used for monitoring, logging,
+      # billing, or other purposes. Examples include virtual machine instances,
+      # databases, and storage devices such as disks. The `type` field identifies a
+      # MonitoredResourceDescriptor object that describes the resource's
+      # schema. Information in the `labels` field identifies the actual resource and
+      # its attributes according to the schema. For example, a particular Compute
+      # Engine VM instance could be represented by the following object, because the
+      # MonitoredResourceDescriptor for `"gce_instance"` has labels
+      # `"instance_id"` and `"zone"`:
+      # ` "type": "gce_instance",
+      # "labels": ` "instance_id": "12345678901234",
+      # "zone": "us-central1-a" ``
+      class MonitoredResource
         include Google::Apis::Core::Hashable
       
-        # Required. An arbitrary operation identifier. Log entries with the same
-        # identifier are assumed to be part of the same operation.
-        # Corresponds to the JSON property `id`
-        # @return [String]
-        attr_accessor :id
+        # Required. Values for all of the labels listed in the associated monitored
+        # resource descriptor. For example, Cloud SQL databases use the labels
+        # `"database_id"` and `"zone"`.
+        # Corresponds to the JSON property `labels`
+        # @return [Hash<String,String>]
+        attr_accessor :labels
       
-        # Required. An arbitrary producer identifier. The combination of `id` and `
-        # producer` must be globally unique. Examples for `producer`: `"MyDivision.
-        # MyBigCompany.com"`, "github.com/MyProject/MyApplication"`.
-        # Corresponds to the JSON property `producer`
+        # Required. The monitored resource type. This field must match
+        # the `type` field of a MonitoredResourceDescriptor object. For
+        # example, the type of a Cloud SQL database is `"cloudsql_database"`.
+        # Corresponds to the JSON property `type`
         # @return [String]
-        attr_accessor :producer
-      
-        # Optional. Set this to True if this is the first log entry in the operation.
-        # Corresponds to the JSON property `first`
-        # @return [Boolean]
-        attr_accessor :first
-        alias_method :first?, :first
-      
-        # Optional. Set this to True if this is the last log entry in the operation.
-        # Corresponds to the JSON property `last`
-        # @return [Boolean]
-        attr_accessor :last
-        alias_method :last?, :last
-      
-        def initialize(**args)
-           update!(**args)
-        end
-      
-        # Update properties of this object
-        def update!(**args)
-          @id = args[:id] if args.key?(:id)
-          @producer = args[:producer] if args.key?(:producer)
-          @first = args[:first] if args.key?(:first)
-          @last = args[:last] if args.key?(:last)
-        end
-      end
-      
-      # Result returned from WriteLogEntries. empty
-      class WriteLogEntriesResponse
-        include Google::Apis::Core::Hashable
+        attr_accessor :type
       
         def initialize(**args)
            update!(**args)
@@ -392,97 +460,68 @@ module Google
       
         # Update properties of this object
         def update!(**args)
+          @labels = args[:labels] if args.key?(:labels)
+          @type = args[:type] if args.key?(:type)
         end
       end
       
-      # The parameters to `ListLogEntries`.
-      class ListLogEntriesRequest
+      # The parameters to WriteLogEntries.
+      class WriteLogEntriesRequest
         include Google::Apis::Core::Hashable
       
-        # Required. One or more project IDs or project numbers from which to retrieve
-        # log entries. Examples of a project ID: `"my-project-1A"`, `"1234567890"`.
-        # Corresponds to the JSON property `projectIds`
-        # @return [Array<String>]
-        attr_accessor :project_ids
-      
-        # Optional. An [advanced logs filter](/logging/docs/view/advanced_filters). The
-        # filter is compared against all log entries in the projects specified by `
-        # projectIds`. Only entries that match the filter are retrieved. An empty filter
-        # matches all log entries.
-        # Corresponds to the JSON property `filter`
-        # @return [String]
-        attr_accessor :filter
-      
-        # Optional. How the results should be sorted. Presently, the only permitted
-        # values are `"timestamp asc"` (default) and `"timestamp desc"`. The first
-        # option returns entries in order of increasing values of `LogEntry.timestamp` (
-        # oldest first), and the second option returns entries in order of decreasing
-        # timestamps (newest first). Entries with equal timestamps are returned in order
-        # of `LogEntry.insertId`.
-        # Corresponds to the JSON property `orderBy`
-        # @return [String]
-        attr_accessor :order_by
+        # Optional. Default labels that are added to the `labels` field of all log
+        # entries in `entries`. If a log entry already has a label with the same key
+        # as a label in this parameter, then the log entry's label is not changed.
+        # See LogEntry.
+        # Corresponds to the JSON property `labels`
+        # @return [Hash<String,String>]
+        attr_accessor :labels
       
-        # Optional. The maximum number of results to return from this request. You must
-        # check for presence of `nextPageToken` to determine if additional results are
-        # available, which you can retrieve by passing the `nextPageToken` value as the `
-        # pageToken` parameter in the next request.
-        # Corresponds to the JSON property `pageSize`
-        # @return [Fixnum]
-        attr_accessor :page_size
+        # Required. The log entries to write. Values supplied for the fields
+        # `log_name`, `resource`, and `labels` in this `entries.write` request are
+        # added to those log entries that do not provide their own values for the
+        # fields.
+        # To improve throughput and to avoid exceeding the
+        # [quota limit](/logging/quota-policy) for calls to `entries.write`,
+        # you should write multiple log entries at once rather than
+        # calling this method for each individual log entry.
+        # Corresponds to the JSON property `entries`
+        # @return [Array<Google::Apis::LoggingV2beta1::LogEntry>]
+        attr_accessor :entries
       
-        # Optional. If the `pageToken` parameter is supplied, then the next page of
-        # results is retrieved. The `pageToken` parameter must be set to the value of
-        # the `nextPageToken` from the previous response. The values of `projectIds`, `
-        # filter`, and `orderBy` must be the same as in the previous request.
-        # Corresponds to the JSON property `pageToken`
+        # Optional. A default log resource name that is assigned to all log entries
+        # in `entries` that do not specify a value for `log_name`.  Example:
+        # `"projects/my-project/logs/syslog"`.  See
+        # LogEntry.
+        # Corresponds to the JSON property `logName`
         # @return [String]
-        attr_accessor :page_token
+        attr_accessor :log_name
       
-        # Optional. If true, read access to all projects is not required and results
-        # will be returned for the subset of projects for which read access is permitted
-        # (empty subset is permitted).
+        # Optional. Whether valid entries should be written even if some other
+        # entries fail due to INVALID_ARGUMENT or PERMISSION_DENIED errors. If any
+        # entry is not written, the response status will be the error associated
+        # with one of the failed entries and include error details in the form of
+        # WriteLogEntriesPartialErrors.
         # Corresponds to the JSON property `partialSuccess`
         # @return [Boolean]
         attr_accessor :partial_success
         alias_method :partial_success?, :partial_success
       
-        def initialize(**args)
-           update!(**args)
-        end
-      
-        # Update properties of this object
-        def update!(**args)
-          @project_ids = args[:project_ids] if args.key?(:project_ids)
-          @filter = args[:filter] if args.key?(:filter)
-          @order_by = args[:order_by] if args.key?(:order_by)
-          @page_size = args[:page_size] if args.key?(:page_size)
-          @page_token = args[:page_token] if args.key?(:page_token)
-          @partial_success = args[:partial_success] if args.key?(:partial_success)
-        end
-      end
-      
-      # Result returned from `ListLogEntries`.
-      class ListLogEntriesResponse
-        include Google::Apis::Core::Hashable
-      
-        # A list of log entries.
-        # Corresponds to the JSON property `entries`
-        # @return [Array<Google::Apis::LoggingV2beta1::LogEntry>]
-        attr_accessor :entries
-      
-        # If there are more results than were returned, then `nextPageToken` is included
-        # in the response. To get the next set of results, call this method again using
-        # the value of `nextPageToken` as `pageToken`.
-        # Corresponds to the JSON property `nextPageToken`
-        # @return [String]
-        attr_accessor :next_page_token
-      
-        # If partial_success is true, contains the project ids that had errors and the
-        # associated errors.
-        # Corresponds to the JSON property `projectIdErrors`
-        # @return [Hash<String,Google::Apis::LoggingV2beta1::Status>]
-        attr_accessor :project_id_errors
+        # An object representing a resource that can be used for monitoring, logging,
+        # billing, or other purposes. Examples include virtual machine instances,
+        # databases, and storage devices such as disks. The `type` field identifies a
+        # MonitoredResourceDescriptor object that describes the resource's
+        # schema. Information in the `labels` field identifies the actual resource and
+        # its attributes according to the schema. For example, a particular Compute
+        # Engine VM instance could be represented by the following object, because the
+        # MonitoredResourceDescriptor for `"gce_instance"` has labels
+        # `"instance_id"` and `"zone"`:
+        # ` "type": "gce_instance",
+        # "labels": ` "instance_id": "12345678901234",
+        # "zone": "us-central1-a" ``
+        # Corresponds to the JSON property `resource`
+        # @return [Google::Apis::LoggingV2beta1::MonitoredResource]
+        attr_accessor :resource
       
         def initialize(**args)
            update!(**args)
@@ -490,64 +529,32 @@ module Google
       
         # Update properties of this object
         def update!(**args)
+          @labels = args[:labels] if args.key?(:labels)
           @entries = args[:entries] if args.key?(:entries)
-          @next_page_token = args[:next_page_token] if args.key?(:next_page_token)
-          @project_id_errors = args[:project_id_errors] if args.key?(:project_id_errors)
+          @log_name = args[:log_name] if args.key?(:log_name)
+          @partial_success = args[:partial_success] if args.key?(:partial_success)
+          @resource = args[:resource] if args.key?(:resource)
         end
       end
       
-      # The `Status` type defines a logical error model that is suitable for different
-      # programming environments, including REST APIs and RPC APIs. It is used by [
-      # gRPC](https://github.com/grpc). The error model is designed to be: - Simple to
-      # use and understand for most users - Flexible enough to meet unexpected needs #
-      # Overview The `Status` message contains three pieces of data: error code, error
-      # message, and error details. The error code should be an enum value of google.
-      # rpc.Code, but it may accept additional error codes if needed. The error
-      # message should be a developer-facing English message that helps developers *
-      # understand* and *resolve* the error. If a localized user-facing error message
-      # is needed, put the localized message in the error details or localize it in
-      # the client. The optional error details may contain arbitrary information about
-      # the error. There is a predefined set of error detail types in the package `
-      # google.rpc` which can be used for common error conditions. # Language mapping
-      # The `Status` message is the logical representation of the error model, but it
-      # is not necessarily the actual wire format. When the `Status` message is
-      # exposed in different client libraries and different wire protocols, it can be
-      # mapped differently. For example, it will likely be mapped to some exceptions
-      # in Java, but more likely mapped to some error codes in C. # Other uses The
-      # error model and the `Status` message can be used in a variety of environments,
-      # either with or without APIs, to provide a consistent developer experience
-      # across different environments. Example uses of this error model include: -
-      # Partial errors. If a service needs to return partial errors to the client, it
-      # may embed the `Status` in the normal response to indicate the partial errors. -
-      # Workflow errors. A typical workflow has multiple steps. Each step may have a `
-      # Status` message for error reporting purpose. - Batch operations. If a client
-      # uses batch request and batch response, the `Status` message should be used
-      # directly inside batch response, one for each error sub-response. -
-      # Asynchronous operations. If an API call embeds asynchronous operation results
-      # in its response, the status of those operations should be represented directly
-      # using the `Status` message. - Logging. If some API errors are stored in logs,
-      # the message `Status` could be used directly after any stripping needed for
-      # security/privacy reasons.
-      class Status
+      # A description of a label.
+      class LabelDescriptor
         include Google::Apis::Core::Hashable
       
-        # The status code, which should be an enum value of google.rpc.Code.
-        # Corresponds to the JSON property `code`
-        # @return [Fixnum]
-        attr_accessor :code
+        # A human-readable description for the label.
+        # Corresponds to the JSON property `description`
+        # @return [String]
+        attr_accessor :description
       
-        # A developer-facing error message, which should be in English. Any user-facing
-        # error message should be localized and sent in the google.rpc.Status.details
-        # field, or localized by the client.
-        # Corresponds to the JSON property `message`
+        # The type of data that can be assigned to the label.
+        # Corresponds to the JSON property `valueType`
         # @return [String]
-        attr_accessor :message
+        attr_accessor :value_type
       
-        # A list of messages that carry the error details. There will be a common set of
-        # message types for APIs to use.
-        # Corresponds to the JSON property `details`
-        # @return [Array<Hash<String,Object>>]
-        attr_accessor :details
+        # The label key.
+        # Corresponds to the JSON property `key`
+        # @return [String]
+        attr_accessor :key
       
         def initialize(**args)
            update!(**args)
@@ -555,24 +562,24 @@ module Google
       
         # Update properties of this object
         def update!(**args)
-          @code = args[:code] if args.key?(:code)
-          @message = args[:message] if args.key?(:message)
-          @details = args[:details] if args.key?(:details)
+          @description = args[:description] if args.key?(:description)
+          @value_type = args[:value_type] if args.key?(:value_type)
+          @key = args[:key] if args.key?(:key)
         end
       end
       
-      # Result returned from ListMonitoredResourceDescriptors.
-      class ListMonitoredResourceDescriptorsResponse
+      # Result returned from ListLogMetrics.
+      class ListLogMetricsResponse
         include Google::Apis::Core::Hashable
       
-        # A list of resource descriptors.
-        # Corresponds to the JSON property `resourceDescriptors`
-        # @return [Array<Google::Apis::LoggingV2beta1::MonitoredResourceDescriptor>]
-        attr_accessor :resource_descriptors
+        # A list of logs-based metrics.
+        # Corresponds to the JSON property `metrics`
+        # @return [Array<Google::Apis::LoggingV2beta1::LogMetric>]
+        attr_accessor :metrics
       
-        # If there are more results than were returned, then `nextPageToken` is included
-        # in the response. To get the next set of results, call this method again using
-        # the value of `nextPageToken` as `pageToken`.
+        # If there might be more results than appear in this response, then
+        # `nextPageToken` is included.  To get the next set of results, call this
+        # method again using the value of `nextPageToken` as `pageToken`.
         # Corresponds to the JSON property `nextPageToken`
         # @return [String]
         attr_accessor :next_page_token
@@ -583,45 +590,32 @@ module Google
       
         # Update properties of this object
         def update!(**args)
-          @resource_descriptors = args[:resource_descriptors] if args.key?(:resource_descriptors)
+          @metrics = args[:metrics] if args.key?(:metrics)
           @next_page_token = args[:next_page_token] if args.key?(:next_page_token)
         end
       end
       
-      # An object that describes the schema of a MonitoredResource object using a type
-      # name and a set of labels. For example, the monitored resource descriptor for
-      # Google Compute Engine VM instances has a type of `"gce_instance"` and
-      # specifies the use of the labels `"instance_id"` and `"zone"` to identify
-      # particular VM instances. Different APIs can support different monitored
-      # resource types. APIs generally provide a `list` method that returns the
-      # monitored resource descriptors used by the API.
+      # An object that describes the schema of a MonitoredResource object using a
+      # type name and a set of labels.  For example, the monitored resource
+      # descriptor for Google Compute Engine VM instances has a type of
+      # `"gce_instance"` and specifies the use of the labels `"instance_id"` and
+      # `"zone"` to identify particular VM instances.
+      # Different APIs can support different monitored resource types. APIs generally
+      # provide a `list` method that returns the monitored resource descriptors used
+      # by the API.
       class MonitoredResourceDescriptor
         include Google::Apis::Core::Hashable
       
-        # Optional. The resource name of the monitored resource descriptor: `"projects/`
-        # project_id`/monitoredResourceDescriptors/`type`"` where `type` is the value of
-        # the `type` field in this object and `project_id` is a project ID that provides
-        # API-specific context for accessing the type. APIs that do not use project
-        # information can use the resource name format `"monitoredResourceDescriptors/`
-        # type`"`.
-        # Corresponds to the JSON property `name`
-        # @return [String]
-        attr_accessor :name
-      
-        # Required. The monitored resource type. For example, the type `"
-        # cloudsql_database"` represents databases in Google Cloud SQL.
-        # Corresponds to the JSON property `type`
-        # @return [String]
-        attr_accessor :type
-      
         # Optional. A concise name for the monitored resource type that might be
-        # displayed in user interfaces. For example, `"Google Cloud SQL Database"`.
+        # displayed in user interfaces. It should be a Title Cased Noun Phrase,
+        # without any article or other determiners. For example,
+        # `"Google Cloud SQL Database"`.
         # Corresponds to the JSON property `displayName`
         # @return [String]
         attr_accessor :display_name
       
-        # Optional. A detailed description of the monitored resource type that might be
-        # used in documentation.
+        # Optional. A detailed description of the monitored resource type that might
+        # be used in documentation.
         # Corresponds to the JSON property `description`
         # @return [String]
         attr_accessor :description
@@ -633,38 +627,22 @@ module Google
         # @return [Array<Google::Apis::LoggingV2beta1::LabelDescriptor>]
         attr_accessor :labels
       
-        def initialize(**args)
-           update!(**args)
-        end
-      
-        # Update properties of this object
-        def update!(**args)
-          @name = args[:name] if args.key?(:name)
-          @type = args[:type] if args.key?(:type)
-          @display_name = args[:display_name] if args.key?(:display_name)
-          @description = args[:description] if args.key?(:description)
-          @labels = args[:labels] if args.key?(:labels)
-        end
-      end
-      
-      # A description of a label.
-      class LabelDescriptor
-        include Google::Apis::Core::Hashable
-      
-        # The label key.
-        # Corresponds to the JSON property `key`
-        # @return [String]
-        attr_accessor :key
-      
-        # The type of data that can be assigned to the label.
-        # Corresponds to the JSON property `valueType`
+        # Required. The monitored resource type. For example, the type
+        # `"cloudsql_database"` represents databases in Google Cloud SQL.
+        # The maximum length of this value is 256 characters.
+        # Corresponds to the JSON property `type`
         # @return [String]
-        attr_accessor :value_type
+        attr_accessor :type
       
-        # A human-readable description for the label.
-        # Corresponds to the JSON property `description`
+        # Optional. The resource name of the monitored resource descriptor:
+        # `"projects/`project_id`/monitoredResourceDescriptors/`type`"` where
+        # `type` is the value of the `type` field in this object and
+        # `project_id` is a project ID that provides API-specific context for
+        # accessing the type.  APIs that do not use project information can use the
+        # resource name format `"monitoredResourceDescriptors/`type`"`.
+        # Corresponds to the JSON property `name`
         # @return [String]
-        attr_accessor :description
+        attr_accessor :name
       
         def initialize(**args)
            update!(**args)
@@ -672,74 +650,70 @@ module Google
       
         # Update properties of this object
         def update!(**args)
-          @key = args[:key] if args.key?(:key)
-          @value_type = args[:value_type] if args.key?(:value_type)
+          @display_name = args[:display_name] if args.key?(:display_name)
           @description = args[:description] if args.key?(:description)
+          @labels = args[:labels] if args.key?(:labels)
+          @type = args[:type] if args.key?(:type)
+          @name = args[:name] if args.key?(:name)
         end
       end
       
-      # Result returned from `ListSinks`.
-      class ListSinksResponse
+      # Result returned from ListMonitoredResourceDescriptors.
+      class ListMonitoredResourceDescriptorsResponse
         include Google::Apis::Core::Hashable
       
-        # A list of sinks.
-        # Corresponds to the JSON property `sinks`
-        # @return [Array<Google::Apis::LoggingV2beta1::LogSink>]
-        attr_accessor :sinks
-      
-        # If there are more results than were returned, then `nextPageToken` is included
-        # in the response. To get the next set of results, call this method again using
-        # the value of `nextPageToken` as `pageToken`.
+        # If there might be more results than appear in this response, then
+        # `nextPageToken` is included.  To get the next set of results, call this
+        # method again using the value of `nextPageToken` as `pageToken`.
         # Corresponds to the JSON property `nextPageToken`
         # @return [String]
         attr_accessor :next_page_token
       
+        # A list of resource descriptors.
+        # Corresponds to the JSON property `resourceDescriptors`
+        # @return [Array<Google::Apis::LoggingV2beta1::MonitoredResourceDescriptor>]
+        attr_accessor :resource_descriptors
+      
         def initialize(**args)
            update!(**args)
         end
       
         # Update properties of this object
         def update!(**args)
-          @sinks = args[:sinks] if args.key?(:sinks)
           @next_page_token = args[:next_page_token] if args.key?(:next_page_token)
+          @resource_descriptors = args[:resource_descriptors] if args.key?(:resource_descriptors)
         end
       end
       
-      # Describes a sink used to export log entries outside Cloud Logging.
-      class LogSink
+      # Additional information about a potentially long-running operation with which
+      # a log entry is associated.
+      class LogEntryOperation
         include Google::Apis::Core::Hashable
       
-        # Required. The client-assigned sink identifier. Example: `"my-severe-errors-to-
-        # pubsub"`. Sink identifiers are limited to 1000 characters and can include only
-        # the following characters: `A-Z`, `a-z`, `0-9`, and the special characters `_-.`
-        # .
-        # Corresponds to the JSON property `name`
+        # Optional. An arbitrary producer identifier. The combination of
+        # `id` and `producer` must be globally unique.  Examples for `producer`:
+        # `"MyDivision.MyBigCompany.com"`, `"github.com/MyProject/MyApplication"`.
+        # Corresponds to the JSON property `producer`
         # @return [String]
-        attr_accessor :name
+        attr_accessor :producer
       
-        # The export destination. See [Exporting Logs With Sinks](/logging/docs/api/
-        # tasks/exporting-logs). Examples: `"storage.googleapis.com/a-bucket"`, `"
-        # bigquery.googleapis.com/projects/a-project-id/datasets/a-dataset"`.
-        # Corresponds to the JSON property `destination`
-        # @return [String]
-        attr_accessor :destination
+        # Optional. Set this to True if this is the last log entry in the operation.
+        # Corresponds to the JSON property `last`
+        # @return [Boolean]
+        attr_accessor :last
+        alias_method :last?, :last
       
-        # An [advanced logs filter](/logging/docs/view/advanced_filters). Only log
-        # entries matching that filter are exported. The filter must be consistent with
-        # the log entry format specified by the `outputVersionFormat` parameter,
-        # regardless of the format of the log entry that was originally written to Cloud
-        # Logging. Example (V2 format): `"logName=projects/my-projectid/logs/syslog AND
-        # severity>=ERROR"`.
-        # Corresponds to the JSON property `filter`
-        # @return [String]
-        attr_accessor :filter
+        # Optional. Set this to True if this is the first log entry in the operation.
+        # Corresponds to the JSON property `first`
+        # @return [Boolean]
+        attr_accessor :first
+        alias_method :first?, :first
       
-        # The log entry version to use for this sink's exported log entries. This
-        # version does not have to correspond to the version of the log entry when it
-        # was written to Cloud Logging.
-        # Corresponds to the JSON property `outputVersionFormat`
+        # Optional. An arbitrary operation identifier. Log entries with the
+        # same identifier are assumed to be part of the same operation.
+        # Corresponds to the JSON property `id`
         # @return [String]
-        attr_accessor :output_version_format
+        attr_accessor :id
       
         def initialize(**args)
            update!(**args)
@@ -747,64 +721,125 @@ module Google
       
         # Update properties of this object
         def update!(**args)
-          @name = args[:name] if args.key?(:name)
-          @destination = args[:destination] if args.key?(:destination)
-          @filter = args[:filter] if args.key?(:filter)
-          @output_version_format = args[:output_version_format] if args.key?(:output_version_format)
+          @producer = args[:producer] if args.key?(:producer)
+          @last = args[:last] if args.key?(:last)
+          @first = args[:first] if args.key?(:first)
+          @id = args[:id] if args.key?(:id)
         end
       end
       
-      # Result returned from ListLogMetrics.
-      class ListLogMetricsResponse
+      # A generic empty message that you can re-use to avoid defining duplicated
+      # empty messages in your APIs. A typical example is to use it as the request
+      # or the response type of an API method. For instance:
+      # service Foo `
+      # rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
+      # `
+      # The JSON representation for `Empty` is empty JSON object ````.
+      class Empty
         include Google::Apis::Core::Hashable
       
-        # A list of logs-based metrics.
-        # Corresponds to the JSON property `metrics`
-        # @return [Array<Google::Apis::LoggingV2beta1::LogMetric>]
-        attr_accessor :metrics
-      
-        # If there are more results than were returned, then `nextPageToken` is included
-        # in the response. To get the next set of results, call this method again using
-        # the value of `nextPageToken` as `pageToken`.
-        # Corresponds to the JSON property `nextPageToken`
-        # @return [String]
-        attr_accessor :next_page_token
-      
         def initialize(**args)
            update!(**args)
         end
       
         # Update properties of this object
         def update!(**args)
-          @metrics = args[:metrics] if args.key?(:metrics)
-          @next_page_token = args[:next_page_token] if args.key?(:next_page_token)
         end
       end
       
-      # Describes a logs-based metric. The value of the metric is the number of log
-      # entries that match a logs filter.
-      class LogMetric
+      # A common proto for logging HTTP requests. Only contains semantics
+      # defined by the HTTP specification. Product-specific logging
+      # information MUST be defined in a separate message.
+      class HttpRequest
         include Google::Apis::Core::Hashable
       
-        # Required. The client-assigned metric identifier. Example: `"severe_errors"`.
-        # Metric identifiers are limited to 1000 characters and can include only the
-        # following characters: `A-Z`, `a-z`, `0-9`, and the special characters `_-.,+!*'
-        # ,()%/\`. The forward-slash character (`/`) denotes a hierarchy of name pieces,
-        # and it cannot be the first character of the name.
-        # Corresponds to the JSON property `name`
+        # Whether or not a cache lookup was attempted.
+        # Corresponds to the JSON property `cacheLookup`
+        # @return [Boolean]
+        attr_accessor :cache_lookup
+        alias_method :cache_lookup?, :cache_lookup
+      
+        # The size of the HTTP response message sent back to the client, in bytes,
+        # including the response headers and the response body.
+        # Corresponds to the JSON property `responseSize`
         # @return [String]
-        attr_accessor :name
+        attr_accessor :response_size
       
-        # A description of this metric, which is used in documentation.
-        # Corresponds to the JSON property `description`
+        # The response code indicating the status of response.
+        # Examples: 200, 404.
+        # Corresponds to the JSON property `status`
+        # @return [Fixnum]
+        attr_accessor :status
+      
+        # Whether or not the response was validated with the origin server before
+        # being served from cache. This field is only meaningful if `cache_hit` is
+        # True.
+        # Corresponds to the JSON property `cacheValidatedWithOriginServer`
+        # @return [Boolean]
+        attr_accessor :cache_validated_with_origin_server
+        alias_method :cache_validated_with_origin_server?, :cache_validated_with_origin_server
+      
+        # The referer URL of the request, as defined in
+        # [HTTP/1.1 Header Field Definitions](http://www.w3.org/Protocols/rfc2616/
+        # rfc2616-sec14.html).
+        # Corresponds to the JSON property `referer`
         # @return [String]
-        attr_accessor :description
+        attr_accessor :referer
       
-        # An [advanced logs filter](/logging/docs/view/advanced_filters). Example: `"
-        # logName:syslog AND severity>=ERROR"`.
-        # Corresponds to the JSON property `filter`
+        # Whether or not an entity was served from cache
+        # (with or without validation).
+        # Corresponds to the JSON property `cacheHit`
+        # @return [Boolean]
+        attr_accessor :cache_hit
+        alias_method :cache_hit?, :cache_hit
+      
+        # The scheme (http, https), the host name, the path and the query
+        # portion of the URL that was requested.
+        # Example: `"http://example.com/some/info?color=red"`.
+        # Corresponds to the JSON property `requestUrl`
         # @return [String]
-        attr_accessor :filter
+        attr_accessor :request_url
+      
+        # The request processing latency on the server, from the time the request was
+        # received until the response was sent.
+        # Corresponds to the JSON property `latency`
+        # @return [String]
+        attr_accessor :latency
+      
+        # The number of HTTP response bytes inserted into cache. Set only when a
+        # cache fill was attempted.
+        # Corresponds to the JSON property `cacheFillBytes`
+        # @return [String]
+        attr_accessor :cache_fill_bytes
+      
+        # The request method. Examples: `"GET"`, `"HEAD"`, `"PUT"`, `"POST"`.
+        # Corresponds to the JSON property `requestMethod`
+        # @return [String]
+        attr_accessor :request_method
+      
+        # The IP address (IPv4 or IPv6) of the client that issued the HTTP
+        # request. Examples: `"192.168.1.1"`, `"FE80::0202:B3FF:FE1E:8329"`.
+        # Corresponds to the JSON property `remoteIp`
+        # @return [String]
+        attr_accessor :remote_ip
+      
+        # The IP address (IPv4 or IPv6) of the origin server that the request was
+        # sent to.
+        # Corresponds to the JSON property `serverIp`
+        # @return [String]
+        attr_accessor :server_ip
+      
+        # The user agent sent by the client. Example:
+        # `"Mozilla/4.0 (compatible; MSIE 6.0; Windows 98; Q312461; .NET CLR 1.0.3705)"`.
+        # Corresponds to the JSON property `userAgent`
+        # @return [String]
+        attr_accessor :user_agent
+      
+        # The size of the HTTP request message in bytes, including the request
+        # headers and the request body.
+        # Corresponds to the JSON property `requestSize`
+        # @return [String]
+        attr_accessor :request_size
       
         def initialize(**args)
            update!(**args)
@@ -812,9 +847,20 @@ module Google
       
         # Update properties of this object
         def update!(**args)
-          @name = args[:name] if args.key?(:name)
-          @description = args[:description] if args.key?(:description)
-          @filter = args[:filter] if args.key?(:filter)
+          @cache_lookup = args[:cache_lookup] if args.key?(:cache_lookup)
+          @response_size = args[:response_size] if args.key?(:response_size)
+          @status = args[:status] if args.key?(:status)
+          @cache_validated_with_origin_server = args[:cache_validated_with_origin_server] if args.key?(:cache_validated_with_origin_server)
+          @referer = args[:referer] if args.key?(:referer)
+          @cache_hit = args[:cache_hit] if args.key?(:cache_hit)
+          @request_url = args[:request_url] if args.key?(:request_url)
+          @latency = args[:latency] if args.key?(:latency)
+          @cache_fill_bytes = args[:cache_fill_bytes] if args.key?(:cache_fill_bytes)
+          @request_method = args[:request_method] if args.key?(:request_method)
+          @remote_ip = args[:remote_ip] if args.key?(:remote_ip)
+          @server_ip = args[:server_ip] if args.key?(:server_ip)
+          @user_agent = args[:user_agent] if args.key?(:user_agent)
+          @request_size = args[:request_size] if args.key?(:request_size)
         end
       end
       
@@ -823,182 +869,184 @@ module Google
       class RequestLog
         include Google::Apis::Core::Hashable
       
-        # Application that handled this request.
-        # Corresponds to the JSON property `appId`
+        # Size in bytes sent back to client by request.
+        # Corresponds to the JSON property `responseSize`
         # @return [String]
-        attr_accessor :app_id
+        attr_accessor :response_size
       
-        # Module of the application that handled this request.
-        # Corresponds to the JSON property `moduleId`
+        # Globally unique identifier for a request, which is based on the request
+        # start time.  Request IDs for requests which started later will compare
+        # greater as strings than those for requests which started earlier.
+        # Corresponds to the JSON property `requestId`
         # @return [String]
-        attr_accessor :module_id
+        attr_accessor :request_id
+      
+        # Whether this is the first `RequestLog` entry for this request.  If an
+        # active request has several `RequestLog` entries written to Stackdriver
+        # Logging, then this field will be set for one of them.
+        # Corresponds to the JSON property `first`
+        # @return [Boolean]
+        attr_accessor :first
+        alias_method :first?, :first
+      
+        # Request method. Example: `"GET"`, `"HEAD"`, `"PUT"`, `"POST"`, `"DELETE"`.
+        # Corresponds to the JSON property `method`
+        # @return [String]
+        attr_accessor :method_prop
       
         # Version of the application that handled this request.
         # Corresponds to the JSON property `versionId`
         # @return [String]
         attr_accessor :version_id
       
-        # Globally unique identifier for a request, which is based on the request start
-        # time. Request IDs for requests which started later will compare greater as
-        # strings than those for requests which started earlier.
-        # Corresponds to the JSON property `requestId`
-        # @return [String]
-        attr_accessor :request_id
+        # HTTP response status code. Example: 200, 404.
+        # Corresponds to the JSON property `status`
+        # @return [Fixnum]
+        attr_accessor :status
+      
+        # Whether this was a loading request for the instance.
+        # Corresponds to the JSON property `wasLoadingRequest`
+        # @return [Boolean]
+        attr_accessor :was_loading_request
+        alias_method :was_loading_request?, :was_loading_request
       
         # Origin IP address.
         # Corresponds to the JSON property `ip`
         # @return [String]
         attr_accessor :ip
       
-        # Time when the request started.
-        # Corresponds to the JSON property `startTime`
-        # @return [String]
-        attr_accessor :start_time
-      
-        # Time when the request finished.
-        # Corresponds to the JSON property `endTime`
-        # @return [String]
-        attr_accessor :end_time
-      
-        # Latency of the request.
-        # Corresponds to the JSON property `latency`
-        # @return [String]
-        attr_accessor :latency
-      
-        # Number of CPU megacycles used to process request.
-        # Corresponds to the JSON property `megaCycles`
-        # @return [String]
-        attr_accessor :mega_cycles
-      
-        # Request method. Example: `"GET"`, `"HEAD"`, `"PUT"`, `"POST"`, `"DELETE"`.
-        # Corresponds to the JSON property `method`
+        # The logged-in user who made the request.
+        # Most likely, this is the part of the user's email before the `@` sign.  The
+        # field value is the same for different requests from the same user, but
+        # different users can have similar names.  This information is also
+        # available to the application via the App Engine Users API.
+        # This field will be populated starting with App Engine 1.9.21.
+        # Corresponds to the JSON property `nickname`
         # @return [String]
-        attr_accessor :method_prop
+        attr_accessor :nickname
       
-        # Contains the path and query portion of the URL that was requested. For example,
-        # if the URL was "http://example.com/app?name=val", the resource would be "/app?
-        # name=val". The fragment identifier, which is identified by the `#` character,
-        # is not included.
-        # Corresponds to the JSON property `resource`
+        # Queue name of the request, in the case of an offline request.
+        # Corresponds to the JSON property `taskQueueName`
         # @return [String]
-        attr_accessor :resource
+        attr_accessor :task_queue_name
       
-        # HTTP version of request. Example: `"HTTP/1.1"`.
-        # Corresponds to the JSON property `httpVersion`
+        # Time this request spent in the pending request queue.
+        # Corresponds to the JSON property `pendingTime`
         # @return [String]
-        attr_accessor :http_version
+        attr_accessor :pending_time
       
-        # HTTP response status code. Example: 200, 404.
-        # Corresponds to the JSON property `status`
+        # If the instance processing this request belongs to a manually scaled
+        # module, then this is the 0-based index of the instance. Otherwise, this
+        # value is -1.
+        # Corresponds to the JSON property `instanceIndex`
         # @return [Fixnum]
-        attr_accessor :status
+        attr_accessor :instance_index
       
-        # Size in bytes sent back to client by request.
-        # Corresponds to the JSON property `responseSize`
-        # @return [String]
-        attr_accessor :response_size
+        # Source code for the application that handled this request. There can be
+        # more than one source reference per deployed application if source code is
+        # distributed among multiple repositories.
+        # Corresponds to the JSON property `sourceReference`
+        # @return [Array<Google::Apis::LoggingV2beta1::SourceReference>]
+        attr_accessor :source_reference
       
-        # Referrer URL of request.
-        # Corresponds to the JSON property `referrer`
+        # Module of the application that handled this request.
+        # Corresponds to the JSON property `moduleId`
         # @return [String]
-        attr_accessor :referrer
+        attr_accessor :module_id
       
-        # User agent that made the request.
-        # Corresponds to the JSON property `userAgent`
+        # Internet host and port number of the resource being requested.
+        # Corresponds to the JSON property `host`
         # @return [String]
-        attr_accessor :user_agent
+        attr_accessor :host
       
-        # The logged-in user who made the request. Most likely, this is the part of the
-        # user's email before the `@` sign. The field value is the same for different
-        # requests from the same user, but different users can have similar names. This
-        # information is also available to the application via the App Engine Users API.
-        # This field will be populated starting with App Engine 1.9.21.
-        # Corresponds to the JSON property `nickname`
+        # Latency of the request.
+        # Corresponds to the JSON property `latency`
         # @return [String]
-        attr_accessor :nickname
+        attr_accessor :latency
       
         # File or class that handled the request.
         # Corresponds to the JSON property `urlMapEntry`
         # @return [String]
         attr_accessor :url_map_entry
       
-        # Internet host and port number of the resource being requested.
-        # Corresponds to the JSON property `host`
+        # Time when the request finished.
+        # Corresponds to the JSON property `endTime`
         # @return [String]
-        attr_accessor :host
+        attr_accessor :end_time
       
-        # An indication of the relative cost of serving this request.
-        # Corresponds to the JSON property `cost`
-        # @return [Float]
-        attr_accessor :cost
+        # A list of log lines emitted by the application while serving this request.
+        # Corresponds to the JSON property `line`
+        # @return [Array<Google::Apis::LoggingV2beta1::LogLine>]
+        attr_accessor :line
       
-        # Queue name of the request, in the case of an offline request.
-        # Corresponds to the JSON property `taskQueueName`
+        # Number of CPU megacycles used to process request.
+        # Corresponds to the JSON property `megaCycles`
         # @return [String]
-        attr_accessor :task_queue_name
+        attr_accessor :mega_cycles
       
-        # Task name of the request, in the case of an offline request.
-        # Corresponds to the JSON property `taskName`
+        # Application that handled this request.
+        # Corresponds to the JSON property `appId`
         # @return [String]
-        attr_accessor :task_name
-      
-        # Whether this was a loading request for the instance.
-        # Corresponds to the JSON property `wasLoadingRequest`
-        # @return [Boolean]
-        attr_accessor :was_loading_request
-        alias_method :was_loading_request?, :was_loading_request
+        attr_accessor :app_id
       
-        # Time this request spent in the pending request queue.
-        # Corresponds to the JSON property `pendingTime`
+        # Stackdriver Trace identifier for this request.
+        # Corresponds to the JSON property `traceId`
         # @return [String]
-        attr_accessor :pending_time
-      
-        # If the instance processing this request belongs to a manually scaled module,
-        # then this is the 0-based index of the instance. Otherwise, this value is -1.
-        # Corresponds to the JSON property `instanceIndex`
-        # @return [Fixnum]
-        attr_accessor :instance_index
+        attr_accessor :trace_id
       
-        # Whether this request is finished or active.
-        # Corresponds to the JSON property `finished`
-        # @return [Boolean]
-        attr_accessor :finished
-        alias_method :finished?, :finished
+        # Task name of the request, in the case of an offline request.
+        # Corresponds to the JSON property `taskName`
+        # @return [String]
+        attr_accessor :task_name
       
-        # Whether this is the first RequestLog entry for this request. If an active
-        # request has several RequestLog entries written to Cloud Logging, this field
-        # will be set for one of them.
-        # Corresponds to the JSON property `first`
-        # @return [Boolean]
-        attr_accessor :first
-        alias_method :first?, :first
+        # An indication of the relative cost of serving this request.
+        # Corresponds to the JSON property `cost`
+        # @return [Float]
+        attr_accessor :cost
       
         # An identifier for the instance that handled the request.
         # Corresponds to the JSON property `instanceId`
         # @return [String]
         attr_accessor :instance_id
       
-        # A list of log lines emitted by the application while serving this request.
-        # Corresponds to the JSON property `line`
-        # @return [Array<Google::Apis::LoggingV2beta1::LogLine>]
-        attr_accessor :line
+        # Time when the request started.
+        # Corresponds to the JSON property `startTime`
+        # @return [String]
+        attr_accessor :start_time
       
         # App Engine release version.
         # Corresponds to the JSON property `appEngineRelease`
         # @return [String]
         attr_accessor :app_engine_release
       
-        # Cloud Trace identifier for this request.
-        # Corresponds to the JSON property `traceId`
+        # Contains the path and query portion of the URL that was requested. For
+        # example, if the URL was "http://example.com/app?name=val", the resource
+        # would be "/app?name=val".  The fragment identifier, which is identified by
+        # the `#` character, is not included.
+        # Corresponds to the JSON property `resource`
         # @return [String]
-        attr_accessor :trace_id
+        attr_accessor :resource
       
-        # Source code for the application that handled this request. There can be more
-        # than one source reference per deployed application if source code is
-        # distributed among multiple repositories.
-        # Corresponds to the JSON property `sourceReference`
-        # @return [Array<Google::Apis::LoggingV2beta1::SourceReference>]
-        attr_accessor :source_reference
+        # HTTP version of request. Example: `"HTTP/1.1"`.
+        # Corresponds to the JSON property `httpVersion`
+        # @return [String]
+        attr_accessor :http_version
+      
+        # Referrer URL of request.
+        # Corresponds to the JSON property `referrer`
+        # @return [String]
+        attr_accessor :referrer
+      
+        # User agent that made the request.
+        # Corresponds to the JSON property `userAgent`
+        # @return [String]
+        attr_accessor :user_agent
+      
+        # Whether this request is finished or active.
+        # Corresponds to the JSON property `finished`
+        # @return [Boolean]
+        attr_accessor :finished
+        alias_method :finished?, :finished
       
         def initialize(**args)
            update!(**args)
@@ -1006,130 +1054,107 @@ module Google
       
         # Update properties of this object
         def update!(**args)
-          @app_id = args[:app_id] if args.key?(:app_id)
-          @module_id = args[:module_id] if args.key?(:module_id)
-          @version_id = args[:version_id] if args.key?(:version_id)
+          @response_size = args[:response_size] if args.key?(:response_size)
           @request_id = args[:request_id] if args.key?(:request_id)
-          @ip = args[:ip] if args.key?(:ip)
-          @start_time = args[:start_time] if args.key?(:start_time)
-          @end_time = args[:end_time] if args.key?(:end_time)
-          @latency = args[:latency] if args.key?(:latency)
-          @mega_cycles = args[:mega_cycles] if args.key?(:mega_cycles)
+          @first = args[:first] if args.key?(:first)
           @method_prop = args[:method_prop] if args.key?(:method_prop)
-          @resource = args[:resource] if args.key?(:resource)
-          @http_version = args[:http_version] if args.key?(:http_version)
+          @version_id = args[:version_id] if args.key?(:version_id)
           @status = args[:status] if args.key?(:status)
-          @response_size = args[:response_size] if args.key?(:response_size)
-          @referrer = args[:referrer] if args.key?(:referrer)
-          @user_agent = args[:user_agent] if args.key?(:user_agent)
+          @was_loading_request = args[:was_loading_request] if args.key?(:was_loading_request)
+          @ip = args[:ip] if args.key?(:ip)
           @nickname = args[:nickname] if args.key?(:nickname)
-          @url_map_entry = args[:url_map_entry] if args.key?(:url_map_entry)
-          @host = args[:host] if args.key?(:host)
-          @cost = args[:cost] if args.key?(:cost)
           @task_queue_name = args[:task_queue_name] if args.key?(:task_queue_name)
-          @task_name = args[:task_name] if args.key?(:task_name)
-          @was_loading_request = args[:was_loading_request] if args.key?(:was_loading_request)
           @pending_time = args[:pending_time] if args.key?(:pending_time)
           @instance_index = args[:instance_index] if args.key?(:instance_index)
-          @finished = args[:finished] if args.key?(:finished)
-          @first = args[:first] if args.key?(:first)
-          @instance_id = args[:instance_id] if args.key?(:instance_id)
+          @source_reference = args[:source_reference] if args.key?(:source_reference)
+          @module_id = args[:module_id] if args.key?(:module_id)
+          @host = args[:host] if args.key?(:host)
+          @latency = args[:latency] if args.key?(:latency)
+          @url_map_entry = args[:url_map_entry] if args.key?(:url_map_entry)
+          @end_time = args[:end_time] if args.key?(:end_time)
           @line = args[:line] if args.key?(:line)
-          @app_engine_release = args[:app_engine_release] if args.key?(:app_engine_release)
+          @mega_cycles = args[:mega_cycles] if args.key?(:mega_cycles)
+          @app_id = args[:app_id] if args.key?(:app_id)
           @trace_id = args[:trace_id] if args.key?(:trace_id)
-          @source_reference = args[:source_reference] if args.key?(:source_reference)
+          @task_name = args[:task_name] if args.key?(:task_name)
+          @cost = args[:cost] if args.key?(:cost)
+          @instance_id = args[:instance_id] if args.key?(:instance_id)
+          @start_time = args[:start_time] if args.key?(:start_time)
+          @app_engine_release = args[:app_engine_release] if args.key?(:app_engine_release)
+          @resource = args[:resource] if args.key?(:resource)
+          @http_version = args[:http_version] if args.key?(:http_version)
+          @referrer = args[:referrer] if args.key?(:referrer)
+          @user_agent = args[:user_agent] if args.key?(:user_agent)
+          @finished = args[:finished] if args.key?(:finished)
         end
       end
       
-      # Application log line emitted while processing a request.
-      class LogLine
+      # Result returned from WriteLogEntries.
+      # empty
+      class WriteLogEntriesResponse
         include Google::Apis::Core::Hashable
       
-        # Approximate time when this log entry was made.
-        # Corresponds to the JSON property `time`
-        # @return [String]
-        attr_accessor :time
-      
-        # Severity of this log entry.
-        # Corresponds to the JSON property `severity`
-        # @return [String]
-        attr_accessor :severity
-      
-        # App-provided log message.
-        # Corresponds to the JSON property `logMessage`
-        # @return [String]
-        attr_accessor :log_message
-      
-        # Specifies a location in a source code file.
-        # Corresponds to the JSON property `sourceLocation`
-        # @return [Google::Apis::LoggingV2beta1::SourceLocation]
-        attr_accessor :source_location
-      
         def initialize(**args)
            update!(**args)
         end
       
         # Update properties of this object
         def update!(**args)
-          @time = args[:time] if args.key?(:time)
-          @severity = args[:severity] if args.key?(:severity)
-          @log_message = args[:log_message] if args.key?(:log_message)
-          @source_location = args[:source_location] if args.key?(:source_location)
         end
       end
       
-      # Specifies a location in a source code file.
-      class SourceLocation
+      # The parameters to `ListLogEntries`.
+      class ListLogEntriesRequest
         include Google::Apis::Core::Hashable
       
-        # Source file name. Depending on the runtime environment, this might be a simple
-        # name or a fully-qualified name.
-        # Corresponds to the JSON property `file`
-        # @return [String]
-        attr_accessor :file
-      
-        # Line within the source file.
-        # Corresponds to the JSON property `line`
-        # @return [String]
-        attr_accessor :line
-      
-        # Human-readable name of the function or method being invoked, with optional
-        # context such as the class or package name. This information is used in
-        # contexts such as the logs viewer, where a file and line number are less
-        # meaningful. The format can vary by language. For example: `qual.if.ied.Class.
-        # method` (Java), `dir/package.func` (Go), `function` (Python).
-        # Corresponds to the JSON property `functionName`
+        # Optional. A filter that chooses which log entries to return.  See [Advanced
+        # Logs Filters](/logging/docs/view/advanced_filters).  Only log entries that
+        # match the filter are returned.  An empty filter matches all log entries.
+        # The maximum length of the filter is 20000 characters.
+        # Corresponds to the JSON property `filter`
         # @return [String]
-        attr_accessor :function_name
+        attr_accessor :filter
       
-        def initialize(**args)
-           update!(**args)
-        end
+        # Deprecated. One or more project identifiers or project numbers from which
+        # to retrieve log entries.  Examples: `"my-project-1A"`, `"1234567890"`. If
+        # present, these project identifiers are converted to resource format and
+        # added to the list of resources in `resourceNames`. Callers should use
+        # `resourceNames` rather than this parameter.
+        # Corresponds to the JSON property `projectIds`
+        # @return [Array<String>]
+        attr_accessor :project_ids
       
-        # Update properties of this object
-        def update!(**args)
-          @file = args[:file] if args.key?(:file)
-          @line = args[:line] if args.key?(:line)
-          @function_name = args[:function_name] if args.key?(:function_name)
-        end
-      end
+        # Required. One or more cloud resources from which to retrieve log entries.
+        # Example: `"projects/my-project-1A"`, `"projects/1234567890"`.  Projects
+        # listed in `projectIds` are added to this list.
+        # Corresponds to the JSON property `resourceNames`
+        # @return [Array<String>]
+        attr_accessor :resource_names
       
-      # A reference to a particular snapshot of the source tree used to build and
-      # deploy an application.
-      class SourceReference
-        include Google::Apis::Core::Hashable
+        # Optional. The maximum number of results to return from this request.
+        # Non-positive values are ignored.  The presence of `nextPageToken` in the
+        # response indicates that more results might be available.
+        # Corresponds to the JSON property `pageSize`
+        # @return [Fixnum]
+        attr_accessor :page_size
       
-        # Optional. A URI string identifying the repository. Example: "https://github.
-        # com/GoogleCloudPlatform/kubernetes.git"
-        # Corresponds to the JSON property `repository`
+        # Optional. How the results should be sorted.  Presently, the only permitted
+        # values are `"timestamp asc"` (default) and `"timestamp desc"`. The first
+        # option returns entries in order of increasing values of
+        # `LogEntry.timestamp` (oldest first), and the second option returns entries
+        # in order of decreasing timestamps (newest first).  Entries with equal
+        # timestamps are returned in order of `LogEntry.insertId`.
+        # Corresponds to the JSON property `orderBy`
         # @return [String]
-        attr_accessor :repository
+        attr_accessor :order_by
       
-        # The canonical and persistent identifier of the deployed revision. Example (git)
-        # : "0035781c50ec7aa23385dc841529ce8a4b70db1b"
-        # Corresponds to the JSON property `revisionId`
+        # Optional. If present, then retrieve the next batch of results from the
+        # preceding call to this method.  `pageToken` must be the value of
+        # `nextPageToken` from the previous response.  The values of other method
+        # parameters should be identical to those in the previous call.
+        # Corresponds to the JSON property `pageToken`
         # @return [String]
-        attr_accessor :revision_id
+        attr_accessor :page_token
       
         def initialize(**args)
            update!(**args)
@@ -1137,8 +1162,12 @@ module Google
       
         # Update properties of this object
         def update!(**args)
-          @repository = args[:repository] if args.key?(:repository)
-          @revision_id = args[:revision_id] if args.key?(:revision_id)
+          @filter = args[:filter] if args.key?(:filter)
+          @project_ids = args[:project_ids] if args.key?(:project_ids)
+          @resource_names = args[:resource_names] if args.key?(:resource_names)
+          @page_size = args[:page_size] if args.key?(:page_size)
+          @order_by = args[:order_by] if args.key?(:order_by)
+          @page_token = args[:page_token] if args.key?(:page_token)
         end
       end
     end