google-api-client 0.8.6 → 0.9.3

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

@@ -0,0 +1,990 @@
+# Copyright 2015 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'date'
+require 'google/apis/core/base_service'
+require 'google/apis/core/json_representation'
+require 'google/apis/core/hashable'
+require 'google/apis/errors'
+
+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
+        include Google::Apis::Core::Hashable
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+        end
+      end
+      
+      # The parameters to WriteLogEntries.
+      class WriteLogEntriesRequest
+        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`
+        # @return [String]
+        attr_accessor :log_name
+      
+        # A specific monitored resource or a group of monitored resources.
+        # Corresponds to the JSON property `resource`
+        # @return [Google::Apis::LoggingV2beta1::MonitoredResource]
+        attr_accessor :resource
+      
+        # 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
+      
+        # 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
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # 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)
+        end
+      end
+      
+      # A specific monitored resource or a group of monitored resources.
+      class MonitoredResource
+        include Google::Apis::Core::Hashable
+      
+        # The type of monitored resource. This field must match the value of the `type`
+        # field in a MonitoredResourceDescriptor object. For example, `"
+        # cloudsql_database"` represents Cloud SQL databases.
+        # Corresponds to the JSON property `type`
+        # @return [String]
+        attr_accessor :type
+      
+        # Values for some or all of the labels listed in the associated monitored
+        # resource descriptor. For example, specify a specific Cloud SQL database by
+        # supplying values for both the `"database_id"` and `"zone"` labels. Specify the
+        # set of all Cloud SQL databases in a particular location by supplying a value
+        # for only the `"zone"` label.
+        # Corresponds to the JSON property `labels`
+        # @return [Hash<String,String>]
+        attr_accessor :labels
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @type = args[:type] if args.key?(:type)
+          @labels = args[:labels] if args.key?(:labels)
+        end
+      end
+      
+      # An individual entry in a log.
+      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/<project-id>/logs/<log-id%gt;`. 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. Forward-slash (`/`)
+        # characters in the log ID must be URL-encoded.
+        # Corresponds to the JSON property `logName`
+        # @return [String]
+        attr_accessor :log_name
+      
+        # A specific monitored resource or a group of monitored resources.
+        # 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.
+        # 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.
+        # 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.
+        # 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.
+        # Corresponds to the JSON property `operation`
+        # @return [Google::Apis::LoggingV2beta1::LogEntryOperation]
+        attr_accessor :operation
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # 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)
+          @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
+        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`
+        # @return [String]
+        attr_accessor :request_url
+      
+        # 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
+      
+        # The response code indicating the status of response. Examples: 200, 404.
+        # Corresponds to the JSON property `status`
+        # @return [Fixnum]
+        attr_accessor :status
+      
+        # 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 :response_size
+      
+        # 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 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 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 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
+      
+        # 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 `validatedWithOriginServer`
+        # @return [Boolean]
+        attr_accessor :validated_with_origin_server
+        alias_method :validated_with_origin_server?, :validated_with_origin_server
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # 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_hit = args[:cache_hit] if args.key?(:cache_hit)
+          @validated_with_origin_server = args[:validated_with_origin_server] if args.key?(:validated_with_origin_server)
+        end
+      end
+      
+      # Additional information about a potentially long-running operation with which a
+      # log entry is associated.
+      class LogEntryOperation
+        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. 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 :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
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+        end
+      end
+      
+      # The parameters to `ListLogEntries`.
+      class ListLogEntriesRequest
+        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"` (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. The maximum number of results to return from this request. Fewer
+        # results might be returned. You must check for the `nextPageToken` result to
+        # determine if additional results are available, which you can retrieve by
+        # passing the `nextPageToken` value in the `pageToken` parameter to the next
+        # request.
+        # Corresponds to the JSON property `pageSize`
+        # @return [Fixnum]
+        attr_accessor :page_size
+      
+        # Optional. If the `pageToken` request parameter is supplied, then the next page
+        # of results in the set are retrieved. The `pageToken` parameter must be set
+        # with the value of the `nextPageToken` result parameter from the previous
+        # request. The values of `projectIds`, `filter`, and `orderBy` must be the same
+        # as in the previous request.
+        # Corresponds to the JSON property `pageToken`
+        # @return [String]
+        attr_accessor :page_token
+      
+        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)
+        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 given a
+        # value in the response. To get the next batch 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
+      
+      # Result returned from ListMonitoredResourceDescriptors.
+      class ListMonitoredResourceDescriptorsResponse
+        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
+      
+        # If there are more results than were returned, then `nextPageToken` is returned
+        # in the response. To get the next batch 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)
+          @resource_descriptors = args[:resource_descriptors] if args.key?(:resource_descriptors)
+          @next_page_token = args[:next_page_token] if args.key?(:next_page_token)
+        end
+      end
+      
+      # A description of a type of monitored resource.
+      class MonitoredResourceDescriptor
+        include Google::Apis::Core::Hashable
+      
+        # 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
+      
+        # A concise name for the monitored resource type, which is displayed in user
+        # interfaces. For example, `"Cloud SQL Database"`.
+        # Corresponds to the JSON property `displayName`
+        # @return [String]
+        attr_accessor :display_name
+      
+        # A detailed description of the monitored resource type, which is used in
+        # documentation.
+        # Corresponds to the JSON property `description`
+        # @return [String]
+        attr_accessor :description
+      
+        # A set of labels that can be used to describe instances of this monitored
+        # resource type. For example, Cloud SQL databases can be labeled with their `"
+        # database_id"` and their `"zone"`.
+        # Corresponds to the JSON property `labels`
+        # @return [Array<Google::Apis::LoggingV2beta1::LabelDescriptor>]
+        attr_accessor :labels
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @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`
+        # @return [String]
+        attr_accessor :value_type
+      
+        # A human-readable description for the label.
+        # Corresponds to the JSON property `description`
+        # @return [String]
+        attr_accessor :description
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # 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)
+          @description = args[:description] if args.key?(:description)
+        end
+      end
+      
+      # Result returned from `ListSinks`.
+      class ListSinksResponse
+        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 given a
+        # value in the response. To get the next batch 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)
+          @sinks = args[:sinks] if args.key?(:sinks)
+          @next_page_token = args[:next_page_token] if args.key?(:next_page_token)
+        end
+      end
+      
+      # Describes a sink used to export log entries outside Cloud Logging.
+      class LogSink
+        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`
+        # @return [String]
+        attr_accessor :name
+      
+        # 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
+      
+        # An [advanced logs filter](/logging/docs/view/advanced_filters) that defines
+        # the log entries to be exported. The filter must be consistent with the log
+        # entry format designed by the `outputVersionFormat` parameter, regardless of
+        # the format of the log entry that was originally written to Cloud Logging.
+        # Example: `"logName:syslog AND severity>=ERROR"`.
+        # Corresponds to the JSON property `filter`
+        # @return [String]
+        attr_accessor :filter
+      
+        # The log entry version used when exporting log entries from this sink. 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`
+        # @return [String]
+        attr_accessor :output_version_format
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # 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)
+        end
+      end
+      
+      # Result returned from ListLogMetrics.
+      class ListLogMetricsResponse
+        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 given a
+        # value in the response. To get the next batch 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
+        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`
+        # @return [String]
+        attr_accessor :name
+      
+        # A description of this metric, which is used in documentation.
+        # Corresponds to the JSON property `description`
+        # @return [String]
+        attr_accessor :description
+      
+        # An [advanced logs filter](/logging/docs/view/advanced_filters). Example: `"
+        # logName:syslog AND severity>=ERROR"`.
+        # Corresponds to the JSON property `filter`
+        # @return [String]
+        attr_accessor :filter
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # 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)
+        end
+      end
+      
+      # Complete log information about a single HTTP request to an App Engine
+      # application.
+      class RequestLog
+        include Google::Apis::Core::Hashable
+      
+        # Application that handled this request.
+        # Corresponds to the JSON property `appId`
+        # @return [String]
+        attr_accessor :app_id
+      
+        # Module of the application that handled this request.
+        # Corresponds to the JSON property `moduleId`
+        # @return [String]
+        attr_accessor :module_id
+      
+        # 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
+      
+        # 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`
+        # @return [String]
+        attr_accessor :method_prop
+      
+        # 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 :resource
+      
+        # HTTP version of request. Example: `"HTTP/1.1"`.
+        # Corresponds to the JSON property `httpVersion`
+        # @return [String]
+        attr_accessor :http_version
+      
+        # HTTP response status code. Example: 200, 404.
+        # Corresponds to the JSON property `status`
+        # @return [Fixnum]
+        attr_accessor :status
+      
+        # Size in bytes sent back to client by request.
+        # Corresponds to the JSON property `responseSize`
+        # @return [String]
+        attr_accessor :response_size
+      
+        # 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
+      
+        # 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 :nickname
+      
+        # 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`
+        # @return [String]
+        attr_accessor :host
+      
+        # An indication of the relative cost of serving this request.
+        # Corresponds to the JSON property `cost`
+        # @return [Float]
+        attr_accessor :cost
+      
+        # Queue name of the request, in the case of an offline request.
+        # Corresponds to the JSON property `taskQueueName`
+        # @return [String]
+        attr_accessor :task_queue_name
+      
+        # 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 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
+      
+        # Time this request spent in the pending request queue.
+        # Corresponds to the JSON property `pendingTime`
+        # @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
+      
+        # Whether this request is finished or active.
+        # Corresponds to the JSON property `finished`
+        # @return [Boolean]
+        attr_accessor :finished
+        alias_method :finished?, :finished
+      
+        # 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
+      
+        # 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`
+        # @return [String]
+        attr_accessor :trace_id
+      
+        # 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
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # 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)
+          @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)
+          @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)
+          @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)
+          @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)
+          @instance_id = args[:instance_id] if args.key?(:instance_id)
+          @line = args[:line] if args.key?(:line)
+          @app_engine_release = args[:app_engine_release] if args.key?(:app_engine_release)
+          @trace_id = args[:trace_id] if args.key?(:trace_id)
+          @source_reference = args[:source_reference] if args.key?(:source_reference)
+        end
+      end
+      
+      # Application log line emitted while processing a request.
+      class LogLine
+        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
+        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`
+        # @return [String]
+        attr_accessor :function_name
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # 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
+      
+      # 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. 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 canonical and persistent identifier of the deployed revision. Example (git)
+        # : "0035781c50ec7aa23385dc841529ce8a4b70db1b"
+        # Corresponds to the JSON property `revisionId`
+        # @return [String]
+        attr_accessor :revision_id
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # 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)
+        end
+      end
+    end
+  end
+end