| // Copyright YEAR Google LLC. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| // Code generated file. DO NOT EDIT. |
| |
| // Package logging provides access to the Google Cloud Logging API. |
| // |
| // This package is DEPRECATED. Use package cloud.google.com/go/logging instead. |
| // |
| // # Library status |
| // |
| // These client libraries are officially supported by Google. However, this |
| // library is considered complete and is in maintenance mode. This means |
| // that we will address critical bugs and security issues but will not add |
| // any new features. |
| // |
| // When possible, we recommend using our newer |
| // [Cloud Client Libraries for Go](https://pkg.go.dev/cloud.google.com/go) |
| // that are still actively being worked and iterated on. |
| // |
| // # Creating a client |
| // |
| // Usage example: |
| // |
| // import "google.golang.org/api/logging/v1beta3" |
| // ... |
| // ctx := context.Background() |
| // loggingService, err := logging.NewService(ctx) |
| // |
| // In this example, Google Application Default Credentials are used for |
| // authentication. For information on how to create and obtain Application |
| // Default Credentials, see https://developers.google.com/identity/protocols/application-default-credentials. |
| // |
| // # Other authentication options |
| // |
| // To use an API key for authentication (note: some APIs do not support API |
| // keys), use [google.golang.org/api/option.WithAPIKey]: |
| // |
| // loggingService, err := logging.NewService(ctx, option.WithAPIKey("AIza...")) |
| // |
| // To use an OAuth token (e.g., a user token obtained via a three-legged OAuth |
| // flow, use [google.golang.org/api/option.WithTokenSource]: |
| // |
| // config := &oauth2.Config{...} |
| // // ... |
| // token, err := config.Exchange(ctx, ...) |
| // loggingService, err := logging.NewService(ctx, option.WithTokenSource(config.TokenSource(ctx, token))) |
| // |
| // See [google.golang.org/api/option.ClientOption] for details on options. |
| package logging // import "google.golang.org/api/logging/v1beta3" |
| |
| import ( |
| "bytes" |
| "context" |
| "encoding/json" |
| "errors" |
| "fmt" |
| "io" |
| "net/http" |
| "net/url" |
| "strconv" |
| "strings" |
| |
| googleapi "google.golang.org/api/googleapi" |
| internal "google.golang.org/api/internal" |
| gensupport "google.golang.org/api/internal/gensupport" |
| option "google.golang.org/api/option" |
| internaloption "google.golang.org/api/option/internaloption" |
| htransport "google.golang.org/api/transport/http" |
| ) |
| |
| // 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 _ = internaloption.WithDefaultEndpoint |
| var _ = internal.Version |
| |
| const apiId = "logging:v1beta3" |
| const apiName = "logging" |
| const apiVersion = "v1beta3" |
| const basePath = "https://logging.googleapis.com/" |
| const basePathTemplate = "https://logging.UNIVERSE_DOMAIN/" |
| const mtlsBasePath = "https://logging.mtls.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" |
| ) |
| |
| // NewService creates a new Service. |
| func NewService(ctx context.Context, opts ...option.ClientOption) (*Service, error) { |
| scopesOption := internaloption.WithDefaultScopes( |
| "https://www.googleapis.com/auth/cloud-platform", |
| ) |
| // NOTE: prepend, so we don't override user-specified scopes. |
| opts = append([]option.ClientOption{scopesOption}, opts...) |
| opts = append(opts, internaloption.WithDefaultEndpoint(basePath)) |
| opts = append(opts, internaloption.WithDefaultEndpointTemplate(basePathTemplate)) |
| opts = append(opts, internaloption.WithDefaultMTLSEndpoint(mtlsBasePath)) |
| opts = append(opts, internaloption.EnableNewAuthLibrary()) |
| client, endpoint, err := htransport.NewClient(ctx, opts...) |
| if err != nil { |
| return nil, err |
| } |
| s, err := New(client) |
| if err != nil { |
| return nil, err |
| } |
| if endpoint != "" { |
| s.BasePath = endpoint |
| } |
| return s, nil |
| } |
| |
| // New creates a new Service. It uses the provided http.Client for requests. |
| // |
| // Deprecated: please use NewService instead. |
| // To provide a custom HTTP client, use option.WithHTTPClient. |
| // If you are using google.golang.org/api/googleapis/transport.APIKey, use option.WithAPIKey with NewService instead. |
| func New(client *http.Client) (*Service, error) { |
| if client == nil { |
| return nil, errors.New("client is nil") |
| } |
| s := &Service{client: client, BasePath: basePath} |
| 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 |
| |
| Projects *ProjectsService |
| } |
| |
| func (s *Service) userAgent() string { |
| if s.UserAgent == "" { |
| return googleapi.UserAgent |
| } |
| return googleapi.UserAgent + " " + s.UserAgent |
| } |
| |
| func NewProjectsService(s *Service) *ProjectsService { |
| rs := &ProjectsService{s: s} |
| rs.LogServices = NewProjectsLogServicesService(s) |
| rs.Logs = NewProjectsLogsService(s) |
| return rs |
| } |
| |
| type ProjectsService struct { |
| s *Service |
| |
| LogServices *ProjectsLogServicesService |
| |
| Logs *ProjectsLogsService |
| } |
| |
| func NewProjectsLogServicesService(s *Service) *ProjectsLogServicesService { |
| rs := &ProjectsLogServicesService{s: s} |
| rs.Indexes = NewProjectsLogServicesIndexesService(s) |
| rs.Sinks = NewProjectsLogServicesSinksService(s) |
| return rs |
| } |
| |
| type ProjectsLogServicesService struct { |
| s *Service |
| |
| Indexes *ProjectsLogServicesIndexesService |
| |
| Sinks *ProjectsLogServicesSinksService |
| } |
| |
| func NewProjectsLogServicesIndexesService(s *Service) *ProjectsLogServicesIndexesService { |
| rs := &ProjectsLogServicesIndexesService{s: s} |
| return rs |
| } |
| |
| type ProjectsLogServicesIndexesService struct { |
| s *Service |
| } |
| |
| func NewProjectsLogServicesSinksService(s *Service) *ProjectsLogServicesSinksService { |
| rs := &ProjectsLogServicesSinksService{s: s} |
| return rs |
| } |
| |
| type ProjectsLogServicesSinksService struct { |
| s *Service |
| } |
| |
| func NewProjectsLogsService(s *Service) *ProjectsLogsService { |
| rs := &ProjectsLogsService{s: s} |
| rs.Entries = NewProjectsLogsEntriesService(s) |
| rs.Sinks = NewProjectsLogsSinksService(s) |
| return rs |
| } |
| |
| type ProjectsLogsService struct { |
| s *Service |
| |
| Entries *ProjectsLogsEntriesService |
| |
| Sinks *ProjectsLogsSinksService |
| } |
| |
| func NewProjectsLogsEntriesService(s *Service) *ProjectsLogsEntriesService { |
| rs := &ProjectsLogsEntriesService{s: s} |
| return rs |
| } |
| |
| type ProjectsLogsEntriesService struct { |
| s *Service |
| } |
| |
| func NewProjectsLogsSinksService(s *Service) *ProjectsLogsSinksService { |
| rs := &ProjectsLogsSinksService{s: s} |
| return rs |
| } |
| |
| type ProjectsLogsSinksService 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); } |
| type Empty struct { |
| // ServerResponse contains the HTTP response code and headers from the server. |
| googleapi.ServerResponse `json:"-"` |
| } |
| |
| // ListLogServiceIndexesResponse: Result returned from |
| // ListLogServiceIndexesRequest. |
| type ListLogServiceIndexesResponse struct { |
| // NextPageToken: If there are more results, then `nextPageToken` is returned |
| // in the response. To get the next batch of indexes, use the value of |
| // `nextPageToken` as `pageToken` in the next call of `ListLogServiceIndexess`. |
| // If `nextPageToken` is empty, then there are no more results. |
| NextPageToken string `json:"nextPageToken,omitempty"` |
| // ServiceIndexPrefixes: A list of log service index prefixes. |
| ServiceIndexPrefixes []string `json:"serviceIndexPrefixes,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 or |
| // default values are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "NextPageToken") to include in API |
| // requests with the JSON null value. By default, fields with empty values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ListLogServiceIndexesResponse) MarshalJSON() ([]byte, error) { |
| type NoMethod ListLogServiceIndexesResponse |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| // ListLogServiceSinksResponse: Result returned from `ListLogServiceSinks`. |
| type ListLogServiceSinksResponse struct { |
| // Sinks: The requested log service sinks. If any of the returned `LogSink` |
| // objects have an empty `destination` field, then call `logServices.sinks.get` |
| // to retrieve the complete `LogSink` object. |
| 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. "Sinks") to unconditionally |
| // include in API requests. By default, fields with empty or default values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "Sinks") to include in API |
| // requests with the JSON null value. By default, fields with empty values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ListLogServiceSinksResponse) MarshalJSON() ([]byte, error) { |
| type NoMethod ListLogServiceSinksResponse |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| // ListLogServicesResponse: Result returned from `ListLogServicesRequest`. |
| type ListLogServicesResponse struct { |
| // LogServices: A list of log services. |
| LogServices []*LogService `json:"logServices,omitempty"` |
| // NextPageToken: If there are more results, then `nextPageToken` is returned |
| // in the response. To get the next batch of services, use the value of |
| // `nextPageToken` as `pageToken` in the next call of `ListLogServices`. If |
| // `nextPageToken` is empty, then there are no more results. |
| 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. "LogServices") to |
| // unconditionally include in API requests. By default, fields with empty or |
| // default values are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "LogServices") to include in API |
| // requests with the JSON null value. By default, fields with empty values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ListLogServicesResponse) MarshalJSON() ([]byte, error) { |
| type NoMethod ListLogServicesResponse |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| // ListLogSinksResponse: Result returned from `ListLogSinks`. |
| type ListLogSinksResponse struct { |
| // Sinks: The requested log sinks. If any of the returned `LogSink` objects |
| // have an empty `destination` field, then call `logServices.sinks.get` to |
| // retrieve the complete `LogSink` object. |
| 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. "Sinks") to unconditionally |
| // include in API requests. By default, fields with empty or default values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "Sinks") to include in API |
| // requests with the JSON null value. By default, fields with empty values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ListLogSinksResponse) MarshalJSON() ([]byte, error) { |
| type NoMethod ListLogSinksResponse |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| // ListLogsResponse: Result returned from ListLogs. |
| type ListLogsResponse struct { |
| // Logs: A list of log resources. |
| Logs []*Log `json:"logs,omitempty"` |
| // NextPageToken: If there are more results, then `nextPageToken` is returned |
| // in the response. To get the next batch of logs, use the value of |
| // `nextPageToken` as `pageToken` in the next call of `ListLogs`. If |
| // `nextPageToken` is empty, then there are no more results. |
| 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. "Logs") to unconditionally |
| // include in API requests. By default, fields with empty or default values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "Logs") to include in API requests |
| // with the JSON null value. By default, fields with empty values are omitted |
| // from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ListLogsResponse) MarshalJSON() ([]byte, error) { |
| type NoMethod ListLogsResponse |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| // Log: A log object. |
| type Log struct { |
| // DisplayName: Name used when displaying the log to the user (for example, in |
| // a UI). Example: "activity_log" |
| DisplayName string `json:"displayName,omitempty"` |
| // Name: REQUIRED: The log's name name. Example: |
| // "compute.googleapis.com/activity_log". |
| Name string `json:"name,omitempty"` |
| // PayloadType: Type URL describing the expected payload type for the log. |
| PayloadType string `json:"payloadType,omitempty"` |
| // ForceSendFields is a list of field names (e.g. "DisplayName") to |
| // unconditionally include in API requests. By default, fields with empty or |
| // default values are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "DisplayName") to include in API |
| // requests with the JSON null value. By default, fields with empty values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Log) MarshalJSON() ([]byte, error) { |
| type NoMethod Log |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| // LogEntry: An individual entry in a log. |
| type LogEntry struct { |
| // InsertId: 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. |
| InsertId string `json:"insertId,omitempty"` |
| // Log: The log to which this entry belongs. When a log entry is ingested, the |
| // value of this field is set by the logging system. |
| Log string `json:"log,omitempty"` |
| // Metadata: Information about the log entry. |
| Metadata *LogEntryMetadata `json:"metadata,omitempty"` |
| // ProtoPayload: The log entry payload, represented as a protocol buffer that |
| // is expressed as a JSON object. You can only pass `protoPayload` values that |
| // belong to a set of approved types. |
| ProtoPayload googleapi.RawMessage `json:"protoPayload,omitempty"` |
| // StructPayload: The log entry payload, represented as a structure that is |
| // expressed as a JSON object. |
| StructPayload googleapi.RawMessage `json:"structPayload,omitempty"` |
| // TextPayload: The log entry payload, represented as a text string. |
| TextPayload string `json:"textPayload,omitempty"` |
| // ForceSendFields is a list of field names (e.g. "InsertId") to |
| // unconditionally include in API requests. By default, fields with empty or |
| // default values are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "InsertId") to include in API |
| // requests with the JSON null value. By default, fields with empty values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *LogEntry) MarshalJSON() ([]byte, error) { |
| type NoMethod LogEntry |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| // LogEntryMetadata: Additional data that is associated with a log entry, set |
| // by the service creating the log entry. |
| type LogEntryMetadata struct { |
| // Labels: A set of (key, value) data that provides additional information |
| // about the log entry. If the log entry is from one of the Google Cloud |
| // Platform sources listed below, the indicated (key, value) information must |
| // be provided: Google App Engine, service_name `appengine.googleapis.com`: |
| // "appengine.googleapis.com/module_id", |
| // "appengine.googleapis.com/version_id", and one of: |
| // "appengine.googleapis.com/replica_index", |
| // "appengine.googleapis.com/clone_id", or else provide the following Compute |
| // Engine labels: Google Compute Engine, service_name `compute.googleapis.com`: |
| // "compute.googleapis.com/resource_type", "instance" |
| // "compute.googleapis.com/resource_id", |
| Labels map[string]string `json:"labels,omitempty"` |
| // ProjectId: The project ID of the Google Cloud Platform service that created |
| // the log entry. |
| ProjectId string `json:"projectId,omitempty"` |
| // Region: The region name of the Google Cloud Platform service that created |
| // the log entry. For example, "us-central1". |
| Region string `json:"region,omitempty"` |
| // ServiceName: The API name of the Google Cloud Platform service that created |
| // the log entry. For example, "compute.googleapis.com". |
| ServiceName string `json:"serviceName,omitempty"` |
| // Severity: The severity of the log entry. |
| // |
| // Possible values: |
| // "DEFAULT" - This is the DEFAULT description |
| // "DEBUG" - This is the DEBUG description |
| // "INFO" - This is the INFO description |
| // "NOTICE" - This is the NOTICE description |
| // "WARNING" - This is the WARNING description |
| // "ERROR" - This is the ERROR description |
| // "CRITICAL" - This is the CRITICAL description |
| // "ALERT" - This is the ALERT description |
| // "EMERGENCY" (default) - This is the EMERGENCY description |
| Severity string `json:"severity,omitempty"` |
| // Timestamp: The time the event described by the log entry occurred. |
| // Timestamps must be later than January 1, 1970. |
| Timestamp string `json:"timestamp,omitempty"` |
| // UserId: The fully-qualified email address of the authenticated user that |
| // performed or requested the action represented by the log entry. If the log |
| // entry does not apply to an action taken by an authenticated user, then the |
| // field should be empty. |
| UserId string `json:"userId,omitempty"` |
| // Zone: The zone of the Google Cloud Platform service that created the log |
| // entry. For example, "us-central1-a". |
| Zone string `json:"zone,omitempty"` |
| // ForceSendFields is a list of field names (e.g. "Labels") to unconditionally |
| // include in API requests. By default, fields with empty or default values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "Labels") to include in API |
| // requests with the JSON null value. By default, fields with empty values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *LogEntryMetadata) MarshalJSON() ([]byte, error) { |
| type NoMethod LogEntryMetadata |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| // LogError: A problem in a sink or the sink's configuration. |
| type LogError struct { |
| // Resource: The resource associated with the error. It may be different from |
| // the sink destination. For example, the sink may point to a BigQuery dataset, |
| // but the error may refer to a table resource inside the dataset. |
| Resource string `json:"resource,omitempty"` |
| // Status: The description of the last error observed. |
| Status *Status `json:"status,omitempty"` |
| // TimeNanos: The last time the error was observed, in nanoseconds since the |
| // Unix epoch. |
| TimeNanos int64 `json:"timeNanos,omitempty,string"` |
| // ForceSendFields is a list of field names (e.g. "Resource") to |
| // unconditionally include in API requests. By default, fields with empty or |
| // default values are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "Resource") to include in API |
| // requests with the JSON null value. By default, fields with empty values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *LogError) MarshalJSON() ([]byte, error) { |
| type NoMethod LogError |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| // LogService: A log service object. |
| type LogService struct { |
| // IndexKeys: Label keys used when labeling log entries for this service. The |
| // order of the keys is significant, with higher priority keys coming earlier |
| // in the list. |
| IndexKeys []string `json:"indexKeys,omitempty"` |
| // Name: The service's name. |
| Name string `json:"name,omitempty"` |
| // ForceSendFields is a list of field names (e.g. "IndexKeys") to |
| // unconditionally include in API requests. By default, fields with empty or |
| // default values are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "IndexKeys") to include in API |
| // requests with the JSON null value. By default, fields with empty values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *LogService) MarshalJSON() ([]byte, error) { |
| type NoMethod LogService |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| // LogSink: An object that describes where a log may be written. |
| type LogSink struct { |
| // Destination: The resource to send log entries to. The supported sink |
| // resource types are: + Google Cloud Storage: `storage.googleapis.com/BUCKET` |
| // or `BUCKET.storage.googleapis.com/` + Google BigQuery: |
| // `bigquery.googleapis.com/projects/PROJECT/datasets/DATASET` Currently the |
| // Cloud Logging API supports at most one sink for each resource type per log |
| // or log service resource. |
| Destination string `json:"destination,omitempty"` |
| // Errors: _Output only._ All active errors found for this sink. |
| Errors []*LogError `json:"errors,omitempty"` |
| // Name: The name of this sink. This is a client-assigned identifier for the |
| // resource. This is ignored by UpdateLogSink and UpdateLogServicesSink. |
| 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. "Destination") to |
| // unconditionally include in API requests. By default, fields with empty or |
| // default values are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "Destination") to include in API |
| // requests with the JSON null value. By default, fields with empty values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *LogSink) MarshalJSON() ([]byte, error) { |
| type NoMethod LogSink |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| // Status: Represents the RPC error status for Google APIs. See |
| // http://go/errormodel for details. |
| 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 []googleapi.RawMessage `json:"details,omitempty"` |
| // Message: A developer-facing error message, which should be in English. The |
| // user-facing error message should be localized and stored in the |
| // [google.rpc.Status.details][google.rpc.Status.details] field. |
| 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 or default values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "Code") to include in API requests |
| // with the JSON null value. By default, fields with empty values are omitted |
| // from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Status) MarshalJSON() ([]byte, error) { |
| type NoMethod Status |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| // WriteLogEntriesRequest: The parameters to WriteLogEntries. |
| type WriteLogEntriesRequest struct { |
| // CommonLabels: Metadata labels that apply to all entries in this request. If |
| // one of the log entries contains a (key, value) with the same key that is in |
| // `commonLabels`, then the entry's (key, value) overrides the one in |
| // `commonLabels`. |
| CommonLabels map[string]string `json:"commonLabels,omitempty"` |
| // Entries: Log entries to insert. |
| Entries []*LogEntry `json:"entries,omitempty"` |
| // ForceSendFields is a list of field names (e.g. "CommonLabels") to |
| // unconditionally include in API requests. By default, fields with empty or |
| // default values are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "CommonLabels") to include in API |
| // requests with the JSON null value. By default, fields with empty values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *WriteLogEntriesRequest) MarshalJSON() ([]byte, error) { |
| type NoMethod WriteLogEntriesRequest |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| // WriteLogEntriesResponse: Result returned from WriteLogEntries. empty |
| type WriteLogEntriesResponse struct { |
| // ServerResponse contains the HTTP response code and headers from the server. |
| googleapi.ServerResponse `json:"-"` |
| } |
| |
| type ProjectsLogServicesListCall struct { |
| s *Service |
| projectsId string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // List: Lists log services associated with log entries ingested for a project. |
| // |
| // - projectsId: Part of `projectName`. The project resource whose services are |
| // to be listed. |
| func (r *ProjectsLogServicesService) List(projectsId string) *ProjectsLogServicesListCall { |
| c := &ProjectsLogServicesListCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.projectsId = projectsId |
| return c |
| } |
| |
| // Log sets the optional parameter "log": The name of the log resource whose |
| // services are to be listed. log for which to list services. When empty, all |
| // services are listed. |
| func (c *ProjectsLogServicesListCall) Log(log string) *ProjectsLogServicesListCall { |
| c.urlParams_.Set("log", log) |
| return c |
| } |
| |
| // PageSize sets the optional parameter "pageSize": The maximum number of |
| // `LogService` objects to return in one operation. |
| func (c *ProjectsLogServicesListCall) PageSize(pageSize int64) *ProjectsLogServicesListCall { |
| c.urlParams_.Set("pageSize", fmt.Sprint(pageSize)) |
| return c |
| } |
| |
| // PageToken sets the optional parameter "pageToken": An opaque token, returned |
| // as `nextPageToken` by a prior `ListLogServices` operation. If `pageToken` is |
| // supplied, then the other fields of this request are ignored, and instead the |
| // previous `ListLogServices` operation is continued. |
| func (c *ProjectsLogServicesListCall) PageToken(pageToken string) *ProjectsLogServicesListCall { |
| 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 |
| // details. |
| func (c *ProjectsLogServicesListCall) Fields(s ...googleapi.Field) *ProjectsLogServicesListCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets an 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. |
| func (c *ProjectsLogServicesListCall) IfNoneMatch(entityTag string) *ProjectsLogServicesListCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *ProjectsLogServicesListCall) Context(ctx context.Context) *ProjectsLogServicesListCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *ProjectsLogServicesListCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *ProjectsLogServicesListCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_, "x-goog-api-version", "v1_20240501") |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "v1beta3/projects/{projectsId}/logServices") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("GET", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "projectsId": c.projectsId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "logging.projects.logServices.list" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *ListLogServicesResponse.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 *ProjectsLogServicesListCall) Do(opts ...googleapi.CallOption) (*ListLogServicesResponse, 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, gensupport.WrapError(&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, gensupport.WrapError(err) |
| } |
| ret := &ListLogServicesResponse{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| // 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 *ProjectsLogServicesListCall) Pages(ctx context.Context, f func(*ListLogServicesResponse) error) error { |
| c.ctx_ = ctx |
| defer c.PageToken(c.urlParams_.Get("pageToken")) |
| 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) |
| } |
| } |
| |
| type ProjectsLogServicesIndexesListCall struct { |
| s *Service |
| projectsId string |
| logServicesId string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // List: Lists log service indexes associated with a log service. |
| // |
| // - logServicesId: Part of `serviceName`. See documentation of `projectsId`. |
| // - projectsId: Part of `serviceName`. A log service resource of the form |
| // `/projects/*/logServices/*`. The service indexes of the log service are |
| // returned. Example: |
| // "/projects/myProj/logServices/appengine.googleapis.com". |
| func (r *ProjectsLogServicesIndexesService) List(projectsId string, logServicesId string) *ProjectsLogServicesIndexesListCall { |
| c := &ProjectsLogServicesIndexesListCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.projectsId = projectsId |
| c.logServicesId = logServicesId |
| return c |
| } |
| |
| // Depth sets the optional parameter "depth": A limit to the number of levels |
| // of the index hierarchy that are expanded. If `depth` is 0, it defaults to |
| // the level specified by the prefix field (the number of slash separators). |
| // The default empty prefix implies a `depth` of 1. It is an error for `depth` |
| // to be any non-zero value less than the number of components in |
| // `indexPrefix`. |
| func (c *ProjectsLogServicesIndexesListCall) Depth(depth int64) *ProjectsLogServicesIndexesListCall { |
| c.urlParams_.Set("depth", fmt.Sprint(depth)) |
| return c |
| } |
| |
| // IndexPrefix sets the optional parameter "indexPrefix": Restricts the indexes |
| // returned to be those with a specified prefix. The prefix has the form |
| // "/label_value/label_value/...", in order corresponding to the [`LogService |
| // indexKeys`][google.logging.v1.LogService.index_keys]. Non-empty prefixes |
| // must begin with `/` . Example prefixes: + "/myModule/" retrieves App |
| // Engine versions associated with `myModule`. The trailing slash terminates |
| // the value. + "/myModule" retrieves App Engine modules with names beginning |
| // with `myModule`. + "" retrieves all indexes. |
| func (c *ProjectsLogServicesIndexesListCall) IndexPrefix(indexPrefix string) *ProjectsLogServicesIndexesListCall { |
| c.urlParams_.Set("indexPrefix", indexPrefix) |
| return c |
| } |
| |
| // Log sets the optional parameter "log": A log resource like |
| // `/projects/project_id/logs/log_name`, identifying the log for which to list |
| // service indexes. |
| func (c *ProjectsLogServicesIndexesListCall) Log(log string) *ProjectsLogServicesIndexesListCall { |
| c.urlParams_.Set("log", log) |
| return c |
| } |
| |
| // PageSize sets the optional parameter "pageSize": The maximum number of log |
| // service index resources to return in one operation. |
| func (c *ProjectsLogServicesIndexesListCall) PageSize(pageSize int64) *ProjectsLogServicesIndexesListCall { |
| c.urlParams_.Set("pageSize", fmt.Sprint(pageSize)) |
| return c |
| } |
| |
| // PageToken sets the optional parameter "pageToken": An opaque token, returned |
| // as `nextPageToken` by a prior `ListLogServiceIndexes` operation. If |
| // `pageToken` is supplied, then the other fields of this request are ignored, |
| // and instead the previous `ListLogServiceIndexes` operation is continued. |
| func (c *ProjectsLogServicesIndexesListCall) PageToken(pageToken string) *ProjectsLogServicesIndexesListCall { |
| 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 |
| // details. |
| func (c *ProjectsLogServicesIndexesListCall) Fields(s ...googleapi.Field) *ProjectsLogServicesIndexesListCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets an 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. |
| func (c *ProjectsLogServicesIndexesListCall) IfNoneMatch(entityTag string) *ProjectsLogServicesIndexesListCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *ProjectsLogServicesIndexesListCall) Context(ctx context.Context) *ProjectsLogServicesIndexesListCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *ProjectsLogServicesIndexesListCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *ProjectsLogServicesIndexesListCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_, "x-goog-api-version", "v1_20240501") |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "v1beta3/projects/{projectsId}/logServices/{logServicesId}/indexes") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("GET", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "projectsId": c.projectsId, |
| "logServicesId": c.logServicesId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "logging.projects.logServices.indexes.list" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *ListLogServiceIndexesResponse.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 *ProjectsLogServicesIndexesListCall) Do(opts ...googleapi.CallOption) (*ListLogServiceIndexesResponse, 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, gensupport.WrapError(&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, gensupport.WrapError(err) |
| } |
| ret := &ListLogServiceIndexesResponse{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| // 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 *ProjectsLogServicesIndexesListCall) Pages(ctx context.Context, f func(*ListLogServiceIndexesResponse) error) error { |
| c.ctx_ = ctx |
| defer c.PageToken(c.urlParams_.Get("pageToken")) |
| 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) |
| } |
| } |
| |
| type ProjectsLogServicesSinksCreateCall struct { |
| s *Service |
| projectsId string |
| logServicesId string |
| logsink *LogSink |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Create: Creates the specified log service sink resource. |
| // |
| // - logServicesId: Part of `serviceName`. See documentation of `projectsId`. |
| // - projectsId: Part of `serviceName`. The name of the service in which to |
| // create a sink. |
| func (r *ProjectsLogServicesSinksService) Create(projectsId string, logServicesId string, logsink *LogSink) *ProjectsLogServicesSinksCreateCall { |
| c := &ProjectsLogServicesSinksCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.projectsId = projectsId |
| c.logServicesId = logServicesId |
| 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 |
| // details. |
| func (c *ProjectsLogServicesSinksCreateCall) Fields(s ...googleapi.Field) *ProjectsLogServicesSinksCreateCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *ProjectsLogServicesSinksCreateCall) Context(ctx context.Context) *ProjectsLogServicesSinksCreateCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *ProjectsLogServicesSinksCreateCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *ProjectsLogServicesSinksCreateCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_, "x-goog-api-version", "v1_20240501") |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.logsink) |
| if err != nil { |
| return nil, err |
| } |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "v1beta3/projects/{projectsId}/logServices/{logServicesId}/sinks") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("POST", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "projectsId": c.projectsId, |
| "logServicesId": c.logServicesId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "logging.projects.logServices.sinks.create" call. |
| // 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 *ProjectsLogServicesSinksCreateCall) 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, gensupport.WrapError(&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, gensupport.WrapError(err) |
| } |
| ret := &LogSink{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type ProjectsLogServicesSinksDeleteCall struct { |
| s *Service |
| projectsId string |
| logServicesId string |
| sinksId string |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Delete: Deletes the specified log service sink. |
| // |
| // - logServicesId: Part of `sinkName`. See documentation of `projectsId`. |
| // - projectsId: Part of `sinkName`. The name of the sink to delete. |
| // - sinksId: Part of `sinkName`. See documentation of `projectsId`. |
| func (r *ProjectsLogServicesSinksService) Delete(projectsId string, logServicesId string, sinksId string) *ProjectsLogServicesSinksDeleteCall { |
| c := &ProjectsLogServicesSinksDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.projectsId = projectsId |
| c.logServicesId = logServicesId |
| c.sinksId = sinksId |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *ProjectsLogServicesSinksDeleteCall) Fields(s ...googleapi.Field) *ProjectsLogServicesSinksDeleteCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *ProjectsLogServicesSinksDeleteCall) Context(ctx context.Context) *ProjectsLogServicesSinksDeleteCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *ProjectsLogServicesSinksDeleteCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *ProjectsLogServicesSinksDeleteCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_, "x-goog-api-version", "v1_20240501") |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "v1beta3/projects/{projectsId}/logServices/{logServicesId}/sinks/{sinksId}") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("DELETE", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "projectsId": c.projectsId, |
| "logServicesId": c.logServicesId, |
| "sinksId": c.sinksId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "logging.projects.logServices.sinks.delete" call. |
| // 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 *ProjectsLogServicesSinksDeleteCall) 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, gensupport.WrapError(&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, gensupport.WrapError(err) |
| } |
| ret := &Empty{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type ProjectsLogServicesSinksGetCall struct { |
| s *Service |
| projectsId string |
| logServicesId string |
| sinksId string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Get: Gets the specified log service sink resource. |
| // |
| // - logServicesId: Part of `sinkName`. See documentation of `projectsId`. |
| // - projectsId: Part of `sinkName`. The name of the sink to return. |
| // - sinksId: Part of `sinkName`. See documentation of `projectsId`. |
| func (r *ProjectsLogServicesSinksService) Get(projectsId string, logServicesId string, sinksId string) *ProjectsLogServicesSinksGetCall { |
| c := &ProjectsLogServicesSinksGetCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.projectsId = projectsId |
| c.logServicesId = logServicesId |
| c.sinksId = sinksId |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *ProjectsLogServicesSinksGetCall) Fields(s ...googleapi.Field) *ProjectsLogServicesSinksGetCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets an 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. |
| func (c *ProjectsLogServicesSinksGetCall) IfNoneMatch(entityTag string) *ProjectsLogServicesSinksGetCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *ProjectsLogServicesSinksGetCall) Context(ctx context.Context) *ProjectsLogServicesSinksGetCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *ProjectsLogServicesSinksGetCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *ProjectsLogServicesSinksGetCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_, "x-goog-api-version", "v1_20240501") |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "v1beta3/projects/{projectsId}/logServices/{logServicesId}/sinks/{sinksId}") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("GET", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "projectsId": c.projectsId, |
| "logServicesId": c.logServicesId, |
| "sinksId": c.sinksId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "logging.projects.logServices.sinks.get" call. |
| // 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 *ProjectsLogServicesSinksGetCall) 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, gensupport.WrapError(&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, gensupport.WrapError(err) |
| } |
| ret := &LogSink{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type ProjectsLogServicesSinksListCall struct { |
| s *Service |
| projectsId string |
| logServicesId string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // List: Lists log service sinks associated with the specified service. |
| // |
| // - logServicesId: Part of `serviceName`. See documentation of `projectsId`. |
| // - projectsId: Part of `serviceName`. The name of the service for which to |
| // list sinks. |
| func (r *ProjectsLogServicesSinksService) List(projectsId string, logServicesId string) *ProjectsLogServicesSinksListCall { |
| c := &ProjectsLogServicesSinksListCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.projectsId = projectsId |
| c.logServicesId = logServicesId |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *ProjectsLogServicesSinksListCall) Fields(s ...googleapi.Field) *ProjectsLogServicesSinksListCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets an 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. |
| func (c *ProjectsLogServicesSinksListCall) IfNoneMatch(entityTag string) *ProjectsLogServicesSinksListCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *ProjectsLogServicesSinksListCall) Context(ctx context.Context) *ProjectsLogServicesSinksListCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *ProjectsLogServicesSinksListCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *ProjectsLogServicesSinksListCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_, "x-goog-api-version", "v1_20240501") |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "v1beta3/projects/{projectsId}/logServices/{logServicesId}/sinks") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("GET", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "projectsId": c.projectsId, |
| "logServicesId": c.logServicesId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "logging.projects.logServices.sinks.list" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *ListLogServiceSinksResponse.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 *ProjectsLogServicesSinksListCall) Do(opts ...googleapi.CallOption) (*ListLogServiceSinksResponse, 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, gensupport.WrapError(&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, gensupport.WrapError(err) |
| } |
| ret := &ListLogServiceSinksResponse{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type ProjectsLogServicesSinksUpdateCall struct { |
| s *Service |
| projectsId string |
| logServicesId string |
| sinksId string |
| logsink *LogSink |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Update: Creates or update the specified log service sink resource. |
| // |
| // - logServicesId: Part of `sinkName`. See documentation of `projectsId`. |
| // - projectsId: Part of `sinkName`. The name of the sink to update. |
| // - sinksId: Part of `sinkName`. See documentation of `projectsId`. |
| func (r *ProjectsLogServicesSinksService) Update(projectsId string, logServicesId string, sinksId string, logsink *LogSink) *ProjectsLogServicesSinksUpdateCall { |
| c := &ProjectsLogServicesSinksUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.projectsId = projectsId |
| c.logServicesId = logServicesId |
| c.sinksId = sinksId |
| 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 |
| // details. |
| func (c *ProjectsLogServicesSinksUpdateCall) Fields(s ...googleapi.Field) *ProjectsLogServicesSinksUpdateCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *ProjectsLogServicesSinksUpdateCall) Context(ctx context.Context) *ProjectsLogServicesSinksUpdateCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *ProjectsLogServicesSinksUpdateCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *ProjectsLogServicesSinksUpdateCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_, "x-goog-api-version", "v1_20240501") |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.logsink) |
| if err != nil { |
| return nil, err |
| } |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "v1beta3/projects/{projectsId}/logServices/{logServicesId}/sinks/{sinksId}") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("PUT", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "projectsId": c.projectsId, |
| "logServicesId": c.logServicesId, |
| "sinksId": c.sinksId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "logging.projects.logServices.sinks.update" call. |
| // 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 *ProjectsLogServicesSinksUpdateCall) 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, gensupport.WrapError(&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, gensupport.WrapError(err) |
| } |
| ret := &LogSink{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type ProjectsLogsDeleteCall struct { |
| s *Service |
| projectsId string |
| logsId string |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Delete: Deletes the specified log resource and all log entries contained in |
| // it. |
| // |
| // - logsId: Part of `logName`. See documentation of `projectsId`. |
| // - projectsId: Part of `logName`. The log resource to delete. |
| func (r *ProjectsLogsService) Delete(projectsId string, logsId string) *ProjectsLogsDeleteCall { |
| c := &ProjectsLogsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.projectsId = projectsId |
| c.logsId = logsId |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| 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. |
| func (c *ProjectsLogsDeleteCall) Context(ctx context.Context) *ProjectsLogsDeleteCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *ProjectsLogsDeleteCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *ProjectsLogsDeleteCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_, "x-goog-api-version", "v1_20240501") |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "v1beta3/projects/{projectsId}/logs/{logsId}") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("DELETE", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "projectsId": c.projectsId, |
| "logsId": c.logsId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "logging.projects.logs.delete" call. |
| // 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, gensupport.WrapError(&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, gensupport.WrapError(err) |
| } |
| ret := &Empty{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type ProjectsLogsListCall struct { |
| s *Service |
| projectsId string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // List: Lists log resources belonging to the specified project. |
| // |
| // - projectsId: Part of `projectName`. The project name for which to list the |
| // log resources. |
| func (r *ProjectsLogsService) List(projectsId string) *ProjectsLogsListCall { |
| c := &ProjectsLogsListCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.projectsId = projectsId |
| return c |
| } |
| |
| // PageSize sets the optional parameter "pageSize": The maximum number of |
| // results to return. |
| func (c *ProjectsLogsListCall) PageSize(pageSize int64) *ProjectsLogsListCall { |
| c.urlParams_.Set("pageSize", fmt.Sprint(pageSize)) |
| return c |
| } |
| |
| // PageToken sets the optional parameter "pageToken": An opaque token, returned |
| // as `nextPageToken` by a prior `ListLogs` operation. If `pageToken` is |
| // supplied, then the other fields of this request are ignored, and instead the |
| // previous `ListLogs` operation is continued. |
| func (c *ProjectsLogsListCall) PageToken(pageToken string) *ProjectsLogsListCall { |
| c.urlParams_.Set("pageToken", pageToken) |
| return c |
| } |
| |
| // ServiceIndexPrefix sets the optional parameter "serviceIndexPrefix": A log |
| // service index prefix for which to list logs. Only logs containing entries |
| // whose metadata that includes these label values (associated with index keys) |
| // are returned. The prefix is a slash separated list of values, and need not |
| // specify all index labels. An empty index (or a single slash) matches all log |
| // service indexes. |
| func (c *ProjectsLogsListCall) ServiceIndexPrefix(serviceIndexPrefix string) *ProjectsLogsListCall { |
| c.urlParams_.Set("serviceIndexPrefix", serviceIndexPrefix) |
| return c |
| } |
| |
| // ServiceName sets the optional parameter "serviceName": A service name for |
| // which to list logs. Only logs containing entries whose metadata includes |
| // this service name are returned. If `serviceName` and `serviceIndexPrefix` |
| // are both empty, then all log names are returned. To list all log names, |
| // regardless of service, leave both the `serviceName` and `serviceIndexPrefix` |
| // empty. To list log names containing entries with a particular service name |
| // (or explicitly empty service name) set `serviceName` to the desired value |
| // and `serviceIndexPrefix` to "/". |
| func (c *ProjectsLogsListCall) ServiceName(serviceName string) *ProjectsLogsListCall { |
| c.urlParams_.Set("serviceName", serviceName) |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *ProjectsLogsListCall) Fields(s ...googleapi.Field) *ProjectsLogsListCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets an 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. |
| func (c *ProjectsLogsListCall) IfNoneMatch(entityTag string) *ProjectsLogsListCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *ProjectsLogsListCall) Context(ctx context.Context) *ProjectsLogsListCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *ProjectsLogsListCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *ProjectsLogsListCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_, "x-goog-api-version", "v1_20240501") |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "v1beta3/projects/{projectsId}/logs") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("GET", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "projectsId": c.projectsId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "logging.projects.logs.list" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *ListLogsResponse.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 *ProjectsLogsListCall) Do(opts ...googleapi.CallOption) (*ListLogsResponse, 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, gensupport.WrapError(&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, gensupport.WrapError(err) |
| } |
| ret := &ListLogsResponse{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| // 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 *ProjectsLogsListCall) Pages(ctx context.Context, f func(*ListLogsResponse) error) error { |
| c.ctx_ = ctx |
| defer c.PageToken(c.urlParams_.Get("pageToken")) |
| 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) |
| } |
| } |
| |
| type ProjectsLogsEntriesWriteCall struct { |
| s *Service |
| projectsId string |
| logsId string |
| writelogentriesrequest *WriteLogEntriesRequest |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Write: Creates one or more log entries in a log. You must supply a list of |
| // `LogEntry` objects, named `entries`. Each `LogEntry` object must contain a |
| // payload object and a `LogEntryMetadata` object that describes the entry. You |
| // must fill in all the fields of the entry, metadata, and payload. You can |
| // also supply a map, `commonLabels`, that supplies default (key, value) data |
| // for the `entries[].metadata.labels` maps, saving you the trouble of creating |
| // identical copies for each entry. |
| // |
| // - logsId: Part of `logName`. See documentation of `projectsId`. |
| // - projectsId: Part of `logName`. The name of the log resource into which to |
| // insert the log entries. |
| func (r *ProjectsLogsEntriesService) Write(projectsId string, logsId string, writelogentriesrequest *WriteLogEntriesRequest) *ProjectsLogsEntriesWriteCall { |
| c := &ProjectsLogsEntriesWriteCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.projectsId = projectsId |
| c.logsId = logsId |
| 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 |
| // details. |
| func (c *ProjectsLogsEntriesWriteCall) Fields(s ...googleapi.Field) *ProjectsLogsEntriesWriteCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *ProjectsLogsEntriesWriteCall) Context(ctx context.Context) *ProjectsLogsEntriesWriteCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *ProjectsLogsEntriesWriteCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *ProjectsLogsEntriesWriteCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_, "x-goog-api-version", "v1_20240501") |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.writelogentriesrequest) |
| if err != nil { |
| return nil, err |
| } |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "v1beta3/projects/{projectsId}/logs/{logsId}/entries:write") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("POST", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "projectsId": c.projectsId, |
| "logsId": c.logsId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "logging.projects.logs.entries.write" call. |
| // 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 *ProjectsLogsEntriesWriteCall) 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, gensupport.WrapError(&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, gensupport.WrapError(err) |
| } |
| ret := &WriteLogEntriesResponse{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type ProjectsLogsSinksCreateCall struct { |
| s *Service |
| projectsId string |
| logsId string |
| logsink *LogSink |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Create: Creates the specified log sink resource. |
| // |
| // - logsId: Part of `logName`. See documentation of `projectsId`. |
| // - projectsId: Part of `logName`. The log in which to create a sink resource. |
| func (r *ProjectsLogsSinksService) Create(projectsId string, logsId string, logsink *LogSink) *ProjectsLogsSinksCreateCall { |
| c := &ProjectsLogsSinksCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.projectsId = projectsId |
| c.logsId = logsId |
| 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 |
| // details. |
| func (c *ProjectsLogsSinksCreateCall) Fields(s ...googleapi.Field) *ProjectsLogsSinksCreateCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *ProjectsLogsSinksCreateCall) Context(ctx context.Context) *ProjectsLogsSinksCreateCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *ProjectsLogsSinksCreateCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *ProjectsLogsSinksCreateCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_, "x-goog-api-version", "v1_20240501") |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.logsink) |
| if err != nil { |
| return nil, err |
| } |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "v1beta3/projects/{projectsId}/logs/{logsId}/sinks") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("POST", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "projectsId": c.projectsId, |
| "logsId": c.logsId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "logging.projects.logs.sinks.create" call. |
| // 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 *ProjectsLogsSinksCreateCall) 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, gensupport.WrapError(&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, gensupport.WrapError(err) |
| } |
| ret := &LogSink{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type ProjectsLogsSinksDeleteCall struct { |
| s *Service |
| projectsId string |
| logsId string |
| sinksId string |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Delete: Deletes the specified log sink resource. |
| // |
| // - logsId: Part of `sinkName`. See documentation of `projectsId`. |
| // - projectsId: Part of `sinkName`. The name of the sink to delete. |
| // - sinksId: Part of `sinkName`. See documentation of `projectsId`. |
| func (r *ProjectsLogsSinksService) Delete(projectsId string, logsId string, sinksId string) *ProjectsLogsSinksDeleteCall { |
| c := &ProjectsLogsSinksDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.projectsId = projectsId |
| c.logsId = logsId |
| c.sinksId = sinksId |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *ProjectsLogsSinksDeleteCall) Fields(s ...googleapi.Field) *ProjectsLogsSinksDeleteCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *ProjectsLogsSinksDeleteCall) Context(ctx context.Context) *ProjectsLogsSinksDeleteCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *ProjectsLogsSinksDeleteCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *ProjectsLogsSinksDeleteCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_, "x-goog-api-version", "v1_20240501") |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "v1beta3/projects/{projectsId}/logs/{logsId}/sinks/{sinksId}") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("DELETE", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "projectsId": c.projectsId, |
| "logsId": c.logsId, |
| "sinksId": c.sinksId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "logging.projects.logs.sinks.delete" call. |
| // 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 *ProjectsLogsSinksDeleteCall) 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, gensupport.WrapError(&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, gensupport.WrapError(err) |
| } |
| ret := &Empty{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type ProjectsLogsSinksGetCall struct { |
| s *Service |
| projectsId string |
| logsId string |
| sinksId string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Get: Gets the specified log sink resource. |
| // |
| // - logsId: Part of `sinkName`. See documentation of `projectsId`. |
| // - projectsId: Part of `sinkName`. The name of the sink resource to return. |
| // - sinksId: Part of `sinkName`. See documentation of `projectsId`. |
| func (r *ProjectsLogsSinksService) Get(projectsId string, logsId string, sinksId string) *ProjectsLogsSinksGetCall { |
| c := &ProjectsLogsSinksGetCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.projectsId = projectsId |
| c.logsId = logsId |
| c.sinksId = sinksId |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *ProjectsLogsSinksGetCall) Fields(s ...googleapi.Field) *ProjectsLogsSinksGetCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets an 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. |
| func (c *ProjectsLogsSinksGetCall) IfNoneMatch(entityTag string) *ProjectsLogsSinksGetCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *ProjectsLogsSinksGetCall) Context(ctx context.Context) *ProjectsLogsSinksGetCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *ProjectsLogsSinksGetCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *ProjectsLogsSinksGetCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_, "x-goog-api-version", "v1_20240501") |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "v1beta3/projects/{projectsId}/logs/{logsId}/sinks/{sinksId}") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("GET", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "projectsId": c.projectsId, |
| "logsId": c.logsId, |
| "sinksId": c.sinksId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "logging.projects.logs.sinks.get" call. |
| // 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 *ProjectsLogsSinksGetCall) 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, gensupport.WrapError(&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, gensupport.WrapError(err) |
| } |
| ret := &LogSink{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type ProjectsLogsSinksListCall struct { |
| s *Service |
| projectsId string |
| logsId string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // List: Lists log sinks associated with the specified log. |
| // |
| // - logsId: Part of `logName`. See documentation of `projectsId`. |
| // - projectsId: Part of `logName`. The log for which to list sinks. |
| func (r *ProjectsLogsSinksService) List(projectsId string, logsId string) *ProjectsLogsSinksListCall { |
| c := &ProjectsLogsSinksListCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.projectsId = projectsId |
| c.logsId = logsId |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *ProjectsLogsSinksListCall) Fields(s ...googleapi.Field) *ProjectsLogsSinksListCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets an 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. |
| func (c *ProjectsLogsSinksListCall) IfNoneMatch(entityTag string) *ProjectsLogsSinksListCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *ProjectsLogsSinksListCall) Context(ctx context.Context) *ProjectsLogsSinksListCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *ProjectsLogsSinksListCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *ProjectsLogsSinksListCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_, "x-goog-api-version", "v1_20240501") |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "v1beta3/projects/{projectsId}/logs/{logsId}/sinks") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("GET", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "projectsId": c.projectsId, |
| "logsId": c.logsId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "logging.projects.logs.sinks.list" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *ListLogSinksResponse.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 *ProjectsLogsSinksListCall) Do(opts ...googleapi.CallOption) (*ListLogSinksResponse, 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, gensupport.WrapError(&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, gensupport.WrapError(err) |
| } |
| ret := &ListLogSinksResponse{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type ProjectsLogsSinksUpdateCall struct { |
| s *Service |
| projectsId string |
| logsId string |
| sinksId string |
| logsink *LogSink |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Update: Creates or updates the specified log sink resource. |
| // |
| // - logsId: Part of `sinkName`. See documentation of `projectsId`. |
| // - projectsId: Part of `sinkName`. The name of the sink to update. |
| // - sinksId: Part of `sinkName`. See documentation of `projectsId`. |
| func (r *ProjectsLogsSinksService) Update(projectsId string, logsId string, sinksId string, logsink *LogSink) *ProjectsLogsSinksUpdateCall { |
| c := &ProjectsLogsSinksUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.projectsId = projectsId |
| c.logsId = logsId |
| c.sinksId = sinksId |
| 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 |
| // details. |
| func (c *ProjectsLogsSinksUpdateCall) Fields(s ...googleapi.Field) *ProjectsLogsSinksUpdateCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *ProjectsLogsSinksUpdateCall) Context(ctx context.Context) *ProjectsLogsSinksUpdateCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *ProjectsLogsSinksUpdateCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *ProjectsLogsSinksUpdateCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_, "x-goog-api-version", "v1_20240501") |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.logsink) |
| if err != nil { |
| return nil, err |
| } |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "v1beta3/projects/{projectsId}/logs/{logsId}/sinks/{sinksId}") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("PUT", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "projectsId": c.projectsId, |
| "logsId": c.logsId, |
| "sinksId": c.sinksId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "logging.projects.logs.sinks.update" call. |
| // 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 *ProjectsLogsSinksUpdateCall) 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, gensupport.WrapError(&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, gensupport.WrapError(err) |
| } |
| ret := &LogSink{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |