apache-airflow-providers-google 10.22.0__py3-none-any.whl → 10.23.0__py3-none-any.whl

airflow/providers/google/cloud/triggers/dataflow.py

@@ -24,8 +24,10 @@ from typing import TYPE_CHECKING, Any, Sequence
 from google.cloud.dataflow_v1beta3 import JobState
 from google.cloud.dataflow_v1beta3.types import (
     AutoscalingEvent,
+    Job,
     JobMessage,
     JobMetrics,
+    JobType,
     MetricUpdate,
 )
 
@@ -157,7 +159,7 @@ class TemplateJobStartTrigger(BaseTrigger):
 
 class DataflowJobStatusTrigger(BaseTrigger):
     """
-    Trigger that checks for metrics associated with a Dataflow job.
+    Trigger that monitors if a Dataflow job has reached any of the expected statuses.
 
     :param job_id: Required. ID of the job.
     :param expected_statuses: The expected state(s) of the operation.
@@ -266,6 +268,148 @@ class DataflowJobStatusTrigger(BaseTrigger):
         )
 
 
+class DataflowStartYamlJobTrigger(BaseTrigger):
+    """
+    Dataflow trigger that checks the state of a Dataflow YAML job.
+
+    :param job_id: Required. ID of the job.
+    :param project_id: Required. The Google Cloud project ID in which the job was started.
+    :param location: The location where job is executed. If set to None then
+        the value of DEFAULT_DATAFLOW_LOCATION will be used.
+    :param gcp_conn_id: The connection ID to use connecting to Google Cloud.
+    :param poll_sleep: Optional. The time in seconds to sleep between polling Google Cloud Platform
+        for the Dataflow job.
+    :param cancel_timeout: Optional. How long (in seconds) operator should wait for the pipeline to be
+        successfully cancelled when task is being killed.
+    :param expected_terminal_state: Optional. The expected terminal state of the Dataflow job at which the
+        operator task is set to succeed. Defaults to 'JOB_STATE_DONE' for the batch jobs and
+        'JOB_STATE_RUNNING' for the streaming jobs.
+    :param impersonation_chain: Optional. Service account to impersonate using short-term
+        credentials, or chained list of accounts required to get the access_token
+        of the last account in the list, which will be impersonated in the request.
+        If set as a string, the account must grant the originating account
+        the Service Account Token Creator IAM role.
+        If set as a sequence, the identities from the list must grant
+        Service Account Token Creator IAM role to the directly preceding identity, with first
+        account from the list granting this role to the originating account (templated).
+    """
+
+    def __init__(
+        self,
+        job_id: str,
+        project_id: str | None,
+        location: str = DEFAULT_DATAFLOW_LOCATION,
+        gcp_conn_id: str = "google_cloud_default",
+        poll_sleep: int = 10,
+        cancel_timeout: int | None = 5 * 60,
+        expected_terminal_state: str | None = None,
+        impersonation_chain: str | Sequence[str] | None = None,
+    ):
+        super().__init__()
+        self.project_id = project_id
+        self.job_id = job_id
+        self.location = location
+        self.gcp_conn_id = gcp_conn_id
+        self.poll_sleep = poll_sleep
+        self.cancel_timeout = cancel_timeout
+        self.expected_terminal_state = expected_terminal_state
+        self.impersonation_chain = impersonation_chain
+
+    def serialize(self) -> tuple[str, dict[str, Any]]:
+        """Serialize class arguments and classpath."""
+        return (
+            "airflow.providers.google.cloud.triggers.dataflow.DataflowStartYamlJobTrigger",
+            {
+                "project_id": self.project_id,
+                "job_id": self.job_id,
+                "location": self.location,
+                "gcp_conn_id": self.gcp_conn_id,
+                "poll_sleep": self.poll_sleep,
+                "expected_terminal_state": self.expected_terminal_state,
+                "impersonation_chain": self.impersonation_chain,
+                "cancel_timeout": self.cancel_timeout,
+            },
+        )
+
+    async def run(self):
+        """
+        Fetch job and yield events depending on the job's type and state.
+
+        Yield TriggerEvent if the job reaches a terminal state.
+        Otherwise awaits for a specified amount of time stored in self.poll_sleep variable.
+        """
+        hook: AsyncDataflowHook = self._get_async_hook()
+        try:
+            while True:
+                job: Job = await hook.get_job(
+                    job_id=self.job_id,
+                    project_id=self.project_id,
+                    location=self.location,
+                )
+                job_state = job.current_state
+                job_type = job.type_
+                if job_state.name == self.expected_terminal_state:
+                    yield TriggerEvent(
+                        {
+                            "job": Job.to_dict(job),
+                            "status": "success",
+                            "message": f"Job reached the expected terminal state: {self.expected_terminal_state}.",
+                        }
+                    )
+                    return
+                elif job_type == JobType.JOB_TYPE_STREAMING and job_state == JobState.JOB_STATE_RUNNING:
+                    yield TriggerEvent(
+                        {
+                            "job": Job.to_dict(job),
+                            "status": "success",
+                            "message": "Streaming job reached the RUNNING state.",
+                        }
+                    )
+                    return
+                elif job_type == JobType.JOB_TYPE_BATCH and job_state == JobState.JOB_STATE_DONE:
+                    yield TriggerEvent(
+                        {
+                            "job": Job.to_dict(job),
+                            "status": "success",
+                            "message": "Batch job completed.",
+                        }
+                    )
+                    return
+                elif job_state == JobState.JOB_STATE_FAILED:
+                    yield TriggerEvent(
+                        {
+                            "job": Job.to_dict(job),
+                            "status": "error",
+                            "message": "Job failed.",
+                        }
+                    )
+                    return
+                elif job_state == JobState.JOB_STATE_STOPPED:
+                    yield TriggerEvent(
+                        {
+                            "job": Job.to_dict(job),
+                            "status": "stopped",
+                            "message": "Job was stopped.",
+                        }
+                    )
+                    return
+                else:
+                    self.log.info("Current job status is: %s", job_state.name)
+                    self.log.info("Sleeping for %s seconds.", self.poll_sleep)
+                    await asyncio.sleep(self.poll_sleep)
+        except Exception as e:
+            self.log.exception("Exception occurred while checking for job completion.")
+            yield TriggerEvent({"job": None, "status": "error", "message": str(e)})
+
+    def _get_async_hook(self) -> AsyncDataflowHook:
+        return AsyncDataflowHook(
+            gcp_conn_id=self.gcp_conn_id,
+            poll_sleep=self.poll_sleep,
+            impersonation_chain=self.impersonation_chain,
+            cancel_timeout=self.cancel_timeout,
+        )
+
+
 class DataflowJobMetricsTrigger(BaseTrigger):
     """
     Trigger that checks for metrics associated with a Dataflow job.

