Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.11/site-packages/google/cloud/logging_v2/services/config_service_v2/async

2461 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

2462 empty messages in your APIs. A typical example is to

2463 use it as the request or the response type of an API

2464 method. For instance:

2465

2466 service Foo {

2467 rpc Bar(google.protobuf.Empty) returns

2468 (google.protobuf.Empty);

2469

2470 }

2471

2472 """

2473 # Create or coerce a protobuf request object.

2474 # - Quick check: If we got a request object, we should *not* have

2475 # gotten any keyword arguments that map to the request.

2476 flattened_params = [name]

2477 has_flattened_params = (

2478 len([param for param in flattened_params if param is not None]) > 0

2479 )

2480 if request is not None and has_flattened_params:

2481 raise ValueError(

2482 "If the `request` argument is set, then none of "

2483 "the individual field arguments should be set."

2484 )

2485

2486 # - Use the request object if provided (there's no risk of modifying the input as

2487 # there are no flattened fields), or create one.

2488 if not isinstance(request, logging_config.DeleteLinkRequest):

2489 request = logging_config.DeleteLinkRequest(request)

2490

2491 # If we have keyword arguments corresponding to fields on the

2492 # request, apply these.

2493 if name is not None:

2494 request.name = name

2495

2496 # Wrap the RPC method; this adds retry and timeout information,

2497 # and friendly error handling.

2498 rpc = self._client._transport._wrapped_methods[

2499 self._client._transport.delete_link

2500 ]

2501

2502 # Certain fields should be provided within the metadata header;

2503 # add these here.

2504 metadata = tuple(metadata) + (

2505 gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),

2506 )

2507

2508 # Validate the universe domain.

2509 self._client._validate_universe_domain()

2510

2511 # Send the request.

2512 response = await rpc(

2513 request,

2514 retry=retry,

2515 timeout=timeout,

2516 metadata=metadata,

2517 )

2518

2519 # Wrap the response in an operation future.

2520 response = operation_async.from_gapic(

2521 response,

2522 self._client._transport.operations_client,

2523 empty_pb2.Empty,

2524 metadata_type=logging_config.LinkMetadata,

2525 )

2526

2527 # Done; return the response.

2528 return response

2529

2530 async def list_links(

2531 self,

2532 request: Optional[Union[logging_config.ListLinksRequest, dict]] = None,

2533 *,

2534 parent: Optional[str] = None,

2535 retry: OptionalRetry = gapic_v1.method.DEFAULT,

2536 timeout: Union[float, object] = gapic_v1.method.DEFAULT,

2537 metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),

2538 ) -> pagers.ListLinksAsyncPager:

2539 r"""Lists links.

2540

2541 .. code-block:: python

2542

2543 # This snippet has been automatically generated and should be regarded as a

2544 # code template only.

2545 # It will require modifications to work:

2546 # - It may require correct/in-range values for request initialization.

2547 # - It may require specifying regional endpoints when creating the service

2548 # client as shown in:

2549 # https://googleapis.dev/python/google-api-core/latest/client_options.html

2550 from google.cloud import logging_v2

2551

2552 async def sample_list_links():

2553 # Create a client

2554 client = logging_v2.ConfigServiceV2AsyncClient()

2555

2556 # Initialize request argument(s)

2557 request = logging_v2.ListLinksRequest(

2558 parent="parent_value",

2559 )

2560

2561 # Make the request

2562 page_result = client.list_links(request=request)

2563

2564 # Handle the response

2565 async for response in page_result:

2566 print(response)

2567

2568 Args:

2569 request (Optional[Union[google.cloud.logging_v2.types.ListLinksRequest, dict]]):

2570 The request object. The parameters to ListLinks.

2571 parent (:class:`str`):

2572 Required. The parent resource whose links are to be

2573 listed:

2574

2575 "projects/[PROJECT_ID]/locations/[LOCATION_ID]/buckets/[BUCKET_ID]/links/"

2576 "organizations/[ORGANIZATION_ID]/locations/[LOCATION_ID]/buckets/[BUCKET_ID]/"

2577 "billingAccounts/[BILLING_ACCOUNT_ID]/locations/[LOCATION_ID]/buckets/[BUCKET_ID]/"

2578 "folders/[FOLDER_ID]/locations/[LOCATION_ID]/buckets/[BUCKET_ID]/

2579

2580 This corresponds to the ``parent`` field

2581 on the ``request`` instance; if ``request`` is provided, this

2582 should not be set.

2583 retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, if any,

2584 should be retried.

2585 timeout (float): The timeout for this request.

2586 metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be

2587 sent along with the request as metadata. Normally, each value must be of type `str`,

2588 but for metadata keys ending with the suffix `-bin`, the corresponding values must

2589 be of type `bytes`.

2590

2591 Returns:

2592 google.cloud.logging_v2.services.config_service_v2.pagers.ListLinksAsyncPager:

2593 The response from ListLinks.

2594

2595 Iterating over this object will yield

2596 results and resolve additional pages

2597 automatically.

2598

2599 """

2600 # Create or coerce a protobuf request object.

2601 # - Quick check: If we got a request object, we should *not* have

2602 # gotten any keyword arguments that map to the request.

2603 flattened_params = [parent]

2604 has_flattened_params = (

2605 len([param for param in flattened_params if param is not None]) > 0

2606 )

2607 if request is not None and has_flattened_params:

2608 raise ValueError(

2609 "If the `request` argument is set, then none of "

2610 "the individual field arguments should be set."

2611 )

2612

2613 # - Use the request object if provided (there's no risk of modifying the input as

2614 # there are no flattened fields), or create one.

2615 if not isinstance(request, logging_config.ListLinksRequest):

2616 request = logging_config.ListLinksRequest(request)

2617

2618 # If we have keyword arguments corresponding to fields on the

2619 # request, apply these.

2620 if parent is not None:

2621 request.parent = parent

2622

2623 # Wrap the RPC method; this adds retry and timeout information,

2624 # and friendly error handling.

2625 rpc = self._client._transport._wrapped_methods[

2626 self._client._transport.list_links

2627 ]

2628

2629 # Certain fields should be provided within the metadata header;

2630 # add these here.

2631 metadata = tuple(metadata) + (

2632 gapic_v1.routing_header.to_grpc_metadata((("parent", request.parent),)),

2633 )

2634

2635 # Validate the universe domain.

2636 self._client._validate_universe_domain()

2637

2638 # Send the request.

2639 response = await rpc(

2640 request,

2641 retry=retry,

2642 timeout=timeout,

2643 metadata=metadata,

2644 )

2645

2646 # This method is paged; wrap the response in a pager, which provides

2647 # an `__aiter__` convenience method.

2648 response = pagers.ListLinksAsyncPager(

2649 method=rpc,

2650 request=request,

2651 response=response,

2652 retry=retry,

2653 timeout=timeout,

2654 metadata=metadata,

2655 )

2656

2657 # Done; return the response.

2658 return response

2659

2660 async def get_link(

2661 self,

2662 request: Optional[Union[logging_config.GetLinkRequest, dict]] = None,

2663 *,

2664 name: Optional[str] = None,

2665 retry: OptionalRetry = gapic_v1.method.DEFAULT,

2666 timeout: Union[float, object] = gapic_v1.method.DEFAULT,

2667 metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),

2668 ) -> logging_config.Link:

2669 r"""Gets a link.

2670

2671 .. code-block:: python

2672

2673 # This snippet has been automatically generated and should be regarded as a

2674 # code template only.

2675 # It will require modifications to work:

2676 # - It may require correct/in-range values for request initialization.

2677 # - It may require specifying regional endpoints when creating the service

2678 # client as shown in:

2679 # https://googleapis.dev/python/google-api-core/latest/client_options.html

2680 from google.cloud import logging_v2

2681

2682 async def sample_get_link():

2683 # Create a client

2684 client = logging_v2.ConfigServiceV2AsyncClient()

2685

2686 # Initialize request argument(s)

2687 request = logging_v2.GetLinkRequest(

2688 name="name_value",

2689 )

2690

2691 # Make the request

2692 response = await client.get_link(request=request)

2693

2694 # Handle the response

2695 print(response)

2696

2697 Args:

2698 request (Optional[Union[google.cloud.logging_v2.types.GetLinkRequest, dict]]):

2699 The request object. The parameters to GetLink.

2700 name (:class:`str`):

2701 Required. The resource name of the link:

2702

2703 "projects/[PROJECT_ID]/locations/[LOCATION_ID]/buckets/[BUCKET_ID]/links/[LINK_ID]"

2704 "organizations/[ORGANIZATION_ID]/locations/[LOCATION_ID]/buckets/[BUCKET_ID]/links/[LINK_ID]"

2705 "billingAccounts/[BILLING_ACCOUNT_ID]/locations/[LOCATION_ID]/buckets/[BUCKET_ID]/links/[LINK_ID]"

2706 "folders/[FOLDER_ID]/locations/[LOCATION_ID]/buckets/[BUCKET_ID]/links/[LINK_ID]

2707

2708 This corresponds to the ``name`` field

2709 on the ``request`` instance; if ``request`` is provided, this

2710 should not be set.

2711 retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, if any,

2712 should be retried.

2713 timeout (float): The timeout for this request.

2714 metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be

2715 sent along with the request as metadata. Normally, each value must be of type `str`,

2716 but for metadata keys ending with the suffix `-bin`, the corresponding values must

2717 be of type `bytes`.

2718

2719 Returns:

2720 google.cloud.logging_v2.types.Link:

2721 Describes a link connected to an

2722 analytics enabled bucket.

2723

2724 """

2725 # Create or coerce a protobuf request object.

2726 # - Quick check: If we got a request object, we should *not* have

2727 # gotten any keyword arguments that map to the request.

2728 flattened_params = [name]

2729 has_flattened_params = (

2730 len([param for param in flattened_params if param is not None]) > 0

2731 )

2732 if request is not None and has_flattened_params:

2733 raise ValueError(

2734 "If the `request` argument is set, then none of "

2735 "the individual field arguments should be set."

2736 )

2737

2738 # - Use the request object if provided (there's no risk of modifying the input as

2739 # there are no flattened fields), or create one.

2740 if not isinstance(request, logging_config.GetLinkRequest):

2741 request = logging_config.GetLinkRequest(request)

2742

2743 # If we have keyword arguments corresponding to fields on the

2744 # request, apply these.

2745 if name is not None:

2746 request.name = name

2747

2748 # Wrap the RPC method; this adds retry and timeout information,

2749 # and friendly error handling.

2750 rpc = self._client._transport._wrapped_methods[self._client._transport.get_link]

2751

2752 # Certain fields should be provided within the metadata header;

2753 # add these here.

2754 metadata = tuple(metadata) + (

2755 gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),

2756 )

2757

2758 # Validate the universe domain.

2759 self._client._validate_universe_domain()

2760

2761 # Send the request.

2762 response = await rpc(

2763 request,

2764 retry=retry,

2765 timeout=timeout,

2766 metadata=metadata,

2767 )

2768

2769 # Done; return the response.

2770 return response

2771

2772 async def list_exclusions(

2773 self,

2774 request: Optional[Union[logging_config.ListExclusionsRequest, dict]] = None,

2775 *,

2776 parent: Optional[str] = None,

2777 retry: OptionalRetry = gapic_v1.method.DEFAULT,

2778 timeout: Union[float, object] = gapic_v1.method.DEFAULT,

2779 metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),

2780 ) -> pagers.ListExclusionsAsyncPager:

2781 r"""Lists all the exclusions on the \_Default sink in a parent

2782 resource.

2783

2784 .. code-block:: python

2785

2786 # This snippet has been automatically generated and should be regarded as a

2787 # code template only.

2788 # It will require modifications to work:

2789 # - It may require correct/in-range values for request initialization.

2790 # - It may require specifying regional endpoints when creating the service

2791 # client as shown in:

2792 # https://googleapis.dev/python/google-api-core/latest/client_options.html

2793 from google.cloud import logging_v2

2794

2795 async def sample_list_exclusions():

2796 # Create a client

2797 client = logging_v2.ConfigServiceV2AsyncClient()

2798

2799 # Initialize request argument(s)

2800 request = logging_v2.ListExclusionsRequest(

2801 parent="parent_value",

2802 )

2803

2804 # Make the request

2805 page_result = client.list_exclusions(request=request)

2806

2807 # Handle the response

2808 async for response in page_result:

2809 print(response)

2810

2811 Args:

2812 request (Optional[Union[google.cloud.logging_v2.types.ListExclusionsRequest, dict]]):

2813 The request object. The parameters to ``ListExclusions``.

2814 parent (:class:`str`):

2815 Required. The parent resource whose exclusions are to be

2816 listed.

2817

2818 ::

2819

2820 "projects/[PROJECT_ID]"

2821 "organizations/[ORGANIZATION_ID]"

2822 "billingAccounts/[BILLING_ACCOUNT_ID]"

2823 "folders/[FOLDER_ID]"

2824

2825 This corresponds to the ``parent`` field

2826 on the ``request`` instance; if ``request`` is provided, this

2827 should not be set.

2828 retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, if any,

2829 should be retried.

2830 timeout (float): The timeout for this request.

2831 metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be

2832 sent along with the request as metadata. Normally, each value must be of type `str`,

2833 but for metadata keys ending with the suffix `-bin`, the corresponding values must

2834 be of type `bytes`.

2835

2836 Returns:

2837 google.cloud.logging_v2.services.config_service_v2.pagers.ListExclusionsAsyncPager:

2838 Result returned from ListExclusions.

2839

2840 Iterating over this object will yield results and

2841 resolve additional pages automatically.

2842

2843 """

2844 # Create or coerce a protobuf request object.

2845 # - Quick check: If we got a request object, we should *not* have

2846 # gotten any keyword arguments that map to the request.

2847 flattened_params = [parent]

2848 has_flattened_params = (

2849 len([param for param in flattened_params if param is not None]) > 0

2850 )

2851 if request is not None and has_flattened_params:

2852 raise ValueError(

2853 "If the `request` argument is set, then none of "

2854 "the individual field arguments should be set."

2855 )

2856

2857 # - Use the request object if provided (there's no risk of modifying the input as

2858 # there are no flattened fields), or create one.

2859 if not isinstance(request, logging_config.ListExclusionsRequest):

2860 request = logging_config.ListExclusionsRequest(request)

2861

2862 # If we have keyword arguments corresponding to fields on the

2863 # request, apply these.

2864 if parent is not None:

2865 request.parent = parent

2866

2867 # Wrap the RPC method; this adds retry and timeout information,

2868 # and friendly error handling.

2869 rpc = self._client._transport._wrapped_methods[

2870 self._client._transport.list_exclusions

2871 ]

2872

2873 # Certain fields should be provided within the metadata header;

2874 # add these here.

2875 metadata = tuple(metadata) + (

2876 gapic_v1.routing_header.to_grpc_metadata((("parent", request.parent),)),

2877 )

2878

2879 # Validate the universe domain.

2880 self._client._validate_universe_domain()

2881

2882 # Send the request.

2883 response = await rpc(

2884 request,

2885 retry=retry,

2886 timeout=timeout,

2887 metadata=metadata,

2888 )

2889

2890 # This method is paged; wrap the response in a pager, which provides

2891 # an `__aiter__` convenience method.

2892 response = pagers.ListExclusionsAsyncPager(

2893 method=rpc,

2894 request=request,

2895 response=response,

2896 retry=retry,

2897 timeout=timeout,

2898 metadata=metadata,

2899 )

2900

2901 # Done; return the response.

2902 return response

2903

2904 async def get_exclusion(

2905 self,

2906 request: Optional[Union[logging_config.GetExclusionRequest, dict]] = None,

2907 *,

2908 name: Optional[str] = None,

2909 retry: OptionalRetry = gapic_v1.method.DEFAULT,

2910 timeout: Union[float, object] = gapic_v1.method.DEFAULT,

2911 metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),

2912 ) -> logging_config.LogExclusion:

2913 r"""Gets the description of an exclusion in the \_Default sink.

2914

2915 .. code-block:: python

2916

2917 # This snippet has been automatically generated and should be regarded as a

2918 # code template only.

2919 # It will require modifications to work:

2920 # - It may require correct/in-range values for request initialization.

2921 # - It may require specifying regional endpoints when creating the service

2922 # client as shown in:

2923 # https://googleapis.dev/python/google-api-core/latest/client_options.html

2924 from google.cloud import logging_v2

2925

2926 async def sample_get_exclusion():

2927 # Create a client

2928 client = logging_v2.ConfigServiceV2AsyncClient()

2929

2930 # Initialize request argument(s)

2931 request = logging_v2.GetExclusionRequest(

2932 name="name_value",

2933 )

2934

2935 # Make the request

2936 response = await client.get_exclusion(request=request)

2937

2938 # Handle the response

2939 print(response)

2940

2941 Args:

2942 request (Optional[Union[google.cloud.logging_v2.types.GetExclusionRequest, dict]]):

2943 The request object. The parameters to ``GetExclusion``.

2944 name (:class:`str`):

2945 Required. The resource name of an existing exclusion:

2946

2947 ::

2948

2949 "projects/[PROJECT_ID]/exclusions/[EXCLUSION_ID]"

2950 "organizations/[ORGANIZATION_ID]/exclusions/[EXCLUSION_ID]"

2951 "billingAccounts/[BILLING_ACCOUNT_ID]/exclusions/[EXCLUSION_ID]"

2952 "folders/[FOLDER_ID]/exclusions/[EXCLUSION_ID]"

2953

2954 For example:

2955

2956 ``"projects/my-project/exclusions/my-exclusion"``

2957

2958 This corresponds to the ``name`` field

2959 on the ``request`` instance; if ``request`` is provided, this

2960 should not be set.

2961 retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, if any,

2962 should be retried.

2963 timeout (float): The timeout for this request.

2964 metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be

2965 sent along with the request as metadata. Normally, each value must be of type `str`,

2966 but for metadata keys ending with the suffix `-bin`, the corresponding values must

2967 be of type `bytes`.

2968

2969 Returns:

2970 google.cloud.logging_v2.types.LogExclusion:

2971 Specifies a set of log entries that are filtered out by a sink. If

2972 your Google Cloud resource receives a large volume of

2973 log entries, you can use exclusions to reduce your

2974 chargeable logs. Note that exclusions on

2975 organization-level and folder-level sinks don't apply

2976 to child resources. Note also that you cannot modify

2977 the Required sink or exclude logs from it.

2978

2979 """

2980 # Create or coerce a protobuf request object.

2981 # - Quick check: If we got a request object, we should *not* have

2982 # gotten any keyword arguments that map to the request.

2983 flattened_params = [name]

2984 has_flattened_params = (

2985 len([param for param in flattened_params if param is not None]) > 0

2986 )

2987 if request is not None and has_flattened_params:

2988 raise ValueError(

2989 "If the `request` argument is set, then none of "

2990 "the individual field arguments should be set."

2991 )

2992

2993 # - Use the request object if provided (there's no risk of modifying the input as

2994 # there are no flattened fields), or create one.

2995 if not isinstance(request, logging_config.GetExclusionRequest):

2996 request = logging_config.GetExclusionRequest(request)

2997

2998 # If we have keyword arguments corresponding to fields on the

2999 # request, apply these.

3000 if name is not None:

3001 request.name = name

3002

3003 # Wrap the RPC method; this adds retry and timeout information,

3004 # and friendly error handling.

3005 rpc = self._client._transport._wrapped_methods[

3006 self._client._transport.get_exclusion

3007 ]

3008

3009 # Certain fields should be provided within the metadata header;

3010 # add these here.

3011 metadata = tuple(metadata) + (

3012 gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),

3013 )

3014

3015 # Validate the universe domain.

3016 self._client._validate_universe_domain()

3017

3018 # Send the request.

3019 response = await rpc(

3020 request,

3021 retry=retry,

3022 timeout=timeout,

3023 metadata=metadata,

3024 )

3025

3026 # Done; return the response.

3027 return response

3028

3029 async def create_exclusion(

3030 self,

3031 request: Optional[Union[logging_config.CreateExclusionRequest, dict]] = None,

3032 *,

3033 parent: Optional[str] = None,

3034 exclusion: Optional[logging_config.LogExclusion] = None,

3035 retry: OptionalRetry = gapic_v1.method.DEFAULT,

3036 timeout: Union[float, object] = gapic_v1.method.DEFAULT,

3037 metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),

3038 ) -> logging_config.LogExclusion:

3039 r"""Creates a new exclusion in the \_Default sink in a specified

3040 parent resource. Only log entries belonging to that resource can

3041 be excluded. You can have up to 10 exclusions in a resource.

3042

3043 .. code-block:: python

3044

3045 # This snippet has been automatically generated and should be regarded as a

3046 # code template only.

3047 # It will require modifications to work:

3048 # - It may require correct/in-range values for request initialization.

3049 # - It may require specifying regional endpoints when creating the service

3050 # client as shown in:

3051 # https://googleapis.dev/python/google-api-core/latest/client_options.html

3052 from google.cloud import logging_v2

3053

3054 async def sample_create_exclusion():

3055 # Create a client

3056 client = logging_v2.ConfigServiceV2AsyncClient()

3057

3058 # Initialize request argument(s)

3059 exclusion = logging_v2.LogExclusion()

3060 exclusion.name = "name_value"

3061 exclusion.filter = "filter_value"

3062

3063 request = logging_v2.CreateExclusionRequest(

3064 parent="parent_value",

3065 exclusion=exclusion,

3066 )

3067

3068 # Make the request

3069 response = await client.create_exclusion(request=request)

3070

3071 # Handle the response

3072 print(response)

3073

3074 Args:

3075 request (Optional[Union[google.cloud.logging_v2.types.CreateExclusionRequest, dict]]):

3076 The request object. The parameters to ``CreateExclusion``.

3077 parent (:class:`str`):

3078 Required. The parent resource in which to create the

3079 exclusion:

3080

3081 ::

3082

3083 "projects/[PROJECT_ID]"

3084 "organizations/[ORGANIZATION_ID]"

3085 "billingAccounts/[BILLING_ACCOUNT_ID]"

3086 "folders/[FOLDER_ID]"

3087

3088 For examples:

3089

3090 ``"projects/my-logging-project"``

3091 ``"organizations/123456789"``

3092

3093 This corresponds to the ``parent`` field

3094 on the ``request`` instance; if ``request`` is provided, this

3095 should not be set.

3096 exclusion (:class:`google.cloud.logging_v2.types.LogExclusion`):

3097 Required. The new exclusion, whose ``name`` parameter is

3098 an exclusion name that is not already used in the parent

3099 resource.

3100

3101 This corresponds to the ``exclusion`` field

3102 on the ``request`` instance; if ``request`` is provided, this

3103 should not be set.

3104 retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, if any,

3105 should be retried.

3106 timeout (float): The timeout for this request.

3107 metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be

3108 sent along with the request as metadata. Normally, each value must be of type `str`,

3109 but for metadata keys ending with the suffix `-bin`, the corresponding values must

3110 be of type `bytes`.

3111

3112 Returns:

3113 google.cloud.logging_v2.types.LogExclusion:

3114 Specifies a set of log entries that are filtered out by a sink. If

3115 your Google Cloud resource receives a large volume of

3116 log entries, you can use exclusions to reduce your

3117 chargeable logs. Note that exclusions on

3118 organization-level and folder-level sinks don't apply

3119 to child resources. Note also that you cannot modify

3120 the Required sink or exclude logs from it.

3121

