| // Package logging provides access to the Google Cloud Logging API. |
| // |
| // See https://cloud.google.com/logging/docs/ |
| // |
| // Usage example: |
| // |
| // import "google.golang.org/api/logging/v2beta1" |
| // ... |
| // loggingService, err := logging.New(oauthHttpClient) |
| package logging // import "google.golang.org/api/logging/v2beta1" |
| |
| import ( |
| "bytes" |
| "encoding/json" |
| "errors" |
| "fmt" |
| context "golang.org/x/net/context" |
| ctxhttp "golang.org/x/net/context/ctxhttp" |
| gensupport "google.golang.org/api/gensupport" |
| googleapi "google.golang.org/api/googleapi" |
| "io" |
| "net/http" |
| "net/url" |
| "strconv" |
| "strings" |
| ) |
| |
| // Always reference these packages, just in case the auto-generated code |
| // below doesn't. |
| var _ = bytes.NewBuffer |
| var _ = strconv.Itoa |
| var _ = fmt.Sprintf |
| var _ = json.NewDecoder |
| var _ = io.Copy |
| var _ = url.Parse |
| var _ = gensupport.MarshalJSON |
| var _ = googleapi.Version |
| var _ = errors.New |
| var _ = strings.Replace |
| var _ = context.Canceled |
| var _ = ctxhttp.Do |
| |
| const apiId = "logging:v2beta1" |
| const apiName = "logging" |
| const apiVersion = "v2beta1" |
| const basePath = "https://logging.googleapis.com/" |
| |
| // OAuth2 scopes used by this API. |
| const ( |
| // View and manage your data across Google Cloud Platform services |
| CloudPlatformScope = "https://www.googleapis.com/auth/cloud-platform" |
| |
| // View your data across Google Cloud Platform services |
| CloudPlatformReadOnlyScope = "https://www.googleapis.com/auth/cloud-platform.read-only" |
| |
| // Administrate log data for your projects |
| LoggingAdminScope = "https://www.googleapis.com/auth/logging.admin" |
| |
| // View log data for your projects |
| LoggingReadScope = "https://www.googleapis.com/auth/logging.read" |
| |
| // Submit log data for your projects |
| LoggingWriteScope = "https://www.googleapis.com/auth/logging.write" |
| ) |
| |
| func New(client *http.Client) (*Service, error) { |
| if client == nil { |
| return nil, errors.New("client is nil") |
| } |
| s := &Service{client: client, BasePath: basePath} |
| s.Entries = NewEntriesService(s) |
| s.MonitoredResourceDescriptors = NewMonitoredResourceDescriptorsService(s) |
| s.Projects = NewProjectsService(s) |
| return s, nil |
| } |
| |
| type Service struct { |
| client *http.Client |
| BasePath string // API endpoint base URL |
| UserAgent string // optional additional User-Agent fragment |
| |
| Entries *EntriesService |
| |
| MonitoredResourceDescriptors *MonitoredResourceDescriptorsService |
| |
| Projects *ProjectsService |
| } |
| |
| func (s *Service) userAgent() string { |
| if s.UserAgent == "" { |
| return googleapi.UserAgent |
| } |
| return googleapi.UserAgent + " " + s.UserAgent |
| } |
| |
| func NewEntriesService(s *Service) *EntriesService { |
| rs := &EntriesService{s: s} |
| return rs |
| } |
| |
| type EntriesService struct { |
| s *Service |
| } |
| |
| func NewMonitoredResourceDescriptorsService(s *Service) *MonitoredResourceDescriptorsService { |
| rs := &MonitoredResourceDescriptorsService{s: s} |
| return rs |
| } |
| |
| type MonitoredResourceDescriptorsService struct { |
| s *Service |
| } |
| |
| func NewProjectsService(s *Service) *ProjectsService { |
| rs := &ProjectsService{s: s} |
| rs.Logs = NewProjectsLogsService(s) |
| rs.Metrics = NewProjectsMetricsService(s) |
| rs.Sinks = NewProjectsSinksService(s) |
| return rs |
| } |
| |
| type ProjectsService struct { |
| s *Service |
| |
| Logs *ProjectsLogsService |
| |
| Metrics *ProjectsMetricsService |
| |
| Sinks *ProjectsSinksService |
| } |
| |
| func NewProjectsLogsService(s *Service) *ProjectsLogsService { |
| rs := &ProjectsLogsService{s: s} |
| return rs |
| } |
| |
| type ProjectsLogsService struct { |
| s *Service |
| } |
| |
| func NewProjectsMetricsService(s *Service) *ProjectsMetricsService { |
| rs := &ProjectsMetricsService{s: s} |
| return rs |
| } |
| |
| type ProjectsMetricsService struct { |
| s *Service |
| } |
| |
| func NewProjectsSinksService(s *Service) *ProjectsSinksService { |
| rs := &ProjectsSinksService{s: s} |
| return rs |
| } |
| |
| type ProjectsSinksService struct { |
| s *Service |
| } |
| |
| // Empty: 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 `{}`. |
| type Empty struct { |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| } |
| |
| // HttpRequest: A common proto for logging HTTP requests. |
| type HttpRequest struct { |
| // CacheHit: Whether or not an entity was served from cache (with or |
| // without validation). |
| CacheHit bool `json:"cacheHit,omitempty"` |
| |
| // Referer: The referer(sic) URL of the request, as defined in [HTTP/1.1 |
| // Header Field |
| // Definitions](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html). |
| Referer string `json:"referer,omitempty"` |
| |
| // RemoteIp: The IP address (IPv4 or IPv6) of the client that issued the |
| // HTTP request. Examples: "192.168.1.1", |
| // "FE80::0202:B3FF:FE1E:8329". |
| RemoteIp string `json:"remoteIp,omitempty"` |
| |
| // RequestMethod: The request method. Examples: "GET", "HEAD", |
| // "PUT", "POST". |
| RequestMethod string `json:"requestMethod,omitempty"` |
| |
| // RequestSize: The size of the HTTP request message in bytes, including |
| // the request headers and the request body. |
| RequestSize int64 `json:"requestSize,omitempty,string"` |
| |
| // RequestUrl: 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". |
| RequestUrl string `json:"requestUrl,omitempty"` |
| |
| // ResponseSize: The size of the HTTP response message sent back to the |
| // client, in bytes, including the response headers and the response |
| // body. |
| ResponseSize int64 `json:"responseSize,omitempty,string"` |
| |
| // Status: The response code indicating the status of response. |
| // Examples: 200, 404. |
| Status int64 `json:"status,omitempty"` |
| |
| // UserAgent: The user agent sent by the client. Example: "Mozilla/4.0 |
| // (compatible; MSIE 6.0; Windows 98; Q312461; .NET CLR 1.0.3705)". |
| UserAgent string `json:"userAgent,omitempty"` |
| |
| // ValidatedWithOriginServer: 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. |
| ValidatedWithOriginServer bool `json:"validatedWithOriginServer,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "CacheHit") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| } |
| |
| func (s *HttpRequest) MarshalJSON() ([]byte, error) { |
| type noMethod HttpRequest |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields) |
| } |
| |
| // LabelDescriptor: A description of a label. |
| type LabelDescriptor struct { |
| // Description: A human-readable description for the label. |
| Description string `json:"description,omitempty"` |
| |
| // Key: The label key. |
| Key string `json:"key,omitempty"` |
| |
| // ValueType: The type of data that can be assigned to the label. |
| // |
| // Possible values: |
| // "STRING" |
| // "BOOL" |
| // "INT64" |
| ValueType string `json:"valueType,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Description") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| } |
| |
| func (s *LabelDescriptor) MarshalJSON() ([]byte, error) { |
| type noMethod LabelDescriptor |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields) |
| } |
| |
| // ListLogEntriesRequest: The parameters to `ListLogEntries`. |
| type ListLogEntriesRequest struct { |
| // Filter: 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. |
| Filter string `json:"filter,omitempty"` |
| |
| // OrderBy: 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`. |
| OrderBy string `json:"orderBy,omitempty"` |
| |
| // PageSize: 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. |
| PageSize int64 `json:"pageSize,omitempty"` |
| |
| // PageToken: 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. |
| PageToken string `json:"pageToken,omitempty"` |
| |
| // ProjectIds: Required. One or more project IDs or project numbers from |
| // which to retrieve log entries. Examples of a project ID: |
| // "my-project-1A", "1234567890". |
| ProjectIds []string `json:"projectIds,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Filter") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| } |
| |
| func (s *ListLogEntriesRequest) MarshalJSON() ([]byte, error) { |
| type noMethod ListLogEntriesRequest |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields) |
| } |
| |
| // ListLogEntriesResponse: Result returned from `ListLogEntries`. |
| type ListLogEntriesResponse struct { |
| // Entries: A list of log entries. |
| Entries []*LogEntry `json:"entries,omitempty"` |
| |
| // NextPageToken: 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`. |
| NextPageToken string `json:"nextPageToken,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Entries") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| } |
| |
| func (s *ListLogEntriesResponse) MarshalJSON() ([]byte, error) { |
| type noMethod ListLogEntriesResponse |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields) |
| } |
| |
| // ListLogMetricsResponse: Result returned from ListLogMetrics. |
| type ListLogMetricsResponse struct { |
| // Metrics: A list of logs-based metrics. |
| Metrics []*LogMetric `json:"metrics,omitempty"` |
| |
| // NextPageToken: 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`. |
| NextPageToken string `json:"nextPageToken,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Metrics") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| } |
| |
| func (s *ListLogMetricsResponse) MarshalJSON() ([]byte, error) { |
| type noMethod ListLogMetricsResponse |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields) |
| } |
| |
| // ListMonitoredResourceDescriptorsResponse: Result returned from |
| // ListMonitoredResourceDescriptors. |
| type ListMonitoredResourceDescriptorsResponse struct { |
| // NextPageToken: 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`. |
| NextPageToken string `json:"nextPageToken,omitempty"` |
| |
| // ResourceDescriptors: A list of resource descriptors. |
| ResourceDescriptors []*MonitoredResourceDescriptor `json:"resourceDescriptors,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "NextPageToken") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| } |
| |
| func (s *ListMonitoredResourceDescriptorsResponse) MarshalJSON() ([]byte, error) { |
| type noMethod ListMonitoredResourceDescriptorsResponse |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields) |
| } |
| |
| // ListSinksResponse: Result returned from `ListSinks`. |
| type ListSinksResponse struct { |
| // NextPageToken: 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`. |
| NextPageToken string `json:"nextPageToken,omitempty"` |
| |
| // Sinks: A list of sinks. |
| Sinks []*LogSink `json:"sinks,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "NextPageToken") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| } |
| |
| func (s *ListSinksResponse) MarshalJSON() ([]byte, error) { |
| type noMethod ListSinksResponse |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields) |
| } |
| |
| // LogEntry: An individual entry in a log. |
| type LogEntry struct { |
| // HttpRequest: Optional. Information about the HTTP request associated |
| // with this log entry, if applicable. |
| HttpRequest *HttpRequest `json:"httpRequest,omitempty"` |
| |
| // InsertId: 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. |
| InsertId string `json:"insertId,omitempty"` |
| |
| // JsonPayload: The log entry payload, represented as a structure that |
| // is expressed as a JSON object. |
| JsonPayload LogEntryJsonPayload `json:"jsonPayload,omitempty"` |
| |
| // Labels: Optional. A set of user-defined (key, value) data that |
| // provides additional information about the log entry. |
| Labels map[string]string `json:"labels,omitempty"` |
| |
| // LogName: 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. |
| LogName string `json:"logName,omitempty"` |
| |
| // Operation: Optional. Information about an operation associated with |
| // the log entry, if applicable. |
| Operation *LogEntryOperation `json:"operation,omitempty"` |
| |
| // ProtoPayload: The log entry payload, represented as a protocol |
| // buffer. You can only use `protoPayload` values that belong to a set |
| // of approved types. |
| ProtoPayload LogEntryProtoPayload `json:"protoPayload,omitempty"` |
| |
| // Resource: Required. The monitored resource associated with this log |
| // entry. Example: a log entry that reports a database error would be |
| // associated with the monitored resource designating the particular |
| // database that reported the error. |
| Resource *MonitoredResource `json:"resource,omitempty"` |
| |
| // Severity: Optional. The severity of the log entry. The default value |
| // is `LogSeverity.DEFAULT`. |
| // |
| // Possible values: |
| // "DEFAULT" |
| // "DEBUG" |
| // "INFO" |
| // "NOTICE" |
| // "WARNING" |
| // "ERROR" |
| // "CRITICAL" |
| // "ALERT" |
| // "EMERGENCY" |
| Severity string `json:"severity,omitempty"` |
| |
| // TextPayload: The log entry payload, represented as a Unicode string |
| // (UTF-8). |
| TextPayload string `json:"textPayload,omitempty"` |
| |
| // Timestamp: Optional. The time the event described by the log entry |
| // occurred. If omitted, Cloud Logging will use the time the log entry |
| // is written. |
| Timestamp string `json:"timestamp,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "HttpRequest") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| } |
| |
| func (s *LogEntry) MarshalJSON() ([]byte, error) { |
| type noMethod LogEntry |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields) |
| } |
| |
| type LogEntryJsonPayload interface{} |
| |
| type LogEntryProtoPayload interface{} |
| |
| // LogEntryOperation: Additional information about a potentially |
| // long-running operation with which a log entry is associated. |
| type LogEntryOperation struct { |
| // First: Optional. Set this to True if this is the first log entry in |
| // the operation. |
| First bool `json:"first,omitempty"` |
| |
| // Id: Required. An arbitrary operation identifier. Log entries with the |
| // same identifier are assumed to be part of the same operation. |
| Id string `json:"id,omitempty"` |
| |
| // Last: Optional. Set this to True if this is the last log entry in the |
| // operation. |
| Last bool `json:"last,omitempty"` |
| |
| // Producer: Required. A arbitrary producer identifier. The combination |
| // of `id` and `producer` must be globally unique. Examples for |
| // `producer`: "MyDivision.MyBigCompany.com", |
| // "github.com/MyProject/MyApplication". |
| Producer string `json:"producer,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "First") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| } |
| |
| func (s *LogEntryOperation) MarshalJSON() ([]byte, error) { |
| type noMethod LogEntryOperation |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields) |
| } |
| |
| // LogLine: Application log line emitted while processing a request. |
| type LogLine struct { |
| // LogMessage: App provided log message. |
| LogMessage string `json:"logMessage,omitempty"` |
| |
| // Severity: Severity of log. |
| // |
| // Possible values: |
| // "DEFAULT" |
| // "DEBUG" |
| // "INFO" |
| // "NOTICE" |
| // "WARNING" |
| // "ERROR" |
| // "CRITICAL" |
| // "ALERT" |
| // "EMERGENCY" |
| Severity string `json:"severity,omitempty"` |
| |
| // SourceLocation: Line of code that generated this log message. |
| SourceLocation *SourceLocation `json:"sourceLocation,omitempty"` |
| |
| // Time: Time when log entry was made. May be inaccurate. |
| Time string `json:"time,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "LogMessage") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| } |
| |
| func (s *LogLine) MarshalJSON() ([]byte, error) { |
| type noMethod LogLine |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields) |
| } |
| |
| // LogMetric: Describes a logs-based metric. The value of the metric is |
| // the number of log entries that match a logs filter. |
| type LogMetric struct { |
| // Description: A description of this metric, which is used in |
| // documentation. |
| Description string `json:"description,omitempty"` |
| |
| // Filter: An [advanced logs |
| // filter](/logging/docs/view/advanced_filters). Example: |
| // "logName:syslog AND severity>=ERROR". |
| Filter string `json:"filter,omitempty"` |
| |
| // Name: 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. |
| Name string `json:"name,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Description") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| } |
| |
| func (s *LogMetric) MarshalJSON() ([]byte, error) { |
| type noMethod LogMetric |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields) |
| } |
| |
| // LogSink: Describes a sink used to export log entries outside Cloud |
| // Logging. |
| type LogSink struct { |
| // Destination: 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". |
| Destination string `json:"destination,omitempty"` |
| |
| // Filter: 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". |
| Filter string `json:"filter,omitempty"` |
| |
| // Name: 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 `_-.`. |
| Name string `json:"name,omitempty"` |
| |
| // OutputVersionFormat: 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. |
| // |
| // Possible values: |
| // "VERSION_FORMAT_UNSPECIFIED" |
| // "V2" |
| // "V1" |
| OutputVersionFormat string `json:"outputVersionFormat,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Destination") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| } |
| |
| func (s *LogSink) MarshalJSON() ([]byte, error) { |
| type noMethod LogSink |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields) |
| } |
| |
| // MonitoredResource: A specific monitored resource or a group of |
| // monitored resources. |
| type MonitoredResource struct { |
| // Labels: 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. |
| Labels map[string]string `json:"labels,omitempty"` |
| |
| // Type: 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. |
| Type string `json:"type,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Labels") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| } |
| |
| func (s *MonitoredResource) MarshalJSON() ([]byte, error) { |
| type noMethod MonitoredResource |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields) |
| } |
| |
| // MonitoredResourceDescriptor: A description of a type of monitored |
| // resource. |
| type MonitoredResourceDescriptor struct { |
| // Description: A detailed description of the monitored resource type, |
| // which is used in documentation. |
| Description string `json:"description,omitempty"` |
| |
| // DisplayName: A concise name for the monitored resource type, which is |
| // displayed in user interfaces. For example, "Cloud SQL Database". |
| DisplayName string `json:"displayName,omitempty"` |
| |
| // Labels: 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". |
| Labels []*LabelDescriptor `json:"labels,omitempty"` |
| |
| // Type: The monitored resource type. For example, the type |
| // "cloudsql_database" represents databases in Google Cloud SQL. |
| Type string `json:"type,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Description") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| } |
| |
| func (s *MonitoredResourceDescriptor) MarshalJSON() ([]byte, error) { |
| type noMethod MonitoredResourceDescriptor |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields) |
| } |
| |
| // RequestLog: Complete log information about a single request to an |
| // application. |
| type RequestLog struct { |
| // AppEngineRelease: App Engine release version string. |
| AppEngineRelease string `json:"appEngineRelease,omitempty"` |
| |
| // AppId: Identifies the application that handled this request. |
| AppId string `json:"appId,omitempty"` |
| |
| // Cost: An indication of the relative cost of serving this request. |
| Cost float64 `json:"cost,omitempty"` |
| |
| // EndTime: Time at which request was known to end processing. |
| EndTime string `json:"endTime,omitempty"` |
| |
| // Finished: If true, represents a finished request. Otherwise, the |
| // request is active. |
| Finished bool `json:"finished,omitempty"` |
| |
| // Host: The Internet host and port number of the resource being |
| // requested. |
| Host string `json:"host,omitempty"` |
| |
| // HttpVersion: HTTP version of request. |
| HttpVersion string `json:"httpVersion,omitempty"` |
| |
| // InstanceId: An opaque identifier for the instance that handled the |
| // request. |
| InstanceId string `json:"instanceId,omitempty"` |
| |
| // InstanceIndex: If the instance that processed this request was |
| // individually addressable (i.e. belongs to a manually scaled module), |
| // this is the 0 based index of the instance, otherwise this value is |
| // -1. |
| InstanceIndex int64 `json:"instanceIndex,omitempty"` |
| |
| // Ip: Origin IP address. |
| Ip string `json:"ip,omitempty"` |
| |
| // Latency: Latency of the request. |
| Latency string `json:"latency,omitempty"` |
| |
| // Line: List of log lines emitted by the application while serving this |
| // request, if requested. |
| Line []*LogLine `json:"line,omitempty"` |
| |
| // MegaCycles: Number of CPU megacycles used to process request. |
| MegaCycles int64 `json:"megaCycles,omitempty,string"` |
| |
| // Method: Request method, such as `GET`, `HEAD`, `PUT`, `POST`, or |
| // `DELETE`. |
| Method string `json:"method,omitempty"` |
| |
| // ModuleId: Identifies the module of the application that handled this |
| // request. |
| ModuleId string `json:"moduleId,omitempty"` |
| |
| // Nickname: A string that identifies a logged-in user who made this |
| // request, or empty if the user is not logged in. 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 may have a similar name. This information is also available to |
| // the application via Users API. This field will be populated starting |
| // with App Engine 1.9.21. |
| Nickname string `json:"nickname,omitempty"` |
| |
| // PendingTime: Time this request spent in the pending request queue, if |
| // it was pending at all. |
| PendingTime string `json:"pendingTime,omitempty"` |
| |
| // Referrer: Referrer URL of request. |
| Referrer string `json:"referrer,omitempty"` |
| |
| // RequestId: Globally unique identifier for a request, based on request |
| // start time. Request IDs for requests which started later will compare |
| // greater as strings than those for requests which started earlier. |
| RequestId string `json:"requestId,omitempty"` |
| |
| // Resource: 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". Any trailing fragment (separated by a '#' character) |
| // will not be included. |
| Resource string `json:"resource,omitempty"` |
| |
| // ResponseSize: Size in bytes sent back to client by request. |
| ResponseSize int64 `json:"responseSize,omitempty,string"` |
| |
| // SourceReference: 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. |
| SourceReference []*SourceReference `json:"sourceReference,omitempty"` |
| |
| // StartTime: Time at which request was known to have begun processing. |
| StartTime string `json:"startTime,omitempty"` |
| |
| // Status: Response status of request. |
| Status int64 `json:"status,omitempty"` |
| |
| // TaskName: Task name of the request (for an offline request). |
| TaskName string `json:"taskName,omitempty"` |
| |
| // TaskQueueName: Queue name of the request (for an offline request). |
| TaskQueueName string `json:"taskQueueName,omitempty"` |
| |
| // TraceId: Cloud Trace identifier of the trace for this request. |
| TraceId string `json:"traceId,omitempty"` |
| |
| // UrlMapEntry: File or class within URL mapping used for request. |
| // Useful for tracking down the source code which was responsible for |
| // managing request. Especially for multiply mapped handlers. |
| UrlMapEntry string `json:"urlMapEntry,omitempty"` |
| |
| // UserAgent: User agent used for making request. |
| UserAgent string `json:"userAgent,omitempty"` |
| |
| // VersionId: Version of the application that handled this request. |
| VersionId string `json:"versionId,omitempty"` |
| |
| // WasLoadingRequest: Was this request a loading request for this |
| // instance? |
| WasLoadingRequest bool `json:"wasLoadingRequest,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "AppEngineRelease") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| } |
| |
| func (s *RequestLog) MarshalJSON() ([]byte, error) { |
| type noMethod RequestLog |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields) |
| } |
| |
| // SourceLocation: Specifies a location in a source file. |
| type SourceLocation struct { |
| // File: Source file name. May or may not be a fully qualified name, |
| // depending on the runtime environment. |
| File string `json:"file,omitempty"` |
| |
| // FunctionName: Human-readable name of the function or method being |
| // invoked, with optional context such as the class or package name, for |
| // use in contexts such as the logs viewer where file:line number is |
| // less meaningful. This may vary by language, for example: in Java: |
| // qual.if.ied.Class.method in Go: dir/package.func in Python: function |
| // ... |
| FunctionName string `json:"functionName,omitempty"` |
| |
| // Line: Line within the source file. |
| Line int64 `json:"line,omitempty,string"` |
| |
| // ForceSendFields is a list of field names (e.g. "File") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| } |
| |
| func (s *SourceLocation) MarshalJSON() ([]byte, error) { |
| type noMethod SourceLocation |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields) |
| } |
| |
| // SourceReference: A reference to a particular snapshot of the source |
| // tree used to build and deploy an application. |
| type SourceReference struct { |
| // Repository: Optional. A URI string identifying the repository. |
| // Example: "https://github.com/GoogleCloudPlatform/kubernetes.git" |
| Repository string `json:"repository,omitempty"` |
| |
| // RevisionId: The canonical (and persistent) identifier of the deployed |
| // revision. Example (git): "0035781c50ec7aa23385dc841529ce8a4b70db1b" |
| RevisionId string `json:"revisionId,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Repository") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| } |
| |
| func (s *SourceReference) MarshalJSON() ([]byte, error) { |
| type noMethod SourceReference |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields) |
| } |
| |
| // WriteLogEntriesRequest: The parameters to WriteLogEntries. |
| type WriteLogEntriesRequest struct { |
| // Entries: Required. The log entries to write. The log entries must |
| // have values for all required fields. |
| Entries []*LogEntry `json:"entries,omitempty"` |
| |
| // Labels: 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" }` |
| Labels map[string]string `json:"labels,omitempty"` |
| |
| // LogName: 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. |
| LogName string `json:"logName,omitempty"` |
| |
| // Resource: Optional. A default monitored resource for those log |
| // entries in `entries` that do not specify their own `resource`. |
| Resource *MonitoredResource `json:"resource,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Entries") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| } |
| |
| func (s *WriteLogEntriesRequest) MarshalJSON() ([]byte, error) { |
| type noMethod WriteLogEntriesRequest |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields) |
| } |
| |
| // WriteLogEntriesResponse: Result returned from WriteLogEntries. empty |
| type WriteLogEntriesResponse struct { |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| } |
| |
| // method id "logging.entries.list": |
| |
| type EntriesListCall struct { |
| s *Service |
| listlogentriesrequest *ListLogEntriesRequest |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| } |
| |
| // List: Lists log entries. Use this method to examine log entries from |
| // Cloud Logging. See [Exporting Logs](/logging/docs/export) for other |
| // ways to copy log entries out of Cloud Logging. |
| func (r *EntriesService) List(listlogentriesrequest *ListLogEntriesRequest) *EntriesListCall { |
| c := &EntriesListCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.listlogentriesrequest = listlogentriesrequest |
| return c |
| } |
| |
| // QuotaUser sets the optional parameter "quotaUser": Available to use |
| // for quota purposes for server-side applications. Can be any arbitrary |
| // string assigned to a user, but should not exceed 40 characters. |
| func (c *EntriesListCall) QuotaUser(quotaUser string) *EntriesListCall { |
| c.urlParams_.Set("quotaUser", quotaUser) |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse |
| // for more information. |
| func (c *EntriesListCall) Fields(s ...googleapi.Field) *EntriesListCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *EntriesListCall) Context(ctx context.Context) *EntriesListCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| func (c *EntriesListCall) doRequest(alt string) (*http.Response, error) { |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.listlogentriesrequest) |
| if err != nil { |
| return nil, err |
| } |
| ctype := "application/json" |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "v2beta1/entries:list") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("POST", urls, body) |
| googleapi.SetOpaque(req.URL) |
| req.Header.Set("Content-Type", ctype) |
| req.Header.Set("User-Agent", c.s.userAgent()) |
| if c.ctx_ != nil { |
| return ctxhttp.Do(c.ctx_, c.s.client, req) |
| } |
| return c.s.client.Do(req) |
| } |
| |
| // Do executes the "logging.entries.list" call. |
| // Exactly one of *ListLogEntriesResponse or error will be non-nil. Any |
| // non-2xx status code is an error. Response headers are in either |
| // *ListLogEntriesResponse.ServerResponse.Header or (if a response was |
| // returned at all) in error.(*googleapi.Error).Header. Use |
| // googleapi.IsNotModified to check whether the returned error was |
| // because http.StatusNotModified was returned. |
| func (c *EntriesListCall) Do() (*ListLogEntriesResponse, error) { |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &ListLogEntriesResponse{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Lists log entries. Use this method to examine log entries from Cloud Logging. See [Exporting Logs](/logging/docs/export) for other ways to copy log entries out of Cloud Logging.", |
| // "httpMethod": "POST", |
| // "id": "logging.entries.list", |
| // "path": "v2beta1/entries:list", |
| // "request": { |
| // "$ref": "ListLogEntriesRequest" |
| // }, |
| // "response": { |
| // "$ref": "ListLogEntriesResponse" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/cloud-platform", |
| // "https://www.googleapis.com/auth/cloud-platform.read-only", |
| // "https://www.googleapis.com/auth/logging.admin", |
| // "https://www.googleapis.com/auth/logging.read" |
| // ] |
| // } |
| |
| } |
| |
| // method id "logging.entries.write": |
| |
| type EntriesWriteCall struct { |
| s *Service |
| writelogentriesrequest *WriteLogEntriesRequest |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| } |
| |
| // Write: Writes log entries to Cloud Logging. All log entries in Cloud |
| // Logging are written by this method. |
| func (r *EntriesService) Write(writelogentriesrequest *WriteLogEntriesRequest) *EntriesWriteCall { |
| c := &EntriesWriteCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.writelogentriesrequest = writelogentriesrequest |
| return c |
| } |
| |
| // QuotaUser sets the optional parameter "quotaUser": Available to use |
| // for quota purposes for server-side applications. Can be any arbitrary |
| // string assigned to a user, but should not exceed 40 characters. |
| func (c *EntriesWriteCall) QuotaUser(quotaUser string) *EntriesWriteCall { |
| c.urlParams_.Set("quotaUser", quotaUser) |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse |
| // for more information. |
| func (c *EntriesWriteCall) Fields(s ...googleapi.Field) *EntriesWriteCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *EntriesWriteCall) Context(ctx context.Context) *EntriesWriteCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| func (c *EntriesWriteCall) doRequest(alt string) (*http.Response, error) { |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.writelogentriesrequest) |
| if err != nil { |
| return nil, err |
| } |
| ctype := "application/json" |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "v2beta1/entries:write") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("POST", urls, body) |
| googleapi.SetOpaque(req.URL) |
| req.Header.Set("Content-Type", ctype) |
| req.Header.Set("User-Agent", c.s.userAgent()) |
| if c.ctx_ != nil { |
| return ctxhttp.Do(c.ctx_, c.s.client, req) |
| } |
| return c.s.client.Do(req) |
| } |
| |
| // Do executes the "logging.entries.write" call. |
| // Exactly one of *WriteLogEntriesResponse or error will be non-nil. Any |
| // non-2xx status code is an error. Response headers are in either |
| // *WriteLogEntriesResponse.ServerResponse.Header or (if a response was |
| // returned at all) in error.(*googleapi.Error).Header. Use |
| // googleapi.IsNotModified to check whether the returned error was |
| // because http.StatusNotModified was returned. |
| func (c *EntriesWriteCall) Do() (*WriteLogEntriesResponse, error) { |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &WriteLogEntriesResponse{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Writes log entries to Cloud Logging. All log entries in Cloud Logging are written by this method.", |
| // "httpMethod": "POST", |
| // "id": "logging.entries.write", |
| // "path": "v2beta1/entries:write", |
| // "request": { |
| // "$ref": "WriteLogEntriesRequest" |
| // }, |
| // "response": { |
| // "$ref": "WriteLogEntriesResponse" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/cloud-platform", |
| // "https://www.googleapis.com/auth/logging.admin", |
| // "https://www.googleapis.com/auth/logging.write" |
| // ] |
| // } |
| |
| } |
| |
| // method id "logging.monitoredResourceDescriptors.list": |
| |
| type MonitoredResourceDescriptorsListCall struct { |
| s *Service |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| } |
| |
| // List: Lists monitored resource descriptors that are used by Cloud |
| // Logging. |
| func (r *MonitoredResourceDescriptorsService) List() *MonitoredResourceDescriptorsListCall { |
| c := &MonitoredResourceDescriptorsListCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| return c |
| } |
| |
| // PageSize sets the optional parameter "pageSize": 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. |
| func (c *MonitoredResourceDescriptorsListCall) PageSize(pageSize int64) *MonitoredResourceDescriptorsListCall { |
| c.urlParams_.Set("pageSize", fmt.Sprint(pageSize)) |
| return c |
| } |
| |
| // PageToken sets the optional parameter "pageToken": 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. |
| func (c *MonitoredResourceDescriptorsListCall) PageToken(pageToken string) *MonitoredResourceDescriptorsListCall { |
| c.urlParams_.Set("pageToken", pageToken) |
| return c |
| } |
| |
| // QuotaUser sets the optional parameter "quotaUser": Available to use |
| // for quota purposes for server-side applications. Can be any arbitrary |
| // string assigned to a user, but should not exceed 40 characters. |
| func (c *MonitoredResourceDescriptorsListCall) QuotaUser(quotaUser string) *MonitoredResourceDescriptorsListCall { |
| c.urlParams_.Set("quotaUser", quotaUser) |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse |
| // for more information. |
| func (c *MonitoredResourceDescriptorsListCall) Fields(s ...googleapi.Field) *MonitoredResourceDescriptorsListCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets the optional parameter which makes the operation |
| // fail if the object's ETag matches the given value. This is useful for |
| // getting updates only after the object has changed since the last |
| // request. Use googleapi.IsNotModified to check whether the response |
| // error from Do is the result of In-None-Match. |
| func (c *MonitoredResourceDescriptorsListCall) IfNoneMatch(entityTag string) *MonitoredResourceDescriptorsListCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *MonitoredResourceDescriptorsListCall) Context(ctx context.Context) *MonitoredResourceDescriptorsListCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| func (c *MonitoredResourceDescriptorsListCall) doRequest(alt string) (*http.Response, error) { |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "v2beta1/monitoredResourceDescriptors") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| googleapi.SetOpaque(req.URL) |
| req.Header.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| req.Header.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| if c.ctx_ != nil { |
| return ctxhttp.Do(c.ctx_, c.s.client, req) |
| } |
| return c.s.client.Do(req) |
| } |
| |
| // Do executes the "logging.monitoredResourceDescriptors.list" call. |
| // Exactly one of *ListMonitoredResourceDescriptorsResponse or error |
| // will be non-nil. Any non-2xx status code is an error. Response |
| // headers are in either |
| // *ListMonitoredResourceDescriptorsResponse.ServerResponse.Header or |
| // (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was |
| // returned. |
| func (c *MonitoredResourceDescriptorsListCall) Do() (*ListMonitoredResourceDescriptorsResponse, error) { |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &ListMonitoredResourceDescriptorsResponse{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Lists monitored resource descriptors that are used by Cloud Logging.", |
| // "httpMethod": "GET", |
| // "id": "logging.monitoredResourceDescriptors.list", |
| // "parameters": { |
| // "pageSize": { |
| // "description": "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.", |
| // "format": "int32", |
| // "location": "query", |
| // "type": "integer" |
| // }, |
| // "pageToken": { |
| // "description": "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.", |
| // "location": "query", |
| // "type": "string" |
| // } |
| // }, |
| // "path": "v2beta1/monitoredResourceDescriptors", |
| // "response": { |
| // "$ref": "ListMonitoredResourceDescriptorsResponse" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/cloud-platform", |
| // "https://www.googleapis.com/auth/cloud-platform.read-only", |
| // "https://www.googleapis.com/auth/logging.admin", |
| // "https://www.googleapis.com/auth/logging.read" |
| // ] |
| // } |
| |
| } |
| |
| // method id "logging.projects.logs.delete": |
| |
| type ProjectsLogsDeleteCall struct { |
| s *Service |
| logName string |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| } |
| |
| // Delete: Deletes a log and all its log entries. The log will reappear |
| // if it receives new entries. |
| func (r *ProjectsLogsService) Delete(logName string) *ProjectsLogsDeleteCall { |
| c := &ProjectsLogsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.logName = logName |
| return c |
| } |
| |
| // QuotaUser sets the optional parameter "quotaUser": Available to use |
| // for quota purposes for server-side applications. Can be any arbitrary |
| // string assigned to a user, but should not exceed 40 characters. |
| func (c *ProjectsLogsDeleteCall) QuotaUser(quotaUser string) *ProjectsLogsDeleteCall { |
| c.urlParams_.Set("quotaUser", quotaUser) |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse |
| // for more information. |
| func (c *ProjectsLogsDeleteCall) Fields(s ...googleapi.Field) *ProjectsLogsDeleteCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *ProjectsLogsDeleteCall) Context(ctx context.Context) *ProjectsLogsDeleteCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| func (c *ProjectsLogsDeleteCall) doRequest(alt string) (*http.Response, error) { |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "v2beta1/{+logName}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("DELETE", urls, body) |
| googleapi.Expand(req.URL, map[string]string{ |
| "logName": c.logName, |
| }) |
| req.Header.Set("User-Agent", c.s.userAgent()) |
| if c.ctx_ != nil { |
| return ctxhttp.Do(c.ctx_, c.s.client, req) |
| } |
| return c.s.client.Do(req) |
| } |
| |
| // Do executes the "logging.projects.logs.delete" call. |
| // Exactly one of *Empty or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *Empty.ServerResponse.Header or (if a response was returned at all) |
| // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified |
| // was returned. |
| func (c *ProjectsLogsDeleteCall) Do() (*Empty, error) { |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &Empty{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Deletes a log and all its log entries. The log will reappear if it receives new entries.", |
| // "httpMethod": "DELETE", |
| // "id": "logging.projects.logs.delete", |
| // "parameterOrder": [ |
| // "logName" |
| // ], |
| // "parameters": { |
| // "logName": { |
| // "description": "Required. The resource name of the log to delete. Example: `\"projects/my-project/logs/syslog\"`.", |
| // "location": "path", |
| // "pattern": "^projects/[^/]*/logs/[^/]*$", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "v2beta1/{+logName}", |
| // "response": { |
| // "$ref": "Empty" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/cloud-platform", |
| // "https://www.googleapis.com/auth/logging.admin" |
| // ] |
| // } |
| |
| } |
| |
| // method id "logging.projects.metrics.create": |
| |
| type ProjectsMetricsCreateCall struct { |
| s *Service |
| projectName string |
| logmetric *LogMetric |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| } |
| |
| // Create: Creates a logs-based metric. |
| func (r *ProjectsMetricsService) Create(projectName string, logmetric *LogMetric) *ProjectsMetricsCreateCall { |
| c := &ProjectsMetricsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.projectName = projectName |
| c.logmetric = logmetric |
| return c |
| } |
| |
| // QuotaUser sets the optional parameter "quotaUser": Available to use |
| // for quota purposes for server-side applications. Can be any arbitrary |
| // string assigned to a user, but should not exceed 40 characters. |
| func (c *ProjectsMetricsCreateCall) QuotaUser(quotaUser string) *ProjectsMetricsCreateCall { |
| c.urlParams_.Set("quotaUser", quotaUser) |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse |
| // for more information. |
| func (c *ProjectsMetricsCreateCall) Fields(s ...googleapi.Field) *ProjectsMetricsCreateCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *ProjectsMetricsCreateCall) Context(ctx context.Context) *ProjectsMetricsCreateCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| func (c *ProjectsMetricsCreateCall) doRequest(alt string) (*http.Response, error) { |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.logmetric) |
| if err != nil { |
| return nil, err |
| } |
| ctype := "application/json" |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "v2beta1/{+projectName}/metrics") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("POST", urls, body) |
| googleapi.Expand(req.URL, map[string]string{ |
| "projectName": c.projectName, |
| }) |
| req.Header.Set("Content-Type", ctype) |
| req.Header.Set("User-Agent", c.s.userAgent()) |
| if c.ctx_ != nil { |
| return ctxhttp.Do(c.ctx_, c.s.client, req) |
| } |
| return c.s.client.Do(req) |
| } |
| |
| // Do executes the "logging.projects.metrics.create" call. |
| // Exactly one of *LogMetric or error will be non-nil. Any non-2xx |
| // status code is an error. Response headers are in either |
| // *LogMetric.ServerResponse.Header or (if a response was returned at |
| // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified |
| // to check whether the returned error was because |
| // http.StatusNotModified was returned. |
| func (c *ProjectsMetricsCreateCall) Do() (*LogMetric, error) { |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &LogMetric{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Creates a logs-based metric.", |
| // "httpMethod": "POST", |
| // "id": "logging.projects.metrics.create", |
| // "parameterOrder": [ |
| // "projectName" |
| // ], |
| // "parameters": { |
| // "projectName": { |
| // "description": "The resource name of the project in which to create the metric. Example: `\"projects/my-project-id\"`. The new metric must be provided in the request.", |
| // "location": "path", |
| // "pattern": "^projects/[^/]*$", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "v2beta1/{+projectName}/metrics", |
| // "request": { |
| // "$ref": "LogMetric" |
| // }, |
| // "response": { |
| // "$ref": "LogMetric" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/cloud-platform", |
| // "https://www.googleapis.com/auth/logging.admin", |
| // "https://www.googleapis.com/auth/logging.write" |
| // ] |
| // } |
| |
| } |
| |
| // method id "logging.projects.metrics.delete": |
| |
| type ProjectsMetricsDeleteCall struct { |
| s *Service |
| metricName string |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| } |
| |
| // Delete: Deletes a logs-based metric. |
| func (r *ProjectsMetricsService) Delete(metricName string) *ProjectsMetricsDeleteCall { |
| c := &ProjectsMetricsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.metricName = metricName |
| return c |
| } |
| |
| // QuotaUser sets the optional parameter "quotaUser": Available to use |
| // for quota purposes for server-side applications. Can be any arbitrary |
| // string assigned to a user, but should not exceed 40 characters. |
| func (c *ProjectsMetricsDeleteCall) QuotaUser(quotaUser string) *ProjectsMetricsDeleteCall { |
| c.urlParams_.Set("quotaUser", quotaUser) |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse |
| // for more information. |
| func (c *ProjectsMetricsDeleteCall) Fields(s ...googleapi.Field) *ProjectsMetricsDeleteCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *ProjectsMetricsDeleteCall) Context(ctx context.Context) *ProjectsMetricsDeleteCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| func (c *ProjectsMetricsDeleteCall) doRequest(alt string) (*http.Response, error) { |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "v2beta1/{+metricName}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("DELETE", urls, body) |
| googleapi.Expand(req.URL, map[string]string{ |
| "metricName": c.metricName, |
| }) |
| req.Header.Set("User-Agent", c.s.userAgent()) |
| if c.ctx_ != nil { |
| return ctxhttp.Do(c.ctx_, c.s.client, req) |
| } |
| return c.s.client.Do(req) |
| } |
| |
| // Do executes the "logging.projects.metrics.delete" call. |
| // Exactly one of *Empty or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *Empty.ServerResponse.Header or (if a response was returned at all) |
| // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified |
| // was returned. |
| func (c *ProjectsMetricsDeleteCall) Do() (*Empty, error) { |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &Empty{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Deletes a logs-based metric.", |
| // "httpMethod": "DELETE", |
| // "id": "logging.projects.metrics.delete", |
| // "parameterOrder": [ |
| // "metricName" |
| // ], |
| // "parameters": { |
| // "metricName": { |
| // "description": "The resource name of the metric to delete. Example: `\"projects/my-project-id/metrics/my-metric-id\"`.", |
| // "location": "path", |
| // "pattern": "^projects/[^/]*/metrics/[^/]*$", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "v2beta1/{+metricName}", |
| // "response": { |
| // "$ref": "Empty" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/cloud-platform", |
| // "https://www.googleapis.com/auth/logging.admin", |
| // "https://www.googleapis.com/auth/logging.write" |
| // ] |
| // } |
| |
| } |
| |
| // method id "logging.projects.metrics.get": |
| |
| type ProjectsMetricsGetCall struct { |
| s *Service |
| metricName string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| } |
| |
| // Get: Gets a logs-based metric. |
| func (r *ProjectsMetricsService) Get(metricName string) *ProjectsMetricsGetCall { |
| c := &ProjectsMetricsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.metricName = metricName |
| return c |
| } |
| |
| // QuotaUser sets the optional parameter "quotaUser": Available to use |
| // for quota purposes for server-side applications. Can be any arbitrary |
| // string assigned to a user, but should not exceed 40 characters. |
| func (c *ProjectsMetricsGetCall) QuotaUser(quotaUser string) *ProjectsMetricsGetCall { |
| c.urlParams_.Set("quotaUser", quotaUser) |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse |
| // for more information. |
| func (c *ProjectsMetricsGetCall) Fields(s ...googleapi.Field) *ProjectsMetricsGetCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets the optional parameter which makes the operation |
| // fail if the object's ETag matches the given value. This is useful for |
| // getting updates only after the object has changed since the last |
| // request. Use googleapi.IsNotModified to check whether the response |
| // error from Do is the result of In-None-Match. |
| func (c *ProjectsMetricsGetCall) IfNoneMatch(entityTag string) *ProjectsMetricsGetCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *ProjectsMetricsGetCall) Context(ctx context.Context) *ProjectsMetricsGetCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| func (c *ProjectsMetricsGetCall) doRequest(alt string) (*http.Response, error) { |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "v2beta1/{+metricName}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| googleapi.Expand(req.URL, map[string]string{ |
| "metricName": c.metricName, |
| }) |
| req.Header.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| req.Header.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| if c.ctx_ != nil { |
| return ctxhttp.Do(c.ctx_, c.s.client, req) |
| } |
| return c.s.client.Do(req) |
| } |
| |
| // Do executes the "logging.projects.metrics.get" call. |
| // Exactly one of *LogMetric or error will be non-nil. Any non-2xx |
| // status code is an error. Response headers are in either |
| // *LogMetric.ServerResponse.Header or (if a response was returned at |
| // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified |
| // to check whether the returned error was because |
| // http.StatusNotModified was returned. |
| func (c *ProjectsMetricsGetCall) Do() (*LogMetric, error) { |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &LogMetric{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Gets a logs-based metric.", |
| // "httpMethod": "GET", |
| // "id": "logging.projects.metrics.get", |
| // "parameterOrder": [ |
| // "metricName" |
| // ], |
| // "parameters": { |
| // "metricName": { |
| // "description": "The resource name of the desired metric. Example: `\"projects/my-project-id/metrics/my-metric-id\"`.", |
| // "location": "path", |
| // "pattern": "^projects/[^/]*/metrics/[^/]*$", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "v2beta1/{+metricName}", |
| // "response": { |
| // "$ref": "LogMetric" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/cloud-platform", |
| // "https://www.googleapis.com/auth/cloud-platform.read-only", |
| // "https://www.googleapis.com/auth/logging.admin", |
| // "https://www.googleapis.com/auth/logging.read" |
| // ] |
| // } |
| |
| } |
| |
| // method id "logging.projects.metrics.list": |
| |
| type ProjectsMetricsListCall struct { |
| s *Service |
| projectName string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| } |
| |
| // List: Lists logs-based metrics. |
| func (r *ProjectsMetricsService) List(projectName string) *ProjectsMetricsListCall { |
| c := &ProjectsMetricsListCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.projectName = projectName |
| return c |
| } |
| |
| // PageSize sets the optional parameter "pageSize": 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. |
| func (c *ProjectsMetricsListCall) PageSize(pageSize int64) *ProjectsMetricsListCall { |
| c.urlParams_.Set("pageSize", fmt.Sprint(pageSize)) |
| return c |
| } |
| |
| // PageToken sets the optional parameter "pageToken": 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 value of `projectName` must be the same as in the |
| // previous request. |
| func (c *ProjectsMetricsListCall) PageToken(pageToken string) *ProjectsMetricsListCall { |
| c.urlParams_.Set("pageToken", pageToken) |
| return c |
| } |
| |
| // QuotaUser sets the optional parameter "quotaUser": Available to use |
| // for quota purposes for server-side applications. Can be any arbitrary |
| // string assigned to a user, but should not exceed 40 characters. |
| func (c *ProjectsMetricsListCall) QuotaUser(quotaUser string) *ProjectsMetricsListCall { |
| c.urlParams_.Set("quotaUser", quotaUser) |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse |
| // for more information. |
| func (c *ProjectsMetricsListCall) Fields(s ...googleapi.Field) *ProjectsMetricsListCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets the optional parameter which makes the operation |
| // fail if the object's ETag matches the given value. This is useful for |
| // getting updates only after the object has changed since the last |
| // request. Use googleapi.IsNotModified to check whether the response |
| // error from Do is the result of In-None-Match. |
| func (c *ProjectsMetricsListCall) IfNoneMatch(entityTag string) *ProjectsMetricsListCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *ProjectsMetricsListCall) Context(ctx context.Context) *ProjectsMetricsListCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| func (c *ProjectsMetricsListCall) doRequest(alt string) (*http.Response, error) { |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "v2beta1/{+projectName}/metrics") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| googleapi.Expand(req.URL, map[string]string{ |
| "projectName": c.projectName, |
| }) |
| req.Header.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| req.Header.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| if c.ctx_ != nil { |
| return ctxhttp.Do(c.ctx_, c.s.client, req) |
| } |
| return c.s.client.Do(req) |
| } |
| |
| // Do executes the "logging.projects.metrics.list" call. |
| // Exactly one of *ListLogMetricsResponse or error will be non-nil. Any |
| // non-2xx status code is an error. Response headers are in either |
| // *ListLogMetricsResponse.ServerResponse.Header or (if a response was |
| // returned at all) in error.(*googleapi.Error).Header. Use |
| // googleapi.IsNotModified to check whether the returned error was |
| // because http.StatusNotModified was returned. |
| func (c *ProjectsMetricsListCall) Do() (*ListLogMetricsResponse, error) { |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &ListLogMetricsResponse{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Lists logs-based metrics.", |
| // "httpMethod": "GET", |
| // "id": "logging.projects.metrics.list", |
| // "parameterOrder": [ |
| // "projectName" |
| // ], |
| // "parameters": { |
| // "pageSize": { |
| // "description": "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.", |
| // "format": "int32", |
| // "location": "query", |
| // "type": "integer" |
| // }, |
| // "pageToken": { |
| // "description": "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 value of `projectName` must be the same as in the previous request.", |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "projectName": { |
| // "description": "Required. The resource name for the project whose metrics are wanted. Example: `\"projects/my-project-id\"`.", |
| // "location": "path", |
| // "pattern": "^projects/[^/]*$", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "v2beta1/{+projectName}/metrics", |
| // "response": { |
| // "$ref": "ListLogMetricsResponse" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/cloud-platform", |
| // "https://www.googleapis.com/auth/cloud-platform.read-only", |
| // "https://www.googleapis.com/auth/logging.admin", |
| // "https://www.googleapis.com/auth/logging.read" |
| // ] |
| // } |
| |
| } |
| |
| // method id "logging.projects.metrics.update": |
| |
| type ProjectsMetricsUpdateCall struct { |
| s *Service |
| metricNameid string |
| logmetric *LogMetric |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| } |
| |
| // Update: Creates or updates a logs-based metric. |
| func (r *ProjectsMetricsService) Update(metricNameid string, logmetric *LogMetric) *ProjectsMetricsUpdateCall { |
| c := &ProjectsMetricsUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.metricNameid = metricNameid |
| c.logmetric = logmetric |
| return c |
| } |
| |
| // QuotaUser sets the optional parameter "quotaUser": Available to use |
| // for quota purposes for server-side applications. Can be any arbitrary |
| // string assigned to a user, but should not exceed 40 characters. |
| func (c *ProjectsMetricsUpdateCall) QuotaUser(quotaUser string) *ProjectsMetricsUpdateCall { |
| c.urlParams_.Set("quotaUser", quotaUser) |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse |
| // for more information. |
| func (c *ProjectsMetricsUpdateCall) Fields(s ...googleapi.Field) *ProjectsMetricsUpdateCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *ProjectsMetricsUpdateCall) Context(ctx context.Context) *ProjectsMetricsUpdateCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| func (c *ProjectsMetricsUpdateCall) doRequest(alt string) (*http.Response, error) { |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.logmetric) |
| if err != nil { |
| return nil, err |
| } |
| ctype := "application/json" |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "v2beta1/{+metricName}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("PUT", urls, body) |
| googleapi.Expand(req.URL, map[string]string{ |
| "metricName": c.metricNameid, |
| }) |
| req.Header.Set("Content-Type", ctype) |
| req.Header.Set("User-Agent", c.s.userAgent()) |
| if c.ctx_ != nil { |
| return ctxhttp.Do(c.ctx_, c.s.client, req) |
| } |
| return c.s.client.Do(req) |
| } |
| |
| // Do executes the "logging.projects.metrics.update" call. |
| // Exactly one of *LogMetric or error will be non-nil. Any non-2xx |
| // status code is an error. Response headers are in either |
| // *LogMetric.ServerResponse.Header or (if a response was returned at |
| // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified |
| // to check whether the returned error was because |
| // http.StatusNotModified was returned. |
| func (c *ProjectsMetricsUpdateCall) Do() (*LogMetric, error) { |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &LogMetric{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Creates or updates a logs-based metric.", |
| // "httpMethod": "PUT", |
| // "id": "logging.projects.metrics.update", |
| // "parameterOrder": [ |
| // "metricName" |
| // ], |
| // "parameters": { |
| // "metricName": { |
| // "description": "The resource name of the metric to update. Example: `\"projects/my-project-id/metrics/my-metric-id\"`. The updated metric must be provided in the request and have the same identifier that is specified in `metricName`. If the metric does not exist, it is created.", |
| // "location": "path", |
| // "pattern": "^projects/[^/]*/metrics/[^/]*$", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "v2beta1/{+metricName}", |
| // "request": { |
| // "$ref": "LogMetric" |
| // }, |
| // "response": { |
| // "$ref": "LogMetric" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/cloud-platform", |
| // "https://www.googleapis.com/auth/logging.admin", |
| // "https://www.googleapis.com/auth/logging.write" |
| // ] |
| // } |
| |
| } |
| |
| // method id "logging.projects.sinks.create": |
| |
| type ProjectsSinksCreateCall struct { |
| s *Service |
| projectName string |
| logsink *LogSink |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| } |
| |
| // Create: Creates a sink. |
| func (r *ProjectsSinksService) Create(projectName string, logsink *LogSink) *ProjectsSinksCreateCall { |
| c := &ProjectsSinksCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.projectName = projectName |
| c.logsink = logsink |
| return c |
| } |
| |
| // QuotaUser sets the optional parameter "quotaUser": Available to use |
| // for quota purposes for server-side applications. Can be any arbitrary |
| // string assigned to a user, but should not exceed 40 characters. |
| func (c *ProjectsSinksCreateCall) QuotaUser(quotaUser string) *ProjectsSinksCreateCall { |
| c.urlParams_.Set("quotaUser", quotaUser) |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse |
| // for more information. |
| func (c *ProjectsSinksCreateCall) Fields(s ...googleapi.Field) *ProjectsSinksCreateCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *ProjectsSinksCreateCall) Context(ctx context.Context) *ProjectsSinksCreateCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| func (c *ProjectsSinksCreateCall) doRequest(alt string) (*http.Response, error) { |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.logsink) |
| if err != nil { |
| return nil, err |
| } |
| ctype := "application/json" |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "v2beta1/{+projectName}/sinks") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("POST", urls, body) |
| googleapi.Expand(req.URL, map[string]string{ |
| "projectName": c.projectName, |
| }) |
| req.Header.Set("Content-Type", ctype) |
| req.Header.Set("User-Agent", c.s.userAgent()) |
| if c.ctx_ != nil { |
| return ctxhttp.Do(c.ctx_, c.s.client, req) |
| } |
| return c.s.client.Do(req) |
| } |
| |
| // Do executes the "logging.projects.sinks.create" call. |
| // Exactly one of *LogSink or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *LogSink.ServerResponse.Header or (if a response was returned at all) |
| // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified |
| // was returned. |
| func (c *ProjectsSinksCreateCall) Do() (*LogSink, error) { |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &LogSink{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Creates a sink.", |
| // "httpMethod": "POST", |
| // "id": "logging.projects.sinks.create", |
| // "parameterOrder": [ |
| // "projectName" |
| // ], |
| // "parameters": { |
| // "projectName": { |
| // "description": "The resource name of the project in which to create the sink. Example: `\"projects/my-project-id\"`. The new sink must be provided in the request.", |
| // "location": "path", |
| // "pattern": "^projects/[^/]*$", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "v2beta1/{+projectName}/sinks", |
| // "request": { |
| // "$ref": "LogSink" |
| // }, |
| // "response": { |
| // "$ref": "LogSink" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/cloud-platform", |
| // "https://www.googleapis.com/auth/logging.admin" |
| // ] |
| // } |
| |
| } |
| |
| // method id "logging.projects.sinks.delete": |
| |
| type ProjectsSinksDeleteCall struct { |
| s *Service |
| sinkName string |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| } |
| |
| // Delete: Deletes a sink. |
| func (r *ProjectsSinksService) Delete(sinkName string) *ProjectsSinksDeleteCall { |
| c := &ProjectsSinksDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.sinkName = sinkName |
| return c |
| } |
| |
| // QuotaUser sets the optional parameter "quotaUser": Available to use |
| // for quota purposes for server-side applications. Can be any arbitrary |
| // string assigned to a user, but should not exceed 40 characters. |
| func (c *ProjectsSinksDeleteCall) QuotaUser(quotaUser string) *ProjectsSinksDeleteCall { |
| c.urlParams_.Set("quotaUser", quotaUser) |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse |
| // for more information. |
| func (c *ProjectsSinksDeleteCall) Fields(s ...googleapi.Field) *ProjectsSinksDeleteCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *ProjectsSinksDeleteCall) Context(ctx context.Context) *ProjectsSinksDeleteCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| func (c *ProjectsSinksDeleteCall) doRequest(alt string) (*http.Response, error) { |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "v2beta1/{+sinkName}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("DELETE", urls, body) |
| googleapi.Expand(req.URL, map[string]string{ |
| "sinkName": c.sinkName, |
| }) |
| req.Header.Set("User-Agent", c.s.userAgent()) |
| if c.ctx_ != nil { |
| return ctxhttp.Do(c.ctx_, c.s.client, req) |
| } |
| return c.s.client.Do(req) |
| } |
| |
| // Do executes the "logging.projects.sinks.delete" call. |
| // Exactly one of *Empty or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *Empty.ServerResponse.Header or (if a response was returned at all) |
| // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified |
| // was returned. |
| func (c *ProjectsSinksDeleteCall) Do() (*Empty, error) { |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &Empty{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Deletes a sink.", |
| // "httpMethod": "DELETE", |
| // "id": "logging.projects.sinks.delete", |
| // "parameterOrder": [ |
| // "sinkName" |
| // ], |
| // "parameters": { |
| // "sinkName": { |
| // "description": "The resource name of the sink to delete. Example: `\"projects/my-project-id/sinks/my-sink-id\"`.", |
| // "location": "path", |
| // "pattern": "^projects/[^/]*/sinks/[^/]*$", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "v2beta1/{+sinkName}", |
| // "response": { |
| // "$ref": "Empty" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/cloud-platform", |
| // "https://www.googleapis.com/auth/logging.admin" |
| // ] |
| // } |
| |
| } |
| |
| // method id "logging.projects.sinks.get": |
| |
| type ProjectsSinksGetCall struct { |
| s *Service |
| sinkName string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| } |
| |
| // Get: Gets a sink. |
| func (r *ProjectsSinksService) Get(sinkName string) *ProjectsSinksGetCall { |
| c := &ProjectsSinksGetCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.sinkName = sinkName |
| return c |
| } |
| |
| // QuotaUser sets the optional parameter "quotaUser": Available to use |
| // for quota purposes for server-side applications. Can be any arbitrary |
| // string assigned to a user, but should not exceed 40 characters. |
| func (c *ProjectsSinksGetCall) QuotaUser(quotaUser string) *ProjectsSinksGetCall { |
| c.urlParams_.Set("quotaUser", quotaUser) |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse |
| // for more information. |
| func (c *ProjectsSinksGetCall) Fields(s ...googleapi.Field) *ProjectsSinksGetCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets the optional parameter which makes the operation |
| // fail if the object's ETag matches the given value. This is useful for |
| // getting updates only after the object has changed since the last |
| // request. Use googleapi.IsNotModified to check whether the response |
| // error from Do is the result of In-None-Match. |
| func (c *ProjectsSinksGetCall) IfNoneMatch(entityTag string) *ProjectsSinksGetCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *ProjectsSinksGetCall) Context(ctx context.Context) *ProjectsSinksGetCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| func (c *ProjectsSinksGetCall) doRequest(alt string) (*http.Response, error) { |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "v2beta1/{+sinkName}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| googleapi.Expand(req.URL, map[string]string{ |
| "sinkName": c.sinkName, |
| }) |
| req.Header.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| req.Header.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| if c.ctx_ != nil { |
| return ctxhttp.Do(c.ctx_, c.s.client, req) |
| } |
| return c.s.client.Do(req) |
| } |
| |
| // Do executes the "logging.projects.sinks.get" call. |
| // Exactly one of *LogSink or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *LogSink.ServerResponse.Header or (if a response was returned at all) |
| // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified |
| // was returned. |
| func (c *ProjectsSinksGetCall) Do() (*LogSink, error) { |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &LogSink{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Gets a sink.", |
| // "httpMethod": "GET", |
| // "id": "logging.projects.sinks.get", |
| // "parameterOrder": [ |
| // "sinkName" |
| // ], |
| // "parameters": { |
| // "sinkName": { |
| // "description": "The resource name of the sink to return. Example: `\"projects/my-project-id/sinks/my-sink-id\"`.", |
| // "location": "path", |
| // "pattern": "^projects/[^/]*/sinks/[^/]*$", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "v2beta1/{+sinkName}", |
| // "response": { |
| // "$ref": "LogSink" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/cloud-platform", |
| // "https://www.googleapis.com/auth/cloud-platform.read-only", |
| // "https://www.googleapis.com/auth/logging.admin", |
| // "https://www.googleapis.com/auth/logging.read" |
| // ] |
| // } |
| |
| } |
| |
| // method id "logging.projects.sinks.list": |
| |
| type ProjectsSinksListCall struct { |
| s *Service |
| projectName string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| } |
| |
| // List: Lists sinks. |
| func (r *ProjectsSinksService) List(projectName string) *ProjectsSinksListCall { |
| c := &ProjectsSinksListCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.projectName = projectName |
| return c |
| } |
| |
| // PageSize sets the optional parameter "pageSize": 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. |
| func (c *ProjectsSinksListCall) PageSize(pageSize int64) *ProjectsSinksListCall { |
| c.urlParams_.Set("pageSize", fmt.Sprint(pageSize)) |
| return c |
| } |
| |
| // PageToken sets the optional parameter "pageToken": 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 value of `projectName` must be the same as in the |
| // previous request. |
| func (c *ProjectsSinksListCall) PageToken(pageToken string) *ProjectsSinksListCall { |
| c.urlParams_.Set("pageToken", pageToken) |
| return c |
| } |
| |
| // QuotaUser sets the optional parameter "quotaUser": Available to use |
| // for quota purposes for server-side applications. Can be any arbitrary |
| // string assigned to a user, but should not exceed 40 characters. |
| func (c *ProjectsSinksListCall) QuotaUser(quotaUser string) *ProjectsSinksListCall { |
| c.urlParams_.Set("quotaUser", quotaUser) |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse |
| // for more information. |
| func (c *ProjectsSinksListCall) Fields(s ...googleapi.Field) *ProjectsSinksListCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets the optional parameter which makes the operation |
| // fail if the object's ETag matches the given value. This is useful for |
| // getting updates only after the object has changed since the last |
| // request. Use googleapi.IsNotModified to check whether the response |
| // error from Do is the result of In-None-Match. |
| func (c *ProjectsSinksListCall) IfNoneMatch(entityTag string) *ProjectsSinksListCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *ProjectsSinksListCall) Context(ctx context.Context) *ProjectsSinksListCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| func (c *ProjectsSinksListCall) doRequest(alt string) (*http.Response, error) { |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "v2beta1/{+projectName}/sinks") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| googleapi.Expand(req.URL, map[string]string{ |
| "projectName": c.projectName, |
| }) |
| req.Header.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| req.Header.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| if c.ctx_ != nil { |
| return ctxhttp.Do(c.ctx_, c.s.client, req) |
| } |
| return c.s.client.Do(req) |
| } |
| |
| // Do executes the "logging.projects.sinks.list" call. |
| // Exactly one of *ListSinksResponse or error will be non-nil. Any |
| // non-2xx status code is an error. Response headers are in either |
| // *ListSinksResponse.ServerResponse.Header or (if a response was |
| // returned at all) in error.(*googleapi.Error).Header. Use |
| // googleapi.IsNotModified to check whether the returned error was |
| // because http.StatusNotModified was returned. |
| func (c *ProjectsSinksListCall) Do() (*ListSinksResponse, error) { |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &ListSinksResponse{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Lists sinks.", |
| // "httpMethod": "GET", |
| // "id": "logging.projects.sinks.list", |
| // "parameterOrder": [ |
| // "projectName" |
| // ], |
| // "parameters": { |
| // "pageSize": { |
| // "description": "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.", |
| // "format": "int32", |
| // "location": "query", |
| // "type": "integer" |
| // }, |
| // "pageToken": { |
| // "description": "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 value of `projectName` must be the same as in the previous request.", |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "projectName": { |
| // "description": "Required. The resource name of the project owning the sinks. Example: `\"projects/my-logging-project\"`, `\"projects/01234567890\"`.", |
| // "location": "path", |
| // "pattern": "^projects/[^/]*$", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "v2beta1/{+projectName}/sinks", |
| // "response": { |
| // "$ref": "ListSinksResponse" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/cloud-platform", |
| // "https://www.googleapis.com/auth/cloud-platform.read-only", |
| // "https://www.googleapis.com/auth/logging.admin", |
| // "https://www.googleapis.com/auth/logging.read" |
| // ] |
| // } |
| |
| } |
| |
| // method id "logging.projects.sinks.update": |
| |
| type ProjectsSinksUpdateCall struct { |
| s *Service |
| sinkName string |
| logsink *LogSink |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| } |
| |
| // Update: Creates or updates a sink. |
| func (r *ProjectsSinksService) Update(sinkName string, logsink *LogSink) *ProjectsSinksUpdateCall { |
| c := &ProjectsSinksUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.sinkName = sinkName |
| c.logsink = logsink |
| return c |
| } |
| |
| // QuotaUser sets the optional parameter "quotaUser": Available to use |
| // for quota purposes for server-side applications. Can be any arbitrary |
| // string assigned to a user, but should not exceed 40 characters. |
| func (c *ProjectsSinksUpdateCall) QuotaUser(quotaUser string) *ProjectsSinksUpdateCall { |
| c.urlParams_.Set("quotaUser", quotaUser) |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse |
| // for more information. |
| func (c *ProjectsSinksUpdateCall) Fields(s ...googleapi.Field) *ProjectsSinksUpdateCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *ProjectsSinksUpdateCall) Context(ctx context.Context) *ProjectsSinksUpdateCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| func (c *ProjectsSinksUpdateCall) doRequest(alt string) (*http.Response, error) { |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.logsink) |
| if err != nil { |
| return nil, err |
| } |
| ctype := "application/json" |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "v2beta1/{+sinkName}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("PUT", urls, body) |
| googleapi.Expand(req.URL, map[string]string{ |
| "sinkName": c.sinkName, |
| }) |
| req.Header.Set("Content-Type", ctype) |
| req.Header.Set("User-Agent", c.s.userAgent()) |
| if c.ctx_ != nil { |
| return ctxhttp.Do(c.ctx_, c.s.client, req) |
| } |
| return c.s.client.Do(req) |
| } |
| |
| // Do executes the "logging.projects.sinks.update" call. |
| // Exactly one of *LogSink or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *LogSink.ServerResponse.Header or (if a response was returned at all) |
| // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified |
| // was returned. |
| func (c *ProjectsSinksUpdateCall) Do() (*LogSink, error) { |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &LogSink{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Creates or updates a sink.", |
| // "httpMethod": "PUT", |
| // "id": "logging.projects.sinks.update", |
| // "parameterOrder": [ |
| // "sinkName" |
| // ], |
| // "parameters": { |
| // "sinkName": { |
| // "description": "The resource name of the sink to update. Example: `\"projects/my-project-id/sinks/my-sink-id\"`. The updated sink must be provided in the request and have the same name that is specified in `sinkName`. If the sink does not exist, it is created.", |
| // "location": "path", |
| // "pattern": "^projects/[^/]*/sinks/[^/]*$", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "v2beta1/{+sinkName}", |
| // "request": { |
| // "$ref": "LogSink" |
| // }, |
| // "response": { |
| // "$ref": "LogSink" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/cloud-platform", |
| // "https://www.googleapis.com/auth/logging.admin" |
| // ] |
| // } |
| |
| } |