airflow/providers/google/cloud/triggers/kubernetes_engine.py

@@ -23,14 +23,18 @@ from functools import cached_property
 from typing import TYPE_CHECKING, Any, AsyncIterator, Sequence
 
 from google.cloud.container_v1.types import Operation
+from packaging.version import parse as parse_version
 
-from airflow.exceptions import AirflowProviderDeprecationWarning
+from airflow.exceptions import AirflowException, AirflowProviderDeprecationWarning
 from airflow.providers.cncf.kubernetes.triggers.pod import KubernetesPodTrigger
-from airflow.providers.cncf.kubernetes.utils.pod_manager import OnFinishAction
+from airflow.providers.cncf.kubernetes.utils.pod_manager import OnFinishAction, PodManager
+from airflow.providers.cncf.kubernetes.utils.xcom_sidecar import PodDefaults
 from airflow.providers.google.cloud.hooks.kubernetes_engine import (
     GKEAsyncHook,
     GKEKubernetesAsyncHook,
+    GKEKubernetesHook,
 )
+from airflow.providers_manager import ProvidersManager
 from airflow.triggers.base import BaseTrigger, TriggerEvent
 
 if TYPE_CHECKING:
@@ -255,18 +259,28 @@ class GKEJobTrigger(BaseTrigger):
         ssl_ca_cert: str,
         job_name: str,
         job_namespace: str,
+        pod_name: str,
+        pod_namespace: str,
+        base_container_name: str,
         gcp_conn_id: str = "google_cloud_default",
         poll_interval: float = 2,
         impersonation_chain: str | Sequence[str] | None = None,
+        get_logs: bool = True,
+        do_xcom_push: bool = False,
     ) -> None:
         super().__init__()
         self.cluster_url = cluster_url
         self.ssl_ca_cert = ssl_ca_cert
         self.job_name = job_name
         self.job_namespace = job_namespace
+        self.pod_name = pod_name
+        self.pod_namespace = pod_namespace
+        self.base_container_name = base_container_name
         self.gcp_conn_id = gcp_conn_id
         self.poll_interval = poll_interval
         self.impersonation_chain = impersonation_chain
+        self.get_logs = get_logs
+        self.do_xcom_push = do_xcom_push
 
     def serialize(self) -> tuple[str, dict[str, Any]]:
         """Serialize KubernetesCreateJobTrigger arguments and classpath."""
@@ -277,15 +291,51 @@ class GKEJobTrigger(BaseTrigger):
                 "ssl_ca_cert": self.ssl_ca_cert,
                 "job_name": self.job_name,
                 "job_namespace": self.job_namespace,
+                "pod_name": self.pod_name,
+                "pod_namespace": self.pod_namespace,
+                "base_container_name": self.base_container_name,
                 "gcp_conn_id": self.gcp_conn_id,
                 "poll_interval": self.poll_interval,
                 "impersonation_chain": self.impersonation_chain,
+                "get_logs": self.get_logs,
+                "do_xcom_push": self.do_xcom_push,
             },
         )
 
     async def run(self) -> AsyncIterator[TriggerEvent]:  # type: ignore[override]
         """Get current job status and yield a TriggerEvent."""
-        job: V1Job = await self.hook.wait_until_job_complete(name=self.job_name, namespace=self.job_namespace)
+        if self.get_logs or self.do_xcom_push:
+            pod = await self.hook.get_pod(name=self.pod_name, namespace=self.pod_namespace)
+        if self.do_xcom_push:
+            kubernetes_provider = ProvidersManager().providers["apache-airflow-providers-cncf-kubernetes"]
+            kubernetes_provider_name = kubernetes_provider.data["package-name"]
+            kubernetes_provider_version = kubernetes_provider.version
+            min_version = "8.4.1"
+            if parse_version(kubernetes_provider_version) < parse_version(min_version):
+                raise AirflowException(
+                    "You are trying to use do_xcom_push in `GKEStartJobOperator` with the provider "
+                    f"package {kubernetes_provider_name}=={kubernetes_provider_version} which doesn't "
+                    f"support this feature. Please upgrade it to version higher than or equal to {min_version}."
+                )
+            await self.hook.wait_until_container_complete(
+                name=self.pod_name,
+                namespace=self.pod_namespace,
+                container_name=self.base_container_name,
+                poll_interval=self.poll_interval,
+            )
+            self.log.info("Checking if xcom sidecar container is started.")
+            await self.hook.wait_until_container_started(
+                name=self.pod_name,
+                namespace=self.pod_namespace,
+                container_name=PodDefaults.SIDECAR_CONTAINER_NAME,
+                poll_interval=self.poll_interval,
+            )
+            self.log.info("Extracting result from xcom sidecar container.")
+            loop = asyncio.get_running_loop()
+            xcom_result = await loop.run_in_executor(None, self.pod_manager.extract_xcom, pod)
+        job: V1Job = await self.hook.wait_until_job_complete(
+            name=self.job_name, namespace=self.job_namespace, poll_interval=self.poll_interval
+        )
         job_dict = job.to_dict()
         error_message = self.hook.is_job_failed(job=job)
         status = "error" if error_message else "success"
@@ -294,9 +344,12 @@ class GKEJobTrigger(BaseTrigger):
             {
                 "name": job.metadata.name,
                 "namespace": job.metadata.namespace,
+                "pod_name": pod.metadata.name if self.get_logs else None,
+                "pod_namespace": pod.metadata.namespace if self.get_logs else None,
                 "status": status,
                 "message": message,
                 "job": job_dict,
+                "xcom_result": xcom_result if self.do_xcom_push else None,
             }
         )
 
@@ -308,3 +361,13 @@ class GKEJobTrigger(BaseTrigger):
             gcp_conn_id=self.gcp_conn_id,
             impersonation_chain=self.impersonation_chain,
         )
+
+    @cached_property
+    def pod_manager(self) -> PodManager:
+        sync_hook = GKEKubernetesHook(
+            gcp_conn_id=self.gcp_conn_id,
+            cluster_url=self.cluster_url,
+            ssl_ca_cert=self.ssl_ca_cert,
+            impersonation_chain=self.impersonation_chain,
+        )
+        return PodManager(kube_client=sync_hook.core_v1_client)