3122 """

3123 # Create or coerce a protobuf request object.

3124 # - Quick check: If we got a request object, we should *not* have

3125 # gotten any keyword arguments that map to the request.

3126 flattened_params = [parent, exclusion]

3127 has_flattened_params = (

3128 len([param for param in flattened_params if param is not None]) > 0

3129 )

3130 if request is not None and has_flattened_params:

3131 raise ValueError(

3132 "If the `request` argument is set, then none of "

3133 "the individual field arguments should be set."

3134 )

3135

3136 # - Use the request object if provided (there's no risk of modifying the input as

3137 # there are no flattened fields), or create one.

3138 if not isinstance(request, logging_config.CreateExclusionRequest):

3139 request = logging_config.CreateExclusionRequest(request)

3140

3141 # If we have keyword arguments corresponding to fields on the

3142 # request, apply these.

3143 if parent is not None:

3144 request.parent = parent

3145 if exclusion is not None:

3146 request.exclusion = exclusion

3147

3148 # Wrap the RPC method; this adds retry and timeout information,

3149 # and friendly error handling.

3150 rpc = self._client._transport._wrapped_methods[

3151 self._client._transport.create_exclusion

3152 ]

3153

3154 # Certain fields should be provided within the metadata header;

3155 # add these here.

3156 metadata = tuple(metadata) + (

3157 gapic_v1.routing_header.to_grpc_metadata((("parent", request.parent),)),

3158 )

3159

3160 # Validate the universe domain.

3161 self._client._validate_universe_domain()

3162

3163 # Send the request.

3164 response = await rpc(

3165 request,

3166 retry=retry,

3167 timeout=timeout,

3168 metadata=metadata,

3169 )

3170

3171 # Done; return the response.

3172 return response

3173

3174 async def update_exclusion(

3175 self,

3176 request: Optional[Union[logging_config.UpdateExclusionRequest, dict]] = None,

3177 *,

3178 name: Optional[str] = None,

3179 exclusion: Optional[logging_config.LogExclusion] = None,

3180 update_mask: Optional[field_mask_pb2.FieldMask] = None,

3181 retry: OptionalRetry = gapic_v1.method.DEFAULT,

3182 timeout: Union[float, object] = gapic_v1.method.DEFAULT,

3183 metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),

3184 ) -> logging_config.LogExclusion:

3185 r"""Changes one or more properties of an existing exclusion in the

3186 \_Default sink.

3187

3188 .. code-block:: python

3189

3190 # This snippet has been automatically generated and should be regarded as a

3191 # code template only.

3192 # It will require modifications to work:

3193 # - It may require correct/in-range values for request initialization.

3194 # - It may require specifying regional endpoints when creating the service

3195 # client as shown in:

3196 # https://googleapis.dev/python/google-api-core/latest/client_options.html

3197 from google.cloud import logging_v2

3198

3199 async def sample_update_exclusion():

3200 # Create a client

3201 client = logging_v2.ConfigServiceV2AsyncClient()

3202

3203 # Initialize request argument(s)

3204 exclusion = logging_v2.LogExclusion()

3205 exclusion.name = "name_value"

3206 exclusion.filter = "filter_value"

3207

3208 request = logging_v2.UpdateExclusionRequest(

3209 name="name_value",

3210 exclusion=exclusion,

3211 )

3212

3213 # Make the request

3214 response = await client.update_exclusion(request=request)

3215

3216 # Handle the response

3217 print(response)

3218

3219 Args:

3220 request (Optional[Union[google.cloud.logging_v2.types.UpdateExclusionRequest, dict]]):

3221 The request object. The parameters to ``UpdateExclusion``.

3222 name (:class:`str`):

3223 Required. The resource name of the exclusion to update:

3224

3225 ::

3226

3227 "projects/[PROJECT_ID]/exclusions/[EXCLUSION_ID]"

3228 "organizations/[ORGANIZATION_ID]/exclusions/[EXCLUSION_ID]"

3229 "billingAccounts/[BILLING_ACCOUNT_ID]/exclusions/[EXCLUSION_ID]"

3230 "folders/[FOLDER_ID]/exclusions/[EXCLUSION_ID]"

3231

3232 For example:

3233

3234 ``"projects/my-project/exclusions/my-exclusion"``

3235

3236 This corresponds to the ``name`` field

3237 on the ``request`` instance; if ``request`` is provided, this

3238 should not be set.

3239 exclusion (:class:`google.cloud.logging_v2.types.LogExclusion`):

3240 Required. New values for the existing exclusion. Only

3241 the fields specified in ``update_mask`` are relevant.

3242

3243 This corresponds to the ``exclusion`` field

3244 on the ``request`` instance; if ``request`` is provided, this

3245 should not be set.

3246 update_mask (:class:`google.protobuf.field_mask_pb2.FieldMask`):

3247 Required. A non-empty list of fields to change in the

3248 existing exclusion. New values for the fields are taken

3249 from the corresponding fields in the

3250 [LogExclusion][google.logging.v2.LogExclusion] included

3251 in this request. Fields not mentioned in ``update_mask``

3252 are not changed and are ignored in the request.

3253

3254 For example, to change the filter and description of an

3255 exclusion, specify an ``update_mask`` of

3256 ``"filter,description"``.

3257

3258 This corresponds to the ``update_mask`` field

3259 on the ``request`` instance; if ``request`` is provided, this

3260 should not be set.

3261 retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, if any,

3262 should be retried.

3263 timeout (float): The timeout for this request.

3264 metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be

3265 sent along with the request as metadata. Normally, each value must be of type `str`,

3266 but for metadata keys ending with the suffix `-bin`, the corresponding values must

3267 be of type `bytes`.

3268

3269 Returns:

3270 google.cloud.logging_v2.types.LogExclusion:

3271 Specifies a set of log entries that are filtered out by a sink. If

3272 your Google Cloud resource receives a large volume of

3273 log entries, you can use exclusions to reduce your

3274 chargeable logs. Note that exclusions on

3275 organization-level and folder-level sinks don't apply

3276 to child resources. Note also that you cannot modify

3277 the Required sink or exclude logs from it.

3278

3279 """

3280 # Create or coerce a protobuf request object.

3281 # - Quick check: If we got a request object, we should *not* have

3282 # gotten any keyword arguments that map to the request.

3283 flattened_params = [name, exclusion, update_mask]

3284 has_flattened_params = (

3285 len([param for param in flattened_params if param is not None]) > 0

3286 )

3287 if request is not None and has_flattened_params:

3288 raise ValueError(

3289 "If the `request` argument is set, then none of "

3290 "the individual field arguments should be set."

3291 )

3292

3293 # - Use the request object if provided (there's no risk of modifying the input as

3294 # there are no flattened fields), or create one.

3295 if not isinstance(request, logging_config.UpdateExclusionRequest):

3296 request = logging_config.UpdateExclusionRequest(request)

3297

3298 # If we have keyword arguments corresponding to fields on the

3299 # request, apply these.

3300 if name is not None:

3301 request.name = name

3302 if exclusion is not None:

3303 request.exclusion = exclusion

3304 if update_mask is not None:

3305 request.update_mask = update_mask

3306

3307 # Wrap the RPC method; this adds retry and timeout information,

3308 # and friendly error handling.

3309 rpc = self._client._transport._wrapped_methods[

3310 self._client._transport.update_exclusion

3311 ]

3312

3313 # Certain fields should be provided within the metadata header;

3314 # add these here.

3315 metadata = tuple(metadata) + (

3316 gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),

3317 )

3318

3319 # Validate the universe domain.

3320 self._client._validate_universe_domain()

3321

3322 # Send the request.

3323 response = await rpc(

3324 request,

3325 retry=retry,

3326 timeout=timeout,

3327 metadata=metadata,

3328 )

3329

3330 # Done; return the response.

3331 return response

3332

3333 async def delete_exclusion(

3334 self,

3335 request: Optional[Union[logging_config.DeleteExclusionRequest, dict]] = None,

3336 *,

3337 name: Optional[str] = None,

3338 retry: OptionalRetry = gapic_v1.method.DEFAULT,

3339 timeout: Union[float, object] = gapic_v1.method.DEFAULT,

3340 metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),

3341 ) -> None:

3342 r"""Deletes an exclusion in the \_Default sink.

3343

3344 .. code-block:: python

3345

3346 # This snippet has been automatically generated and should be regarded as a

3347 # code template only.

3348 # It will require modifications to work:

3349 # - It may require correct/in-range values for request initialization.

