| // 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 { |
| // CacheFillBytes: The number of HTTP response bytes inserted into |
| // cache. Set only when a cache fill was attempted. |
| CacheFillBytes int64 `json:"cacheFillBytes,omitempty,string"` |
| |
| // CacheHit: Whether or not an entity was served from cache (with or |
| // without validation). |
| CacheHit bool `json:"cacheHit,omitempty"` |
| |
| // CacheLookup: Whether or not a cache lookup was attempted. |
| CacheLookup bool `json:"cacheLookup,omitempty"` |
| |
| // CacheValidatedWithOriginServer: 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. |
| CacheValidatedWithOriginServer bool `json:"cacheValidatedWithOriginServer,omitempty"` |
| |
| // Referer: The referer 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"` |
| |
| // ForceSendFields is a list of field names (e.g. "CacheFillBytes") 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 asc" (default) and "timestamp |
| // desc". The first option returns entries in order of increasing |
| // values of `LogEntry.timestamp` (oldest first), and the second option |
| // returns entries in order of decreasing timestamps (newest first). |
| // Entries with equal timestamps are returned in order of |
| // `LogEntry.insertId`. |
| OrderBy string `json:"orderBy,omitempty"` |
| |
| // PageSize: Optional. The maximum number of results to return from this |
| // request. You must check for presence of `nextPageToken` to determine |
| // if additional results are available, which you can retrieve by |
| // passing the `nextPageToken` value as the `pageToken` parameter in the |
| // next request. |
| PageSize int64 `json:"pageSize,omitempty"` |
| |
| // PageToken: Optional. If the `pageToken` parameter is supplied, then |
| // the next page of results is retrieved. The `pageToken` parameter must |
| // be set to the value of the `nextPageToken` from the previous |
| // response. The values of `projectIds`, `filter`, and `orderBy` must be |
| // the same as in the previous request. |
| PageToken string `json:"pageToken,omitempty"` |
| |
| // PartialSuccess: Optional. If true, read access to all projects is not |
| // required and results will be returned for the subset of projects for |
| // which read access is permitted (empty subset is permitted). |
| PartialSuccess bool `json:"partialSuccess,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 included in the response. To get the next set of |
| // results, call this method again using the value of `nextPageToken` as |
| // `pageToken`. |
| NextPageToken string `json:"nextPageToken,omitempty"` |
| |
| // ProjectIdErrors: If partial_success is true, contains the project ids |
| // that had errors and the associated errors. |
| ProjectIdErrors map[string]Status `json:"projectIdErrors,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 included in the response. To get the next set 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 included in the response. To get the next set 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 included in the response. To get the next set 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/ |
| // /logs/". Examples: "projects/my-projectid/logs/syslog", |
| // "projects/1234567890/logs/library.googleapis.com%2Fbook_log". The |
| // log ID part of resource name must be less than 512 characters long |
| // and can only include the following characters: upper and lower case |
| // alphanumeric characters: [A-Za-z0-9]; and punctuation characters: |
| // forward-slash, underscore, hyphen, and period. 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. An 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 this log entry. |
| // |
| // Possible values: |
| // "DEFAULT" |
| // "DEBUG" |
| // "INFO" |
| // "NOTICE" |
| // "WARNING" |
| // "ERROR" |
| // "CRITICAL" |
| // "ALERT" |
| // "EMERGENCY" |
| Severity string `json:"severity,omitempty"` |
| |
| // SourceLocation: Where in the source code this log message was |
| // written. |
| SourceLocation *SourceLocation `json:"sourceLocation,omitempty"` |
| |
| // Time: Approximate time when this log entry was made. |
| 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). Only log entries |
| // matching that filter are exported. The filter must be consistent with |
| // the log entry format specified by the `outputVersionFormat` |
| // parameter, regardless of the format of the log entry that was |
| // originally written to Cloud Logging. Example (V2 format): |
| // "logName=projects/my-projectid/logs/syslog AND severity>=ERROR". |
| 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 to use for this sink's |
| // exported log entries. This version does not have to correspond to the |
| // version of the log entry when it was written to Cloud Logging. |
| // |
| // 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: An object representing a resource that can be used |
| // for monitoring, logging, billing, or other purposes. Examples include |
| // virtual machine instances, databases, and storage devices such as |
| // disks. The `type` field identifies a MonitoredResourceDescriptor |
| // object that describes the resource's schema. Information in the |
| // `labels` field identifies the actual resource and its attributes |
| // according to the schema. For example, a particular Compute Engine VM |
| // instance could be represented by the following object, because the |
| // MonitoredResourceDescriptor for "gce_instance" has labels |
| // "instance_id" and "zone": { "type": "gce_instance", "labels": { |
| // "instance_id": "my-instance", "zone": "us-central1-a" }} |
| type MonitoredResource struct { |
| // Labels: Required. Values for all of the labels listed in the |
| // associated monitored resource descriptor. For example, Cloud SQL |
| // databases use the labels "database_id" and "zone". |
| Labels map[string]string `json:"labels,omitempty"` |
| |
| // Type: Required. The monitored resource type. This field must match |
| // the `type` field of a MonitoredResourceDescriptor object. For |
| // example, the type of a Cloud SQL database is "cloudsql_database". |
| 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: An object that describes the schema of a |
| // MonitoredResource object using a type name and a set of labels. For |
| // example, the monitored resource descriptor for Google Compute Engine |
| // VM instances has a type of "gce_instance" and specifies the use of |
| // the labels "instance_id" and "zone" to identify particular VM |
| // instances. Different APIs can support different monitored resource |
| // types. APIs generally provide a `list` method that returns the |
| // monitored resource descriptors used by the API. |
| type MonitoredResourceDescriptor struct { |
| // Description: Optional. A detailed description of the monitored |
| // resource type that might be used in documentation. |
| Description string `json:"description,omitempty"` |
| |
| // DisplayName: Optional. A concise name for the monitored resource type |
| // that might be displayed in user interfaces. For example, "Google |
| // Cloud SQL Database". |
| DisplayName string `json:"displayName,omitempty"` |
| |
| // Labels: Required. A set of labels used to describe instances of this |
| // monitored resource type. For example, an individual Google Cloud SQL |
| // database is identified by values for the labels "database_id" and |
| // "zone". |
| Labels []*LabelDescriptor `json:"labels,omitempty"` |
| |
| // Name: Optional. The resource name of the monitored resource |
| // descriptor: |
| // "projects/{project_id}/monitoredResourceDescriptors/{type}" where |
| // {type} is the value of the `type` field in this object and |
| // {project_id} is a project ID that provides API-specific context for |
| // accessing the type. APIs that do not use project information can use |
| // the resource name format "monitoredResourceDescriptors/{type}". |
| Name string `json:"name,omitempty"` |
| |
| // Type: Required. 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 HTTP request to |
| // an App Engine application. |
| type RequestLog struct { |
| // AppEngineRelease: App Engine release version. |
| AppEngineRelease string `json:"appEngineRelease,omitempty"` |
| |
| // AppId: 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 when the request finished. |
| EndTime string `json:"endTime,omitempty"` |
| |
| // Finished: Whether this request is finished or active. |
| Finished bool `json:"finished,omitempty"` |
| |
| // First: Whether this is the first RequestLog entry for this request. |
| // If an active request has several RequestLog entries written to Cloud |
| // Logging, this field will be set for one of them. |
| First bool `json:"first,omitempty"` |
| |
| // Host: Internet host and port number of the resource being requested. |
| Host string `json:"host,omitempty"` |
| |
| // HttpVersion: HTTP version of request. Example: "HTTP/1.1". |
| HttpVersion string `json:"httpVersion,omitempty"` |
| |
| // InstanceId: An identifier for the instance that handled the request. |
| InstanceId string `json:"instanceId,omitempty"` |
| |
| // InstanceIndex: If the instance processing this request belongs to a |
| // manually scaled module, then this is the 0-based index of the |
| // instance. Otherwise, this value is -1. |
| 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: A list of log lines emitted by the application while serving |
| // this request. |
| Line []*LogLine `json:"line,omitempty"` |
| |
| // MegaCycles: Number of CPU megacycles used to process request. |
| MegaCycles int64 `json:"megaCycles,omitempty,string"` |
| |
| // Method: Request method. Example: "GET", "HEAD", "PUT", |
| // "POST", "DELETE". |
| Method string `json:"method,omitempty"` |
| |
| // ModuleId: Module of the application that handled this request. |
| ModuleId string `json:"moduleId,omitempty"` |
| |
| // Nickname: The logged-in user who made the request. Most likely, this |
| // is the part of the user's email before the `@` sign. The field value |
| // is the same for different requests from the same user, but different |
| // users can have similar names. This information is also available to |
| // the application via the App Engine Users API. This field will be |
| // populated starting with App Engine 1.9.21. |
| Nickname string `json:"nickname,omitempty"` |
| |
| // PendingTime: Time this request spent in the pending request queue. |
| PendingTime string `json:"pendingTime,omitempty"` |
| |
| // Referrer: Referrer URL of request. |
| Referrer string `json:"referrer,omitempty"` |
| |
| // RequestId: Globally unique identifier for a request, which is based |
| // on the request start time. Request IDs for requests which started |
| // later will compare greater as strings than those for requests which |
| // started earlier. |
| 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". The fragment identifier, which is identified by the |
| // `#` character, is not 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 when the request started. |
| StartTime string `json:"startTime,omitempty"` |
| |
| // Status: HTTP response status code. Example: 200, 404. |
| Status int64 `json:"status,omitempty"` |
| |
| // TaskName: Task name of the request, in the case of an offline |
| // request. |
| TaskName string `json:"taskName,omitempty"` |
| |
| // TaskQueueName: Queue name of the request, in the case of an offline |
| // request. |
| TaskQueueName string `json:"taskQueueName,omitempty"` |
| |
| // TraceId: Cloud Trace identifier for this request. |
| TraceId string `json:"traceId,omitempty"` |
| |
| // UrlMapEntry: File or class that handled the request. |
| UrlMapEntry string `json:"urlMapEntry,omitempty"` |
| |
| // UserAgent: User agent that made the request. |
| UserAgent string `json:"userAgent,omitempty"` |
| |
| // VersionId: Version of the application that handled this request. |
| VersionId string `json:"versionId,omitempty"` |
| |
| // WasLoadingRequest: Whether this was a loading request for the |
| // 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 code file. |
| type SourceLocation struct { |
| // File: Source file name. Depending on the runtime environment, this |
| // might be a simple name or a fully-qualified name. |
| 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. |
| // This information is used in contexts such as the logs viewer, where a |
| // file and line number are less meaningful. The format can vary by |
| // language. For example: `qual.if.ied.Class.method` (Java), |
| // `dir/package.func` (Go), `function` (Python). |
| 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) |
| } |
| |
| // Status: The `Status` type defines a logical error model that is |
| // suitable for different programming environments, including REST APIs |
| // and RPC APIs. It is used by [gRPC](https://github.com/grpc). The |
| // error model is designed to be: - Simple to use and understand for |
| // most users - Flexible enough to meet unexpected needs # Overview The |
| // `Status` message contains three pieces of data: error code, error |
| // message, and error details. The error code should be an enum value of |
| // google.rpc.Code, but it may accept additional error codes if needed. |
| // The error message should be a developer-facing English message that |
| // helps developers *understand* and *resolve* the error. If a localized |
| // user-facing error message is needed, put the localized message in the |
| // error details or localize it in the client. The optional error |
| // details may contain arbitrary information about the error. There is a |
| // predefined set of error detail types in the package `google.rpc` |
| // which can be used for common error conditions. # Language mapping The |
| // `Status` message is the logical representation of the error model, |
| // but it is not necessarily the actual wire format. When the `Status` |
| // message is exposed in different client libraries and different wire |
| // protocols, it can be mapped differently. For example, it will likely |
| // be mapped to some exceptions in Java, but more likely mapped to some |
| // error codes in C. # Other uses The error model and the `Status` |
| // message can be used in a variety of environments, either with or |
| // without APIs, to provide a consistent developer experience across |
| // different environments. Example uses of this error model include: - |
| // Partial errors. If a service needs to return partial errors to the |
| // client, it may embed the `Status` in the normal response to indicate |
| // the partial errors. - Workflow errors. A typical workflow has |
| // multiple steps. Each step may have a `Status` message for error |
| // reporting purpose. - Batch operations. If a client uses batch request |
| // and batch response, the `Status` message should be used directly |
| // inside batch response, one for each error sub-response. - |
| // Asynchronous operations. If an API call embeds asynchronous operation |
| // results in its response, the status of those operations should be |
| // represented directly using the `Status` message. - Logging. If some |
| // API errors are stored in logs, the message `Status` could be used |
| // directly after any stripping needed for security/privacy reasons. |
| type Status struct { |
| // Code: The status code, which should be an enum value of |
| // google.rpc.Code. |
| Code int64 `json:"code,omitempty"` |
| |
| // Details: A list of messages that carry the error details. There will |
| // be a common set of message types for APIs to use. |
| Details []StatusDetails `json:"details,omitempty"` |
| |
| // Message: A developer-facing error message, which should be in |
| // English. Any user-facing error message should be localized and sent |
| // in the google.rpc.Status.details field, or localized by the client. |
| Message string `json:"message,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Code") 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 *Status) MarshalJSON() ([]byte, error) { |
| type noMethod Status |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields) |
| } |
| |
| type StatusDetails interface{} |
| |
| // 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"` |
| |
| // PartialSuccess: Optional. Whether valid entries should be written |
| // even if some other entries fail due to INVALID_ARGUMENT or |
| // PERMISSION_DENIED errors. If any entry is not written, the response |
| // status will be the error associated with one of the failed entries |
| // and include error details in the form of |
| // WriteLogEntriesPartialErrors. |
| PartialSuccess bool `json:"partialSuccess,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 retrieve log entries from |
| // Cloud Logging. For ways to export log entries, see [Exporting |
| // Logs](/logging/docs/export). |
| func (r *EntriesService) List(listlogentriesrequest *ListLogEntriesRequest) *EntriesListCall { |
| c := &EntriesListCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.listlogentriesrequest = listlogentriesrequest |
| 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) { |
| reqHeaders := make(http.Header) |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.listlogentriesrequest) |
| if err != nil { |
| return nil, err |
| } |
| reqHeaders.Set("Content-Type", "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) |
| req.Header = reqHeaders |
| googleapi.SetOpaque(req.URL) |
| return gensupport.SendRequest(c.ctx_, c.s.client, 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(opts ...googleapi.CallOption) (*ListLogEntriesResponse, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| 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, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Lists log entries. Use this method to retrieve log entries from Cloud Logging. For ways to export log entries, see [Exporting Logs](/logging/docs/export).", |
| // "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 |
| } |
| |
| // 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) { |
| reqHeaders := make(http.Header) |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.writelogentriesrequest) |
| if err != nil { |
| return nil, err |
| } |
| reqHeaders.Set("Content-Type", "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) |
| req.Header = reqHeaders |
| googleapi.SetOpaque(req.URL) |
| return gensupport.SendRequest(c.ctx_, c.s.client, 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(opts ...googleapi.CallOption) (*WriteLogEntriesResponse, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| 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, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); 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. You must check for presence |
| // of `nextPageToken` to determine if additional results are available, |
| // which you can retrieve by passing the `nextPageToken` value as the |
| // `pageToken` parameter in the next request. |
| 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` |
| // parameter is supplied, then the next page of results is retrieved. |
| // The `pageToken` parameter must be set to the value of the |
| // `nextPageToken` from the previous response. |
| func (c *MonitoredResourceDescriptorsListCall) PageToken(pageToken string) *MonitoredResourceDescriptorsListCall { |
| c.urlParams_.Set("pageToken", pageToken) |
| 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) { |
| reqHeaders := make(http.Header) |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| 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) |
| req.Header = reqHeaders |
| googleapi.SetOpaque(req.URL) |
| return gensupport.SendRequest(c.ctx_, c.s.client, 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(opts ...googleapi.CallOption) (*ListMonitoredResourceDescriptorsResponse, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| 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, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); 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. You must check for presence of `nextPageToken` to determine if additional results are available, which you can retrieve by passing the `nextPageToken` value as the `pageToken` parameter in the next request.", |
| // "format": "int32", |
| // "location": "query", |
| // "type": "integer" |
| // }, |
| // "pageToken": { |
| // "description": "Optional. If the `pageToken` parameter is supplied, then the next page of results is retrieved. The `pageToken` parameter must be set to the value of the `nextPageToken` from the previous response.", |
| // "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" |
| // ] |
| // } |
| |
| } |
| |
| // Pages invokes f for each page of results. |
| // A non-nil error returned from f will halt the iteration. |
| // The provided context supersedes any context provided to the Context method. |
| func (c *MonitoredResourceDescriptorsListCall) Pages(ctx context.Context, f func(*ListMonitoredResourceDescriptorsResponse) error) error { |
| c.ctx_ = ctx |
| defer c.PageToken(c.urlParams_.Get("pageToken")) // reset paging to original point |
| for { |
| x, err := c.Do() |
| if err != nil { |
| return err |
| } |
| if err := f(x); err != nil { |
| return err |
| } |
| if x.NextPageToken == "" { |
| return nil |
| } |
| c.PageToken(x.NextPageToken) |
| } |
| } |
| |
| // 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 |
| } |
| |
| // 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) { |
| reqHeaders := make(http.Header) |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| 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) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "logName": c.logName, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, 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(opts ...googleapi.CallOption) (*Empty, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| 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, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); 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 |
| } |
| |
| // 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) { |
| reqHeaders := make(http.Header) |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.logmetric) |
| if err != nil { |
| return nil, err |
| } |
| reqHeaders.Set("Content-Type", "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) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "projectName": c.projectName, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, 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(opts ...googleapi.CallOption) (*LogMetric, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| 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, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); 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 |
| } |
| |
| // 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) { |
| reqHeaders := make(http.Header) |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| 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) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "metricName": c.metricName, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, 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(opts ...googleapi.CallOption) (*Empty, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| 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, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); 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 |
| } |
| |
| // 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) { |
| reqHeaders := make(http.Header) |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| 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) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "metricName": c.metricName, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, 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(opts ...googleapi.CallOption) (*LogMetric, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| 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, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); 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. You must check for presence |
| // of `nextPageToken` to determine if additional results are available, |
| // which you can retrieve by passing the `nextPageToken` value as the |
| // `pageToken` parameter in the next request. |
| 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` |
| // parameter is supplied, then the next page of results is retrieved. |
| // The `pageToken` parameter must be set to the value of the |
| // `nextPageToken` from the previous response. The 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 |
| } |
| |
| // 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) { |
| reqHeaders := make(http.Header) |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| 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) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "projectName": c.projectName, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, 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(opts ...googleapi.CallOption) (*ListLogMetricsResponse, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| 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, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); 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. You must check for presence of `nextPageToken` to determine if additional results are available, which you can retrieve by passing the `nextPageToken` value as the `pageToken` parameter in the next request.", |
| // "format": "int32", |
| // "location": "query", |
| // "type": "integer" |
| // }, |
| // "pageToken": { |
| // "description": "Optional. If the `pageToken` parameter is supplied, then the next page of results is retrieved. The `pageToken` parameter must be set to the value of the `nextPageToken` from the previous response. The 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 containing the metrics. 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" |
| // ] |
| // } |
| |
| } |
| |
| // Pages invokes f for each page of results. |
| // A non-nil error returned from f will halt the iteration. |
| // The provided context supersedes any context provided to the Context method. |
| func (c *ProjectsMetricsListCall) Pages(ctx context.Context, f func(*ListLogMetricsResponse) error) error { |
| c.ctx_ = ctx |
| defer c.PageToken(c.urlParams_.Get("pageToken")) // reset paging to original point |
| for { |
| x, err := c.Do() |
| if err != nil { |
| return err |
| } |
| if err := f(x); err != nil { |
| return err |
| } |
| if x.NextPageToken == "" { |
| return nil |
| } |
| c.PageToken(x.NextPageToken) |
| } |
| } |
| |
| // 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 |
| } |
| |
| // 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) { |
| reqHeaders := make(http.Header) |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.logmetric) |
| if err != nil { |
| return nil, err |
| } |
| reqHeaders.Set("Content-Type", "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) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "metricName": c.metricNameid, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, 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(opts ...googleapi.CallOption) (*LogMetric, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| 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, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); 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 |
| } |
| |
| // 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) { |
| reqHeaders := make(http.Header) |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.logsink) |
| if err != nil { |
| return nil, err |
| } |
| reqHeaders.Set("Content-Type", "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) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "projectName": c.projectName, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, 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(opts ...googleapi.CallOption) (*LogSink, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| 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, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); 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 |
| } |
| |
| // 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) { |
| reqHeaders := make(http.Header) |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| 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) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "sinkName": c.sinkName, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, 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(opts ...googleapi.CallOption) (*Empty, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| 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, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); 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 |
| } |
| |
| // 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) { |
| reqHeaders := make(http.Header) |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| 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) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "sinkName": c.sinkName, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, 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(opts ...googleapi.CallOption) (*LogSink, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| 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, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); 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. You must check for presence |
| // of `nextPageToken` to determine if additional results are available, |
| // which you can retrieve by passing the `nextPageToken` value as the |
| // `pageToken` parameter in the next request. |
| 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` |
| // parameter is supplied, then the next page of results is retrieved. |
| // The `pageToken` parameter must be set to the value of the |
| // `nextPageToken` from the previous response. The 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 |
| } |
| |
| // 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) { |
| reqHeaders := make(http.Header) |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| 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) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "projectName": c.projectName, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, 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(opts ...googleapi.CallOption) (*ListSinksResponse, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| 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, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); 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. You must check for presence of `nextPageToken` to determine if additional results are available, which you can retrieve by passing the `nextPageToken` value as the `pageToken` parameter in the next request.", |
| // "format": "int32", |
| // "location": "query", |
| // "type": "integer" |
| // }, |
| // "pageToken": { |
| // "description": "Optional. If the `pageToken` parameter is supplied, then the next page of results is retrieved. The `pageToken` parameter must be set to the value of the `nextPageToken` from the previous response. The 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 containing the sinks. Example: `\"projects/my-logging-project\"`.", |
| // "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" |
| // ] |
| // } |
| |
| } |
| |
| // Pages invokes f for each page of results. |
| // A non-nil error returned from f will halt the iteration. |
| // The provided context supersedes any context provided to the Context method. |
| func (c *ProjectsSinksListCall) Pages(ctx context.Context, f func(*ListSinksResponse) error) error { |
| c.ctx_ = ctx |
| defer c.PageToken(c.urlParams_.Get("pageToken")) // reset paging to original point |
| for { |
| x, err := c.Do() |
| if err != nil { |
| return err |
| } |
| if err := f(x); err != nil { |
| return err |
| } |
| if x.NextPageToken == "" { |
| return nil |
| } |
| c.PageToken(x.NextPageToken) |
| } |
| } |
| |
| // 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 |
| } |
| |
| // 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) { |
| reqHeaders := make(http.Header) |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.logsink) |
| if err != nil { |
| return nil, err |
| } |
| reqHeaders.Set("Content-Type", "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) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "sinkName": c.sinkName, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, 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(opts ...googleapi.CallOption) (*LogSink, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| 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, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); 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" |
| // ] |
| // } |
| |
| } |