airflow/providers/google/common/deprecated.py

@@ -0,0 +1,176 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+from __future__ import annotations
+
+import inspect
+import re
+from datetime import date, datetime
+from typing import Any, Callable
+
+from deprecated import deprecated as standard_deprecated
+from deprecated.classic import ClassicAdapter
+
+
+class AirflowDeprecationAdapter(ClassicAdapter):
+    """
+    Build a detailed deprecation message based on the wrapped object type and other provided details.
+
+    :param planned_removal_date: The date after which the deprecated object should be removed.
+        The recommended date is six months ahead from today. The expected date format is `Month DD, YYYY`,
+        for example: `August 22, 2024`.
+        This parameter is required if the `planned_removal_release` parameter is not set.
+    :param planned_removal_release: The package name and the version in which the deprecated object is
+        expected to be removed. The expected format is `<package_name>==<package_version>`, for example
+        `apache-airflow==2.10.0` or `apache-airflow-providers-google==10.22.0`.
+        This parameter is required if the `planned_removal_date` parameter is not set.
+    :param use_instead: Optional. Replacement of the deprecated object.
+    :param reason: Optional. The detailed reason for the deprecated object.
+    :param instructions: Optional. The detailed instructions for migrating from the deprecated object.
+    :param category: Optional. The warning category to be used for the deprecation warning.
+    """
+
+    def __init__(
+        self,
+        planned_removal_date: str | None = None,
+        planned_removal_release: str | None = None,
+        use_instead: str | None = None,
+        reason: str | None = None,
+        instructions: str | None = None,
+        category: type[DeprecationWarning] = DeprecationWarning,
+        **kwargs: Any,
+    ):
+        super().__init__(**kwargs)
+        self.planned_removal_date: date | None = self._validate_date(planned_removal_date)
+        self.planned_removal_release: str | None = self._validate_removal_release(planned_removal_release)
+        self.use_instead: str | None = use_instead
+        self.reason: str = reason or ""
+        self.instructions: str | None = instructions
+        self.category: type[DeprecationWarning] = category
+        self._validate_fields()
+
+    def get_deprecated_msg(self, wrapped: Callable, instance: Any):
+        """
+        Generate a deprecation message for wrapped callable.
+
+        :param wrapped: Deprecated entity.
+        :param instance: The instance to which the callable belongs. (not used)
+        :return: A formatted deprecation message with all the details.
+        """
+        entity_type = self.entity_type(entity=wrapped)
+        entity_path = self.entity_path(entity=wrapped)
+        sunset = self.sunset_message()
+        replacement = self.replacement_message()
+        msg = f"The {entity_type} `{entity_path}` is deprecated and will be removed {sunset}. {replacement}"
+        if self.reason:
+            msg += f" The reason is: {self.reason}"
+        if self.instructions:
+            msg += f" Instructions: {self.instructions}"
+        return msg
+
+    @staticmethod
+    def _validate_date(value: str | None) -> date | None:
+        if value:
+            try:
+                return datetime.strptime(value, "%B %d, %Y").date()
+            except ValueError as ex:
+                error_message = (
+                    f"Invalid date '{value}'. "
+                    f"The expected format is 'Month DD, YYYY', for example 'August 22, 2024'."
+                )
+                raise ValueError(error_message) from ex
+        return None
+
+    @staticmethod
+    def _validate_removal_release(value: str | None) -> str | None:
+        if value:
+            pattern = r"^apache-airflow(-providers-[a-zA-Z-]+)?==\d+\.\d+\.\d+.*$"
+            if not bool(re.match(pattern, value)):
+                raise ValueError(
+                    f"`{value}` must follow the format 'apache-airflow(-providers-<name>)==<X.Y.Z>'."
+                )
+        return value
+
+    def _validate_fields(self):
+        msg = "Only one of two parameters must be set: `planned_removal_date` or 'planned_removal_release'."
+        if self.planned_removal_release and self.planned_removal_date:
+            raise ValueError(f"{msg} You specified both.")
+
+    @staticmethod
+    def entity_type(entity: Callable) -> str:
+        return "class" if inspect.isclass(entity) else "function (or method)"
+
+    @staticmethod
+    def entity_path(entity: Callable) -> str:
+        module_name = getattr(entity, "__module__", "")
+        qualified_name = getattr(entity, "__qualname__", "")
+        full_path = f"{module_name}.{qualified_name}".strip(".")
+
+        if module_name and full_path:
+            return full_path
+        return str(entity)
+
+    def sunset_message(self) -> str:
+        if self.planned_removal_date:
+            return f"after {self.planned_removal_date.strftime('%B %d, %Y')}"
+        if self.planned_removal_release:
+            return f"since version {self.planned_removal_release}"
+        return "in the future"
+
+    def replacement_message(self):
+        if self.use_instead:
+            replacements = ", ".join(f"`{replacement}`" for replacement in self.use_instead.split(", "))
+            return f"Please use {replacements} instead."
+        return "There is no replacement."
+
+
+def deprecated(
+    *args,
+    planned_removal_date: str | None = None,
+    planned_removal_release: str | None = None,
+    use_instead: str | None = None,
+    reason: str | None = None,
+    instructions: str | None = None,
+    adapter_cls: type[AirflowDeprecationAdapter] = AirflowDeprecationAdapter,
+    **kwargs,
+):
+    """
+    Mark a class, method or a function deprecated.
+
+    :param planned_removal_date: The date after which the deprecated object should be removed.
+        The recommended date is six months ahead from today. The expected date format is `Month DD, YYYY`,
+        for example: `August 22, 2024`.
+        This parameter is required if the `planned_removal_release` parameter is not set.
+    :param planned_removal_release: The package name and the version in which the deprecated object is
+        expected to be removed. The expected format is `<package_name>==<package_version>`, for example
+        `apache-airflow==2.10.0` or `apache-airflow-providers-google==10.22.0`.
+        This parameter is required if the `planned_removal_date` parameter is not set.
+    :param use_instead: Optional. Replacement of the deprecated object.
+    :param reason: Optional. The detailed reason for the deprecated object.
+    :param instructions: Optional. The detailed instructions for migrating from the deprecated object.
+    :param adapter_cls: Optional. Adapter class that is used to get the deprecation message
+        This should be a subclass of `AirflowDeprecationAdapter`.
+    """
+    _kwargs = {
+        **kwargs,
+        "planned_removal_date": planned_removal_date,
+        "planned_removal_release": planned_removal_release,
+        "use_instead": use_instead,
+        "reason": reason,
+        "instructions": instructions,
+        "adapter_cls": adapter_cls,
+    }
+    return standard_deprecated(*args, **_kwargs)

