Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.8/site-packages/google/cloud/logging_v2/services/config_service_v2/client.py: 25%
553 statements
« prev ^ index » next coverage.py v7.3.2, created at 2023-12-08 06:45 +0000
« prev ^ index » next coverage.py v7.3.2, created at 2023-12-08 06:45 +0000
1# -*- coding: utf-8 -*-
2# Copyright 2023 Google LLC
3#
4# Licensed under the Apache License, Version 2.0 (the "License");
5# you may not use this file except in compliance with the License.
6# You may obtain a copy of the License at
7#
8# http://www.apache.org/licenses/LICENSE-2.0
9#
10# Unless required by applicable law or agreed to in writing, software
11# distributed under the License is distributed on an "AS IS" BASIS,
12# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13# See the License for the specific language governing permissions and
14# limitations under the License.
15#
16from collections import OrderedDict
17import os
18import re
19from typing import (
20 Dict,
21 Mapping,
22 MutableMapping,
23 MutableSequence,
24 Optional,
25 Sequence,
26 Tuple,
27 Type,
28 Union,
29 cast,
30)
32from google.cloud.logging_v2 import gapic_version as package_version
34from google.api_core import client_options as client_options_lib
35from google.api_core import exceptions as core_exceptions
36from google.api_core import gapic_v1
37from google.api_core import retry as retries
38from google.auth import credentials as ga_credentials # type: ignore
39from google.auth.transport import mtls # type: ignore
40from google.auth.transport.grpc import SslCredentials # type: ignore
41from google.auth.exceptions import MutualTLSChannelError # type: ignore
42from google.oauth2 import service_account # type: ignore
44try:
45 OptionalRetry = Union[retries.Retry, gapic_v1.method._MethodDefault]
46except AttributeError: # pragma: NO COVER
47 OptionalRetry = Union[retries.Retry, object] # type: ignore
49from google.api_core import operation # type: ignore
50from google.api_core import operation_async # type: ignore
51from google.cloud.logging_v2.services.config_service_v2 import pagers
52from google.cloud.logging_v2.types import logging_config
53from google.longrunning import operations_pb2 # type: ignore
54from google.protobuf import empty_pb2 # type: ignore
55from google.protobuf import field_mask_pb2 # type: ignore
56from google.protobuf import timestamp_pb2 # type: ignore
57from .transports.base import ConfigServiceV2Transport, DEFAULT_CLIENT_INFO
58from .transports.grpc import ConfigServiceV2GrpcTransport
59from .transports.grpc_asyncio import ConfigServiceV2GrpcAsyncIOTransport
62class ConfigServiceV2ClientMeta(type):
63 """Metaclass for the ConfigServiceV2 client.
65 This provides class-level methods for building and retrieving
66 support objects (e.g. transport) without polluting the client instance
67 objects.
68 """
70 _transport_registry = (
71 OrderedDict()
72 ) # type: Dict[str, Type[ConfigServiceV2Transport]]
73 _transport_registry["grpc"] = ConfigServiceV2GrpcTransport
74 _transport_registry["grpc_asyncio"] = ConfigServiceV2GrpcAsyncIOTransport
76 def get_transport_class(
77 cls,
78 label: Optional[str] = None,
79 ) -> Type[ConfigServiceV2Transport]:
80 """Returns an appropriate transport class.
82 Args:
83 label: The name of the desired transport. If none is
84 provided, then the first transport in the registry is used.
86 Returns:
87 The transport class to use.
88 """
89 # If a specific transport is requested, return that one.
90 if label:
91 return cls._transport_registry[label]
93 # No transport is requested; return the default (that is, the first one
94 # in the dictionary).
95 return next(iter(cls._transport_registry.values()))
98class ConfigServiceV2Client(metaclass=ConfigServiceV2ClientMeta):
99 """Service for configuring sinks used to route log entries."""
101 @staticmethod
102 def _get_default_mtls_endpoint(api_endpoint):
103 """Converts api endpoint to mTLS endpoint.
105 Convert "*.sandbox.googleapis.com" and "*.googleapis.com" to
106 "*.mtls.sandbox.googleapis.com" and "*.mtls.googleapis.com" respectively.
107 Args:
108 api_endpoint (Optional[str]): the api endpoint to convert.
109 Returns:
110 str: converted mTLS api endpoint.
111 """
112 if not api_endpoint:
113 return api_endpoint
115 mtls_endpoint_re = re.compile(
116 r"(?P<name>[^.]+)(?P<mtls>\.mtls)?(?P<sandbox>\.sandbox)?(?P<googledomain>\.googleapis\.com)?"
117 )
119 m = mtls_endpoint_re.match(api_endpoint)
120 name, mtls, sandbox, googledomain = m.groups()
121 if mtls or not googledomain:
122 return api_endpoint
124 if sandbox:
125 return api_endpoint.replace(
126 "sandbox.googleapis.com", "mtls.sandbox.googleapis.com"
127 )
129 return api_endpoint.replace(".googleapis.com", ".mtls.googleapis.com")
131 DEFAULT_ENDPOINT = "logging.googleapis.com"
132 DEFAULT_MTLS_ENDPOINT = _get_default_mtls_endpoint.__func__( # type: ignore
133 DEFAULT_ENDPOINT
134 )
136 @classmethod
137 def from_service_account_info(cls, info: dict, *args, **kwargs):
138 """Creates an instance of this client using the provided credentials
139 info.
141 Args:
142 info (dict): The service account private key info.
143 args: Additional arguments to pass to the constructor.
144 kwargs: Additional arguments to pass to the constructor.
146 Returns:
147 ConfigServiceV2Client: The constructed client.
148 """
149 credentials = service_account.Credentials.from_service_account_info(info)
150 kwargs["credentials"] = credentials
151 return cls(*args, **kwargs)
153 @classmethod
154 def from_service_account_file(cls, filename: str, *args, **kwargs):
155 """Creates an instance of this client using the provided credentials
156 file.
158 Args:
159 filename (str): The path to the service account private key json
160 file.
161 args: Additional arguments to pass to the constructor.
162 kwargs: Additional arguments to pass to the constructor.
164 Returns:
165 ConfigServiceV2Client: The constructed client.
166 """
167 credentials = service_account.Credentials.from_service_account_file(filename)
168 kwargs["credentials"] = credentials
169 return cls(*args, **kwargs)
171 from_service_account_json = from_service_account_file
173 @property
174 def transport(self) -> ConfigServiceV2Transport:
175 """Returns the transport used by the client instance.
177 Returns:
178 ConfigServiceV2Transport: The transport used by the client
179 instance.
180 """
181 return self._transport
183 @staticmethod
184 def cmek_settings_path(
185 project: str,
186 ) -> str:
187 """Returns a fully-qualified cmek_settings string."""
188 return "projects/{project}/cmekSettings".format(
189 project=project,
190 )
192 @staticmethod
193 def parse_cmek_settings_path(path: str) -> Dict[str, str]:
194 """Parses a cmek_settings path into its component segments."""
195 m = re.match(r"^projects/(?P<project>.+?)/cmekSettings$", path)
196 return m.groupdict() if m else {}
198 @staticmethod
199 def link_path(
200 project: str,
201 location: str,
202 bucket: str,
203 link: str,
204 ) -> str:
205 """Returns a fully-qualified link string."""
206 return "projects/{project}/locations/{location}/buckets/{bucket}/links/{link}".format(
207 project=project,
208 location=location,
209 bucket=bucket,
210 link=link,
211 )
213 @staticmethod
214 def parse_link_path(path: str) -> Dict[str, str]:
215 """Parses a link path into its component segments."""
216 m = re.match(
217 r"^projects/(?P<project>.+?)/locations/(?P<location>.+?)/buckets/(?P<bucket>.+?)/links/(?P<link>.+?)$",
218 path,
219 )
220 return m.groupdict() if m else {}
222 @staticmethod
223 def log_bucket_path(
224 project: str,
225 location: str,
226 bucket: str,
227 ) -> str:
228 """Returns a fully-qualified log_bucket string."""
229 return "projects/{project}/locations/{location}/buckets/{bucket}".format(
230 project=project,
231 location=location,
232 bucket=bucket,
233 )
235 @staticmethod
236 def parse_log_bucket_path(path: str) -> Dict[str, str]:
237 """Parses a log_bucket path into its component segments."""
238 m = re.match(
239 r"^projects/(?P<project>.+?)/locations/(?P<location>.+?)/buckets/(?P<bucket>.+?)$",
240 path,
241 )
242 return m.groupdict() if m else {}
244 @staticmethod
245 def log_exclusion_path(
246 project: str,
247 exclusion: str,
248 ) -> str:
249 """Returns a fully-qualified log_exclusion string."""
250 return "projects/{project}/exclusions/{exclusion}".format(
251 project=project,
252 exclusion=exclusion,
253 )
255 @staticmethod
256 def parse_log_exclusion_path(path: str) -> Dict[str, str]:
257 """Parses a log_exclusion path into its component segments."""
258 m = re.match(r"^projects/(?P<project>.+?)/exclusions/(?P<exclusion>.+?)$", path)
259 return m.groupdict() if m else {}
261 @staticmethod
262 def log_sink_path(
263 project: str,
264 sink: str,
265 ) -> str:
266 """Returns a fully-qualified log_sink string."""
267 return "projects/{project}/sinks/{sink}".format(
268 project=project,
269 sink=sink,
270 )
272 @staticmethod
273 def parse_log_sink_path(path: str) -> Dict[str, str]:
274 """Parses a log_sink path into its component segments."""
275 m = re.match(r"^projects/(?P<project>.+?)/sinks/(?P<sink>.+?)$", path)
276 return m.groupdict() if m else {}
278 @staticmethod
279 def log_view_path(
280 project: str,
281 location: str,
282 bucket: str,
283 view: str,
284 ) -> str:
285 """Returns a fully-qualified log_view string."""
286 return "projects/{project}/locations/{location}/buckets/{bucket}/views/{view}".format(
287 project=project,
288 location=location,
289 bucket=bucket,
290 view=view,
291 )
293 @staticmethod
294 def parse_log_view_path(path: str) -> Dict[str, str]:
295 """Parses a log_view path into its component segments."""
296 m = re.match(
297 r"^projects/(?P<project>.+?)/locations/(?P<location>.+?)/buckets/(?P<bucket>.+?)/views/(?P<view>.+?)$",
298 path,
299 )
300 return m.groupdict() if m else {}
302 @staticmethod
303 def settings_path(
304 project: str,
305 ) -> str:
306 """Returns a fully-qualified settings string."""
307 return "projects/{project}/settings".format(
308 project=project,
309 )
311 @staticmethod
312 def parse_settings_path(path: str) -> Dict[str, str]:
313 """Parses a settings path into its component segments."""
314 m = re.match(r"^projects/(?P<project>.+?)/settings$", path)
315 return m.groupdict() if m else {}
317 @staticmethod
318 def common_billing_account_path(
319 billing_account: str,
320 ) -> str:
321 """Returns a fully-qualified billing_account string."""
322 return "billingAccounts/{billing_account}".format(
323 billing_account=billing_account,
324 )
326 @staticmethod
327 def parse_common_billing_account_path(path: str) -> Dict[str, str]:
328 """Parse a billing_account path into its component segments."""
329 m = re.match(r"^billingAccounts/(?P<billing_account>.+?)$", path)
330 return m.groupdict() if m else {}
332 @staticmethod
333 def common_folder_path(
334 folder: str,
335 ) -> str:
336 """Returns a fully-qualified folder string."""
337 return "folders/{folder}".format(
338 folder=folder,
339 )
341 @staticmethod
342 def parse_common_folder_path(path: str) -> Dict[str, str]:
343 """Parse a folder path into its component segments."""
344 m = re.match(r"^folders/(?P<folder>.+?)$", path)
345 return m.groupdict() if m else {}
347 @staticmethod
348 def common_organization_path(
349 organization: str,
350 ) -> str:
351 """Returns a fully-qualified organization string."""
352 return "organizations/{organization}".format(
353 organization=organization,
354 )
356 @staticmethod
357 def parse_common_organization_path(path: str) -> Dict[str, str]:
358 """Parse a organization path into its component segments."""
359 m = re.match(r"^organizations/(?P<organization>.+?)$", path)
360 return m.groupdict() if m else {}
362 @staticmethod
363 def common_project_path(
364 project: str,
365 ) -> str:
366 """Returns a fully-qualified project string."""
367 return "projects/{project}".format(
368 project=project,
369 )
371 @staticmethod
372 def parse_common_project_path(path: str) -> Dict[str, str]:
373 """Parse a project path into its component segments."""
374 m = re.match(r"^projects/(?P<project>.+?)$", path)
375 return m.groupdict() if m else {}
377 @staticmethod
378 def common_location_path(
379 project: str,
380 location: str,
381 ) -> str:
382 """Returns a fully-qualified location string."""
383 return "projects/{project}/locations/{location}".format(
384 project=project,
385 location=location,
386 )
388 @staticmethod
389 def parse_common_location_path(path: str) -> Dict[str, str]:
390 """Parse a location path into its component segments."""
391 m = re.match(r"^projects/(?P<project>.+?)/locations/(?P<location>.+?)$", path)
392 return m.groupdict() if m else {}
394 @classmethod
395 def get_mtls_endpoint_and_cert_source(
396 cls, client_options: Optional[client_options_lib.ClientOptions] = None
397 ):
398 """Return the API endpoint and client cert source for mutual TLS.
400 The client cert source is determined in the following order:
401 (1) if `GOOGLE_API_USE_CLIENT_CERTIFICATE` environment variable is not "true", the
402 client cert source is None.
403 (2) if `client_options.client_cert_source` is provided, use the provided one; if the
404 default client cert source exists, use the default one; otherwise the client cert
405 source is None.
407 The API endpoint is determined in the following order:
408 (1) if `client_options.api_endpoint` if provided, use the provided one.
409 (2) if `GOOGLE_API_USE_CLIENT_CERTIFICATE` environment variable is "always", use the
410 default mTLS endpoint; if the environment variable is "never", use the default API
411 endpoint; otherwise if client cert source exists, use the default mTLS endpoint, otherwise
412 use the default API endpoint.
414 More details can be found at https://google.aip.dev/auth/4114.
416 Args:
417 client_options (google.api_core.client_options.ClientOptions): Custom options for the
418 client. Only the `api_endpoint` and `client_cert_source` properties may be used
419 in this method.
421 Returns:
422 Tuple[str, Callable[[], Tuple[bytes, bytes]]]: returns the API endpoint and the
423 client cert source to use.
425 Raises:
426 google.auth.exceptions.MutualTLSChannelError: If any errors happen.
427 """
428 if client_options is None:
429 client_options = client_options_lib.ClientOptions()
430 use_client_cert = os.getenv("GOOGLE_API_USE_CLIENT_CERTIFICATE", "false")
431 use_mtls_endpoint = os.getenv("GOOGLE_API_USE_MTLS_ENDPOINT", "auto")
432 if use_client_cert not in ("true", "false"):
433 raise ValueError(
434 "Environment variable `GOOGLE_API_USE_CLIENT_CERTIFICATE` must be either `true` or `false`"
435 )
436 if use_mtls_endpoint not in ("auto", "never", "always"):
437 raise MutualTLSChannelError(
438 "Environment variable `GOOGLE_API_USE_MTLS_ENDPOINT` must be `never`, `auto` or `always`"
439 )
441 # Figure out the client cert source to use.
442 client_cert_source = None
443 if use_client_cert == "true":
444 if client_options.client_cert_source:
445 client_cert_source = client_options.client_cert_source
446 elif mtls.has_default_client_cert_source():
447 client_cert_source = mtls.default_client_cert_source()
449 # Figure out which api endpoint to use.
450 if client_options.api_endpoint is not None:
451 api_endpoint = client_options.api_endpoint
452 elif use_mtls_endpoint == "always" or (
453 use_mtls_endpoint == "auto" and client_cert_source
454 ):
455 api_endpoint = cls.DEFAULT_MTLS_ENDPOINT
456 else:
457 api_endpoint = cls.DEFAULT_ENDPOINT
459 return api_endpoint, client_cert_source
461 def __init__(
462 self,
463 *,
464 credentials: Optional[ga_credentials.Credentials] = None,
465 transport: Optional[Union[str, ConfigServiceV2Transport]] = None,
466 client_options: Optional[Union[client_options_lib.ClientOptions, dict]] = None,
467 client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO,
468 ) -> None:
469 """Instantiates the config service v2 client.
471 Args:
472 credentials (Optional[google.auth.credentials.Credentials]): The
473 authorization credentials to attach to requests. These
474 credentials identify the application to the service; if none
475 are specified, the client will attempt to ascertain the
476 credentials from the environment.
477 transport (Union[str, ConfigServiceV2Transport]): The
478 transport to use. If set to None, a transport is chosen
479 automatically.
480 client_options (Optional[Union[google.api_core.client_options.ClientOptions, dict]]): Custom options for the
481 client. It won't take effect if a ``transport`` instance is provided.
482 (1) The ``api_endpoint`` property can be used to override the
483 default endpoint provided by the client. GOOGLE_API_USE_MTLS_ENDPOINT
484 environment variable can also be used to override the endpoint:
485 "always" (always use the default mTLS endpoint), "never" (always
486 use the default regular endpoint) and "auto" (auto switch to the
487 default mTLS endpoint if client certificate is present, this is
488 the default value). However, the ``api_endpoint`` property takes
489 precedence if provided.
490 (2) If GOOGLE_API_USE_CLIENT_CERTIFICATE environment variable
491 is "true", then the ``client_cert_source`` property can be used
492 to provide client certificate for mutual TLS transport. If
493 not provided, the default SSL client certificate will be used if
494 present. If GOOGLE_API_USE_CLIENT_CERTIFICATE is "false" or not
495 set, no client certificate will be used.
496 client_info (google.api_core.gapic_v1.client_info.ClientInfo):
497 The client info used to send a user-agent string along with
498 API requests. If ``None``, then default info will be used.
499 Generally, you only need to set this if you're developing
500 your own client library.
502 Raises:
503 google.auth.exceptions.MutualTLSChannelError: If mutual TLS transport
504 creation failed for any reason.
505 """
506 if isinstance(client_options, dict):
507 client_options = client_options_lib.from_dict(client_options)
508 if client_options is None:
509 client_options = client_options_lib.ClientOptions()
510 client_options = cast(client_options_lib.ClientOptions, client_options)
512 api_endpoint, client_cert_source_func = self.get_mtls_endpoint_and_cert_source(
513 client_options
514 )
516 api_key_value = getattr(client_options, "api_key", None)
517 if api_key_value and credentials:
518 raise ValueError(
519 "client_options.api_key and credentials are mutually exclusive"
520 )
522 # Save or instantiate the transport.
523 # Ordinarily, we provide the transport, but allowing a custom transport
524 # instance provides an extensibility point for unusual situations.
525 if isinstance(transport, ConfigServiceV2Transport):
526 # transport is a ConfigServiceV2Transport instance.
527 if credentials or client_options.credentials_file or api_key_value:
528 raise ValueError(
529 "When providing a transport instance, "
530 "provide its credentials directly."
531 )
532 if client_options.scopes:
533 raise ValueError(
534 "When providing a transport instance, provide its scopes "
535 "directly."
536 )
537 self._transport = transport
538 else:
539 import google.auth._default # type: ignore
541 if api_key_value and hasattr(
542 google.auth._default, "get_api_key_credentials"
543 ):
544 credentials = google.auth._default.get_api_key_credentials(
545 api_key_value
546 )
548 Transport = type(self).get_transport_class(transport)
549 self._transport = Transport(
550 credentials=credentials,
551 credentials_file=client_options.credentials_file,
552 host=api_endpoint,
553 scopes=client_options.scopes,
554 client_cert_source_for_mtls=client_cert_source_func,
555 quota_project_id=client_options.quota_project_id,
556 client_info=client_info,
557 always_use_jwt_access=True,
558 api_audience=client_options.api_audience,
559 )
561 def list_buckets(
562 self,
563 request: Optional[Union[logging_config.ListBucketsRequest, dict]] = None,
564 *,
565 parent: Optional[str] = None,
566 retry: OptionalRetry = gapic_v1.method.DEFAULT,
567 timeout: Union[float, object] = gapic_v1.method.DEFAULT,
568 metadata: Sequence[Tuple[str, str]] = (),
569 ) -> pagers.ListBucketsPager:
570 r"""Lists log buckets.
572 .. code-block:: python
574 # This snippet has been automatically generated and should be regarded as a
575 # code template only.
576 # It will require modifications to work:
577 # - It may require correct/in-range values for request initialization.
578 # - It may require specifying regional endpoints when creating the service
579 # client as shown in:
580 # https://googleapis.dev/python/google-api-core/latest/client_options.html
581 from google.cloud import logging_v2
583 def sample_list_buckets():
584 # Create a client
585 client = logging_v2.ConfigServiceV2Client()
587 # Initialize request argument(s)
588 request = logging_v2.ListBucketsRequest(
589 parent="parent_value",
590 )
592 # Make the request
593 page_result = client.list_buckets(request=request)
595 # Handle the response
596 for response in page_result:
597 print(response)
599 Args:
600 request (Union[google.cloud.logging_v2.types.ListBucketsRequest, dict]):
601 The request object. The parameters to ``ListBuckets``.
602 parent (str):
603 Required. The parent resource whose buckets are to be
604 listed:
606 ::
608 "projects/[PROJECT_ID]/locations/[LOCATION_ID]"
609 "organizations/[ORGANIZATION_ID]/locations/[LOCATION_ID]"
610 "billingAccounts/[BILLING_ACCOUNT_ID]/locations/[LOCATION_ID]"
611 "folders/[FOLDER_ID]/locations/[LOCATION_ID]"
613 Note: The locations portion of the resource must be
614 specified, but supplying the character ``-`` in place of
615 [LOCATION_ID] will return all buckets.
617 This corresponds to the ``parent`` field
618 on the ``request`` instance; if ``request`` is provided, this
619 should not be set.
620 retry (google.api_core.retry.Retry): Designation of what errors, if any,
621 should be retried.
622 timeout (float): The timeout for this request.
623 metadata (Sequence[Tuple[str, str]]): Strings which should be
624 sent along with the request as metadata.
626 Returns:
627 google.cloud.logging_v2.services.config_service_v2.pagers.ListBucketsPager:
628 The response from ListBuckets.
630 Iterating over this object will yield
631 results and resolve additional pages
632 automatically.
634 """
635 # Create or coerce a protobuf request object.
636 # Quick check: If we got a request object, we should *not* have
637 # gotten any keyword arguments that map to the request.
638 has_flattened_params = any([parent])
639 if request is not None and has_flattened_params:
640 raise ValueError(
641 "If the `request` argument is set, then none of "
642 "the individual field arguments should be set."
643 )
645 # Minor optimization to avoid making a copy if the user passes
646 # in a logging_config.ListBucketsRequest.
647 # There's no risk of modifying the input as we've already verified
648 # there are no flattened fields.
649 if not isinstance(request, logging_config.ListBucketsRequest):
650 request = logging_config.ListBucketsRequest(request)
651 # If we have keyword arguments corresponding to fields on the
652 # request, apply these.
653 if parent is not None:
654 request.parent = parent
656 # Wrap the RPC method; this adds retry and timeout information,
657 # and friendly error handling.
658 rpc = self._transport._wrapped_methods[self._transport.list_buckets]
660 # Certain fields should be provided within the metadata header;
661 # add these here.
662 metadata = tuple(metadata) + (
663 gapic_v1.routing_header.to_grpc_metadata((("parent", request.parent),)),
664 )
666 # Send the request.
667 response = rpc(
668 request,
669 retry=retry,
670 timeout=timeout,
671 metadata=metadata,
672 )
674 # This method is paged; wrap the response in a pager, which provides
675 # an `__iter__` convenience method.
676 response = pagers.ListBucketsPager(
677 method=rpc,
678 request=request,
679 response=response,
680 metadata=metadata,
681 )
683 # Done; return the response.
684 return response
686 def get_bucket(
687 self,
688 request: Optional[Union[logging_config.GetBucketRequest, dict]] = None,
689 *,
690 retry: OptionalRetry = gapic_v1.method.DEFAULT,
691 timeout: Union[float, object] = gapic_v1.method.DEFAULT,
692 metadata: Sequence[Tuple[str, str]] = (),
693 ) -> logging_config.LogBucket:
694 r"""Gets a log bucket.
696 .. code-block:: python
698 # This snippet has been automatically generated and should be regarded as a
699 # code template only.
700 # It will require modifications to work:
701 # - It may require correct/in-range values for request initialization.
702 # - It may require specifying regional endpoints when creating the service
703 # client as shown in:
704 # https://googleapis.dev/python/google-api-core/latest/client_options.html
705 from google.cloud import logging_v2
707 def sample_get_bucket():
708 # Create a client
709 client = logging_v2.ConfigServiceV2Client()
711 # Initialize request argument(s)
712 request = logging_v2.GetBucketRequest(
713 name="name_value",
714 )
716 # Make the request
717 response = client.get_bucket(request=request)
719 # Handle the response
720 print(response)
722 Args:
723 request (Union[google.cloud.logging_v2.types.GetBucketRequest, dict]):
724 The request object. The parameters to ``GetBucket``.
725 retry (google.api_core.retry.Retry): Designation of what errors, if any,
726 should be retried.
727 timeout (float): The timeout for this request.
728 metadata (Sequence[Tuple[str, str]]): Strings which should be
729 sent along with the request as metadata.
731 Returns:
732 google.cloud.logging_v2.types.LogBucket:
733 Describes a repository in which log
734 entries are stored.
736 """
737 # Create or coerce a protobuf request object.
738 # Minor optimization to avoid making a copy if the user passes
739 # in a logging_config.GetBucketRequest.
740 # There's no risk of modifying the input as we've already verified
741 # there are no flattened fields.
742 if not isinstance(request, logging_config.GetBucketRequest):
743 request = logging_config.GetBucketRequest(request)
745 # Wrap the RPC method; this adds retry and timeout information,
746 # and friendly error handling.
747 rpc = self._transport._wrapped_methods[self._transport.get_bucket]
749 # Certain fields should be provided within the metadata header;
750 # add these here.
751 metadata = tuple(metadata) + (
752 gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
753 )
755 # Send the request.
756 response = rpc(
757 request,
758 retry=retry,
759 timeout=timeout,
760 metadata=metadata,
761 )
763 # Done; return the response.
764 return response
766 def create_bucket_async(
767 self,
768 request: Optional[Union[logging_config.CreateBucketRequest, dict]] = None,
769 *,
770 retry: OptionalRetry = gapic_v1.method.DEFAULT,
771 timeout: Union[float, object] = gapic_v1.method.DEFAULT,
772 metadata: Sequence[Tuple[str, str]] = (),
773 ) -> operation.Operation:
774 r"""Creates a log bucket asynchronously that can be used
775 to store log entries.
776 After a bucket has been created, the bucket's location
777 cannot be changed.
779 .. code-block:: python
781 # This snippet has been automatically generated and should be regarded as a
782 # code template only.
783 # It will require modifications to work:
784 # - It may require correct/in-range values for request initialization.
785 # - It may require specifying regional endpoints when creating the service
786 # client as shown in:
787 # https://googleapis.dev/python/google-api-core/latest/client_options.html
788 from google.cloud import logging_v2
790 def sample_create_bucket_async():
791 # Create a client
792 client = logging_v2.ConfigServiceV2Client()
794 # Initialize request argument(s)
795 request = logging_v2.CreateBucketRequest(
796 parent="parent_value",
797 bucket_id="bucket_id_value",
798 )
800 # Make the request
801 operation = client.create_bucket_async(request=request)
803 print("Waiting for operation to complete...")
805 response = operation.result()
807 # Handle the response
808 print(response)
810 Args:
811 request (Union[google.cloud.logging_v2.types.CreateBucketRequest, dict]):
812 The request object. The parameters to ``CreateBucket``.
813 retry (google.api_core.retry.Retry): Designation of what errors, if any,
814 should be retried.
815 timeout (float): The timeout for this request.
816 metadata (Sequence[Tuple[str, str]]): Strings which should be
817 sent along with the request as metadata.
819 Returns:
820 google.api_core.operation.Operation:
821 An object representing a long-running operation.
823 The result type for the operation will be
824 :class:`google.cloud.logging_v2.types.LogBucket`
825 Describes a repository in which log entries are stored.
827 """
828 # Create or coerce a protobuf request object.
829 # Minor optimization to avoid making a copy if the user passes
830 # in a logging_config.CreateBucketRequest.
831 # There's no risk of modifying the input as we've already verified
832 # there are no flattened fields.
833 if not isinstance(request, logging_config.CreateBucketRequest):
834 request = logging_config.CreateBucketRequest(request)
836 # Wrap the RPC method; this adds retry and timeout information,
837 # and friendly error handling.
838 rpc = self._transport._wrapped_methods[self._transport.create_bucket_async]
840 # Certain fields should be provided within the metadata header;
841 # add these here.
842 metadata = tuple(metadata) + (
843 gapic_v1.routing_header.to_grpc_metadata((("parent", request.parent),)),
844 )
846 # Send the request.
847 response = rpc(
848 request,
849 retry=retry,
850 timeout=timeout,
851 metadata=metadata,
852 )
854 # Wrap the response in an operation future.
855 response = operation.from_gapic(
856 response,
857 self._transport.operations_client,
858 logging_config.LogBucket,
859 metadata_type=logging_config.BucketMetadata,
860 )
862 # Done; return the response.
863 return response
865 def update_bucket_async(
866 self,
867 request: Optional[Union[logging_config.UpdateBucketRequest, dict]] = None,
868 *,
869 retry: OptionalRetry = gapic_v1.method.DEFAULT,
870 timeout: Union[float, object] = gapic_v1.method.DEFAULT,
871 metadata: Sequence[Tuple[str, str]] = (),
872 ) -> operation.Operation:
873 r"""Updates a log bucket asynchronously.
875 If the bucket has a ``lifecycle_state`` of ``DELETE_REQUESTED``,
876 then ``FAILED_PRECONDITION`` will be returned.
878 After a bucket has been created, the bucket's location cannot be
879 changed.
881 .. code-block:: python
883 # This snippet has been automatically generated and should be regarded as a
884 # code template only.
885 # It will require modifications to work:
886 # - It may require correct/in-range values for request initialization.
887 # - It may require specifying regional endpoints when creating the service
888 # client as shown in:
889 # https://googleapis.dev/python/google-api-core/latest/client_options.html
890 from google.cloud import logging_v2
892 def sample_update_bucket_async():
893 # Create a client
894 client = logging_v2.ConfigServiceV2Client()
896 # Initialize request argument(s)
897 request = logging_v2.UpdateBucketRequest(
898 name="name_value",
899 )
901 # Make the request
902 operation = client.update_bucket_async(request=request)
904 print("Waiting for operation to complete...")
906 response = operation.result()
908 # Handle the response
909 print(response)
911 Args:
912 request (Union[google.cloud.logging_v2.types.UpdateBucketRequest, dict]):
913 The request object. The parameters to ``UpdateBucket``.
914 retry (google.api_core.retry.Retry): Designation of what errors, if any,
915 should be retried.
916 timeout (float): The timeout for this request.
917 metadata (Sequence[Tuple[str, str]]): Strings which should be
918 sent along with the request as metadata.
920 Returns:
921 google.api_core.operation.Operation:
922 An object representing a long-running operation.
924 The result type for the operation will be
925 :class:`google.cloud.logging_v2.types.LogBucket`
926 Describes a repository in which log entries are stored.
928 """
929 # Create or coerce a protobuf request object.
930 # Minor optimization to avoid making a copy if the user passes
931 # in a logging_config.UpdateBucketRequest.
932 # There's no risk of modifying the input as we've already verified
933 # there are no flattened fields.
934 if not isinstance(request, logging_config.UpdateBucketRequest):
935 request = logging_config.UpdateBucketRequest(request)
937 # Wrap the RPC method; this adds retry and timeout information,
938 # and friendly error handling.
939 rpc = self._transport._wrapped_methods[self._transport.update_bucket_async]
941 # Certain fields should be provided within the metadata header;
942 # add these here.
943 metadata = tuple(metadata) + (
944 gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
945 )
947 # Send the request.
948 response = rpc(
949 request,
950 retry=retry,
951 timeout=timeout,
952 metadata=metadata,
953 )
955 # Wrap the response in an operation future.
956 response = operation.from_gapic(
957 response,
958 self._transport.operations_client,
959 logging_config.LogBucket,
960 metadata_type=logging_config.BucketMetadata,
961 )
963 # Done; return the response.
964 return response
966 def create_bucket(
967 self,
968 request: Optional[Union[logging_config.CreateBucketRequest, dict]] = None,
969 *,
970 retry: OptionalRetry = gapic_v1.method.DEFAULT,
971 timeout: Union[float, object] = gapic_v1.method.DEFAULT,
972 metadata: Sequence[Tuple[str, str]] = (),
973 ) -> logging_config.LogBucket:
974 r"""Creates a log bucket that can be used to store log
975 entries. After a bucket has been created, the bucket's
976 location cannot be changed.
978 .. code-block:: python
980 # This snippet has been automatically generated and should be regarded as a
981 # code template only.
982 # It will require modifications to work:
983 # - It may require correct/in-range values for request initialization.
984 # - It may require specifying regional endpoints when creating the service
985 # client as shown in:
986 # https://googleapis.dev/python/google-api-core/latest/client_options.html
987 from google.cloud import logging_v2
989 def sample_create_bucket():
990 # Create a client
991 client = logging_v2.ConfigServiceV2Client()
993 # Initialize request argument(s)
994 request = logging_v2.CreateBucketRequest(
995 parent="parent_value",
996 bucket_id="bucket_id_value",
997 )
999 # Make the request
1000 response = client.create_bucket(request=request)
1002 # Handle the response
1003 print(response)
1005 Args:
1006 request (Union[google.cloud.logging_v2.types.CreateBucketRequest, dict]):
1007 The request object. The parameters to ``CreateBucket``.
1008 retry (google.api_core.retry.Retry): Designation of what errors, if any,
1009 should be retried.
1010 timeout (float): The timeout for this request.
1011 metadata (Sequence[Tuple[str, str]]): Strings which should be
1012 sent along with the request as metadata.
1014 Returns:
1015 google.cloud.logging_v2.types.LogBucket:
1016 Describes a repository in which log
1017 entries are stored.
1019 """
1020 # Create or coerce a protobuf request object.
1021 # Minor optimization to avoid making a copy if the user passes
1022 # in a logging_config.CreateBucketRequest.
1023 # There's no risk of modifying the input as we've already verified
1024 # there are no flattened fields.
1025 if not isinstance(request, logging_config.CreateBucketRequest):
1026 request = logging_config.CreateBucketRequest(request)
1028 # Wrap the RPC method; this adds retry and timeout information,
1029 # and friendly error handling.
1030 rpc = self._transport._wrapped_methods[self._transport.create_bucket]
1032 # Certain fields should be provided within the metadata header;
1033 # add these here.
1034 metadata = tuple(metadata) + (
1035 gapic_v1.routing_header.to_grpc_metadata((("parent", request.parent),)),
1036 )
1038 # Send the request.
1039 response = rpc(
1040 request,
1041 retry=retry,
1042 timeout=timeout,
1043 metadata=metadata,
1044 )
1046 # Done; return the response.
1047 return response
1049 def update_bucket(
1050 self,
1051 request: Optional[Union[logging_config.UpdateBucketRequest, dict]] = None,
1052 *,
1053 retry: OptionalRetry = gapic_v1.method.DEFAULT,
1054 timeout: Union[float, object] = gapic_v1.method.DEFAULT,
1055 metadata: Sequence[Tuple[str, str]] = (),
1056 ) -> logging_config.LogBucket:
1057 r"""Updates a log bucket.
1059 If the bucket has a ``lifecycle_state`` of ``DELETE_REQUESTED``,
1060 then ``FAILED_PRECONDITION`` will be returned.
1062 After a bucket has been created, the bucket's location cannot be
1063 changed.
1065 .. code-block:: python
1067 # This snippet has been automatically generated and should be regarded as a
1068 # code template only.
1069 # It will require modifications to work:
1070 # - It may require correct/in-range values for request initialization.
1071 # - It may require specifying regional endpoints when creating the service
1072 # client as shown in:
1073 # https://googleapis.dev/python/google-api-core/latest/client_options.html
1074 from google.cloud import logging_v2
1076 def sample_update_bucket():
1077 # Create a client
1078 client = logging_v2.ConfigServiceV2Client()
1080 # Initialize request argument(s)
1081 request = logging_v2.UpdateBucketRequest(
1082 name="name_value",
1083 )
1085 # Make the request
1086 response = client.update_bucket(request=request)
1088 # Handle the response
1089 print(response)
1091 Args:
1092 request (Union[google.cloud.logging_v2.types.UpdateBucketRequest, dict]):
1093 The request object. The parameters to ``UpdateBucket``.
1094 retry (google.api_core.retry.Retry): Designation of what errors, if any,
1095 should be retried.
1096 timeout (float): The timeout for this request.
1097 metadata (Sequence[Tuple[str, str]]): Strings which should be
1098 sent along with the request as metadata.
1100 Returns:
1101 google.cloud.logging_v2.types.LogBucket:
1102 Describes a repository in which log
1103 entries are stored.
1105 """
1106 # Create or coerce a protobuf request object.
1107 # Minor optimization to avoid making a copy if the user passes
1108 # in a logging_config.UpdateBucketRequest.
1109 # There's no risk of modifying the input as we've already verified
1110 # there are no flattened fields.
1111 if not isinstance(request, logging_config.UpdateBucketRequest):
1112 request = logging_config.UpdateBucketRequest(request)
1114 # Wrap the RPC method; this adds retry and timeout information,
1115 # and friendly error handling.
1116 rpc = self._transport._wrapped_methods[self._transport.update_bucket]
1118 # Certain fields should be provided within the metadata header;
1119 # add these here.
1120 metadata = tuple(metadata) + (
1121 gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
1122 )
1124 # Send the request.
1125 response = rpc(
1126 request,
1127 retry=retry,
1128 timeout=timeout,
1129 metadata=metadata,
1130 )
1132 # Done; return the response.
1133 return response
1135 def delete_bucket(
1136 self,
1137 request: Optional[Union[logging_config.DeleteBucketRequest, dict]] = None,
1138 *,
1139 retry: OptionalRetry = gapic_v1.method.DEFAULT,
1140 timeout: Union[float, object] = gapic_v1.method.DEFAULT,
1141 metadata: Sequence[Tuple[str, str]] = (),
1142 ) -> None:
1143 r"""Deletes a log bucket.
1145 Changes the bucket's ``lifecycle_state`` to the
1146 ``DELETE_REQUESTED`` state. After 7 days, the bucket will be
1147 purged and all log entries in the bucket will be permanently
1148 deleted.
1150 .. code-block:: python
1152 # This snippet has been automatically generated and should be regarded as a
1153 # code template only.
1154 # It will require modifications to work:
1155 # - It may require correct/in-range values for request initialization.
1156 # - It may require specifying regional endpoints when creating the service
1157 # client as shown in:
1158 # https://googleapis.dev/python/google-api-core/latest/client_options.html
1159 from google.cloud import logging_v2
1161 def sample_delete_bucket():
1162 # Create a client
1163 client = logging_v2.ConfigServiceV2Client()
1165 # Initialize request argument(s)
1166 request = logging_v2.DeleteBucketRequest(
1167 name="name_value",
1168 )
1170 # Make the request
1171 client.delete_bucket(request=request)
1173 Args:
1174 request (Union[google.cloud.logging_v2.types.DeleteBucketRequest, dict]):
1175 The request object. The parameters to ``DeleteBucket``.
1176 retry (google.api_core.retry.Retry): Designation of what errors, if any,
1177 should be retried.
1178 timeout (float): The timeout for this request.
1179 metadata (Sequence[Tuple[str, str]]): Strings which should be
1180 sent along with the request as metadata.
1181 """
1182 # Create or coerce a protobuf request object.
1183 # Minor optimization to avoid making a copy if the user passes
1184 # in a logging_config.DeleteBucketRequest.
1185 # There's no risk of modifying the input as we've already verified
1186 # there are no flattened fields.
1187 if not isinstance(request, logging_config.DeleteBucketRequest):
1188 request = logging_config.DeleteBucketRequest(request)
1190 # Wrap the RPC method; this adds retry and timeout information,
1191 # and friendly error handling.
1192 rpc = self._transport._wrapped_methods[self._transport.delete_bucket]
1194 # Certain fields should be provided within the metadata header;
1195 # add these here.
1196 metadata = tuple(metadata) + (
1197 gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
1198 )
1200 # Send the request.
1201 rpc(
1202 request,
1203 retry=retry,
1204 timeout=timeout,
1205 metadata=metadata,
1206 )
1208 def undelete_bucket(
1209 self,
1210 request: Optional[Union[logging_config.UndeleteBucketRequest, dict]] = None,
1211 *,
1212 retry: OptionalRetry = gapic_v1.method.DEFAULT,
1213 timeout: Union[float, object] = gapic_v1.method.DEFAULT,
1214 metadata: Sequence[Tuple[str, str]] = (),
1215 ) -> None:
1216 r"""Undeletes a log bucket. A bucket that has been
1217 deleted can be undeleted within the grace period of 7
1218 days.
1220 .. code-block:: python
1222 # This snippet has been automatically generated and should be regarded as a
1223 # code template only.
1224 # It will require modifications to work:
1225 # - It may require correct/in-range values for request initialization.
1226 # - It may require specifying regional endpoints when creating the service
1227 # client as shown in:
1228 # https://googleapis.dev/python/google-api-core/latest/client_options.html
1229 from google.cloud import logging_v2
1231 def sample_undelete_bucket():
1232 # Create a client
1233 client = logging_v2.ConfigServiceV2Client()
1235 # Initialize request argument(s)
1236 request = logging_v2.UndeleteBucketRequest(
1237 name="name_value",
1238 )
1240 # Make the request
1241 client.undelete_bucket(request=request)
1243 Args:
1244 request (Union[google.cloud.logging_v2.types.UndeleteBucketRequest, dict]):
1245 The request object. The parameters to ``UndeleteBucket``.
1246 retry (google.api_core.retry.Retry): Designation of what errors, if any,
1247 should be retried.
1248 timeout (float): The timeout for this request.
1249 metadata (Sequence[Tuple[str, str]]): Strings which should be
1250 sent along with the request as metadata.
1251 """
1252 # Create or coerce a protobuf request object.
1253 # Minor optimization to avoid making a copy if the user passes
1254 # in a logging_config.UndeleteBucketRequest.
1255 # There's no risk of modifying the input as we've already verified
1256 # there are no flattened fields.
1257 if not isinstance(request, logging_config.UndeleteBucketRequest):
1258 request = logging_config.UndeleteBucketRequest(request)
1260 # Wrap the RPC method; this adds retry and timeout information,
1261 # and friendly error handling.
1262 rpc = self._transport._wrapped_methods[self._transport.undelete_bucket]
1264 # Certain fields should be provided within the metadata header;
1265 # add these here.
1266 metadata = tuple(metadata) + (
1267 gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
1268 )
1270 # Send the request.
1271 rpc(
1272 request,
1273 retry=retry,
1274 timeout=timeout,
1275 metadata=metadata,
1276 )
1278 def list_views(
1279 self,
1280 request: Optional[Union[logging_config.ListViewsRequest, dict]] = None,
1281 *,
1282 parent: Optional[str] = None,
1283 retry: OptionalRetry = gapic_v1.method.DEFAULT,
1284 timeout: Union[float, object] = gapic_v1.method.DEFAULT,
1285 metadata: Sequence[Tuple[str, str]] = (),
1286 ) -> pagers.ListViewsPager:
1287 r"""Lists views on a log bucket.
1289 .. code-block:: python
1291 # This snippet has been automatically generated and should be regarded as a
1292 # code template only.
1293 # It will require modifications to work:
1294 # - It may require correct/in-range values for request initialization.
1295 # - It may require specifying regional endpoints when creating the service
1296 # client as shown in:
1297 # https://googleapis.dev/python/google-api-core/latest/client_options.html
1298 from google.cloud import logging_v2
1300 def sample_list_views():
1301 # Create a client
1302 client = logging_v2.ConfigServiceV2Client()
1304 # Initialize request argument(s)
1305 request = logging_v2.ListViewsRequest(
1306 parent="parent_value",
1307 )
1309 # Make the request
1310 page_result = client.list_views(request=request)
1312 # Handle the response
1313 for response in page_result:
1314 print(response)
1316 Args:
1317 request (Union[google.cloud.logging_v2.types.ListViewsRequest, dict]):
1318 The request object. The parameters to ``ListViews``.
1319 parent (str):
1320 Required. The bucket whose views are to be listed:
1322 ::
1324 "projects/[PROJECT_ID]/locations/[LOCATION_ID]/buckets/[BUCKET_ID]"
1326 This corresponds to the ``parent`` field
1327 on the ``request`` instance; if ``request`` is provided, this
1328 should not be set.
1329 retry (google.api_core.retry.Retry): Designation of what errors, if any,
1330 should be retried.
1331 timeout (float): The timeout for this request.
1332 metadata (Sequence[Tuple[str, str]]): Strings which should be
1333 sent along with the request as metadata.
1335 Returns:
1336 google.cloud.logging_v2.services.config_service_v2.pagers.ListViewsPager:
1337 The response from ListViews.
1339 Iterating over this object will yield
1340 results and resolve additional pages
1341 automatically.
1343 """
1344 # Create or coerce a protobuf request object.
1345 # Quick check: If we got a request object, we should *not* have
1346 # gotten any keyword arguments that map to the request.
1347 has_flattened_params = any([parent])
1348 if request is not None and has_flattened_params:
1349 raise ValueError(
1350 "If the `request` argument is set, then none of "
1351 "the individual field arguments should be set."
1352 )
1354 # Minor optimization to avoid making a copy if the user passes
1355 # in a logging_config.ListViewsRequest.
1356 # There's no risk of modifying the input as we've already verified
1357 # there are no flattened fields.
1358 if not isinstance(request, logging_config.ListViewsRequest):
1359 request = logging_config.ListViewsRequest(request)
1360 # If we have keyword arguments corresponding to fields on the
1361 # request, apply these.
1362 if parent is not None:
1363 request.parent = parent
1365 # Wrap the RPC method; this adds retry and timeout information,
1366 # and friendly error handling.
1367 rpc = self._transport._wrapped_methods[self._transport.list_views]
1369 # Certain fields should be provided within the metadata header;
1370 # add these here.
1371 metadata = tuple(metadata) + (
1372 gapic_v1.routing_header.to_grpc_metadata((("parent", request.parent),)),
1373 )
1375 # Send the request.
1376 response = rpc(
1377 request,
1378 retry=retry,
1379 timeout=timeout,
1380 metadata=metadata,
1381 )
1383 # This method is paged; wrap the response in a pager, which provides
1384 # an `__iter__` convenience method.
1385 response = pagers.ListViewsPager(
1386 method=rpc,
1387 request=request,
1388 response=response,
1389 metadata=metadata,
1390 )
1392 # Done; return the response.
1393 return response
1395 def get_view(
1396 self,
1397 request: Optional[Union[logging_config.GetViewRequest, dict]] = None,
1398 *,
1399 retry: OptionalRetry = gapic_v1.method.DEFAULT,
1400 timeout: Union[float, object] = gapic_v1.method.DEFAULT,
1401 metadata: Sequence[Tuple[str, str]] = (),
1402 ) -> logging_config.LogView:
1403 r"""Gets a view on a log bucket..
1405 .. code-block:: python
1407 # This snippet has been automatically generated and should be regarded as a
1408 # code template only.
1409 # It will require modifications to work:
1410 # - It may require correct/in-range values for request initialization.
1411 # - It may require specifying regional endpoints when creating the service
1412 # client as shown in:
1413 # https://googleapis.dev/python/google-api-core/latest/client_options.html
1414 from google.cloud import logging_v2
1416 def sample_get_view():
1417 # Create a client
1418 client = logging_v2.ConfigServiceV2Client()
1420 # Initialize request argument(s)
1421 request = logging_v2.GetViewRequest(
1422 name="name_value",
1423 )
1425 # Make the request
1426 response = client.get_view(request=request)
1428 # Handle the response
1429 print(response)
1431 Args:
1432 request (Union[google.cloud.logging_v2.types.GetViewRequest, dict]):
1433 The request object. The parameters to ``GetView``.
1434 retry (google.api_core.retry.Retry): Designation of what errors, if any,
1435 should be retried.
1436 timeout (float): The timeout for this request.
1437 metadata (Sequence[Tuple[str, str]]): Strings which should be
1438 sent along with the request as metadata.
1440 Returns:
1441 google.cloud.logging_v2.types.LogView:
1442 Describes a view over log entries in
1443 a bucket.
1445 """
1446 # Create or coerce a protobuf request object.
1447 # Minor optimization to avoid making a copy if the user passes
1448 # in a logging_config.GetViewRequest.
1449 # There's no risk of modifying the input as we've already verified
1450 # there are no flattened fields.
1451 if not isinstance(request, logging_config.GetViewRequest):
1452 request = logging_config.GetViewRequest(request)
1454 # Wrap the RPC method; this adds retry and timeout information,
1455 # and friendly error handling.
1456 rpc = self._transport._wrapped_methods[self._transport.get_view]
1458 # Certain fields should be provided within the metadata header;
1459 # add these here.
1460 metadata = tuple(metadata) + (
1461 gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
1462 )
1464 # Send the request.
1465 response = rpc(
1466 request,
1467 retry=retry,
1468 timeout=timeout,
1469 metadata=metadata,
1470 )
1472 # Done; return the response.
1473 return response
1475 def create_view(
1476 self,
1477 request: Optional[Union[logging_config.CreateViewRequest, dict]] = None,
1478 *,
1479 retry: OptionalRetry = gapic_v1.method.DEFAULT,
1480 timeout: Union[float, object] = gapic_v1.method.DEFAULT,
1481 metadata: Sequence[Tuple[str, str]] = (),
1482 ) -> logging_config.LogView:
1483 r"""Creates a view over log entries in a log bucket. A
1484 bucket may contain a maximum of 30 views.
1486 .. code-block:: python
1488 # This snippet has been automatically generated and should be regarded as a
1489 # code template only.
1490 # It will require modifications to work:
1491 # - It may require correct/in-range values for request initialization.
1492 # - It may require specifying regional endpoints when creating the service
1493 # client as shown in:
1494 # https://googleapis.dev/python/google-api-core/latest/client_options.html
1495 from google.cloud import logging_v2
1497 def sample_create_view():
1498 # Create a client
1499 client = logging_v2.ConfigServiceV2Client()
1501 # Initialize request argument(s)
1502 request = logging_v2.CreateViewRequest(
1503 parent="parent_value",
1504 view_id="view_id_value",
1505 )
1507 # Make the request
1508 response = client.create_view(request=request)
1510 # Handle the response
1511 print(response)
1513 Args:
1514 request (Union[google.cloud.logging_v2.types.CreateViewRequest, dict]):
1515 The request object. The parameters to ``CreateView``.
1516 retry (google.api_core.retry.Retry): Designation of what errors, if any,
1517 should be retried.
1518 timeout (float): The timeout for this request.
1519 metadata (Sequence[Tuple[str, str]]): Strings which should be
1520 sent along with the request as metadata.
1522 Returns:
1523 google.cloud.logging_v2.types.LogView:
1524 Describes a view over log entries in
1525 a bucket.
1527 """
1528 # Create or coerce a protobuf request object.
1529 # Minor optimization to avoid making a copy if the user passes
1530 # in a logging_config.CreateViewRequest.
1531 # There's no risk of modifying the input as we've already verified
1532 # there are no flattened fields.
1533 if not isinstance(request, logging_config.CreateViewRequest):
1534 request = logging_config.CreateViewRequest(request)
1536 # Wrap the RPC method; this adds retry and timeout information,
1537 # and friendly error handling.
1538 rpc = self._transport._wrapped_methods[self._transport.create_view]
1540 # Certain fields should be provided within the metadata header;
1541 # add these here.
1542 metadata = tuple(metadata) + (
1543 gapic_v1.routing_header.to_grpc_metadata((("parent", request.parent),)),
1544 )
1546 # Send the request.
1547 response = rpc(
1548 request,
1549 retry=retry,
1550 timeout=timeout,
1551 metadata=metadata,
1552 )
1554 # Done; return the response.
1555 return response
1557 def update_view(
1558 self,
1559 request: Optional[Union[logging_config.UpdateViewRequest, dict]] = None,
1560 *,
1561 retry: OptionalRetry = gapic_v1.method.DEFAULT,
1562 timeout: Union[float, object] = gapic_v1.method.DEFAULT,
1563 metadata: Sequence[Tuple[str, str]] = (),
1564 ) -> logging_config.LogView:
1565 r"""Updates a view on a log bucket. This method replaces the
1566 following fields in the existing view with values from the new
1567 view: ``filter``. If an ``UNAVAILABLE`` error is returned, this
1568 indicates that system is not in a state where it can update the
1569 view. If this occurs, please try again in a few minutes.
1571 .. code-block:: python
1573 # This snippet has been automatically generated and should be regarded as a
1574 # code template only.
1575 # It will require modifications to work:
1576 # - It may require correct/in-range values for request initialization.
1577 # - It may require specifying regional endpoints when creating the service
1578 # client as shown in:
1579 # https://googleapis.dev/python/google-api-core/latest/client_options.html
1580 from google.cloud import logging_v2
1582 def sample_update_view():
1583 # Create a client
1584 client = logging_v2.ConfigServiceV2Client()
1586 # Initialize request argument(s)
1587 request = logging_v2.UpdateViewRequest(
1588 name="name_value",
1589 )
1591 # Make the request
1592 response = client.update_view(request=request)
1594 # Handle the response
1595 print(response)
1597 Args:
1598 request (Union[google.cloud.logging_v2.types.UpdateViewRequest, dict]):
1599 The request object. The parameters to ``UpdateView``.
1600 retry (google.api_core.retry.Retry): Designation of what errors, if any,
1601 should be retried.
1602 timeout (float): The timeout for this request.
1603 metadata (Sequence[Tuple[str, str]]): Strings which should be
1604 sent along with the request as metadata.
1606 Returns:
1607 google.cloud.logging_v2.types.LogView:
1608 Describes a view over log entries in
1609 a bucket.
1611 """
1612 # Create or coerce a protobuf request object.
1613 # Minor optimization to avoid making a copy if the user passes
1614 # in a logging_config.UpdateViewRequest.
1615 # There's no risk of modifying the input as we've already verified
1616 # there are no flattened fields.
1617 if not isinstance(request, logging_config.UpdateViewRequest):
1618 request = logging_config.UpdateViewRequest(request)
1620 # Wrap the RPC method; this adds retry and timeout information,
1621 # and friendly error handling.
1622 rpc = self._transport._wrapped_methods[self._transport.update_view]
1624 # Certain fields should be provided within the metadata header;
1625 # add these here.
1626 metadata = tuple(metadata) + (
1627 gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
1628 )
1630 # Send the request.
1631 response = rpc(
1632 request,
1633 retry=retry,
1634 timeout=timeout,
1635 metadata=metadata,
1636 )
1638 # Done; return the response.
1639 return response
1641 def delete_view(
1642 self,
1643 request: Optional[Union[logging_config.DeleteViewRequest, dict]] = None,
1644 *,
1645 retry: OptionalRetry = gapic_v1.method.DEFAULT,
1646 timeout: Union[float, object] = gapic_v1.method.DEFAULT,
1647 metadata: Sequence[Tuple[str, str]] = (),
1648 ) -> None:
1649 r"""Deletes a view on a log bucket. If an ``UNAVAILABLE`` error is
1650 returned, this indicates that system is not in a state where it
1651 can delete the view. If this occurs, please try again in a few
1652 minutes.
1654 .. code-block:: python
1656 # This snippet has been automatically generated and should be regarded as a
1657 # code template only.
1658 # It will require modifications to work:
1659 # - It may require correct/in-range values for request initialization.
1660 # - It may require specifying regional endpoints when creating the service
1661 # client as shown in:
1662 # https://googleapis.dev/python/google-api-core/latest/client_options.html
1663 from google.cloud import logging_v2
1665 def sample_delete_view():
1666 # Create a client
1667 client = logging_v2.ConfigServiceV2Client()
1669 # Initialize request argument(s)
1670 request = logging_v2.DeleteViewRequest(
1671 name="name_value",
1672 )
1674 # Make the request
1675 client.delete_view(request=request)
1677 Args:
1678 request (Union[google.cloud.logging_v2.types.DeleteViewRequest, dict]):
1679 The request object. The parameters to ``DeleteView``.
1680 retry (google.api_core.retry.Retry): Designation of what errors, if any,
1681 should be retried.
1682 timeout (float): The timeout for this request.
1683 metadata (Sequence[Tuple[str, str]]): Strings which should be
1684 sent along with the request as metadata.
1685 """
1686 # Create or coerce a protobuf request object.
1687 # Minor optimization to avoid making a copy if the user passes
1688 # in a logging_config.DeleteViewRequest.
1689 # There's no risk of modifying the input as we've already verified
1690 # there are no flattened fields.
1691 if not isinstance(request, logging_config.DeleteViewRequest):
1692 request = logging_config.DeleteViewRequest(request)
1694 # Wrap the RPC method; this adds retry and timeout information,
1695 # and friendly error handling.
1696 rpc = self._transport._wrapped_methods[self._transport.delete_view]
1698 # Certain fields should be provided within the metadata header;
1699 # add these here.
1700 metadata = tuple(metadata) + (
1701 gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
1702 )
1704 # Send the request.
1705 rpc(
1706 request,
1707 retry=retry,
1708 timeout=timeout,
1709 metadata=metadata,
1710 )
1712 def list_sinks(
1713 self,
1714 request: Optional[Union[logging_config.ListSinksRequest, dict]] = None,
1715 *,
1716 parent: Optional[str] = None,
1717 retry: OptionalRetry = gapic_v1.method.DEFAULT,
1718 timeout: Union[float, object] = gapic_v1.method.DEFAULT,
1719 metadata: Sequence[Tuple[str, str]] = (),
1720 ) -> pagers.ListSinksPager:
1721 r"""Lists sinks.
1723 .. code-block:: python
1725 # This snippet has been automatically generated and should be regarded as a
1726 # code template only.
1727 # It will require modifications to work:
1728 # - It may require correct/in-range values for request initialization.
1729 # - It may require specifying regional endpoints when creating the service
1730 # client as shown in:
1731 # https://googleapis.dev/python/google-api-core/latest/client_options.html
1732 from google.cloud import logging_v2
1734 def sample_list_sinks():
1735 # Create a client
1736 client = logging_v2.ConfigServiceV2Client()
1738 # Initialize request argument(s)
1739 request = logging_v2.ListSinksRequest(
1740 parent="parent_value",
1741 )
1743 # Make the request
1744 page_result = client.list_sinks(request=request)
1746 # Handle the response
1747 for response in page_result:
1748 print(response)
1750 Args:
1751 request (Union[google.cloud.logging_v2.types.ListSinksRequest, dict]):
1752 The request object. The parameters to ``ListSinks``.
1753 parent (str):
1754 Required. The parent resource whose sinks are to be
1755 listed:
1757 ::
1759 "projects/[PROJECT_ID]"
1760 "organizations/[ORGANIZATION_ID]"
1761 "billingAccounts/[BILLING_ACCOUNT_ID]"
1762 "folders/[FOLDER_ID]"
1764 This corresponds to the ``parent`` field
1765 on the ``request`` instance; if ``request`` is provided, this
1766 should not be set.
1767 retry (google.api_core.retry.Retry): Designation of what errors, if any,
1768 should be retried.
1769 timeout (float): The timeout for this request.
1770 metadata (Sequence[Tuple[str, str]]): Strings which should be
1771 sent along with the request as metadata.
1773 Returns:
1774 google.cloud.logging_v2.services.config_service_v2.pagers.ListSinksPager:
1775 Result returned from ListSinks.
1777 Iterating over this object will yield results and
1778 resolve additional pages automatically.
1780 """
1781 # Create or coerce a protobuf request object.
1782 # Quick check: If we got a request object, we should *not* have
1783 # gotten any keyword arguments that map to the request.
1784 has_flattened_params = any([parent])
1785 if request is not None and has_flattened_params:
1786 raise ValueError(
1787 "If the `request` argument is set, then none of "
1788 "the individual field arguments should be set."
1789 )
1791 # Minor optimization to avoid making a copy if the user passes
1792 # in a logging_config.ListSinksRequest.
1793 # There's no risk of modifying the input as we've already verified
1794 # there are no flattened fields.
1795 if not isinstance(request, logging_config.ListSinksRequest):
1796 request = logging_config.ListSinksRequest(request)
1797 # If we have keyword arguments corresponding to fields on the
1798 # request, apply these.
1799 if parent is not None:
1800 request.parent = parent
1802 # Wrap the RPC method; this adds retry and timeout information,
1803 # and friendly error handling.
1804 rpc = self._transport._wrapped_methods[self._transport.list_sinks]
1806 # Certain fields should be provided within the metadata header;
1807 # add these here.
1808 metadata = tuple(metadata) + (
1809 gapic_v1.routing_header.to_grpc_metadata((("parent", request.parent),)),
1810 )
1812 # Send the request.
1813 response = rpc(
1814 request,
1815 retry=retry,
1816 timeout=timeout,
1817 metadata=metadata,
1818 )
1820 # This method is paged; wrap the response in a pager, which provides
1821 # an `__iter__` convenience method.
1822 response = pagers.ListSinksPager(
1823 method=rpc,
1824 request=request,
1825 response=response,
1826 metadata=metadata,
1827 )
1829 # Done; return the response.
1830 return response
1832 def get_sink(
1833 self,
1834 request: Optional[Union[logging_config.GetSinkRequest, dict]] = None,
1835 *,
1836 sink_name: Optional[str] = None,
1837 retry: OptionalRetry = gapic_v1.method.DEFAULT,
1838 timeout: Union[float, object] = gapic_v1.method.DEFAULT,
1839 metadata: Sequence[Tuple[str, str]] = (),
1840 ) -> logging_config.LogSink:
1841 r"""Gets a sink.
1843 .. code-block:: python
1845 # This snippet has been automatically generated and should be regarded as a
1846 # code template only.
1847 # It will require modifications to work:
1848 # - It may require correct/in-range values for request initialization.
1849 # - It may require specifying regional endpoints when creating the service
1850 # client as shown in:
1851 # https://googleapis.dev/python/google-api-core/latest/client_options.html
1852 from google.cloud import logging_v2
1854 def sample_get_sink():
1855 # Create a client
1856 client = logging_v2.ConfigServiceV2Client()
1858 # Initialize request argument(s)
1859 request = logging_v2.GetSinkRequest(
1860 sink_name="sink_name_value",
1861 )
1863 # Make the request
1864 response = client.get_sink(request=request)
1866 # Handle the response
1867 print(response)
1869 Args:
1870 request (Union[google.cloud.logging_v2.types.GetSinkRequest, dict]):
1871 The request object. The parameters to ``GetSink``.
1872 sink_name (str):
1873 Required. The resource name of the sink:
1875 ::
1877 "projects/[PROJECT_ID]/sinks/[SINK_ID]"
1878 "organizations/[ORGANIZATION_ID]/sinks/[SINK_ID]"
1879 "billingAccounts/[BILLING_ACCOUNT_ID]/sinks/[SINK_ID]"
1880 "folders/[FOLDER_ID]/sinks/[SINK_ID]"
1882 For example:
1884 ``"projects/my-project/sinks/my-sink"``
1886 This corresponds to the ``sink_name`` field
1887 on the ``request`` instance; if ``request`` is provided, this
1888 should not be set.
1889 retry (google.api_core.retry.Retry): Designation of what errors, if any,
1890 should be retried.
1891 timeout (float): The timeout for this request.
1892 metadata (Sequence[Tuple[str, str]]): Strings which should be
1893 sent along with the request as metadata.
1895 Returns:
1896 google.cloud.logging_v2.types.LogSink:
1897 Describes a sink used to export log
1898 entries to one of the following
1899 destinations in any project: a Cloud
1900 Storage bucket, a BigQuery dataset, a
1901 Pub/Sub topic or a Cloud Logging log
1902 bucket. A logs filter controls which log
1903 entries are exported. The sink must be
1904 created within a project, organization,
1905 billing account, or folder.
1907 """
1908 # Create or coerce a protobuf request object.
1909 # Quick check: If we got a request object, we should *not* have
1910 # gotten any keyword arguments that map to the request.
1911 has_flattened_params = any([sink_name])
1912 if request is not None and has_flattened_params:
1913 raise ValueError(
1914 "If the `request` argument is set, then none of "
1915 "the individual field arguments should be set."
1916 )
1918 # Minor optimization to avoid making a copy if the user passes
1919 # in a logging_config.GetSinkRequest.
1920 # There's no risk of modifying the input as we've already verified
1921 # there are no flattened fields.
1922 if not isinstance(request, logging_config.GetSinkRequest):
1923 request = logging_config.GetSinkRequest(request)
1924 # If we have keyword arguments corresponding to fields on the
1925 # request, apply these.
1926 if sink_name is not None:
1927 request.sink_name = sink_name
1929 # Wrap the RPC method; this adds retry and timeout information,
1930 # and friendly error handling.
1931 rpc = self._transport._wrapped_methods[self._transport.get_sink]
1933 # Certain fields should be provided within the metadata header;
1934 # add these here.
1935 metadata = tuple(metadata) + (
1936 gapic_v1.routing_header.to_grpc_metadata(
1937 (("sink_name", request.sink_name),)
1938 ),
1939 )
1941 # Send the request.
1942 response = rpc(
1943 request,
1944 retry=retry,
1945 timeout=timeout,
1946 metadata=metadata,
1947 )
1949 # Done; return the response.
1950 return response
1952 def create_sink(
1953 self,
1954 request: Optional[Union[logging_config.CreateSinkRequest, dict]] = None,
1955 *,
1956 parent: Optional[str] = None,
1957 sink: Optional[logging_config.LogSink] = None,
1958 retry: OptionalRetry = gapic_v1.method.DEFAULT,
1959 timeout: Union[float, object] = gapic_v1.method.DEFAULT,
1960 metadata: Sequence[Tuple[str, str]] = (),
1961 ) -> logging_config.LogSink:
1962 r"""Creates a sink that exports specified log entries to a
1963 destination. The export of newly-ingested log entries begins
1964 immediately, unless the sink's ``writer_identity`` is not
1965 permitted to write to the destination. A sink can export log
1966 entries only from the resource owning the sink.
1968 .. code-block:: python
1970 # This snippet has been automatically generated and should be regarded as a
1971 # code template only.
1972 # It will require modifications to work:
1973 # - It may require correct/in-range values for request initialization.
1974 # - It may require specifying regional endpoints when creating the service
1975 # client as shown in:
1976 # https://googleapis.dev/python/google-api-core/latest/client_options.html
1977 from google.cloud import logging_v2
1979 def sample_create_sink():
1980 # Create a client
1981 client = logging_v2.ConfigServiceV2Client()
1983 # Initialize request argument(s)
1984 sink = logging_v2.LogSink()
1985 sink.name = "name_value"
1986 sink.destination = "destination_value"
1988 request = logging_v2.CreateSinkRequest(
1989 parent="parent_value",
1990 sink=sink,
1991 )
1993 # Make the request
1994 response = client.create_sink(request=request)
1996 # Handle the response
1997 print(response)
1999 Args:
2000 request (Union[google.cloud.logging_v2.types.CreateSinkRequest, dict]):
2001 The request object. The parameters to ``CreateSink``.
2002 parent (str):
2003 Required. The resource in which to create the sink:
2005 ::
2007 "projects/[PROJECT_ID]"
2008 "organizations/[ORGANIZATION_ID]"
2009 "billingAccounts/[BILLING_ACCOUNT_ID]"
2010 "folders/[FOLDER_ID]"
2012 For examples:
2014 ``"projects/my-project"`` ``"organizations/123456789"``
2016 This corresponds to the ``parent`` field
2017 on the ``request`` instance; if ``request`` is provided, this
2018 should not be set.
2019 sink (google.cloud.logging_v2.types.LogSink):
2020 Required. The new sink, whose ``name`` parameter is a
2021 sink identifier that is not already in use.
2023 This corresponds to the ``sink`` field
2024 on the ``request`` instance; if ``request`` is provided, this
2025 should not be set.
2026 retry (google.api_core.retry.Retry): Designation of what errors, if any,
2027 should be retried.
2028 timeout (float): The timeout for this request.
2029 metadata (Sequence[Tuple[str, str]]): Strings which should be
2030 sent along with the request as metadata.
2032 Returns:
2033 google.cloud.logging_v2.types.LogSink:
2034 Describes a sink used to export log
2035 entries to one of the following
2036 destinations in any project: a Cloud
2037 Storage bucket, a BigQuery dataset, a
2038 Pub/Sub topic or a Cloud Logging log
2039 bucket. A logs filter controls which log
2040 entries are exported. The sink must be
2041 created within a project, organization,
2042 billing account, or folder.
2044 """
2045 # Create or coerce a protobuf request object.
2046 # Quick check: If we got a request object, we should *not* have
2047 # gotten any keyword arguments that map to the request.
2048 has_flattened_params = any([parent, sink])
2049 if request is not None and has_flattened_params:
2050 raise ValueError(
2051 "If the `request` argument is set, then none of "
2052 "the individual field arguments should be set."
2053 )
2055 # Minor optimization to avoid making a copy if the user passes
2056 # in a logging_config.CreateSinkRequest.
2057 # There's no risk of modifying the input as we've already verified
2058 # there are no flattened fields.
2059 if not isinstance(request, logging_config.CreateSinkRequest):
2060 request = logging_config.CreateSinkRequest(request)
2061 # If we have keyword arguments corresponding to fields on the
2062 # request, apply these.
2063 if parent is not None:
2064 request.parent = parent
2065 if sink is not None:
2066 request.sink = sink
2068 # Wrap the RPC method; this adds retry and timeout information,
2069 # and friendly error handling.
2070 rpc = self._transport._wrapped_methods[self._transport.create_sink]
2072 # Certain fields should be provided within the metadata header;
2073 # add these here.
2074 metadata = tuple(metadata) + (
2075 gapic_v1.routing_header.to_grpc_metadata((("parent", request.parent),)),
2076 )
2078 # Send the request.
2079 response = rpc(
2080 request,
2081 retry=retry,
2082 timeout=timeout,
2083 metadata=metadata,
2084 )
2086 # Done; return the response.
2087 return response
2089 def update_sink(
2090 self,
2091 request: Optional[Union[logging_config.UpdateSinkRequest, dict]] = None,
2092 *,
2093 sink_name: Optional[str] = None,
2094 sink: Optional[logging_config.LogSink] = None,
2095 update_mask: Optional[field_mask_pb2.FieldMask] = None,
2096 retry: OptionalRetry = gapic_v1.method.DEFAULT,
2097 timeout: Union[float, object] = gapic_v1.method.DEFAULT,
2098 metadata: Sequence[Tuple[str, str]] = (),
2099 ) -> logging_config.LogSink:
2100 r"""Updates a sink. This method replaces the following fields in the
2101 existing sink with values from the new sink: ``destination``,
2102 and ``filter``.
2104 The updated sink might also have a new ``writer_identity``; see
2105 the ``unique_writer_identity`` field.
2107 .. code-block:: python
2109 # This snippet has been automatically generated and should be regarded as a
2110 # code template only.
2111 # It will require modifications to work:
2112 # - It may require correct/in-range values for request initialization.
2113 # - It may require specifying regional endpoints when creating the service
2114 # client as shown in:
2115 # https://googleapis.dev/python/google-api-core/latest/client_options.html
2116 from google.cloud import logging_v2
2118 def sample_update_sink():
2119 # Create a client
2120 client = logging_v2.ConfigServiceV2Client()
2122 # Initialize request argument(s)
2123 sink = logging_v2.LogSink()
2124 sink.name = "name_value"
2125 sink.destination = "destination_value"
2127 request = logging_v2.UpdateSinkRequest(
2128 sink_name="sink_name_value",
2129 sink=sink,
2130 )
2132 # Make the request
2133 response = client.update_sink(request=request)
2135 # Handle the response
2136 print(response)
2138 Args:
2139 request (Union[google.cloud.logging_v2.types.UpdateSinkRequest, dict]):
2140 The request object. The parameters to ``UpdateSink``.
2141 sink_name (str):
2142 Required. The full resource name of the sink to update,
2143 including the parent resource and the sink identifier:
2145 ::
2147 "projects/[PROJECT_ID]/sinks/[SINK_ID]"
2148 "organizations/[ORGANIZATION_ID]/sinks/[SINK_ID]"
2149 "billingAccounts/[BILLING_ACCOUNT_ID]/sinks/[SINK_ID]"
2150 "folders/[FOLDER_ID]/sinks/[SINK_ID]"
2152 For example:
2154 ``"projects/my-project/sinks/my-sink"``
2156 This corresponds to the ``sink_name`` field
2157 on the ``request`` instance; if ``request`` is provided, this
2158 should not be set.
2159 sink (google.cloud.logging_v2.types.LogSink):
2160 Required. The updated sink, whose name is the same
2161 identifier that appears as part of ``sink_name``.
2163 This corresponds to the ``sink`` field
2164 on the ``request`` instance; if ``request`` is provided, this
2165 should not be set.
2166 update_mask (google.protobuf.field_mask_pb2.FieldMask):
2167 Optional. Field mask that specifies the fields in
2168 ``sink`` that need an update. A sink field will be
2169 overwritten if, and only if, it is in the update mask.
2170 ``name`` and output only fields cannot be updated.
2172 An empty ``updateMask`` is temporarily treated as using
2173 the following mask for backwards compatibility purposes:
2175 ``destination,filter,includeChildren``
2177 At some point in the future, behavior will be removed
2178 and specifying an empty ``updateMask`` will be an error.
2180 For a detailed ``FieldMask`` definition, see
2181 https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#google.protobuf.FieldMask
2183 For example: ``updateMask=filter``
2185 This corresponds to the ``update_mask`` field
2186 on the ``request`` instance; if ``request`` is provided, this
2187 should not be set.
2188 retry (google.api_core.retry.Retry): Designation of what errors, if any,
2189 should be retried.
2190 timeout (float): The timeout for this request.
2191 metadata (Sequence[Tuple[str, str]]): Strings which should be
2192 sent along with the request as metadata.
2194 Returns:
2195 google.cloud.logging_v2.types.LogSink:
2196 Describes a sink used to export log
2197 entries to one of the following
2198 destinations in any project: a Cloud
2199 Storage bucket, a BigQuery dataset, a
2200 Pub/Sub topic or a Cloud Logging log
2201 bucket. A logs filter controls which log
2202 entries are exported. The sink must be
2203 created within a project, organization,
2204 billing account, or folder.
2206 """
2207 # Create or coerce a protobuf request object.
2208 # Quick check: If we got a request object, we should *not* have
2209 # gotten any keyword arguments that map to the request.
2210 has_flattened_params = any([sink_name, sink, update_mask])
2211 if request is not None and has_flattened_params:
2212 raise ValueError(
2213 "If the `request` argument is set, then none of "
2214 "the individual field arguments should be set."
2215 )
2217 # Minor optimization to avoid making a copy if the user passes
2218 # in a logging_config.UpdateSinkRequest.
2219 # There's no risk of modifying the input as we've already verified
2220 # there are no flattened fields.
2221 if not isinstance(request, logging_config.UpdateSinkRequest):
2222 request = logging_config.UpdateSinkRequest(request)
2223 # If we have keyword arguments corresponding to fields on the
2224 # request, apply these.
2225 if sink_name is not None:
2226 request.sink_name = sink_name
2227 if sink is not None:
2228 request.sink = sink
2229 if update_mask is not None:
2230 request.update_mask = update_mask
2232 # Wrap the RPC method; this adds retry and timeout information,
2233 # and friendly error handling.
2234 rpc = self._transport._wrapped_methods[self._transport.update_sink]
2236 # Certain fields should be provided within the metadata header;
2237 # add these here.
2238 metadata = tuple(metadata) + (
2239 gapic_v1.routing_header.to_grpc_metadata(
2240 (("sink_name", request.sink_name),)
2241 ),
2242 )
2244 # Send the request.
2245 response = rpc(
2246 request,
2247 retry=retry,
2248 timeout=timeout,
2249 metadata=metadata,
2250 )
2252 # Done; return the response.
2253 return response
2255 def delete_sink(
2256 self,
2257 request: Optional[Union[logging_config.DeleteSinkRequest, dict]] = None,
2258 *,
2259 sink_name: Optional[str] = None,
2260 retry: OptionalRetry = gapic_v1.method.DEFAULT,
2261 timeout: Union[float, object] = gapic_v1.method.DEFAULT,
2262 metadata: Sequence[Tuple[str, str]] = (),
2263 ) -> None:
2264 r"""Deletes a sink. If the sink has a unique ``writer_identity``,
2265 then that service account is also deleted.
2267 .. code-block:: python
2269 # This snippet has been automatically generated and should be regarded as a
2270 # code template only.
2271 # It will require modifications to work:
2272 # - It may require correct/in-range values for request initialization.
2273 # - It may require specifying regional endpoints when creating the service
2274 # client as shown in:
2275 # https://googleapis.dev/python/google-api-core/latest/client_options.html
2276 from google.cloud import logging_v2
2278 def sample_delete_sink():
2279 # Create a client
2280 client = logging_v2.ConfigServiceV2Client()
2282 # Initialize request argument(s)
2283 request = logging_v2.DeleteSinkRequest(
2284 sink_name="sink_name_value",
2285 )
2287 # Make the request
2288 client.delete_sink(request=request)
2290 Args:
2291 request (Union[google.cloud.logging_v2.types.DeleteSinkRequest, dict]):
2292 The request object. The parameters to ``DeleteSink``.
2293 sink_name (str):
2294 Required. The full resource name of the sink to delete,
2295 including the parent resource and the sink identifier:
2297 ::
2299 "projects/[PROJECT_ID]/sinks/[SINK_ID]"
2300 "organizations/[ORGANIZATION_ID]/sinks/[SINK_ID]"
2301 "billingAccounts/[BILLING_ACCOUNT_ID]/sinks/[SINK_ID]"
2302 "folders/[FOLDER_ID]/sinks/[SINK_ID]"
2304 For example:
2306 ``"projects/my-project/sinks/my-sink"``
2308 This corresponds to the ``sink_name`` field
2309 on the ``request`` instance; if ``request`` is provided, this
2310 should not be set.
2311 retry (google.api_core.retry.Retry): Designation of what errors, if any,
2312 should be retried.
2313 timeout (float): The timeout for this request.
2314 metadata (Sequence[Tuple[str, str]]): Strings which should be
2315 sent along with the request as metadata.
2316 """
2317 # Create or coerce a protobuf request object.
2318 # Quick check: If we got a request object, we should *not* have
2319 # gotten any keyword arguments that map to the request.
2320 has_flattened_params = any([sink_name])
2321 if request is not None and has_flattened_params:
2322 raise ValueError(
2323 "If the `request` argument is set, then none of "
2324 "the individual field arguments should be set."
2325 )
2327 # Minor optimization to avoid making a copy if the user passes
2328 # in a logging_config.DeleteSinkRequest.
2329 # There's no risk of modifying the input as we've already verified
2330 # there are no flattened fields.
2331 if not isinstance(request, logging_config.DeleteSinkRequest):
2332 request = logging_config.DeleteSinkRequest(request)
2333 # If we have keyword arguments corresponding to fields on the
2334 # request, apply these.
2335 if sink_name is not None:
2336 request.sink_name = sink_name
2338 # Wrap the RPC method; this adds retry and timeout information,
2339 # and friendly error handling.
2340 rpc = self._transport._wrapped_methods[self._transport.delete_sink]
2342 # Certain fields should be provided within the metadata header;
2343 # add these here.
2344 metadata = tuple(metadata) + (
2345 gapic_v1.routing_header.to_grpc_metadata(
2346 (("sink_name", request.sink_name),)
2347 ),
2348 )
2350 # Send the request.
2351 rpc(
2352 request,
2353 retry=retry,
2354 timeout=timeout,
2355 metadata=metadata,
2356 )
2358 def create_link(
2359 self,
2360 request: Optional[Union[logging_config.CreateLinkRequest, dict]] = None,
2361 *,
2362 parent: Optional[str] = None,
2363 link: Optional[logging_config.Link] = None,
2364 link_id: Optional[str] = None,
2365 retry: OptionalRetry = gapic_v1.method.DEFAULT,
2366 timeout: Union[float, object] = gapic_v1.method.DEFAULT,
2367 metadata: Sequence[Tuple[str, str]] = (),
2368 ) -> operation.Operation:
2369 r"""Asynchronously creates a linked dataset in BigQuery
2370 which makes it possible to use BigQuery to read the logs
2371 stored in the log bucket. A log bucket may currently
2372 only contain one link.
2374 .. code-block:: python
2376 # This snippet has been automatically generated and should be regarded as a
2377 # code template only.
2378 # It will require modifications to work:
2379 # - It may require correct/in-range values for request initialization.
2380 # - It may require specifying regional endpoints when creating the service
2381 # client as shown in:
2382 # https://googleapis.dev/python/google-api-core/latest/client_options.html
2383 from google.cloud import logging_v2
2385 def sample_create_link():
2386 # Create a client
2387 client = logging_v2.ConfigServiceV2Client()
2389 # Initialize request argument(s)
2390 request = logging_v2.CreateLinkRequest(
2391 parent="parent_value",
2392 link_id="link_id_value",
2393 )
2395 # Make the request
2396 operation = client.create_link(request=request)
2398 print("Waiting for operation to complete...")
2400 response = operation.result()
2402 # Handle the response
2403 print(response)
2405 Args:
2406 request (Union[google.cloud.logging_v2.types.CreateLinkRequest, dict]):
2407 The request object. The parameters to CreateLink.
2408 parent (str):
2409 Required. The full resource name of the bucket to create
2410 a link for.
2412 ::
2414 "projects/[PROJECT_ID]/locations/[LOCATION_ID]/buckets/[BUCKET_ID]"
2415 "organizations/[ORGANIZATION_ID]/locations/[LOCATION_ID]/buckets/[BUCKET_ID]"
2416 "billingAccounts/[BILLING_ACCOUNT_ID]/locations/[LOCATION_ID]/buckets/[BUCKET_ID]"
2417 "folders/[FOLDER_ID]/locations/[LOCATION_ID]/buckets/[BUCKET_ID]"
2419 This corresponds to the ``parent`` field
2420 on the ``request`` instance; if ``request`` is provided, this
2421 should not be set.
2422 link (google.cloud.logging_v2.types.Link):
2423 Required. The new link.
2424 This corresponds to the ``link`` field
2425 on the ``request`` instance; if ``request`` is provided, this
2426 should not be set.
2427 link_id (str):
2428 Required. The ID to use for the link. The link_id can
2429 have up to 100 characters. A valid link_id must only
2430 have alphanumeric characters and underscores within it.
2432 This corresponds to the ``link_id`` field
2433 on the ``request`` instance; if ``request`` is provided, this
2434 should not be set.
2435 retry (google.api_core.retry.Retry): Designation of what errors, if any,
2436 should be retried.
2437 timeout (float): The timeout for this request.
2438 metadata (Sequence[Tuple[str, str]]): Strings which should be
2439 sent along with the request as metadata.
2441 Returns:
2442 google.api_core.operation.Operation:
2443 An object representing a long-running operation.
2445 The result type for the operation will be
2446 :class:`google.cloud.logging_v2.types.Link` Describes a
2447 link connected to an analytics enabled bucket.
2449 """
2450 # Create or coerce a protobuf request object.
2451 # Quick check: If we got a request object, we should *not* have
2452 # gotten any keyword arguments that map to the request.
2453 has_flattened_params = any([parent, link, link_id])
2454 if request is not None and has_flattened_params:
2455 raise ValueError(
2456 "If the `request` argument is set, then none of "
2457 "the individual field arguments should be set."
2458 )
2460 # Minor optimization to avoid making a copy if the user passes
2461 # in a logging_config.CreateLinkRequest.
2462 # There's no risk of modifying the input as we've already verified
2463 # there are no flattened fields.
2464 if not isinstance(request, logging_config.CreateLinkRequest):
2465 request = logging_config.CreateLinkRequest(request)
2466 # If we have keyword arguments corresponding to fields on the
2467 # request, apply these.
2468 if parent is not None:
2469 request.parent = parent
2470 if link is not None:
2471 request.link = link
2472 if link_id is not None:
2473 request.link_id = link_id
2475 # Wrap the RPC method; this adds retry and timeout information,
2476 # and friendly error handling.
2477 rpc = self._transport._wrapped_methods[self._transport.create_link]
2479 # Certain fields should be provided within the metadata header;
2480 # add these here.
2481 metadata = tuple(metadata) + (
2482 gapic_v1.routing_header.to_grpc_metadata((("parent", request.parent),)),
2483 )
2485 # Send the request.
2486 response = rpc(
2487 request,
2488 retry=retry,
2489 timeout=timeout,
2490 metadata=metadata,
2491 )
2493 # Wrap the response in an operation future.
2494 response = operation.from_gapic(
2495 response,
2496 self._transport.operations_client,
2497 logging_config.Link,
2498 metadata_type=logging_config.LinkMetadata,
2499 )
2501 # Done; return the response.
2502 return response
2504 def delete_link(
2505 self,
2506 request: Optional[Union[logging_config.DeleteLinkRequest, dict]] = None,
2507 *,
2508 name: Optional[str] = None,
2509 retry: OptionalRetry = gapic_v1.method.DEFAULT,
2510 timeout: Union[float, object] = gapic_v1.method.DEFAULT,
2511 metadata: Sequence[Tuple[str, str]] = (),
2512 ) -> operation.Operation:
2513 r"""Deletes a link. This will also delete the
2514 corresponding BigQuery linked dataset.
2516 .. code-block:: python
2518 # This snippet has been automatically generated and should be regarded as a
2519 # code template only.
2520 # It will require modifications to work:
2521 # - It may require correct/in-range values for request initialization.
2522 # - It may require specifying regional endpoints when creating the service
2523 # client as shown in:
2524 # https://googleapis.dev/python/google-api-core/latest/client_options.html
2525 from google.cloud import logging_v2
2527 def sample_delete_link():
2528 # Create a client
2529 client = logging_v2.ConfigServiceV2Client()
2531 # Initialize request argument(s)
2532 request = logging_v2.DeleteLinkRequest(
2533 name="name_value",
2534 )
2536 # Make the request
2537 operation = client.delete_link(request=request)
2539 print("Waiting for operation to complete...")
2541 response = operation.result()
2543 # Handle the response
2544 print(response)
2546 Args:
2547 request (Union[google.cloud.logging_v2.types.DeleteLinkRequest, dict]):
2548 The request object. The parameters to DeleteLink.
2549 name (str):
2550 Required. The full resource name of the link to delete.
2552 "projects/[PROJECT_ID]/locations/[LOCATION_ID]/buckets/[BUCKET_ID]/links/[LINK_ID]"
2553 "organizations/[ORGANIZATION_ID]/locations/[LOCATION_ID]/buckets/[BUCKET_ID]/links/[LINK_ID]"
2554 "billingAccounts/[BILLING_ACCOUNT_ID]/locations/[LOCATION_ID]/buckets/[BUCKET_ID]/links/[LINK_ID]"
2555 "folders/[FOLDER_ID]/locations/[LOCATION_ID]/buckets/[BUCKET_ID]/links/[LINK_ID]"
2557 This corresponds to the ``name`` field
2558 on the ``request`` instance; if ``request`` is provided, this
2559 should not be set.
2560 retry (google.api_core.retry.Retry): Designation of what errors, if any,
2561 should be retried.
2562 timeout (float): The timeout for this request.
2563 metadata (Sequence[Tuple[str, str]]): Strings which should be
2564 sent along with the request as metadata.
2566 Returns:
2567 google.api_core.operation.Operation:
2568 An object representing a long-running operation.
2570 The result type for the operation will be :class:`google.protobuf.empty_pb2.Empty` A generic empty message that you can re-use to avoid defining duplicated
2571 empty messages in your APIs. A typical example is to
2572 use it as the request or the response type of an API
2573 method. For instance:
2575 service Foo {
2576 rpc Bar(google.protobuf.Empty) returns
2577 (google.protobuf.Empty);
2579 }
2581 """
2582 # Create or coerce a protobuf request object.
2583 # Quick check: If we got a request object, we should *not* have
2584 # gotten any keyword arguments that map to the request.
2585 has_flattened_params = any([name])
2586 if request is not None and has_flattened_params:
2587 raise ValueError(
2588 "If the `request` argument is set, then none of "
2589 "the individual field arguments should be set."
2590 )
2592 # Minor optimization to avoid making a copy if the user passes
2593 # in a logging_config.DeleteLinkRequest.
2594 # There's no risk of modifying the input as we've already verified
2595 # there are no flattened fields.
2596 if not isinstance(request, logging_config.DeleteLinkRequest):
2597 request = logging_config.DeleteLinkRequest(request)
2598 # If we have keyword arguments corresponding to fields on the
2599 # request, apply these.
2600 if name is not None:
2601 request.name = name
2603 # Wrap the RPC method; this adds retry and timeout information,
2604 # and friendly error handling.
2605 rpc = self._transport._wrapped_methods[self._transport.delete_link]
2607 # Certain fields should be provided within the metadata header;
2608 # add these here.
2609 metadata = tuple(metadata) + (
2610 gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
2611 )
2613 # Send the request.
2614 response = rpc(
2615 request,
2616 retry=retry,
2617 timeout=timeout,
2618 metadata=metadata,
2619 )
2621 # Wrap the response in an operation future.
2622 response = operation.from_gapic(
2623 response,
2624 self._transport.operations_client,
2625 empty_pb2.Empty,
2626 metadata_type=logging_config.LinkMetadata,
2627 )
2629 # Done; return the response.
2630 return response
2632 def list_links(
2633 self,
2634 request: Optional[Union[logging_config.ListLinksRequest, dict]] = None,
2635 *,
2636 parent: Optional[str] = None,
2637 retry: OptionalRetry = gapic_v1.method.DEFAULT,
2638 timeout: Union[float, object] = gapic_v1.method.DEFAULT,
2639 metadata: Sequence[Tuple[str, str]] = (),
2640 ) -> pagers.ListLinksPager:
2641 r"""Lists links.
2643 .. code-block:: python
2645 # This snippet has been automatically generated and should be regarded as a
2646 # code template only.
2647 # It will require modifications to work:
2648 # - It may require correct/in-range values for request initialization.
2649 # - It may require specifying regional endpoints when creating the service
2650 # client as shown in:
2651 # https://googleapis.dev/python/google-api-core/latest/client_options.html
2652 from google.cloud import logging_v2
2654 def sample_list_links():
2655 # Create a client
2656 client = logging_v2.ConfigServiceV2Client()
2658 # Initialize request argument(s)
2659 request = logging_v2.ListLinksRequest(
2660 parent="parent_value",
2661 )
2663 # Make the request
2664 page_result = client.list_links(request=request)
2666 # Handle the response
2667 for response in page_result:
2668 print(response)
2670 Args:
2671 request (Union[google.cloud.logging_v2.types.ListLinksRequest, dict]):
2672 The request object. The parameters to ListLinks.
2673 parent (str):
2674 Required. The parent resource whose links are to be
2675 listed:
2677 "projects/[PROJECT_ID]/locations/[LOCATION_ID]/buckets/[BUCKET_ID]/links/"
2678 "organizations/[ORGANIZATION_ID]/locations/[LOCATION_ID]/buckets/[BUCKET_ID]/"
2679 "billingAccounts/[BILLING_ACCOUNT_ID]/locations/[LOCATION_ID]/buckets/[BUCKET_ID]/"
2680 "folders/[FOLDER_ID]/locations/[LOCATION_ID]/buckets/[BUCKET_ID]/
2682 This corresponds to the ``parent`` field
2683 on the ``request`` instance; if ``request`` is provided, this
2684 should not be set.
2685 retry (google.api_core.retry.Retry): Designation of what errors, if any,
2686 should be retried.
2687 timeout (float): The timeout for this request.
2688 metadata (Sequence[Tuple[str, str]]): Strings which should be
2689 sent along with the request as metadata.
2691 Returns:
2692 google.cloud.logging_v2.services.config_service_v2.pagers.ListLinksPager:
2693 The response from ListLinks.
2695 Iterating over this object will yield
2696 results and resolve additional pages
2697 automatically.
2699 """
2700 # Create or coerce a protobuf request object.
2701 # Quick check: If we got a request object, we should *not* have
2702 # gotten any keyword arguments that map to the request.
2703 has_flattened_params = any([parent])
2704 if request is not None and has_flattened_params:
2705 raise ValueError(
2706 "If the `request` argument is set, then none of "
2707 "the individual field arguments should be set."
2708 )
2710 # Minor optimization to avoid making a copy if the user passes
2711 # in a logging_config.ListLinksRequest.
2712 # There's no risk of modifying the input as we've already verified
2713 # there are no flattened fields.
2714 if not isinstance(request, logging_config.ListLinksRequest):
2715 request = logging_config.ListLinksRequest(request)
2716 # If we have keyword arguments corresponding to fields on the
2717 # request, apply these.
2718 if parent is not None:
2719 request.parent = parent
2721 # Wrap the RPC method; this adds retry and timeout information,
2722 # and friendly error handling.
2723 rpc = self._transport._wrapped_methods[self._transport.list_links]
2725 # Certain fields should be provided within the metadata header;
2726 # add these here.
2727 metadata = tuple(metadata) + (
2728 gapic_v1.routing_header.to_grpc_metadata((("parent", request.parent),)),
2729 )
2731 # Send the request.
2732 response = rpc(
2733 request,
2734 retry=retry,
2735 timeout=timeout,
2736 metadata=metadata,
2737 )
2739 # This method is paged; wrap the response in a pager, which provides
2740 # an `__iter__` convenience method.
2741 response = pagers.ListLinksPager(
2742 method=rpc,
2743 request=request,
2744 response=response,
2745 metadata=metadata,
2746 )
2748 # Done; return the response.
2749 return response
2751 def get_link(
2752 self,
2753 request: Optional[Union[logging_config.GetLinkRequest, dict]] = None,
2754 *,
2755 name: Optional[str] = None,
2756 retry: OptionalRetry = gapic_v1.method.DEFAULT,
2757 timeout: Union[float, object] = gapic_v1.method.DEFAULT,
2758 metadata: Sequence[Tuple[str, str]] = (),
2759 ) -> logging_config.Link:
2760 r"""Gets a link.
2762 .. code-block:: python
2764 # This snippet has been automatically generated and should be regarded as a
2765 # code template only.
2766 # It will require modifications to work:
2767 # - It may require correct/in-range values for request initialization.
2768 # - It may require specifying regional endpoints when creating the service
2769 # client as shown in:
2770 # https://googleapis.dev/python/google-api-core/latest/client_options.html
2771 from google.cloud import logging_v2
2773 def sample_get_link():
2774 # Create a client
2775 client = logging_v2.ConfigServiceV2Client()
2777 # Initialize request argument(s)
2778 request = logging_v2.GetLinkRequest(
2779 name="name_value",
2780 )
2782 # Make the request
2783 response = client.get_link(request=request)
2785 # Handle the response
2786 print(response)
2788 Args:
2789 request (Union[google.cloud.logging_v2.types.GetLinkRequest, dict]):
2790 The request object. The parameters to GetLink.
2791 name (str):
2792 Required. The resource name of the link:
2794 "projects/[PROJECT_ID]/locations/[LOCATION_ID]/buckets/[BUCKET_ID]/links/[LINK_ID]"
2795 "organizations/[ORGANIZATION_ID]/locations/[LOCATION_ID]/buckets/[BUCKET_ID]/links/[LINK_ID]"
2796 "billingAccounts/[BILLING_ACCOUNT_ID]/locations/[LOCATION_ID]/buckets/[BUCKET_ID]/links/[LINK_ID]"
2797 "folders/[FOLDER_ID]/locations/[LOCATION_ID]/buckets/[BUCKET_ID]/links/[LINK_ID]
2799 This corresponds to the ``name`` field
2800 on the ``request`` instance; if ``request`` is provided, this
2801 should not be set.
2802 retry (google.api_core.retry.Retry): Designation of what errors, if any,
2803 should be retried.
2804 timeout (float): The timeout for this request.
2805 metadata (Sequence[Tuple[str, str]]): Strings which should be
2806 sent along with the request as metadata.
2808 Returns:
2809 google.cloud.logging_v2.types.Link:
2810 Describes a link connected to an
2811 analytics enabled bucket.
2813 """
2814 # Create or coerce a protobuf request object.
2815 # Quick check: If we got a request object, we should *not* have
2816 # gotten any keyword arguments that map to the request.
2817 has_flattened_params = any([name])
2818 if request is not None and has_flattened_params:
2819 raise ValueError(
2820 "If the `request` argument is set, then none of "
2821 "the individual field arguments should be set."
2822 )
2824 # Minor optimization to avoid making a copy if the user passes
2825 # in a logging_config.GetLinkRequest.
2826 # There's no risk of modifying the input as we've already verified
2827 # there are no flattened fields.
2828 if not isinstance(request, logging_config.GetLinkRequest):
2829 request = logging_config.GetLinkRequest(request)
2830 # If we have keyword arguments corresponding to fields on the
2831 # request, apply these.
2832 if name is not None:
2833 request.name = name
2835 # Wrap the RPC method; this adds retry and timeout information,
2836 # and friendly error handling.
2837 rpc = self._transport._wrapped_methods[self._transport.get_link]
2839 # Certain fields should be provided within the metadata header;
2840 # add these here.
2841 metadata = tuple(metadata) + (
2842 gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
2843 )
2845 # Send the request.
2846 response = rpc(
2847 request,
2848 retry=retry,
2849 timeout=timeout,
2850 metadata=metadata,
2851 )
2853 # Done; return the response.
2854 return response
2856 def list_exclusions(
2857 self,
2858 request: Optional[Union[logging_config.ListExclusionsRequest, dict]] = None,
2859 *,
2860 parent: Optional[str] = None,
2861 retry: OptionalRetry = gapic_v1.method.DEFAULT,
2862 timeout: Union[float, object] = gapic_v1.method.DEFAULT,
2863 metadata: Sequence[Tuple[str, str]] = (),
2864 ) -> pagers.ListExclusionsPager:
2865 r"""Lists all the exclusions on the \_Default sink in a parent
2866 resource.
2868 .. code-block:: python
2870 # This snippet has been automatically generated and should be regarded as a
2871 # code template only.
2872 # It will require modifications to work:
2873 # - It may require correct/in-range values for request initialization.
2874 # - It may require specifying regional endpoints when creating the service
2875 # client as shown in:
2876 # https://googleapis.dev/python/google-api-core/latest/client_options.html
2877 from google.cloud import logging_v2
2879 def sample_list_exclusions():
2880 # Create a client
2881 client = logging_v2.ConfigServiceV2Client()
2883 # Initialize request argument(s)
2884 request = logging_v2.ListExclusionsRequest(
2885 parent="parent_value",
2886 )
2888 # Make the request
2889 page_result = client.list_exclusions(request=request)
2891 # Handle the response
2892 for response in page_result:
2893 print(response)
2895 Args:
2896 request (Union[google.cloud.logging_v2.types.ListExclusionsRequest, dict]):
2897 The request object. The parameters to ``ListExclusions``.
2898 parent (str):
2899 Required. The parent resource whose exclusions are to be
2900 listed.
2902 ::
2904 "projects/[PROJECT_ID]"
2905 "organizations/[ORGANIZATION_ID]"
2906 "billingAccounts/[BILLING_ACCOUNT_ID]"
2907 "folders/[FOLDER_ID]"
2909 This corresponds to the ``parent`` field
2910 on the ``request`` instance; if ``request`` is provided, this
2911 should not be set.
2912 retry (google.api_core.retry.Retry): Designation of what errors, if any,
2913 should be retried.
2914 timeout (float): The timeout for this request.
2915 metadata (Sequence[Tuple[str, str]]): Strings which should be
2916 sent along with the request as metadata.
2918 Returns:
2919 google.cloud.logging_v2.services.config_service_v2.pagers.ListExclusionsPager:
2920 Result returned from ListExclusions.
2922 Iterating over this object will yield results and
2923 resolve additional pages automatically.
2925 """
2926 # Create or coerce a protobuf request object.
2927 # Quick check: If we got a request object, we should *not* have
2928 # gotten any keyword arguments that map to the request.
2929 has_flattened_params = any([parent])
2930 if request is not None and has_flattened_params:
2931 raise ValueError(
2932 "If the `request` argument is set, then none of "
2933 "the individual field arguments should be set."
2934 )
2936 # Minor optimization to avoid making a copy if the user passes
2937 # in a logging_config.ListExclusionsRequest.
2938 # There's no risk of modifying the input as we've already verified
2939 # there are no flattened fields.
2940 if not isinstance(request, logging_config.ListExclusionsRequest):
2941 request = logging_config.ListExclusionsRequest(request)
2942 # If we have keyword arguments corresponding to fields on the
2943 # request, apply these.
2944 if parent is not None:
2945 request.parent = parent
2947 # Wrap the RPC method; this adds retry and timeout information,
2948 # and friendly error handling.
2949 rpc = self._transport._wrapped_methods[self._transport.list_exclusions]
2951 # Certain fields should be provided within the metadata header;
2952 # add these here.
2953 metadata = tuple(metadata) + (
2954 gapic_v1.routing_header.to_grpc_metadata((("parent", request.parent),)),
2955 )
2957 # Send the request.
2958 response = rpc(
2959 request,
2960 retry=retry,
2961 timeout=timeout,
2962 metadata=metadata,
2963 )
2965 # This method is paged; wrap the response in a pager, which provides
2966 # an `__iter__` convenience method.
2967 response = pagers.ListExclusionsPager(
2968 method=rpc,
2969 request=request,
2970 response=response,
2971 metadata=metadata,
2972 )
2974 # Done; return the response.
2975 return response
2977 def get_exclusion(
2978 self,
2979 request: Optional[Union[logging_config.GetExclusionRequest, dict]] = None,
2980 *,
2981 name: Optional[str] = None,
2982 retry: OptionalRetry = gapic_v1.method.DEFAULT,
2983 timeout: Union[float, object] = gapic_v1.method.DEFAULT,
2984 metadata: Sequence[Tuple[str, str]] = (),
2985 ) -> logging_config.LogExclusion:
2986 r"""Gets the description of an exclusion in the \_Default sink.
2988 .. code-block:: python
2990 # This snippet has been automatically generated and should be regarded as a
2991 # code template only.
2992 # It will require modifications to work:
2993 # - It may require correct/in-range values for request initialization.
2994 # - It may require specifying regional endpoints when creating the service
2995 # client as shown in:
2996 # https://googleapis.dev/python/google-api-core/latest/client_options.html
2997 from google.cloud import logging_v2
2999 def sample_get_exclusion():
3000 # Create a client
3001 client = logging_v2.ConfigServiceV2Client()
3003 # Initialize request argument(s)
3004 request = logging_v2.GetExclusionRequest(
3005 name="name_value",
3006 )
3008 # Make the request
3009 response = client.get_exclusion(request=request)
3011 # Handle the response
3012 print(response)
3014 Args:
3015 request (Union[google.cloud.logging_v2.types.GetExclusionRequest, dict]):
3016 The request object. The parameters to ``GetExclusion``.
3017 name (str):
3018 Required. The resource name of an existing exclusion:
3020 ::
3022 "projects/[PROJECT_ID]/exclusions/[EXCLUSION_ID]"
3023 "organizations/[ORGANIZATION_ID]/exclusions/[EXCLUSION_ID]"
3024 "billingAccounts/[BILLING_ACCOUNT_ID]/exclusions/[EXCLUSION_ID]"
3025 "folders/[FOLDER_ID]/exclusions/[EXCLUSION_ID]"
3027 For example:
3029 ``"projects/my-project/exclusions/my-exclusion"``
3031 This corresponds to the ``name`` field
3032 on the ``request`` instance; if ``request`` is provided, this
3033 should not be set.
3034 retry (google.api_core.retry.Retry): Designation of what errors, if any,
3035 should be retried.
3036 timeout (float): The timeout for this request.
3037 metadata (Sequence[Tuple[str, str]]): Strings which should be
3038 sent along with the request as metadata.
3040 Returns:
3041 google.cloud.logging_v2.types.LogExclusion:
3042 Specifies a set of log entries that are filtered out by a sink. If
3043 your Google Cloud resource receives a large volume of
3044 log entries, you can use exclusions to reduce your
3045 chargeable logs. Note that exclusions on
3046 organization-level and folder-level sinks don't apply
3047 to child resources. Note also that you cannot modify
3048 the \_Required sink or exclude logs from it.
3050 """
3051 # Create or coerce a protobuf request object.
3052 # Quick check: If we got a request object, we should *not* have
3053 # gotten any keyword arguments that map to the request.
3054 has_flattened_params = any([name])
3055 if request is not None and has_flattened_params:
3056 raise ValueError(
3057 "If the `request` argument is set, then none of "
3058 "the individual field arguments should be set."
3059 )
3061 # Minor optimization to avoid making a copy if the user passes
3062 # in a logging_config.GetExclusionRequest.
3063 # There's no risk of modifying the input as we've already verified
3064 # there are no flattened fields.
3065 if not isinstance(request, logging_config.GetExclusionRequest):
3066 request = logging_config.GetExclusionRequest(request)
3067 # If we have keyword arguments corresponding to fields on the
3068 # request, apply these.
3069 if name is not None:
3070 request.name = name
3072 # Wrap the RPC method; this adds retry and timeout information,
3073 # and friendly error handling.
3074 rpc = self._transport._wrapped_methods[self._transport.get_exclusion]
3076 # Certain fields should be provided within the metadata header;
3077 # add these here.
3078 metadata = tuple(metadata) + (
3079 gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
3080 )
3082 # Send the request.
3083 response = rpc(
3084 request,
3085 retry=retry,
3086 timeout=timeout,
3087 metadata=metadata,
3088 )
3090 # Done; return the response.
3091 return response
3093 def create_exclusion(
3094 self,
3095 request: Optional[Union[logging_config.CreateExclusionRequest, dict]] = None,
3096 *,
3097 parent: Optional[str] = None,
3098 exclusion: Optional[logging_config.LogExclusion] = None,
3099 retry: OptionalRetry = gapic_v1.method.DEFAULT,
3100 timeout: Union[float, object] = gapic_v1.method.DEFAULT,
3101 metadata: Sequence[Tuple[str, str]] = (),
3102 ) -> logging_config.LogExclusion:
3103 r"""Creates a new exclusion in the \_Default sink in a specified
3104 parent resource. Only log entries belonging to that resource can
3105 be excluded. You can have up to 10 exclusions in a resource.
3107 .. code-block:: python
3109 # This snippet has been automatically generated and should be regarded as a
3110 # code template only.
3111 # It will require modifications to work:
3112 # - It may require correct/in-range values for request initialization.
3113 # - It may require specifying regional endpoints when creating the service
3114 # client as shown in:
3115 # https://googleapis.dev/python/google-api-core/latest/client_options.html
3116 from google.cloud import logging_v2
3118 def sample_create_exclusion():
3119 # Create a client
3120 client = logging_v2.ConfigServiceV2Client()
3122 # Initialize request argument(s)
3123 exclusion = logging_v2.LogExclusion()
3124 exclusion.name = "name_value"
3125 exclusion.filter = "filter_value"
3127 request = logging_v2.CreateExclusionRequest(
3128 parent="parent_value",
3129 exclusion=exclusion,
3130 )
3132 # Make the request
3133 response = client.create_exclusion(request=request)
3135 # Handle the response
3136 print(response)
3138 Args:
3139 request (Union[google.cloud.logging_v2.types.CreateExclusionRequest, dict]):
3140 The request object. The parameters to ``CreateExclusion``.
3141 parent (str):
3142 Required. The parent resource in which to create the
3143 exclusion:
3145 ::
3147 "projects/[PROJECT_ID]"
3148 "organizations/[ORGANIZATION_ID]"
3149 "billingAccounts/[BILLING_ACCOUNT_ID]"
3150 "folders/[FOLDER_ID]"
3152 For examples:
3154 ``"projects/my-logging-project"``
3155 ``"organizations/123456789"``
3157 This corresponds to the ``parent`` field
3158 on the ``request`` instance; if ``request`` is provided, this
3159 should not be set.
3160 exclusion (google.cloud.logging_v2.types.LogExclusion):
3161 Required. The new exclusion, whose ``name`` parameter is
3162 an exclusion name that is not already used in the parent
3163 resource.
3165 This corresponds to the ``exclusion`` field
3166 on the ``request`` instance; if ``request`` is provided, this
3167 should not be set.
3168 retry (google.api_core.retry.Retry): Designation of what errors, if any,
3169 should be retried.
3170 timeout (float): The timeout for this request.
3171 metadata (Sequence[Tuple[str, str]]): Strings which should be
3172 sent along with the request as metadata.
3174 Returns:
3175 google.cloud.logging_v2.types.LogExclusion:
3176 Specifies a set of log entries that are filtered out by a sink. If
3177 your Google Cloud resource receives a large volume of
3178 log entries, you can use exclusions to reduce your
3179 chargeable logs. Note that exclusions on
3180 organization-level and folder-level sinks don't apply
3181 to child resources. Note also that you cannot modify
3182 the \_Required sink or exclude logs from it.
3184 """
3185 # Create or coerce a protobuf request object.
3186 # Quick check: If we got a request object, we should *not* have
3187 # gotten any keyword arguments that map to the request.
3188 has_flattened_params = any([parent, exclusion])
3189 if request is not None and has_flattened_params:
3190 raise ValueError(
3191 "If the `request` argument is set, then none of "
3192 "the individual field arguments should be set."
3193 )
3195 # Minor optimization to avoid making a copy if the user passes
3196 # in a logging_config.CreateExclusionRequest.
3197 # There's no risk of modifying the input as we've already verified
3198 # there are no flattened fields.
3199 if not isinstance(request, logging_config.CreateExclusionRequest):
3200 request = logging_config.CreateExclusionRequest(request)
3201 # If we have keyword arguments corresponding to fields on the
3202 # request, apply these.
3203 if parent is not None:
3204 request.parent = parent
3205 if exclusion is not None:
3206 request.exclusion = exclusion
3208 # Wrap the RPC method; this adds retry and timeout information,
3209 # and friendly error handling.
3210 rpc = self._transport._wrapped_methods[self._transport.create_exclusion]
3212 # Certain fields should be provided within the metadata header;
3213 # add these here.
3214 metadata = tuple(metadata) + (
3215 gapic_v1.routing_header.to_grpc_metadata((("parent", request.parent),)),
3216 )
3218 # Send the request.
3219 response = rpc(
3220 request,
3221 retry=retry,
3222 timeout=timeout,
3223 metadata=metadata,
3224 )
3226 # Done; return the response.
3227 return response
3229 def update_exclusion(
3230 self,
3231 request: Optional[Union[logging_config.UpdateExclusionRequest, dict]] = None,
3232 *,
3233 name: Optional[str] = None,
3234 exclusion: Optional[logging_config.LogExclusion] = None,
3235 update_mask: Optional[field_mask_pb2.FieldMask] = None,
3236 retry: OptionalRetry = gapic_v1.method.DEFAULT,
3237 timeout: Union[float, object] = gapic_v1.method.DEFAULT,
3238 metadata: Sequence[Tuple[str, str]] = (),
3239 ) -> logging_config.LogExclusion:
3240 r"""Changes one or more properties of an existing exclusion in the
3241 \_Default sink.
3243 .. code-block:: python
3245 # This snippet has been automatically generated and should be regarded as a
3246 # code template only.
3247 # It will require modifications to work:
3248 # - It may require correct/in-range values for request initialization.
3249 # - It may require specifying regional endpoints when creating the service
3250 # client as shown in:
3251 # https://googleapis.dev/python/google-api-core/latest/client_options.html
3252 from google.cloud import logging_v2
3254 def sample_update_exclusion():
3255 # Create a client
3256 client = logging_v2.ConfigServiceV2Client()
3258 # Initialize request argument(s)
3259 exclusion = logging_v2.LogExclusion()
3260 exclusion.name = "name_value"
3261 exclusion.filter = "filter_value"
3263 request = logging_v2.UpdateExclusionRequest(
3264 name="name_value",
3265 exclusion=exclusion,
3266 )
3268 # Make the request
3269 response = client.update_exclusion(request=request)
3271 # Handle the response
3272 print(response)
3274 Args:
3275 request (Union[google.cloud.logging_v2.types.UpdateExclusionRequest, dict]):
3276 The request object. The parameters to ``UpdateExclusion``.
3277 name (str):
3278 Required. The resource name of the exclusion to update:
3280 ::
3282 "projects/[PROJECT_ID]/exclusions/[EXCLUSION_ID]"
3283 "organizations/[ORGANIZATION_ID]/exclusions/[EXCLUSION_ID]"
3284 "billingAccounts/[BILLING_ACCOUNT_ID]/exclusions/[EXCLUSION_ID]"
3285 "folders/[FOLDER_ID]/exclusions/[EXCLUSION_ID]"
3287 For example:
3289 ``"projects/my-project/exclusions/my-exclusion"``
3291 This corresponds to the ``name`` field
3292 on the ``request`` instance; if ``request`` is provided, this
3293 should not be set.
3294 exclusion (google.cloud.logging_v2.types.LogExclusion):
3295 Required. New values for the existing exclusion. Only
3296 the fields specified in ``update_mask`` are relevant.
3298 This corresponds to the ``exclusion`` field
3299 on the ``request`` instance; if ``request`` is provided, this
3300 should not be set.
3301 update_mask (google.protobuf.field_mask_pb2.FieldMask):
3302 Required. A non-empty list of fields to change in the
3303 existing exclusion. New values for the fields are taken
3304 from the corresponding fields in the
3305 [LogExclusion][google.logging.v2.LogExclusion] included
3306 in this request. Fields not mentioned in ``update_mask``
3307 are not changed and are ignored in the request.
3309 For example, to change the filter and description of an
3310 exclusion, specify an ``update_mask`` of
3311 ``"filter,description"``.
3313 This corresponds to the ``update_mask`` field
3314 on the ``request`` instance; if ``request`` is provided, this
3315 should not be set.
3316 retry (google.api_core.retry.Retry): Designation of what errors, if any,
3317 should be retried.
3318 timeout (float): The timeout for this request.
3319 metadata (Sequence[Tuple[str, str]]): Strings which should be
3320 sent along with the request as metadata.
3322 Returns:
3323 google.cloud.logging_v2.types.LogExclusion:
3324 Specifies a set of log entries that are filtered out by a sink. If
3325 your Google Cloud resource receives a large volume of
3326 log entries, you can use exclusions to reduce your
3327 chargeable logs. Note that exclusions on
3328 organization-level and folder-level sinks don't apply
3329 to child resources. Note also that you cannot modify
3330 the \_Required sink or exclude logs from it.
3332 """
3333 # Create or coerce a protobuf request object.
3334 # Quick check: If we got a request object, we should *not* have
3335 # gotten any keyword arguments that map to the request.
3336 has_flattened_params = any([name, exclusion, update_mask])
3337 if request is not None and has_flattened_params:
3338 raise ValueError(
3339 "If the `request` argument is set, then none of "
3340 "the individual field arguments should be set."
3341 )
3343 # Minor optimization to avoid making a copy if the user passes
3344 # in a logging_config.UpdateExclusionRequest.
3345 # There's no risk of modifying the input as we've already verified
3346 # there are no flattened fields.
3347 if not isinstance(request, logging_config.UpdateExclusionRequest):
3348 request = logging_config.UpdateExclusionRequest(request)
3349 # If we have keyword arguments corresponding to fields on the
3350 # request, apply these.
3351 if name is not None:
3352 request.name = name
3353 if exclusion is not None:
3354 request.exclusion = exclusion
3355 if update_mask is not None:
3356 request.update_mask = update_mask
3358 # Wrap the RPC method; this adds retry and timeout information,
3359 # and friendly error handling.
3360 rpc = self._transport._wrapped_methods[self._transport.update_exclusion]
3362 # Certain fields should be provided within the metadata header;
3363 # add these here.
3364 metadata = tuple(metadata) + (
3365 gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
3366 )
3368 # Send the request.
3369 response = rpc(
3370 request,
3371 retry=retry,
3372 timeout=timeout,
3373 metadata=metadata,
3374 )
3376 # Done; return the response.
3377 return response
3379 def delete_exclusion(
3380 self,
3381 request: Optional[Union[logging_config.DeleteExclusionRequest, dict]] = None,
3382 *,
3383 name: Optional[str] = None,
3384 retry: OptionalRetry = gapic_v1.method.DEFAULT,
3385 timeout: Union[float, object] = gapic_v1.method.DEFAULT,
3386 metadata: Sequence[Tuple[str, str]] = (),
3387 ) -> None:
3388 r"""Deletes an exclusion in the \_Default sink.
3390 .. code-block:: python
3392 # This snippet has been automatically generated and should be regarded as a
3393 # code template only.
3394 # It will require modifications to work:
3395 # - It may require correct/in-range values for request initialization.
3396 # - It may require specifying regional endpoints when creating the service
3397 # client as shown in:
3398 # https://googleapis.dev/python/google-api-core/latest/client_options.html
3399 from google.cloud import logging_v2
3401 def sample_delete_exclusion():
3402 # Create a client
3403 client = logging_v2.ConfigServiceV2Client()
3405 # Initialize request argument(s)
3406 request = logging_v2.DeleteExclusionRequest(
3407 name="name_value",
3408 )
3410 # Make the request
3411 client.delete_exclusion(request=request)
3413 Args:
3414 request (Union[google.cloud.logging_v2.types.DeleteExclusionRequest, dict]):
3415 The request object. The parameters to ``DeleteExclusion``.
3416 name (str):
3417 Required. The resource name of an existing exclusion to
3418 delete:
3420 ::
3422 "projects/[PROJECT_ID]/exclusions/[EXCLUSION_ID]"
3423 "organizations/[ORGANIZATION_ID]/exclusions/[EXCLUSION_ID]"
3424 "billingAccounts/[BILLING_ACCOUNT_ID]/exclusions/[EXCLUSION_ID]"
3425 "folders/[FOLDER_ID]/exclusions/[EXCLUSION_ID]"
3427 For example:
3429 ``"projects/my-project/exclusions/my-exclusion"``
3431 This corresponds to the ``name`` field
3432 on the ``request`` instance; if ``request`` is provided, this
3433 should not be set.
3434 retry (google.api_core.retry.Retry): Designation of what errors, if any,
3435 should be retried.
3436 timeout (float): The timeout for this request.
3437 metadata (Sequence[Tuple[str, str]]): Strings which should be
3438 sent along with the request as metadata.
3439 """
3440 # Create or coerce a protobuf request object.
3441 # Quick check: If we got a request object, we should *not* have
3442 # gotten any keyword arguments that map to the request.
3443 has_flattened_params = any([name])
3444 if request is not None and has_flattened_params:
3445 raise ValueError(
3446 "If the `request` argument is set, then none of "
3447 "the individual field arguments should be set."
3448 )
3450 # Minor optimization to avoid making a copy if the user passes
3451 # in a logging_config.DeleteExclusionRequest.
3452 # There's no risk of modifying the input as we've already verified
3453 # there are no flattened fields.
3454 if not isinstance(request, logging_config.DeleteExclusionRequest):
3455 request = logging_config.DeleteExclusionRequest(request)
3456 # If we have keyword arguments corresponding to fields on the
3457 # request, apply these.
3458 if name is not None:
3459 request.name = name
3461 # Wrap the RPC method; this adds retry and timeout information,
3462 # and friendly error handling.
3463 rpc = self._transport._wrapped_methods[self._transport.delete_exclusion]
3465 # Certain fields should be provided within the metadata header;
3466 # add these here.
3467 metadata = tuple(metadata) + (
3468 gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
3469 )
3471 # Send the request.
3472 rpc(
3473 request,
3474 retry=retry,
3475 timeout=timeout,
3476 metadata=metadata,
3477 )
3479 def get_cmek_settings(
3480 self,
3481 request: Optional[Union[logging_config.GetCmekSettingsRequest, dict]] = None,
3482 *,
3483 retry: OptionalRetry = gapic_v1.method.DEFAULT,
3484 timeout: Union[float, object] = gapic_v1.method.DEFAULT,
3485 metadata: Sequence[Tuple[str, str]] = (),
3486 ) -> logging_config.CmekSettings:
3487 r"""Gets the Logging CMEK settings for the given resource.
3489 Note: CMEK for the Log Router can be configured for Google Cloud
3490 projects, folders, organizations and billing accounts. Once
3491 configured for an organization, it applies to all projects and
3492 folders in the Google Cloud organization.
3494 See `Enabling CMEK for Log
3495 Router <https://cloud.google.com/logging/docs/routing/managed-encryption>`__
3496 for more information.
3498 .. code-block:: python
3500 # This snippet has been automatically generated and should be regarded as a
3501 # code template only.
3502 # It will require modifications to work:
3503 # - It may require correct/in-range values for request initialization.
3504 # - It may require specifying regional endpoints when creating the service
3505 # client as shown in:
3506 # https://googleapis.dev/python/google-api-core/latest/client_options.html
3507 from google.cloud import logging_v2
3509 def sample_get_cmek_settings():
3510 # Create a client
3511 client = logging_v2.ConfigServiceV2Client()
3513 # Initialize request argument(s)
3514 request = logging_v2.GetCmekSettingsRequest(
3515 name="name_value",
3516 )
3518 # Make the request
3519 response = client.get_cmek_settings(request=request)
3521 # Handle the response
3522 print(response)
3524 Args:
3525 request (Union[google.cloud.logging_v2.types.GetCmekSettingsRequest, dict]):
3526 The request object. The parameters to
3527 [GetCmekSettings][google.logging.v2.ConfigServiceV2.GetCmekSettings].
3529 See `Enabling CMEK for Log
3530 Router <https://cloud.google.com/logging/docs/routing/managed-encryption>`__
3531 for more information.
3532 retry (google.api_core.retry.Retry): Designation of what errors, if any,
3533 should be retried.
3534 timeout (float): The timeout for this request.
3535 metadata (Sequence[Tuple[str, str]]): Strings which should be
3536 sent along with the request as metadata.
3538 Returns:
3539 google.cloud.logging_v2.types.CmekSettings:
3540 Describes the customer-managed encryption key (CMEK) settings associated with
3541 a project, folder, organization, billing account, or
3542 flexible resource.
3544 Note: CMEK for the Log Router can currently only be
3545 configured for Google Cloud organizations. Once
3546 configured, it applies to all projects and folders in
3547 the Google Cloud organization.
3549 See [Enabling CMEK for Log
3550 Router](\ https://cloud.google.com/logging/docs/routing/managed-encryption)
3551 for more information.
3553 """
3554 # Create or coerce a protobuf request object.
3555 # Minor optimization to avoid making a copy if the user passes
3556 # in a logging_config.GetCmekSettingsRequest.
3557 # There's no risk of modifying the input as we've already verified
3558 # there are no flattened fields.
3559 if not isinstance(request, logging_config.GetCmekSettingsRequest):
3560 request = logging_config.GetCmekSettingsRequest(request)
3562 # Wrap the RPC method; this adds retry and timeout information,
3563 # and friendly error handling.
3564 rpc = self._transport._wrapped_methods[self._transport.get_cmek_settings]
3566 # Certain fields should be provided within the metadata header;
3567 # add these here.
3568 metadata = tuple(metadata) + (
3569 gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
3570 )
3572 # Send the request.
3573 response = rpc(
3574 request,
3575 retry=retry,
3576 timeout=timeout,
3577 metadata=metadata,
3578 )
3580 # Done; return the response.
3581 return response
3583 def update_cmek_settings(
3584 self,
3585 request: Optional[Union[logging_config.UpdateCmekSettingsRequest, dict]] = None,
3586 *,
3587 retry: OptionalRetry = gapic_v1.method.DEFAULT,
3588 timeout: Union[float, object] = gapic_v1.method.DEFAULT,
3589 metadata: Sequence[Tuple[str, str]] = (),
3590 ) -> logging_config.CmekSettings:
3591 r"""Updates the Log Router CMEK settings for the given resource.
3593 Note: CMEK for the Log Router can currently only be configured
3594 for Google Cloud organizations. Once configured, it applies to
3595 all projects and folders in the Google Cloud organization.
3597 [UpdateCmekSettings][google.logging.v2.ConfigServiceV2.UpdateCmekSettings]
3598 will fail if 1) ``kms_key_name`` is invalid, or 2) the
3599 associated service account does not have the required
3600 ``roles/cloudkms.cryptoKeyEncrypterDecrypter`` role assigned for
3601 the key, or 3) access to the key is disabled.
3603 See `Enabling CMEK for Log
3604 Router <https://cloud.google.com/logging/docs/routing/managed-encryption>`__
3605 for more information.
3607 .. code-block:: python
3609 # This snippet has been automatically generated and should be regarded as a
3610 # code template only.
3611 # It will require modifications to work:
3612 # - It may require correct/in-range values for request initialization.
3613 # - It may require specifying regional endpoints when creating the service
3614 # client as shown in:
3615 # https://googleapis.dev/python/google-api-core/latest/client_options.html
3616 from google.cloud import logging_v2
3618 def sample_update_cmek_settings():
3619 # Create a client
3620 client = logging_v2.ConfigServiceV2Client()
3622 # Initialize request argument(s)
3623 request = logging_v2.UpdateCmekSettingsRequest(
3624 name="name_value",
3625 )
3627 # Make the request
3628 response = client.update_cmek_settings(request=request)
3630 # Handle the response
3631 print(response)
3633 Args:
3634 request (Union[google.cloud.logging_v2.types.UpdateCmekSettingsRequest, dict]):
3635 The request object. The parameters to
3636 [UpdateCmekSettings][google.logging.v2.ConfigServiceV2.UpdateCmekSettings].
3638 See `Enabling CMEK for Log
3639 Router <https://cloud.google.com/logging/docs/routing/managed-encryption>`__
3640 for more information.
3641 retry (google.api_core.retry.Retry): Designation of what errors, if any,
3642 should be retried.
3643 timeout (float): The timeout for this request.
3644 metadata (Sequence[Tuple[str, str]]): Strings which should be
3645 sent along with the request as metadata.
3647 Returns:
3648 google.cloud.logging_v2.types.CmekSettings:
3649 Describes the customer-managed encryption key (CMEK) settings associated with
3650 a project, folder, organization, billing account, or
3651 flexible resource.
3653 Note: CMEK for the Log Router can currently only be
3654 configured for Google Cloud organizations. Once
3655 configured, it applies to all projects and folders in
3656 the Google Cloud organization.
3658 See [Enabling CMEK for Log
3659 Router](\ https://cloud.google.com/logging/docs/routing/managed-encryption)
3660 for more information.
3662 """
3663 # Create or coerce a protobuf request object.
3664 # Minor optimization to avoid making a copy if the user passes
3665 # in a logging_config.UpdateCmekSettingsRequest.
3666 # There's no risk of modifying the input as we've already verified
3667 # there are no flattened fields.
3668 if not isinstance(request, logging_config.UpdateCmekSettingsRequest):
3669 request = logging_config.UpdateCmekSettingsRequest(request)
3671 # Wrap the RPC method; this adds retry and timeout information,
3672 # and friendly error handling.
3673 rpc = self._transport._wrapped_methods[self._transport.update_cmek_settings]
3675 # Certain fields should be provided within the metadata header;
3676 # add these here.
3677 metadata = tuple(metadata) + (
3678 gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
3679 )
3681 # Send the request.
3682 response = rpc(
3683 request,
3684 retry=retry,
3685 timeout=timeout,
3686 metadata=metadata,
3687 )
3689 # Done; return the response.
3690 return response
3692 def get_settings(
3693 self,
3694 request: Optional[Union[logging_config.GetSettingsRequest, dict]] = None,
3695 *,
3696 name: Optional[str] = None,
3697 retry: OptionalRetry = gapic_v1.method.DEFAULT,
3698 timeout: Union[float, object] = gapic_v1.method.DEFAULT,
3699 metadata: Sequence[Tuple[str, str]] = (),
3700 ) -> logging_config.Settings:
3701 r"""Gets the Log Router settings for the given resource.
3703 Note: Settings for the Log Router can be get for Google Cloud
3704 projects, folders, organizations and billing accounts. Currently
3705 it can only be configured for organizations. Once configured for
3706 an organization, it applies to all projects and folders in the
3707 Google Cloud organization.
3709 See `Enabling CMEK for Log
3710 Router <https://cloud.google.com/logging/docs/routing/managed-encryption>`__
3711 for more information.
3713 .. code-block:: python
3715 # This snippet has been automatically generated and should be regarded as a
3716 # code template only.
3717 # It will require modifications to work:
3718 # - It may require correct/in-range values for request initialization.
3719 # - It may require specifying regional endpoints when creating the service
3720 # client as shown in:
3721 # https://googleapis.dev/python/google-api-core/latest/client_options.html
3722 from google.cloud import logging_v2
3724 def sample_get_settings():
3725 # Create a client
3726 client = logging_v2.ConfigServiceV2Client()
3728 # Initialize request argument(s)
3729 request = logging_v2.GetSettingsRequest(
3730 name="name_value",
3731 )
3733 # Make the request
3734 response = client.get_settings(request=request)
3736 # Handle the response
3737 print(response)
3739 Args:
3740 request (Union[google.cloud.logging_v2.types.GetSettingsRequest, dict]):
3741 The request object. The parameters to
3742 [GetSettings][google.logging.v2.ConfigServiceV2.GetSettings].
3744 See `Enabling CMEK for Log
3745 Router <https://cloud.google.com/logging/docs/routing/managed-encryption>`__
3746 for more information.
3747 name (str):
3748 Required. The resource for which to retrieve settings.
3750 ::
3752 "projects/[PROJECT_ID]/settings"
3753 "organizations/[ORGANIZATION_ID]/settings"
3754 "billingAccounts/[BILLING_ACCOUNT_ID]/settings"
3755 "folders/[FOLDER_ID]/settings"
3757 For example:
3759 ``"organizations/12345/settings"``
3761 Note: Settings for the Log Router can be get for Google
3762 Cloud projects, folders, organizations and billing
3763 accounts. Currently it can only be configured for
3764 organizations. Once configured for an organization, it
3765 applies to all projects and folders in the Google Cloud
3766 organization.
3768 This corresponds to the ``name`` field
3769 on the ``request`` instance; if ``request`` is provided, this
3770 should not be set.
3771 retry (google.api_core.retry.Retry): Designation of what errors, if any,
3772 should be retried.
3773 timeout (float): The timeout for this request.
3774 metadata (Sequence[Tuple[str, str]]): Strings which should be
3775 sent along with the request as metadata.
3777 Returns:
3778 google.cloud.logging_v2.types.Settings:
3779 Describes the settings associated
3780 with a project, folder, organization,
3781 billing account, or flexible resource.
3783 """
3784 # Create or coerce a protobuf request object.
3785 # Quick check: If we got a request object, we should *not* have
3786 # gotten any keyword arguments that map to the request.
3787 has_flattened_params = any([name])
3788 if request is not None and has_flattened_params:
3789 raise ValueError(
3790 "If the `request` argument is set, then none of "
3791 "the individual field arguments should be set."
3792 )
3794 # Minor optimization to avoid making a copy if the user passes
3795 # in a logging_config.GetSettingsRequest.
3796 # There's no risk of modifying the input as we've already verified
3797 # there are no flattened fields.
3798 if not isinstance(request, logging_config.GetSettingsRequest):
3799 request = logging_config.GetSettingsRequest(request)
3800 # If we have keyword arguments corresponding to fields on the
3801 # request, apply these.
3802 if name is not None:
3803 request.name = name
3805 # Wrap the RPC method; this adds retry and timeout information,
3806 # and friendly error handling.
3807 rpc = self._transport._wrapped_methods[self._transport.get_settings]
3809 # Certain fields should be provided within the metadata header;
3810 # add these here.
3811 metadata = tuple(metadata) + (
3812 gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
3813 )
3815 # Send the request.
3816 response = rpc(
3817 request,
3818 retry=retry,
3819 timeout=timeout,
3820 metadata=metadata,
3821 )
3823 # Done; return the response.
3824 return response
3826 def update_settings(
3827 self,
3828 request: Optional[Union[logging_config.UpdateSettingsRequest, dict]] = None,
3829 *,
3830 settings: Optional[logging_config.Settings] = None,
3831 update_mask: Optional[field_mask_pb2.FieldMask] = None,
3832 retry: OptionalRetry = gapic_v1.method.DEFAULT,
3833 timeout: Union[float, object] = gapic_v1.method.DEFAULT,
3834 metadata: Sequence[Tuple[str, str]] = (),
3835 ) -> logging_config.Settings:
3836 r"""Updates the Log Router settings for the given resource.
3838 Note: Settings for the Log Router can currently only be
3839 configured for Google Cloud organizations. Once configured, it
3840 applies to all projects and folders in the Google Cloud
3841 organization.
3843 [UpdateSettings][google.logging.v2.ConfigServiceV2.UpdateSettings]
3844 will fail if 1) ``kms_key_name`` is invalid, or 2) the
3845 associated service account does not have the required
3846 ``roles/cloudkms.cryptoKeyEncrypterDecrypter`` role assigned for
3847 the key, or 3) access to the key is disabled. 4) ``location_id``
3848 is not supported by Logging. 5) ``location_id`` violate
3849 OrgPolicy.
3851 See `Enabling CMEK for Log
3852 Router <https://cloud.google.com/logging/docs/routing/managed-encryption>`__
3853 for more information.
3855 .. code-block:: python
3857 # This snippet has been automatically generated and should be regarded as a
3858 # code template only.
3859 # It will require modifications to work:
3860 # - It may require correct/in-range values for request initialization.
3861 # - It may require specifying regional endpoints when creating the service
3862 # client as shown in:
3863 # https://googleapis.dev/python/google-api-core/latest/client_options.html
3864 from google.cloud import logging_v2
3866 def sample_update_settings():
3867 # Create a client
3868 client = logging_v2.ConfigServiceV2Client()
3870 # Initialize request argument(s)
3871 request = logging_v2.UpdateSettingsRequest(
3872 name="name_value",
3873 )
3875 # Make the request
3876 response = client.update_settings(request=request)
3878 # Handle the response
3879 print(response)
3881 Args:
3882 request (Union[google.cloud.logging_v2.types.UpdateSettingsRequest, dict]):
3883 The request object. The parameters to
3884 [UpdateSettings][google.logging.v2.ConfigServiceV2.UpdateSettings].
3886 See `Enabling CMEK for Log
3887 Router <https://cloud.google.com/logging/docs/routing/managed-encryption>`__
3888 for more information.
3889 settings (google.cloud.logging_v2.types.Settings):
3890 Required. The settings to update.
3892 See `Enabling CMEK for Log
3893 Router <https://cloud.google.com/logging/docs/routing/managed-encryption>`__
3894 for more information.
3896 This corresponds to the ``settings`` field
3897 on the ``request`` instance; if ``request`` is provided, this
3898 should not be set.
3899 update_mask (google.protobuf.field_mask_pb2.FieldMask):
3900 Optional. Field mask identifying which fields from
3901 ``settings`` should be updated. A field will be
3902 overwritten if and only if it is in the update mask.
3903 Output only fields cannot be updated.
3905 See [FieldMask][google.protobuf.FieldMask] for more
3906 information.
3908 For example: ``"updateMask=kmsKeyName"``
3910 This corresponds to the ``update_mask`` field
3911 on the ``request`` instance; if ``request`` is provided, this
3912 should not be set.
3913 retry (google.api_core.retry.Retry): Designation of what errors, if any,
3914 should be retried.
3915 timeout (float): The timeout for this request.
3916 metadata (Sequence[Tuple[str, str]]): Strings which should be
3917 sent along with the request as metadata.
3919 Returns:
3920 google.cloud.logging_v2.types.Settings:
3921 Describes the settings associated
3922 with a project, folder, organization,
3923 billing account, or flexible resource.
3925 """
3926 # Create or coerce a protobuf request object.
3927 # Quick check: If we got a request object, we should *not* have
3928 # gotten any keyword arguments that map to the request.
3929 has_flattened_params = any([settings, update_mask])
3930 if request is not None and has_flattened_params:
3931 raise ValueError(
3932 "If the `request` argument is set, then none of "
3933 "the individual field arguments should be set."
3934 )
3936 # Minor optimization to avoid making a copy if the user passes
3937 # in a logging_config.UpdateSettingsRequest.
3938 # There's no risk of modifying the input as we've already verified
3939 # there are no flattened fields.
3940 if not isinstance(request, logging_config.UpdateSettingsRequest):
3941 request = logging_config.UpdateSettingsRequest(request)
3942 # If we have keyword arguments corresponding to fields on the
3943 # request, apply these.
3944 if settings is not None:
3945 request.settings = settings
3946 if update_mask is not None:
3947 request.update_mask = update_mask
3949 # Wrap the RPC method; this adds retry and timeout information,
3950 # and friendly error handling.
3951 rpc = self._transport._wrapped_methods[self._transport.update_settings]
3953 # Certain fields should be provided within the metadata header;
3954 # add these here.
3955 metadata = tuple(metadata) + (
3956 gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
3957 )
3959 # Send the request.
3960 response = rpc(
3961 request,
3962 retry=retry,
3963 timeout=timeout,
3964 metadata=metadata,
3965 )
3967 # Done; return the response.
3968 return response
3970 def copy_log_entries(
3971 self,
3972 request: Optional[Union[logging_config.CopyLogEntriesRequest, dict]] = None,
3973 *,
3974 retry: OptionalRetry = gapic_v1.method.DEFAULT,
3975 timeout: Union[float, object] = gapic_v1.method.DEFAULT,
3976 metadata: Sequence[Tuple[str, str]] = (),
3977 ) -> operation.Operation:
3978 r"""Copies a set of log entries from a log bucket to a
3979 Cloud Storage bucket.
3981 .. code-block:: python
3983 # This snippet has been automatically generated and should be regarded as a
3984 # code template only.
3985 # It will require modifications to work:
3986 # - It may require correct/in-range values for request initialization.
3987 # - It may require specifying regional endpoints when creating the service
3988 # client as shown in:
3989 # https://googleapis.dev/python/google-api-core/latest/client_options.html
3990 from google.cloud import logging_v2
3992 def sample_copy_log_entries():
3993 # Create a client
3994 client = logging_v2.ConfigServiceV2Client()
3996 # Initialize request argument(s)
3997 request = logging_v2.CopyLogEntriesRequest(
3998 name="name_value",
3999 destination="destination_value",
4000 )
4002 # Make the request
4003 operation = client.copy_log_entries(request=request)
4005 print("Waiting for operation to complete...")
4007 response = operation.result()
4009 # Handle the response
4010 print(response)
4012 Args:
4013 request (Union[google.cloud.logging_v2.types.CopyLogEntriesRequest, dict]):
4014 The request object. The parameters to CopyLogEntries.
4015 retry (google.api_core.retry.Retry): Designation of what errors, if any,
4016 should be retried.
4017 timeout (float): The timeout for this request.
4018 metadata (Sequence[Tuple[str, str]]): Strings which should be
4019 sent along with the request as metadata.
4021 Returns:
4022 google.api_core.operation.Operation:
4023 An object representing a long-running operation.
4025 The result type for the operation will be
4026 :class:`google.cloud.logging_v2.types.CopyLogEntriesResponse`
4027 Response type for CopyLogEntries long running
4028 operations.
4030 """
4031 # Create or coerce a protobuf request object.
4032 # Minor optimization to avoid making a copy if the user passes
4033 # in a logging_config.CopyLogEntriesRequest.
4034 # There's no risk of modifying the input as we've already verified
4035 # there are no flattened fields.
4036 if not isinstance(request, logging_config.CopyLogEntriesRequest):
4037 request = logging_config.CopyLogEntriesRequest(request)
4039 # Wrap the RPC method; this adds retry and timeout information,
4040 # and friendly error handling.
4041 rpc = self._transport._wrapped_methods[self._transport.copy_log_entries]
4043 # Send the request.
4044 response = rpc(
4045 request,
4046 retry=retry,
4047 timeout=timeout,
4048 metadata=metadata,
4049 )
4051 # Wrap the response in an operation future.
4052 response = operation.from_gapic(
4053 response,
4054 self._transport.operations_client,
4055 logging_config.CopyLogEntriesResponse,
4056 metadata_type=logging_config.CopyLogEntriesMetadata,
4057 )
4059 # Done; return the response.
4060 return response
4062 def __enter__(self) -> "ConfigServiceV2Client":
4063 return self
4065 def __exit__(self, type, value, traceback):
4066 """Releases underlying transport's resources.
4068 .. warning::
4069 ONLY use as a context manager if the transport is NOT shared
4070 with other clients! Exiting the with block will CLOSE the transport
4071 and may cause errors in other clients!
4072 """
4073 self.transport.close()
4075 def list_operations(
4076 self,
4077 request: Optional[operations_pb2.ListOperationsRequest] = None,
4078 *,
4079 retry: OptionalRetry = gapic_v1.method.DEFAULT,
4080 timeout: Union[float, object] = gapic_v1.method.DEFAULT,
4081 metadata: Sequence[Tuple[str, str]] = (),
4082 ) -> operations_pb2.ListOperationsResponse:
4083 r"""Lists operations that match the specified filter in the request.
4085 Args:
4086 request (:class:`~.operations_pb2.ListOperationsRequest`):
4087 The request object. Request message for
4088 `ListOperations` method.
4089 retry (google.api_core.retry.Retry): Designation of what errors,
4090 if any, should be retried.
4091 timeout (float): The timeout for this request.
4092 metadata (Sequence[Tuple[str, str]]): Strings which should be
4093 sent along with the request as metadata.
4094 Returns:
4095 ~.operations_pb2.ListOperationsResponse:
4096 Response message for ``ListOperations`` method.
4097 """
4098 # Create or coerce a protobuf request object.
4099 # The request isn't a proto-plus wrapped type,
4100 # so it must be constructed via keyword expansion.
4101 if isinstance(request, dict):
4102 request = operations_pb2.ListOperationsRequest(**request)
4104 # Wrap the RPC method; this adds retry and timeout information,
4105 # and friendly error handling.
4106 rpc = gapic_v1.method.wrap_method(
4107 self._transport.list_operations,
4108 default_timeout=None,
4109 client_info=DEFAULT_CLIENT_INFO,
4110 )
4112 # Certain fields should be provided within the metadata header;
4113 # add these here.
4114 metadata = tuple(metadata) + (
4115 gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
4116 )
4118 # Send the request.
4119 response = rpc(
4120 request,
4121 retry=retry,
4122 timeout=timeout,
4123 metadata=metadata,
4124 )
4126 # Done; return the response.
4127 return response
4129 def get_operation(
4130 self,
4131 request: Optional[operations_pb2.GetOperationRequest] = None,
4132 *,
4133 retry: OptionalRetry = gapic_v1.method.DEFAULT,
4134 timeout: Union[float, object] = gapic_v1.method.DEFAULT,
4135 metadata: Sequence[Tuple[str, str]] = (),
4136 ) -> operations_pb2.Operation:
4137 r"""Gets the latest state of a long-running operation.
4139 Args:
4140 request (:class:`~.operations_pb2.GetOperationRequest`):
4141 The request object. Request message for
4142 `GetOperation` method.
4143 retry (google.api_core.retry.Retry): Designation of what errors,
4144 if any, should be retried.
4145 timeout (float): The timeout for this request.
4146 metadata (Sequence[Tuple[str, str]]): Strings which should be
4147 sent along with the request as metadata.
4148 Returns:
4149 ~.operations_pb2.Operation:
4150 An ``Operation`` object.
4151 """
4152 # Create or coerce a protobuf request object.
4153 # The request isn't a proto-plus wrapped type,
4154 # so it must be constructed via keyword expansion.
4155 if isinstance(request, dict):
4156 request = operations_pb2.GetOperationRequest(**request)
4158 # Wrap the RPC method; this adds retry and timeout information,
4159 # and friendly error handling.
4160 rpc = gapic_v1.method.wrap_method(
4161 self._transport.get_operation,
4162 default_timeout=None,
4163 client_info=DEFAULT_CLIENT_INFO,
4164 )
4166 # Certain fields should be provided within the metadata header;
4167 # add these here.
4168 metadata = tuple(metadata) + (
4169 gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
4170 )
4172 # Send the request.
4173 response = rpc(
4174 request,
4175 retry=retry,
4176 timeout=timeout,
4177 metadata=metadata,
4178 )
4180 # Done; return the response.
4181 return response
4183 def cancel_operation(
4184 self,
4185 request: Optional[operations_pb2.CancelOperationRequest] = None,
4186 *,
4187 retry: OptionalRetry = gapic_v1.method.DEFAULT,
4188 timeout: Union[float, object] = gapic_v1.method.DEFAULT,
4189 metadata: Sequence[Tuple[str, str]] = (),
4190 ) -> None:
4191 r"""Starts asynchronous cancellation on a long-running operation.
4193 The server makes a best effort to cancel the operation, but success
4194 is not guaranteed. If the server doesn't support this method, it returns
4195 `google.rpc.Code.UNIMPLEMENTED`.
4197 Args:
4198 request (:class:`~.operations_pb2.CancelOperationRequest`):
4199 The request object. Request message for
4200 `CancelOperation` method.
4201 retry (google.api_core.retry.Retry): Designation of what errors,
4202 if any, should be retried.
4203 timeout (float): The timeout for this request.
4204 metadata (Sequence[Tuple[str, str]]): Strings which should be
4205 sent along with the request as metadata.
4206 Returns:
4207 None
4208 """
4209 # Create or coerce a protobuf request object.
4210 # The request isn't a proto-plus wrapped type,
4211 # so it must be constructed via keyword expansion.
4212 if isinstance(request, dict):
4213 request = operations_pb2.CancelOperationRequest(**request)
4215 # Wrap the RPC method; this adds retry and timeout information,
4216 # and friendly error handling.
4217 rpc = gapic_v1.method.wrap_method(
4218 self._transport.cancel_operation,
4219 default_timeout=None,
4220 client_info=DEFAULT_CLIENT_INFO,
4221 )
4223 # Certain fields should be provided within the metadata header;
4224 # add these here.
4225 metadata = tuple(metadata) + (
4226 gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
4227 )
4229 # Send the request.
4230 rpc(
4231 request,
4232 retry=retry,
4233 timeout=timeout,
4234 metadata=metadata,
4235 )
4238DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo(
4239 gapic_version=package_version.__version__
4240)
4243__all__ = ("ConfigServiceV2Client",)