3350 # - It may require specifying regional endpoints when creating the service

3351 # client as shown in:

3352 # https://googleapis.dev/python/google-api-core/latest/client_options.html

3353 from google.cloud import logging_v2

3354

3355 async def sample_delete_exclusion():

3356 # Create a client

3357 client = logging_v2.ConfigServiceV2AsyncClient()

3358

3359 # Initialize request argument(s)

3360 request = logging_v2.DeleteExclusionRequest(

3361 name="name_value",

3362 )

3363

3364 # Make the request

3365 await client.delete_exclusion(request=request)

3366

3367 Args:

3368 request (Optional[Union[google.cloud.logging_v2.types.DeleteExclusionRequest, dict]]):

3369 The request object. The parameters to ``DeleteExclusion``.

3370 name (:class:`str`):

3371 Required. The resource name of an existing exclusion to

3372 delete:

3373

3374 ::

3375

3376 "projects/[PROJECT_ID]/exclusions/[EXCLUSION_ID]"

3377 "organizations/[ORGANIZATION_ID]/exclusions/[EXCLUSION_ID]"

3378 "billingAccounts/[BILLING_ACCOUNT_ID]/exclusions/[EXCLUSION_ID]"

3379 "folders/[FOLDER_ID]/exclusions/[EXCLUSION_ID]"

3380

3381 For example:

3382

3383 ``"projects/my-project/exclusions/my-exclusion"``

3384

3385 This corresponds to the ``name`` field

3386 on the ``request`` instance; if ``request`` is provided, this

3387 should not be set.

3388 retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, if any,

3389 should be retried.

3390 timeout (float): The timeout for this request.

3391 metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be

3392 sent along with the request as metadata. Normally, each value must be of type `str`,

3393 but for metadata keys ending with the suffix `-bin`, the corresponding values must

3394 be of type `bytes`.

3395 """

3396 # Create or coerce a protobuf request object.

3397 # - Quick check: If we got a request object, we should *not* have

3398 # gotten any keyword arguments that map to the request.

3399 flattened_params = [name]

3400 has_flattened_params = (

3401 len([param for param in flattened_params if param is not None]) > 0

3402 )

3403 if request is not None and has_flattened_params:

3404 raise ValueError(

3405 "If the `request` argument is set, then none of "

3406 "the individual field arguments should be set."

3407 )

3408

3409 # - Use the request object if provided (there's no risk of modifying the input as

3410 # there are no flattened fields), or create one.

3411 if not isinstance(request, logging_config.DeleteExclusionRequest):

3412 request = logging_config.DeleteExclusionRequest(request)

3413

3414 # If we have keyword arguments corresponding to fields on the

3415 # request, apply these.

3416 if name is not None:

3417 request.name = name

3418

3419 # Wrap the RPC method; this adds retry and timeout information,

3420 # and friendly error handling.

3421 rpc = self._client._transport._wrapped_methods[

3422 self._client._transport.delete_exclusion

3423 ]

3424

3425 # Certain fields should be provided within the metadata header;

3426 # add these here.

3427 metadata = tuple(metadata) + (

3428 gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),

3429 )

3430

3431 # Validate the universe domain.

3432 self._client._validate_universe_domain()

3433

3434 # Send the request.

3435 await rpc(

3436 request,

3437 retry=retry,

3438 timeout=timeout,

3439 metadata=metadata,

3440 )

3441

3442 async def get_cmek_settings(

3443 self,

3444 request: Optional[Union[logging_config.GetCmekSettingsRequest, dict]] = None,

3445 *,

3446 retry: OptionalRetry = gapic_v1.method.DEFAULT,

3447 timeout: Union[float, object] = gapic_v1.method.DEFAULT,

3448 metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),

3449 ) -> logging_config.CmekSettings:

3450 r"""Gets the Logging CMEK settings for the given resource.

3451

3452 Note: CMEK for the Log Router can be configured for Google Cloud

3453 projects, folders, organizations and billing accounts. Once

3454 configured for an organization, it applies to all projects and

3455 folders in the Google Cloud organization.

3456

3457 See `Enabling CMEK for Log

3458 Router <https://cloud.google.com/logging/docs/routing/managed-encryption>`__

3459 for more information.

3460

3461 .. code-block:: python

3462

3463 # This snippet has been automatically generated and should be regarded as a

3464 # code template only.

3465 # It will require modifications to work:

3466 # - It may require correct/in-range values for request initialization.

3467 # - It may require specifying regional endpoints when creating the service

3468 # client as shown in:

3469 # https://googleapis.dev/python/google-api-core/latest/client_options.html

3470 from google.cloud import logging_v2

3471

3472 async def sample_get_cmek_settings():

3473 # Create a client

3474 client = logging_v2.ConfigServiceV2AsyncClient()

3475

3476 # Initialize request argument(s)

3477 request = logging_v2.GetCmekSettingsRequest(

3478 name="name_value",

3479 )

3480

3481 # Make the request

3482 response = await client.get_cmek_settings(request=request)

3483

3484 # Handle the response

3485 print(response)

3486

3487 Args:

3488 request (Optional[Union[google.cloud.logging_v2.types.GetCmekSettingsRequest, dict]]):

3489 The request object. The parameters to

3490 [GetCmekSettings][google.logging.v2.ConfigServiceV2.GetCmekSettings].

3491

3492 See `Enabling CMEK for Log

3493 Router <https://cloud.google.com/logging/docs/routing/managed-encryption>`__

3494 for more information.

3495 retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, if any,

3496 should be retried.

3497 timeout (float): The timeout for this request.

3498 metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be

3499 sent along with the request as metadata. Normally, each value must be of type `str`,

3500 but for metadata keys ending with the suffix `-bin`, the corresponding values must

3501 be of type `bytes`.

3502

3503 Returns:

3504 google.cloud.logging_v2.types.CmekSettings:

3505 Describes the customer-managed encryption key (CMEK) settings associated with

3506 a project, folder, organization, billing account, or

3507 flexible resource.

3508

3509 Note: CMEK for the Log Router can currently only be

3510 configured for Google Cloud organizations. Once

3511 configured, it applies to all projects and folders in

3512 the Google Cloud organization.

3513

3514 See [Enabling CMEK for Log

3515 Router](https://cloud.google.com/logging/docs/routing/managed-encryption)

3516 for more information.

3517

3518 """

3519 # Create or coerce a protobuf request object.

3520 # - Use the request object if provided (there's no risk of modifying the input as

3521 # there are no flattened fields), or create one.

3522 if not isinstance(request, logging_config.GetCmekSettingsRequest):

3523 request = logging_config.GetCmekSettingsRequest(request)

3524

3525 # Wrap the RPC method; this adds retry and timeout information,

3526 # and friendly error handling.

3527 rpc = self._client._transport._wrapped_methods[

3528 self._client._transport.get_cmek_settings

3529 ]

3530

3531 # Certain fields should be provided within the metadata header;

3532 # add these here.

3533 metadata = tuple(metadata) + (

3534 gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),

3535 )

3536

3537 # Validate the universe domain.

3538 self._client._validate_universe_domain()

3539

3540 # Send the request.

3541 response = await rpc(

3542 request,

3543 retry=retry,

3544 timeout=timeout,

3545 metadata=metadata,

3546 )

3547

3548 # Done; return the response.

3549 return response

3550

3551 async def update_cmek_settings(

3552 self,

3553 request: Optional[Union[logging_config.UpdateCmekSettingsRequest, dict]] = None,

3554 *,

3555 retry: OptionalRetry = gapic_v1.method.DEFAULT,

3556 timeout: Union[float, object] = gapic_v1.method.DEFAULT,

3557 metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),

3558 ) -> logging_config.CmekSettings:

3559 r"""Updates the Log Router CMEK settings for the given resource.

3560

3561 Note: CMEK for the Log Router can currently only be configured

3562 for Google Cloud organizations. Once configured, it applies to

3563 all projects and folders in the Google Cloud organization.

3564

3565 [UpdateCmekSettings][google.logging.v2.ConfigServiceV2.UpdateCmekSettings]

3566 will fail if 1) ``kms_key_name`` is invalid, or 2) the