airflow/providers/google/common/hooks/base_google.py

@@ -36,7 +36,6 @@ import google_auth_httplib2
 import requests
 import tenacity
 from asgiref.sync import sync_to_async
-from deprecated import deprecated
 from gcloud.aio.auth.token import Token, TokenResponse
 from google.api_core.exceptions import Forbidden, ResourceExhausted, TooManyRequests
 from google.auth import _cloud_sdk, compute_engine  # type: ignore[attr-defined]
@@ -57,6 +56,7 @@ from airflow.providers.google.cloud.utils.credentials_provider import (
     get_credentials_and_project_id,
 )
 from airflow.providers.google.common.consts import CLIENT_INFO
+from airflow.providers.google.common.deprecated import deprecated
 from airflow.utils.process_utils import patch_environ
 
 if TYPE_CHECKING:
@@ -451,7 +451,8 @@ class GoogleBaseHook(BaseHook):
 
     @property
     @deprecated(
-        reason="Please use `airflow.providers.google.common.consts.CLIENT_INFO`.",
+        planned_removal_date="March 01, 2025",
+        use_instead="airflow.providers.google.common.consts.CLIENT_INFO",
         category=AirflowProviderDeprecationWarning,
     )
     def client_info(self) -> ClientInfo:

airflow/providers/google/get_provider_info.py

@@ -28,8 +28,9 @@ def get_provider_info():
         "name": "Google",
         "description": "Google services including:\n\n  - `Google Ads <https://ads.google.com/>`__\n  - `Google Cloud (GCP) <https://cloud.google.com/>`__\n  - `Google Firebase <https://firebase.google.com/>`__\n  - `Google LevelDB <https://github.com/google/leveldb/>`__\n  - `Google Marketing Platform <https://marketingplatform.google.com/>`__\n  - `Google Workspace <https://workspace.google.com/>`__ (formerly Google Suite)\n",
         "state": "ready",
-        "source-date-epoch": 1723970253,
+        "source-date-epoch": 1726860901,
         "versions": [
+            "10.23.0",
             "10.22.0",
             "10.21.1",
             "10.21.0",
@@ -101,15 +102,15 @@ def get_provider_info():
             "gcloud-aio-bigquery>=6.1.2",
             "gcloud-aio-storage>=9.0.0",
             "gcsfs>=2023.10.0",
-            "google-ads>=24.1.0",
+            "google-ads>=25.0.0",
             "google-analytics-admin>=0.9.0",
             "google-api-core>=2.11.0,!=2.16.0,!=2.18.0",
             "google-api-python-client>=2.0.2",
             "google-auth>=2.29.0",
             "google-auth-httplib2>=0.0.1",
-            "google-cloud-aiplatform>=1.57.0",
+            "google-cloud-aiplatform>=1.63.0",
             "google-cloud-automl>=2.12.0",
-            "google-cloud-bigquery<3.21.0,>=3.4.0",
+            "google-cloud-bigquery>=3.4.0,!=3.21.*,!=3.22.0,!=3.23.*",
             "google-cloud-bigquery-datatransfer>=3.13.0",
             "google-cloud-bigtable>=2.17.0",
             "google-cloud-build>=3.22.0",
@@ -119,7 +120,7 @@ def get_provider_info():
             "google-cloud-dataflow-client>=0.8.6",
             "google-cloud-dataform>=0.5.0",
             "google-cloud-dataplex>=1.10.0",
-            "google-cloud-dataproc>=5.8.0",
+            "google-cloud-dataproc>=5.12.0",
             "google-cloud-dataproc-metastore>=1.12.0",
             "google-cloud-dlp>=3.12.0",
             "google-cloud-kms>=2.15.0",
@@ -132,7 +133,7 @@ def get_provider_info():
             "google-cloud-pubsub>=2.19.0",
             "google-cloud-redis>=2.12.0",
             "google-cloud-secret-manager>=2.16.0",
-            "google-cloud-spanner>=3.11.1",
+            "google-cloud-spanner>=3.11.1,!=3.49.0",
             "google-cloud-speech>=2.18.0",
             "google-cloud-storage>=2.7.0",
             "google-cloud-storage-transfer>=1.4.1",
@@ -157,6 +158,7 @@ def get_provider_info():
             "sqlalchemy-bigquery>=1.2.1",
             "sqlalchemy-spanner>=1.6.2",
             "tenacity>=8.1.0",
+            "immutabledict>=4.2.0",
         ],
         "additional-extras": [
             {"name": "apache.beam", "dependencies": ["apache-beam[gcp]"]},
@@ -905,10 +907,6 @@ def get_provider_info():
                 "integration-name": "Google Display&Video 360",
                 "python-modules": ["airflow.providers.google.marketing_platform.sensors.display_video"],
             },
-            {
-                "integration-name": "Google Search Ads 360",
-                "python-modules": ["airflow.providers.google.marketing_platform.sensors.search_ads"],
-            },
             {
                 "integration-name": "Google Looker",
                 "python-modules": ["airflow.providers.google.cloud.sensors.looker"],

airflow/providers/google/marketing_platform/hooks/analytics.py

@@ -19,16 +19,18 @@ from __future__ import annotations
 
 from typing import Any
 
-from deprecated import deprecated
 from googleapiclient.discovery import Resource, build
 from googleapiclient.http import MediaFileUpload
 
 from airflow.exceptions import AirflowProviderDeprecationWarning
+from airflow.providers.google.common.deprecated import deprecated
 from airflow.providers.google.common.hooks.base_google import GoogleBaseHook
 
 
 @deprecated(
-    reason="The `GoogleAnalyticsHook` class is deprecated, please use `GoogleAnalyticsAdminHook` instead.",
+    planned_removal_date="November 01, 2024",
+    use_instead="GoogleAnalyticsAdminHook",
+    reason="The Google Analytics API v3 has sunset and is no longer available as of July 1, 2024.",
     category=AirflowProviderDeprecationWarning,
 )
 class GoogleAnalyticsHook(GoogleBaseHook):