3567 associated service account does not have the required

3568 ``roles/cloudkms.cryptoKeyEncrypterDecrypter`` role assigned for

3569 the key, or 3) access to the key is disabled.

3570

3571 See `Enabling CMEK for Log

3572 Router <https://cloud.google.com/logging/docs/routing/managed-encryption>`__

3573 for more information.

3574

3575 .. code-block:: python

3576

3577 # This snippet has been automatically generated and should be regarded as a

3578 # code template only.

3579 # It will require modifications to work:

3580 # - It may require correct/in-range values for request initialization.

3581 # - It may require specifying regional endpoints when creating the service

3582 # client as shown in:

3583 # https://googleapis.dev/python/google-api-core/latest/client_options.html

3584 from google.cloud import logging_v2

3585

3586 async def sample_update_cmek_settings():

3587 # Create a client

3588 client = logging_v2.ConfigServiceV2AsyncClient()

3589

3590 # Initialize request argument(s)

3591 request = logging_v2.UpdateCmekSettingsRequest(

3592 name="name_value",

3593 )

3594

3595 # Make the request

3596 response = await client.update_cmek_settings(request=request)

3597

3598 # Handle the response

3599 print(response)

3600

3601 Args:

3602 request (Optional[Union[google.cloud.logging_v2.types.UpdateCmekSettingsRequest, dict]]):

3603 The request object. The parameters to

3604 [UpdateCmekSettings][google.logging.v2.ConfigServiceV2.UpdateCmekSettings].

3605

3606 See `Enabling CMEK for Log

3607 Router <https://cloud.google.com/logging/docs/routing/managed-encryption>`__

3608 for more information.

3609 retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, if any,

3610 should be retried.

3611 timeout (float): The timeout for this request.

3612 metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be

3613 sent along with the request as metadata. Normally, each value must be of type `str`,

3614 but for metadata keys ending with the suffix `-bin`, the corresponding values must

3615 be of type `bytes`.

3616

3617 Returns:

3618 google.cloud.logging_v2.types.CmekSettings:

3619 Describes the customer-managed encryption key (CMEK) settings associated with

3620 a project, folder, organization, billing account, or

3621 flexible resource.

3622

3623 Note: CMEK for the Log Router can currently only be

3624 configured for Google Cloud organizations. Once

3625 configured, it applies to all projects and folders in

3626 the Google Cloud organization.

3627

3628 See [Enabling CMEK for Log

3629 Router](https://cloud.google.com/logging/docs/routing/managed-encryption)

3630 for more information.

3631

3632 """

3633 # Create or coerce a protobuf request object.

3634 # - Use the request object if provided (there's no risk of modifying the input as

3635 # there are no flattened fields), or create one.

3636 if not isinstance(request, logging_config.UpdateCmekSettingsRequest):

3637 request = logging_config.UpdateCmekSettingsRequest(request)

3638

3639 # Wrap the RPC method; this adds retry and timeout information,

3640 # and friendly error handling.

3641 rpc = self._client._transport._wrapped_methods[

3642 self._client._transport.update_cmek_settings

3643 ]

3644

3645 # Certain fields should be provided within the metadata header;

3646 # add these here.

3647 metadata = tuple(metadata) + (

3648 gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),

3649 )

3650

3651 # Validate the universe domain.

3652 self._client._validate_universe_domain()

3653

3654 # Send the request.

3655 response = await rpc(

3656 request,

3657 retry=retry,

3658 timeout=timeout,

3659 metadata=metadata,

3660 )

3661

3662 # Done; return the response.

3663 return response

3664

3665 async def get_settings(

3666 self,

3667 request: Optional[Union[logging_config.GetSettingsRequest, dict]] = None,

3668 *,

3669 name: Optional[str] = None,

3670 retry: OptionalRetry = gapic_v1.method.DEFAULT,

3671 timeout: Union[float, object] = gapic_v1.method.DEFAULT,

3672 metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),

3673 ) -> logging_config.Settings:

3674 r"""Gets the Log Router settings for the given resource.

3675

3676 Note: Settings for the Log Router can be get for Google Cloud

3677 projects, folders, organizations and billing accounts. Currently

3678 it can only be configured for organizations. Once configured for

3679 an organization, it applies to all projects and folders in the

3680 Google Cloud organization.

3681

3682 See `Enabling CMEK for Log

3683 Router <https://cloud.google.com/logging/docs/routing/managed-encryption>`__

3684 for more information.

3685

3686 .. code-block:: python

3687

3688 # This snippet has been automatically generated and should be regarded as a

3689 # code template only.

3690 # It will require modifications to work:

3691 # - It may require correct/in-range values for request initialization.

3692 # - It may require specifying regional endpoints when creating the service

3693 # client as shown in:

3694 # https://googleapis.dev/python/google-api-core/latest/client_options.html

3695 from google.cloud import logging_v2

3696

3697 async def sample_get_settings():

3698 # Create a client

3699 client = logging_v2.ConfigServiceV2AsyncClient()

3700

3701 # Initialize request argument(s)

3702 request = logging_v2.GetSettingsRequest(

3703 name="name_value",

3704 )

3705

3706 # Make the request

3707 response = await client.get_settings(request=request)

3708

3709 # Handle the response

3710 print(response)

3711

3712 Args:

3713 request (Optional[Union[google.cloud.logging_v2.types.GetSettingsRequest, dict]]):

3714 The request object. The parameters to

3715 [GetSettings][google.logging.v2.ConfigServiceV2.GetSettings].

3716

3717 See `Enabling CMEK for Log

3718 Router <https://cloud.google.com/logging/docs/routing/managed-encryption>`__

3719 for more information.

3720 name (:class:`str`):

3721 Required. The resource for which to retrieve settings.

3722

3723 ::

3724

3725 "projects/[PROJECT_ID]/settings"

3726 "organizations/[ORGANIZATION_ID]/settings"

3727 "billingAccounts/[BILLING_ACCOUNT_ID]/settings"

3728 "folders/[FOLDER_ID]/settings"

3729

3730 For example:

3731

3732 ``"organizations/12345/settings"``

3733

3734 Note: Settings for the Log Router can be get for Google

3735 Cloud projects, folders, organizations and billing

3736 accounts. Currently it can only be configured for

3737 organizations. Once configured for an organization, it

3738 applies to all projects and folders in the Google Cloud

3739 organization.

3740

3741 This corresponds to the ``name`` field

3742 on the ``request`` instance; if ``request`` is provided, this

3743 should not be set.

3744 retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, if any,

3745 should be retried.

3746 timeout (float): The timeout for this request.

3747 metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be

3748 sent along with the request as metadata. Normally, each value must be of type `str`,

3749 but for metadata keys ending with the suffix `-bin`, the corresponding values must

3750 be of type `bytes`.

3751

3752 Returns:

3753 google.cloud.logging_v2.types.Settings:

3754 Describes the settings associated

3755 with a project, folder, organization,

3756 billing account, or flexible resource.

3757

3758 """

3759 # Create or coerce a protobuf request object.

3760 # - Quick check: If we got a request object, we should *not* have

3761 # gotten any keyword arguments that map to the request.

3762 flattened_params = [name]

3763 has_flattened_params = (

3764 len([param for param in flattened_params if param is not None]) > 0

3765 )

3766 if request is not None and has_flattened_params:

3767 raise ValueError(

3768 "If the `request` argument is set, then none of "

3769 "the individual field arguments should be set."

3770 )

3771

3772 # - Use the request object if provided (there's no risk of modifying the input as

3773 # there are no flattened fields), or create one.

3774 if not isinstance(request, logging_config.GetSettingsRequest):

3775 request = logging_config.GetSettingsRequest(request)

3776

3777 # If we have keyword arguments corresponding to fields on the

3778 # request, apply these.

3779 if name is not None:

3780 request.name = name

3781

3782 # Wrap the RPC method; this adds retry and timeout information,

3783 # and friendly error handling.

3784 rpc = self._client._transport._wrapped_methods[

3785 self._client._transport.get_settings

3786 ]

3787

3788 # Certain fields should be provided within the metadata header;

3789 # add these here.

3790 metadata = tuple(metadata) + (

3791 gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),

3792 )

3793

3794 # Validate the universe domain.

3795 self._client._validate_universe_domain()

3796

3797 # Send the request.

3798 response = await rpc(

3799 request,

3800 retry=retry,

3801 timeout=timeout,

3802 metadata=metadata,

3803 )

3804

3805 # Done; return the response.

3806 return response

3807

3808 async def update_settings(

3809 self,

3810 request: Optional[Union[logging_config.UpdateSettingsRequest, dict]] = None,

3811 *,

3812 settings: Optional[logging_config.Settings] = None,

3813 update_mask: Optional[field_mask_pb2.FieldMask] = None,

3814 retry: OptionalRetry = gapic_v1.method.DEFAULT,

3815 timeout: Union[float, object] = gapic_v1.method.DEFAULT,

3816 metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),

3817 ) -> logging_config.Settings:

3818 r"""Updates the Log Router settings for the given resource.

3819

3820 Note: Settings for the Log Router can currently only be

3821 configured for Google Cloud organizations. Once configured, it

3822 applies to all projects and folders in the Google Cloud

3823 organization.

3824

3825 [UpdateSettings][google.logging.v2.ConfigServiceV2.UpdateSettings]

3826 will fail if 1) ``kms_key_name`` is invalid, or 2) the

3827 associated service account does not have the required

3828 ``roles/cloudkms.cryptoKeyEncrypterDecrypter`` role assigned for

3829 the key, or 3) access to the key is disabled. 4) ``location_id``

3830 is not supported by Logging. 5) ``location_id`` violate

3831 OrgPolicy.

3832

3833 See `Enabling CMEK for Log

3834 Router <https://cloud.google.com/logging/docs/routing/managed-encryption>`__

3835 for more information.

3836

3837 .. code-block:: python

3838

3839 # This snippet has been automatically generated and should be regarded as a

3840 # code template only.

3841 # It will require modifications to work:

3842 # - It may require correct/in-range values for request initialization.

3843 # - It may require specifying regional endpoints when creating the service

3844 # client as shown in:

3845 # https://googleapis.dev/python/google-api-core/latest/client_options.html

3846 from google.cloud import logging_v2

3847

3848 async def sample_update_settings():

3849 # Create a client

3850 client = logging_v2.ConfigServiceV2AsyncClient()

3851

3852 # Initialize request argument(s)

3853 request = logging_v2.UpdateSettingsRequest(

3854 name="name_value",

3855 )

3856

3857 # Make the request

3858 response = await client.update_settings(request=request)

3859

3860 # Handle the response

3861 print(response)

3862

3863 Args:

3864 request (Optional[Union[google.cloud.logging_v2.types.UpdateSettingsRequest, dict]]):

3865 The request object. The parameters to

3866 [UpdateSettings][google.logging.v2.ConfigServiceV2.UpdateSettings].

3867

3868 See `Enabling CMEK for Log

3869 Router <https://cloud.google.com/logging/docs/routing/managed-encryption>`__

3870 for more information.

3871 settings (:class:`google.cloud.logging_v2.types.Settings`):

3872 Required. The settings to update.

3873

3874 See `Enabling CMEK for Log

3875 Router <https://cloud.google.com/logging/docs/routing/managed-encryption>`__

3876 for more information.

3877

3878 This corresponds to the ``settings`` field

3879 on the ``request`` instance; if ``request`` is provided, this

3880 should not be set.

3881 update_mask (:class:`google.protobuf.field_mask_pb2.FieldMask`):

3882 Optional. Field mask identifying which fields from

3883 ``settings`` should be updated. A field will be

3884 overwritten if and only if it is in the update mask.

3885 Output only fields cannot be updated.

3886

3887 See [FieldMask][google.protobuf.FieldMask] for more

3888 information.

3889

3890 For example: ``"updateMask=kmsKeyName"``

3891

3892 This corresponds to the ``update_mask`` field

3893 on the ``request`` instance; if ``request`` is provided, this

3894 should not be set.

3895 retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, if any,

3896 should be retried.

3897 timeout (float): The timeout for this request.

3898 metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be

3899 sent along with the request as metadata. Normally, each value must be of type `str`,

3900 but for metadata keys ending with the suffix `-bin`, the corresponding values must

3901 be of type `bytes`.

3902

3903 Returns:

3904 google.cloud.logging_v2.types.Settings:

3905 Describes the settings associated

3906 with a project, folder, organization,

3907 billing account, or flexible resource.

3908

3909 """

3910 # Create or coerce a protobuf request object.

3911 # - Quick check: If we got a request object, we should *not* have

3912 # gotten any keyword arguments that map to the request.

3913 flattened_params = [settings, update_mask]

3914 has_flattened_params = (

3915 len([param for param in flattened_params if param is not None]) > 0

3916 )

3917 if request is not None and has_flattened_params:

3918 raise ValueError(

3919 "If the `request` argument is set, then none of "

3920 "the individual field arguments should be set."

3921 )

3922

3923 # - Use the request object if provided (there's no risk of modifying the input as

3924 # there are no flattened fields), or create one.

3925 if not isinstance(request, logging_config.UpdateSettingsRequest):

3926 request = logging_config.UpdateSettingsRequest(request)

3927

3928 # If we have keyword arguments corresponding to fields on the

3929 # request, apply these.

3930 if settings is not None:

3931 request.settings = settings

3932 if update_mask is not None:

3933 request.update_mask = update_mask

3934

3935 # Wrap the RPC method; this adds retry and timeout information,

3936 # and friendly error handling.

3937 rpc = self._client._transport._wrapped_methods[

3938 self._client._transport.update_settings

3939 ]

3940

3941 # Certain fields should be provided within the metadata header;

3942 # add these here.

3943 metadata = tuple(metadata) + (

3944 gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),

3945 )

3946

3947 # Validate the universe domain.

3948 self._client._validate_universe_domain()

3949

3950 # Send the request.

3951 response = await rpc(

3952 request,

3953 retry=retry,

3954 timeout=timeout,

3955 metadata=metadata,

3956 )

3957

3958 # Done; return the response.

3959 return response

3960

3961 async def copy_log_entries(

3962 self,

3963 request: Optional[Union[logging_config.CopyLogEntriesRequest, dict]] = None,

3964 *,

3965 retry: OptionalRetry = gapic_v1.method.DEFAULT,

3966 timeout: Union[float, object] = gapic_v1.method.DEFAULT,

3967 metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),

3968 ) -> operation_async.AsyncOperation:

3969 r"""Copies a set of log entries from a log bucket to a

3970 Cloud Storage bucket.

3971

3972 .. code-block:: python

3973

3974 # This snippet has been automatically generated and should be regarded as a

3975 # code template only.

3976 # It will require modifications to work:

3977 # - It may require correct/in-range values for request initialization.

3978 # - It may require specifying regional endpoints when creating the service

3979 # client as shown in:

3980 # https://googleapis.dev/python/google-api-core/latest/client_options.html

3981 from google.cloud import logging_v2

3982

3983 async def sample_copy_log_entries():

3984 # Create a client

3985 client = logging_v2.ConfigServiceV2AsyncClient()

3986

3987 # Initialize request argument(s)

3988 request = logging_v2.CopyLogEntriesRequest(

3989 name="name_value",

3990 destination="destination_value",

3991 )

3992

3993 # Make the request

3994 operation = client.copy_log_entries(request=request)

3995

3996 print("Waiting for operation to complete...")

3997

3998 response = (await operation).result()

3999

4000 # Handle the response

4001 print(response)

4002

4003 Args:

4004 request (Optional[Union[google.cloud.logging_v2.types.CopyLogEntriesRequest, dict]]):

4005 The request object. The parameters to CopyLogEntries.

4006 retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, if any,

4007 should be retried.

4008 timeout (float): The timeout for this request.

4009 metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be

4010 sent along with the request as metadata. Normally, each value must be of type `str`,

4011 but for metadata keys ending with the suffix `-bin`, the corresponding values must

4012 be of type `bytes`.

4013

4014 Returns:

4015 google.api_core.operation_async.AsyncOperation:

4016 An object representing a long-running operation.

4017

4018 The result type for the operation will be

4019 :class:`google.cloud.logging_v2.types.CopyLogEntriesResponse`

4020 Response type for CopyLogEntries long running

4021 operations.

4022

4023 """

4024 # Create or coerce a protobuf request object.

4025 # - Use the request object if provided (there's no risk of modifying the input as

4026 # there are no flattened fields), or create one.

4027 if not isinstance(request, logging_config.CopyLogEntriesRequest):

4028 request = logging_config.CopyLogEntriesRequest(request)

4029

4030 # Wrap the RPC method; this adds retry and timeout information,

4031 # and friendly error handling.

4032 rpc = self._client._transport._wrapped_methods[

4033 self._client._transport.copy_log_entries

4034 ]

4035

4036 # Validate the universe domain.

4037 self._client._validate_universe_domain()

4038

4039 # Send the request.

4040 response = await rpc(

4041 request,

4042 retry=retry,

4043 timeout=timeout,

4044 metadata=metadata,

4045 )

4046

4047 # Wrap the response in an operation future.

4048 response = operation_async.from_gapic(

4049 response,

4050 self._client._transport.operations_client,

4051 logging_config.CopyLogEntriesResponse,

4052 metadata_type=logging_config.CopyLogEntriesMetadata,

4053 )

4054

4055 # Done; return the response.

4056 return response

4057

4058 async def list_operations(

4059 self,

4060 request: Optional[operations_pb2.ListOperationsRequest] = None,

4061 *,

4062 retry: OptionalRetry = gapic_v1.method.DEFAULT,

4063 timeout: Union[float, object] = gapic_v1.method.DEFAULT,

4064 metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),

4065 ) -> operations_pb2.ListOperationsResponse:

4066 r"""Lists operations that match the specified filter in the request.

4067

4068 Args:

4069 request (:class:`~.operations_pb2.ListOperationsRequest`):

4070 The request object. Request message for

4071 `ListOperations` method.

4072 retry (google.api_core.retry_async.AsyncRetry): Designation of what errors,

4073 if any, should be retried.

4074 timeout (float): The timeout for this request.

4075 metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be

4076 sent along with the request as metadata. Normally, each value must be of type `str`,

4077 but for metadata keys ending with the suffix `-bin`, the corresponding values must

4078 be of type `bytes`.

4079 Returns:

4080 ~.operations_pb2.ListOperationsResponse:

4081 Response message for ``ListOperations`` method.

4082 """

4083 # Create or coerce a protobuf request object.

4084 # The request isn't a proto-plus wrapped type,

4085 # so it must be constructed via keyword expansion.

4086 if isinstance(request, dict):

4087 request = operations_pb2.ListOperationsRequest(**request)

4088

4089 # Wrap the RPC method; this adds retry and timeout information,

4090 # and friendly error handling.

4091 rpc = self.transport._wrapped_methods[self._client._transport.list_operations]

4092

4093 # Certain fields should be provided within the metadata header;

4094 # add these here.

4095 metadata = tuple(metadata) + (

4096 gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),

4097 )

4098

4099 # Validate the universe domain.

4100 self._client._validate_universe_domain()

4101

4102 # Send the request.

4103 response = await rpc(

4104 request,

4105 retry=retry,

4106 timeout=timeout,

4107 metadata=metadata,

4108 )

4109

4110 # Done; return the response.

4111 return response

4112

4113 async def get_operation(

4114 self,

4115 request: Optional[operations_pb2.GetOperationRequest] = None,

4116 *,

4117 retry: OptionalRetry = gapic_v1.method.DEFAULT,

4118 timeout: Union[float, object] = gapic_v1.method.DEFAULT,

4119 metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),

4120 ) -> operations_pb2.Operation:

4121 r"""Gets the latest state of a long-running operation.

4122

4123 Args:

4124 request (:class:`~.operations_pb2.GetOperationRequest`):

4125 The request object. Request message for

4126 `GetOperation` method.

4127 retry (google.api_core.retry_async.AsyncRetry): Designation of what errors,

4128 if any, should be retried.

4129 timeout (float): The timeout for this request.

4130 metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be

4131 sent along with the request as metadata. Normally, each value must be of type `str`,

4132 but for metadata keys ending with the suffix `-bin`, the corresponding values must

4133 be of type `bytes`.

4134 Returns:

4135 ~.operations_pb2.Operation:

4136 An ``Operation`` object.

4137 """

4138 # Create or coerce a protobuf request object.

4139 # The request isn't a proto-plus wrapped type,

4140 # so it must be constructed via keyword expansion.

4141 if isinstance(request, dict):

4142 request = operations_pb2.GetOperationRequest(**request)

4143

4144 # Wrap the RPC method; this adds retry and timeout information,

4145 # and friendly error handling.

4146 rpc = self.transport._wrapped_methods[self._client._transport.get_operation]

4147

4148 # Certain fields should be provided within the metadata header;

4149 # add these here.

4150 metadata = tuple(metadata) + (

4151 gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),

4152 )

4153

4154 # Validate the universe domain.

4155 self._client._validate_universe_domain()

4156

4157 # Send the request.

4158 response = await rpc(

4159 request,

4160 retry=retry,

4161 timeout=timeout,

4162 metadata=metadata,

4163 )

4164

4165 # Done; return the response.

4166 return response

4167

4168 async def cancel_operation(

4169 self,

4170 request: Optional[operations_pb2.CancelOperationRequest] = None,

4171 *,

4172 retry: OptionalRetry = gapic_v1.method.DEFAULT,

4173 timeout: Union[float, object] = gapic_v1.method.DEFAULT,

4174 metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),

4175 ) -> None:

4176 r"""Starts asynchronous cancellation on a long-running operation.

4177

4178 The server makes a best effort to cancel the operation, but success

4179 is not guaranteed. If the server doesn't support this method, it returns

4180 `google.rpc.Code.UNIMPLEMENTED`.

4181

4182 Args:

4183 request (:class:`~.operations_pb2.CancelOperationRequest`):

4184 The request object. Request message for

4185 `CancelOperation` method.

4186 retry (google.api_core.retry_async.AsyncRetry): Designation of what errors,

4187 if any, should be retried.

4188 timeout (float): The timeout for this request.

4189 metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be

4190 sent along with the request as metadata. Normally, each value must be of type `str`,

4191 but for metadata keys ending with the suffix `-bin`, the corresponding values must

4192 be of type `bytes`.

4193 Returns:

4194 None

4195 """

4196 # Create or coerce a protobuf request object.

4197 # The request isn't a proto-plus wrapped type,

4198 # so it must be constructed via keyword expansion.

4199 if isinstance(request, dict):

4200 request = operations_pb2.CancelOperationRequest(**request)

4201

4202 # Wrap the RPC method; this adds retry and timeout information,

4203 # and friendly error handling.

4204 rpc = self.transport._wrapped_methods[self._client._transport.cancel_operation]

4205

4206 # Certain fields should be provided within the metadata header;

4207 # add these here.

4208 metadata = tuple(metadata) + (

4209 gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),

4210 )

4211

4212 # Validate the universe domain.

4213 self._client._validate_universe_domain()

4214

4215 # Send the request.

4216 await rpc(

4217 request,

4218 retry=retry,

4219 timeout=timeout,

4220 metadata=metadata,

4221 )

4222

4223 async def __aenter__(self) -> "ConfigServiceV2AsyncClient":

4224 return self

4225

4226 async def __aexit__(self, exc_type, exc, tb):

4227 await self.transport.close()

4228

4229

4230DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo(

4231 gapic_version=package_version.__version__

4232)

4233

4234if hasattr(DEFAULT_CLIENT_INFO, "protobuf_runtime_version"): # pragma: NO COVER

4235 DEFAULT_CLIENT_INFO.protobuf_runtime_version = google.protobuf.__version__

4236

4237

4238__all__ = ("ConfigServiceV2AsyncClient",)

Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.11/site-packages/google/cloud/logging_v2/services/config_service_v2/async_client.py: 23%

499 statements