apache-airflow-providers-openlineage 1.7.1__py3-none-any.whl → 1.8.0__py3-none-any.whl

airflow/providers/openlineage/__init__.py

@@ -25,14 +25,11 @@ from __future__ import annotations
 
 import packaging.version
 
-__all__ = ["__version__"]
+from airflow import __version__ as airflow_version
 
-__version__ = "1.7.1"
+__all__ = ["__version__"]
 
-try:
-    from airflow import __version__ as airflow_version
-except ImportError:
-    from airflow.version import version as airflow_version
+__version__ = "1.8.0"
 
 if packaging.version.parse(packaging.version.parse(airflow_version).base_version) < packaging.version.parse(
     "2.7.0"

airflow/providers/openlineage/conf.py

@@ -14,6 +14,19 @@
 # KIND, either express or implied.  See the License for the
 # specific language governing permissions and limitations
 # under the License.
+"""
+This module provides functions for safely retrieving and handling OpenLineage configurations.
+
+To prevent errors caused by invalid user-provided configuration values, we use ``conf.get()``
+to fetch values as strings and perform safe conversions using custom functions.
+
+Any invalid configuration values should be treated as incorrect and replaced with default values.
+For example, if the default for boolean ``custom_ol_var`` is False, any non-true value provided:
+``"asdf"``, ``12345``, ``{"key": 1}`` or empty string, will result in False being used.
+
+By using default values for invalid configuration values, we ensure that the configurations are handled
+safely, preventing potential runtime errors due to conversion issues.
+"""
 
 from __future__ import annotations
 
@@ -26,6 +39,17 @@ from airflow.configuration import conf
 _CONFIG_SECTION = "openlineage"
 
 
+def _is_true(arg: Any) -> bool:
+    return str(arg).lower().strip() in ("true", "1", "t")
+
+
+def _safe_int_convert(arg: Any, default: int) -> int:
+    try:
+        return int(arg)
+    except (ValueError, TypeError):
+        return default
+
+
 @cache
 def config_path(check_legacy_env_var: bool = True) -> str:
     """[openlineage] config_path."""
@@ -41,7 +65,8 @@ def is_source_enabled() -> bool:
     option = conf.get(_CONFIG_SECTION, "disable_source_code", fallback="")
     if not option:
         option = os.getenv("OPENLINEAGE_AIRFLOW_DISABLE_SOURCE_CODE", "")
-    return option.lower() not in ("true", "1", "t")
+    # when disable_source_code is True, is_source_enabled() should be False
+    return not _is_true(option)
 
 
 @cache
@@ -53,7 +78,9 @@ def disabled_operators() -> set[str]:
 
 @cache
 def selective_enable() -> bool:
-    return conf.getboolean(_CONFIG_SECTION, "selective_enable", fallback=False)
+    """[openlineage] selective_enable."""
+    option = conf.get(_CONFIG_SECTION, "selective_enable", fallback="")
+    return _is_true(option)
 
 
 @cache
@@ -85,11 +112,7 @@ def transport() -> dict[str, Any]:
 
 @cache
 def is_disabled() -> bool:
-    """[openlineage] disabled + some extra checks."""
-
-    def _is_true(val):
-        return str(val).lower().strip() in ("true", "1", "t")
-
+    """[openlineage] disabled + check if any configuration is present."""
     option = conf.get(_CONFIG_SECTION, "disabled", fallback="")
     if _is_true(option):
         return True
@@ -97,7 +120,13 @@ def is_disabled() -> bool:
     option = os.getenv("OPENLINEAGE_DISABLED", "")
     if _is_true(option):
         return True
-
     # Check if both 'transport' and 'config_path' are not present and also
     # if legacy 'OPENLINEAGE_URL' environment variables is not set
     return transport() == {} and config_path(True) == "" and os.getenv("OPENLINEAGE_URL", "") == ""
+
+
+@cache
+def dag_state_change_process_pool_size() -> int:
+    """[openlineage] dag_state_change_process_pool_size."""
+    option = conf.get(_CONFIG_SECTION, "dag_state_change_process_pool_size", fallback="")
+    return _safe_int_convert(str(option).strip(), default=1)

airflow/providers/openlineage/extractors/base.py

@@ -87,6 +87,9 @@ class DefaultExtractor(BaseExtractor):
     def _execute_extraction(self) -> OperatorLineage | None:
         # OpenLineage methods are optional - if there's no method, return None
         try:
+            self.log.debug(
+                "Trying to execute `get_openlineage_facets_on_start` for %s.", self.operator.task_type
+            )
             return self._get_openlineage_facets(self.operator.get_openlineage_facets_on_start)  # type: ignore
         except ImportError:
             self.log.error(
@@ -105,9 +108,13 @@ class DefaultExtractor(BaseExtractor):
         if task_instance.state == TaskInstanceState.FAILED:
             on_failed = getattr(self.operator, "get_openlineage_facets_on_failure", None)
             if on_failed and callable(on_failed):
+                self.log.debug(
+                    "Executing `get_openlineage_facets_on_failure` for %s.", self.operator.task_type
+                )
                 return self._get_openlineage_facets(on_failed, task_instance)
         on_complete = getattr(self.operator, "get_openlineage_facets_on_complete", None)
         if on_complete and callable(on_complete):
+            self.log.debug("Executing `get_openlineage_facets_on_complete` for %s.", self.operator.task_type)
             return self._get_openlineage_facets(on_complete, task_instance)
         return self.extract()
 

airflow/providers/openlineage/extractors/bash.py

@@ -53,6 +53,10 @@ class BashExtractor(BaseExtractor):
                     source=self.operator.bash_command,
                 )
             }
+        else:
+            self.log.debug(
+                "OpenLineage disable_source_code option is on - no source code is extracted.",
+            )
 
         return OperatorLineage(
             job_facets=job_facets,

airflow/providers/openlineage/extractors/manager.py

@@ -16,7 +16,6 @@
 # under the License.
 from __future__ import annotations
 
-from contextlib import suppress
 from typing import TYPE_CHECKING, Iterator
 
 from airflow.providers.openlineage import conf
@@ -24,9 +23,11 @@ from airflow.providers.openlineage.extractors import BaseExtractor, OperatorLine
 from airflow.providers.openlineage.extractors.base import DefaultExtractor
 from airflow.providers.openlineage.extractors.bash import BashExtractor
 from airflow.providers.openlineage.extractors.python import PythonExtractor
-from airflow.providers.openlineage.utils.utils import get_unknown_source_attribute_run_facet
+from airflow.providers.openlineage.utils.utils import (
+    get_unknown_source_attribute_run_facet,
+    try_import_from_string,
+)
 from airflow.utils.log.logging_mixin import LoggingMixin
-from airflow.utils.module_loading import import_string
 
 if TYPE_CHECKING:
     from openlineage.client.run import Dataset
@@ -35,11 +36,6 @@ if TYPE_CHECKING:
     from airflow.models import Operator
 
 
-def try_import_from_string(string):
-    with suppress(ImportError):
-        return import_string(string)
-
-
 def _iter_extractor_types() -> Iterator[type[BaseExtractor]]:
     if PythonExtractor is not None:
         yield PythonExtractor
@@ -61,16 +57,27 @@ class ExtractorManager(LoggingMixin):
                 self.extractors[operator_class] = extractor
 
         for extractor_path in conf.custom_extractors():
-            extractor: type[BaseExtractor] = try_import_from_string(extractor_path)
+            extractor: type[BaseExtractor] | None = try_import_from_string(extractor_path)
+            if not extractor:
+                self.log.warning(
+                    "OpenLineage is unable to import custom extractor `%s`; will ignore it.", extractor_path
+                )
+                continue
             for operator_class in extractor.get_operator_classnames():
                 if operator_class in self.extractors:
-                    self.log.debug(
-                        "Duplicate extractor found for `%s`. `%s` will be used instead of `%s`",
+                    self.log.warning(
+                        "Duplicate OpenLineage custom extractor found for `%s`. "
+                        "`%s` will be used instead of `%s`",
                         operator_class,
                         extractor_path,
                         self.extractors[operator_class],
                     )
                 self.extractors[operator_class] = extractor
+                self.log.debug(
+                    "Registered custom OpenLineage extractor `%s` for class `%s`",
+                    extractor_path,
+                    operator_class,
+                )
 
     def add_extractor(self, operator_class: str, extractor: type[BaseExtractor]):
         self.extractors[operator_class] = extractor

airflow/providers/openlineage/extractors/python.py

@@ -57,6 +57,11 @@ class PythonExtractor(BaseExtractor):
                     source=source_code,
                 )
             }
+        else:
+            self.log.debug(
+                "OpenLineage disable_source_code option is on - no source code is extracted.",
+            )
+
         return OperatorLineage(
             job_facets=job_facet,
             # The PythonOperator is recorded as an "unknownSource" even though we have an extractor,

airflow/providers/openlineage/get_provider_info.py

@@ -28,8 +28,9 @@ def get_provider_info():
         "name": "OpenLineage Airflow",
         "description": "`OpenLineage <https://openlineage.io/>`__\n",
         "state": "ready",
-        "source-date-epoch": 1714477058,
+        "source-date-epoch": 1715684338,
         "versions": [
+            "1.8.0",
             "1.7.1",
             "1.7.0",
             "1.6.0",
@@ -121,11 +122,18 @@ def get_provider_info():
                     },
                     "disable_source_code": {
                         "description": "Disable the inclusion of source code in OpenLineage events by setting this to `true`.\nBy default, several Operators (e.g. Python, Bash) will include their source code in the events\nunless disabled.\n",
-                        "default": None,
+                        "default": "False",
                         "example": None,
                         "type": "boolean",
                         "version_added": None,
                     },
+                    "dag_state_change_process_pool_size": {
+                        "description": "Number of processes to utilize for processing DAG state changes\nin an asynchronous manner within the scheduler process.\n",
+                        "default": "1",
+                        "example": None,
+                        "type": "integer",
+                        "version_added": "1.8.0",
+                    },
                 },
             }
         },

airflow/providers/openlineage/plugins/adapter.py

@@ -16,6 +16,7 @@
 # under the License.
 from __future__ import annotations
 
+import traceback
 import uuid
 from contextlib import ExitStack
 from typing import TYPE_CHECKING
@@ -73,8 +74,16 @@ class OpenLineageAdapter(LoggingMixin):
         if not self._client:
             config = self.get_openlineage_config()
             if config:
+                self.log.debug(
+                    "OpenLineage configuration found. Transport type: `%s`",
+                    config.get("type", "no type provided"),
+                )
                 self._client = OpenLineageClient.from_dict(config=config)
             else:
+                self.log.debug(
+                    "OpenLineage configuration not found directly in Airflow. "
+                    "Looking for legacy environment configuration. "
+                )
                 self._client = OpenLineageClient.from_environment()
         return self._client
 
@@ -85,13 +94,19 @@ class OpenLineageAdapter(LoggingMixin):
             config = self._read_yaml_config(openlineage_config_path)
             if config:
                 return config.get("transport", None)
+            self.log.debug("OpenLineage config file is empty: `%s`", openlineage_config_path)
+        else:
+            self.log.debug("OpenLineage config_path configuration not found.")
+
         # Second, try to get transport config
         transport_config = conf.transport()
         if not transport_config:
+            self.log.debug("OpenLineage transport configuration not found.")
             return None
         return transport_config
 
-    def _read_yaml_config(self, path: str) -> dict | None:
+    @staticmethod
+    def _read_yaml_config(path: str) -> dict | None:
         with open(path) as config_file:
             return yaml.safe_load(config_file)
 
@@ -125,6 +140,7 @@ class OpenLineageAdapter(LoggingMixin):
                 stack.enter_context(Stats.timer(f"ol.emit.attempts.{event_type}.{transport_type}"))
                 stack.enter_context(Stats.timer("ol.emit.attempts"))
                 self._client.emit(redacted_event)
+                self.log.debug("Successfully emitted OpenLineage event of id %s", event.run.runId)
         except Exception as e:
             Stats.incr("ol.emit.failed")
             self.log.warning("Failed to emit OpenLineage event of id %s", event.run.runId)
@@ -284,48 +300,66 @@ class OpenLineageAdapter(LoggingMixin):
         nominal_start_time: str,
         nominal_end_time: str,
     ):
-        event = RunEvent(
-            eventType=RunState.START,
-            eventTime=dag_run.start_date.isoformat(),
-            job=self._build_job(job_name=dag_run.dag_id, job_type=_JOB_TYPE_DAG),
-            run=self._build_run(
-                run_id=self.build_dag_run_id(dag_run.dag_id, dag_run.run_id),
-                job_name=dag_run.dag_id,
-                nominal_start_time=nominal_start_time,
-                nominal_end_time=nominal_end_time,
-            ),
-            inputs=[],
-            outputs=[],
-            producer=_PRODUCER,
-        )
-        self.emit(event)
+        try:
+            event = RunEvent(
+                eventType=RunState.START,
+                eventTime=dag_run.start_date.isoformat(),
+                job=self._build_job(job_name=dag_run.dag_id, job_type=_JOB_TYPE_DAG),
+                run=self._build_run(
+                    run_id=self.build_dag_run_id(dag_run.dag_id, dag_run.run_id),
+                    job_name=dag_run.dag_id,
+                    nominal_start_time=nominal_start_time,
+                    nominal_end_time=nominal_end_time,
+                ),
+                inputs=[],
+                outputs=[],
+                producer=_PRODUCER,
+            )
+            self.emit(event)
+        except BaseException:
+            # Catch all exceptions to prevent ProcessPoolExecutor from silently swallowing them.
+            # This ensures that any unexpected exceptions are logged for debugging purposes.
+            # This part cannot be wrapped to deduplicate code, otherwise the method cannot be pickled in multiprocessing.
+            self.log.warning("Failed to emit DAG started event: \n %s", traceback.format_exc())
 
     def dag_success(self, dag_run: DagRun, msg: str):
-        event = RunEvent(
-            eventType=RunState.COMPLETE,
-            eventTime=dag_run.end_date.isoformat(),
-            job=self._build_job(job_name=dag_run.dag_id, job_type=_JOB_TYPE_DAG),
-            run=Run(runId=self.build_dag_run_id(dag_run.dag_id, dag_run.run_id)),
-            inputs=[],
-            outputs=[],
-            producer=_PRODUCER,
-        )
-        self.emit(event)
+        try:
+            event = RunEvent(
+                eventType=RunState.COMPLETE,
+                eventTime=dag_run.end_date.isoformat(),
+                job=self._build_job(job_name=dag_run.dag_id, job_type=_JOB_TYPE_DAG),
+                run=Run(runId=self.build_dag_run_id(dag_run.dag_id, dag_run.run_id)),
+                inputs=[],
+                outputs=[],
+                producer=_PRODUCER,
+            )
+            self.emit(event)
+        except BaseException:
+            # Catch all exceptions to prevent ProcessPoolExecutor from silently swallowing them.
+            # This ensures that any unexpected exceptions are logged for debugging purposes.
+            # This part cannot be wrapped to deduplicate code, otherwise the method cannot be pickled in multiprocessing.
+            self.log.warning("Failed to emit DAG success event: \n %s", traceback.format_exc())
 
     def dag_failed(self, dag_run: DagRun, msg: str):
-        event = RunEvent(
-            eventType=RunState.FAIL,
-            eventTime=dag_run.end_date.isoformat(),
-            job=self._build_job(job_name=dag_run.dag_id, job_type=_JOB_TYPE_DAG),
-            run=Run(
-                runId=self.build_dag_run_id(dag_run.dag_id, dag_run.run_id),
-                facets={"errorMessage": ErrorMessageRunFacet(message=msg, programmingLanguage="python")},
-            ),
-            inputs=[],
-            outputs=[],
-            producer=_PRODUCER,
-        )
-        self.emit(event)
+        try:
+            event = RunEvent(
+                eventType=RunState.FAIL,
+                eventTime=dag_run.end_date.isoformat(),
+                job=self._build_job(job_name=dag_run.dag_id, job_type=_JOB_TYPE_DAG),
+                run=Run(
+                    runId=self.build_dag_run_id(dag_run.dag_id, dag_run.run_id),
+                    facets={"errorMessage": ErrorMessageRunFacet(message=msg, programmingLanguage="python")},
+                ),
+                inputs=[],
+                outputs=[],
+                producer=_PRODUCER,
+            )
+            self.emit(event)
+        except BaseException:
+            # Catch all exceptions to prevent ProcessPoolExecutor from silently swallowing them.
+            # This ensures that any unexpected exceptions are logged for debugging purposes.
+            # This part cannot be wrapped to deduplicate code, otherwise the method cannot be pickled in multiprocessing.
+            self.log.warning("Failed to emit DAG failed event: \n %s", traceback.format_exc())
 
     @staticmethod
     def _build_run(

airflow/providers/openlineage/plugins/listener.py

@@ -17,13 +17,15 @@
 from __future__ import annotations
 
 import logging
-from concurrent.futures import ThreadPoolExecutor
+from concurrent.futures import ProcessPoolExecutor
 from datetime import datetime
 from typing import TYPE_CHECKING
 
 from openlineage.client.serde import Serde
 
+from airflow import __version__ as airflow_version, settings
 from airflow.listeners import hookimpl
+from airflow.providers.openlineage import conf
 from airflow.providers.openlineage.extractors import ExtractorManager
 from airflow.providers.openlineage.plugins.adapter import OpenLineageAdapter, RunState
 from airflow.providers.openlineage.utils.utils import (
@@ -45,6 +47,16 @@ if TYPE_CHECKING:
 _openlineage_listener: OpenLineageListener | None = None
 
 
+def _get_try_number_success(val):
+    # todo: remove when min airflow version >= 2.10.0
+    from packaging.version import parse
+
+    if parse(parse(airflow_version).base_version) < parse("2.10.0"):
+        return val.try_number - 1
+    else:
+        return val.try_number
+
+
 class OpenLineageListener:
     """OpenLineage listener sends events on task instance and dag run starts, completes and failures."""
 
@@ -78,13 +90,19 @@ class OpenLineageListener:
         dag = task.dag
         if is_operator_disabled(task):
             self.log.debug(
-                "Skipping OpenLineage event emission for operator %s "
+                "Skipping OpenLineage event emission for operator `%s` "
                 "due to its presence in [openlineage] disabled_for_operators.",
                 task.task_type,
             )
-            return None
+            return
 
         if not is_selective_lineage_enabled(task):
+            self.log.debug(
+                "Skipping OpenLineage event emission for task `%s` "
+                "due to lack of explicit lineage enablement for task or DAG while "
+                "[openlineage] selective_enable is on.",
+                task.task_id,
+            )
             return
 
         @print_warning(self.log)
@@ -146,15 +164,22 @@ class OpenLineageListener:
         if TYPE_CHECKING:
             assert task
         dag = task.dag
+
         if is_operator_disabled(task):
             self.log.debug(
-                "Skipping OpenLineage event emission for operator %s "
+                "Skipping OpenLineage event emission for operator `%s` "
                 "due to its presence in [openlineage] disabled_for_operators.",
                 task.task_type,
             )
-            return None
+            return
 
         if not is_selective_lineage_enabled(task):
+            self.log.debug(
+                "Skipping OpenLineage event emission for task `%s` "
+                "due to lack of explicit lineage enablement for task or DAG while "
+                "[openlineage] selective_enable is on.",
+                task.task_id,
+            )
             return
 
         @print_warning(self.log)
@@ -165,7 +190,7 @@ class OpenLineageListener:
                 dag_id=dag.dag_id,
                 task_id=task.task_id,
                 execution_date=task_instance.execution_date,
-                try_number=task_instance.try_number - 1,
+                try_number=_get_try_number_success(task_instance),
             )
             event_type = RunState.COMPLETE.value.lower()
             operator_name = task.task_type.lower()
@@ -201,15 +226,22 @@ class OpenLineageListener:
         if TYPE_CHECKING:
             assert task
         dag = task.dag
+
         if is_operator_disabled(task):
             self.log.debug(
-                "Skipping OpenLineage event emission for operator %s "
+                "Skipping OpenLineage event emission for operator `%s` "
                 "due to its presence in [openlineage] disabled_for_operators.",
                 task.task_type,
             )
-            return None
+            return
 
         if not is_selective_lineage_enabled(task):
+            self.log.debug(
+                "Skipping OpenLineage event emission for task `%s` "
+                "due to lack of explicit lineage enablement for task or DAG while "
+                "[openlineage] selective_enable is on.",
+                task.task_id,
+            )
             return
 
         @print_warning(self.log)
@@ -249,8 +281,16 @@ class OpenLineageListener:
 
     @property
     def executor(self):
+        def initializer():
+            # Re-configure the ORM engine as there are issues with multiple processes
+            # if process calls Airflow DB.
+            settings.configure_orm()
+
         if not self._executor:
-            self._executor = ThreadPoolExecutor(max_workers=8, thread_name_prefix="openlineage_")
+            self._executor = ProcessPoolExecutor(
+                max_workers=conf.dag_state_change_process_pool_size(),
+                initializer=initializer,
+            )
         return self._executor
 
     @hookimpl
@@ -266,7 +306,18 @@ class OpenLineageListener:
     @hookimpl
     def on_dag_run_running(self, dag_run: DagRun, msg: str):
         if dag_run.dag and not is_selective_lineage_enabled(dag_run.dag):
+            self.log.debug(
+                "Skipping OpenLineage event emission for DAG `%s` "
+                "due to lack of explicit lineage enablement for DAG while "
+                "[openlineage] selective_enable is on.",
+                dag_run.dag_id,
+            )
+            return
+
+        if not self.executor:
+            self.log.debug("Executor have not started before `on_dag_run_running`")
             return
+
         data_interval_start = dag_run.data_interval_start.isoformat() if dag_run.data_interval_start else None
         data_interval_end = dag_run.data_interval_end.isoformat() if dag_run.data_interval_end else None
         self.executor.submit(
@@ -280,19 +331,35 @@ class OpenLineageListener:
     @hookimpl
     def on_dag_run_success(self, dag_run: DagRun, msg: str):
         if dag_run.dag and not is_selective_lineage_enabled(dag_run.dag):
+            self.log.debug(
+                "Skipping OpenLineage event emission for DAG `%s` "
+                "due to lack of explicit lineage enablement for DAG while "
+                "[openlineage] selective_enable is on.",
+                dag_run.dag_id,
+            )
             return
+
         if not self.executor:
             self.log.debug("Executor have not started before `on_dag_run_success`")
             return
+
         self.executor.submit(self.adapter.dag_success, dag_run=dag_run, msg=msg)
 
     @hookimpl
     def on_dag_run_failed(self, dag_run: DagRun, msg: str):
         if dag_run.dag and not is_selective_lineage_enabled(dag_run.dag):
+            self.log.debug(
+                "Skipping OpenLineage event emission for DAG `%s` "
+                "due to lack of explicit lineage enablement for DAG while "
+                "[openlineage] selective_enable is on.",
+                dag_run.dag_id,
+            )
             return
+
         if not self.executor:
             self.log.debug("Executor have not started before `on_dag_run_failed`")
             return
+
         self.executor.submit(self.adapter.dag_failed, dag_run=dag_run, msg=msg)
 
 

airflow/providers/openlineage/plugins/openlineage.py

@@ -39,3 +39,6 @@ class OpenLineageProviderPlugin(AirflowPlugin):
     if not conf.is_disabled():
         macros = [lineage_job_namespace, lineage_job_name, lineage_run_id, lineage_parent_id]
         listeners = [get_openlineage_listener()]
+    else:
+        macros = []
+        listeners = []

airflow/providers/openlineage/utils/utils.py

@@ -25,8 +25,10 @@ from functools import wraps
 from typing import TYPE_CHECKING, Any, Iterable
 
 import attrs
-from openlineage.client.utils import RedactMixin  # TODO: move this maybe to Airflow's logic?
+from deprecated import deprecated
+from openlineage.client.utils import RedactMixin
 
+from airflow.exceptions import AirflowProviderDeprecationWarning  # TODO: move this maybe to Airflow's logic?
 from airflow.models import DAG, BaseOperator, MappedOperator
 from airflow.providers.openlineage import conf
 from airflow.providers.openlineage.plugins.facets import (
@@ -41,6 +43,7 @@ from airflow.providers.openlineage.utils.selective_enable import (
 )
 from airflow.utils.context import AirflowContextDeprecationWarning
 from airflow.utils.log.secrets_masker import Redactable, Redacted, SecretsMasker, should_hide_value_for_key
+from airflow.utils.module_loading import import_string
 
 if TYPE_CHECKING:
     from airflow.models import DagRun, TaskInstance
@@ -50,6 +53,11 @@ log = logging.getLogger(__name__)
 _NOMINAL_TIME_FORMAT = "%Y-%m-%dT%H:%M:%S.%fZ"
 
 
+def try_import_from_string(string: str) -> Any:
+    with suppress(ImportError):
+        return import_string(string)
+
+
 def get_operator_class(task: BaseOperator) -> type:
     if task.__class__.__name__ in ("DecoratedMappedOperator", "MappedOperator"):
         return task.operator_class
@@ -367,6 +375,9 @@ def print_warning(log):
             try:
                 return f(*args, **kwargs)
             except Exception as e:
+                log.warning(
+                    "Note: exception below is being caught: it's printed for visibility. However OpenLineage events aren't being emitted. If you see that, task has completed successfully despite not getting OL events."
+                )
                 log.warning(e)
 
         return wrapper
@@ -379,6 +390,13 @@ def get_filtered_unknown_operator_keys(operator: BaseOperator) -> dict:
     return {attr: value for attr, value in operator.__dict__.items() if attr not in not_required_keys}
 
 
+@deprecated(
+    reason=(
+        "`airflow.providers.openlineage.utils.utils.normalize_sql` "
+        "has been deprecated and will be removed in future"
+    ),
+    category=AirflowProviderDeprecationWarning,
+)
 def normalize_sql(sql: str | Iterable[str]):
     if isinstance(sql, str):
         sql = [stmt for stmt in sql.split(";") if stmt != ""]

{apache_airflow_providers_openlineage-1.7.1.dist-info → apache_airflow_providers_openlineage-1.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: apache-airflow-providers-openlineage
-Version: 1.7.1
+Version: 1.8.0
 Summary: Provider package apache-airflow-providers-openlineage for Apache Airflow
 Keywords: airflow-provider,openlineage,airflow,integration
 Author-email: Apache Software Foundation <dev@airflow.apache.org>
@@ -28,8 +28,8 @@ Requires-Dist: openlineage-integration-common>=0.28.0
 Requires-Dist: openlineage-python>=0.28.0
 Requires-Dist: apache-airflow-providers-common-sql ; extra == "common.sql"
 Project-URL: Bug Tracker, https://github.com/apache/airflow/issues
-Project-URL: Changelog, https://airflow.apache.org/docs/apache-airflow-providers-openlineage/1.7.1/changelog.html
-Project-URL: Documentation, https://airflow.apache.org/docs/apache-airflow-providers-openlineage/1.7.1
+Project-URL: Changelog, https://airflow.apache.org/docs/apache-airflow-providers-openlineage/1.8.0/changelog.html
+Project-URL: Documentation, https://airflow.apache.org/docs/apache-airflow-providers-openlineage/1.8.0
 Project-URL: Slack Chat, https://s.apache.org/airflow-slack
 Project-URL: Source Code, https://github.com/apache/airflow
 Project-URL: Twitter, https://twitter.com/ApacheAirflow
@@ -80,7 +80,7 @@ Provides-Extra: common.sql
 
 Package ``apache-airflow-providers-openlineage``
 
-Release: ``1.7.1``
+Release: ``1.8.0``
 
 
 `OpenLineage <https://openlineage.io/>`__
@@ -93,7 +93,7 @@ This is a provider package for ``openlineage`` provider. All classes for this pr
 are in ``airflow.providers.openlineage`` python package.
 
 You can find package information and changelog for the provider
-in the `documentation <https://airflow.apache.org/docs/apache-airflow-providers-openlineage/1.7.1/>`_.
+in the `documentation <https://airflow.apache.org/docs/apache-airflow-providers-openlineage/1.8.0/>`_.
 
 Installation
 ------------
@@ -137,4 +137,4 @@ Dependent package
 ============================================================================================================  ==============
 
 The changelog for the provider package can be found in the
-`changelog <https://airflow.apache.org/docs/apache-airflow-providers-openlineage/1.7.1/changelog.html>`_.
+`changelog <https://airflow.apache.org/docs/apache-airflow-providers-openlineage/1.8.0/changelog.html>`_.

apache_airflow_providers_openlineage-1.8.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+airflow/providers/openlineage/LICENSE,sha256=ywUBpKZc7Jb96rVt5I3IDbg7dIJAbUSHkuoDcF3jbH4,13569
+airflow/providers/openlineage/__init__.py,sha256=Y_3EiIS_TiqaVpc68HfekILHQRlsSGQLhs72joO7THg,1498
+airflow/providers/openlineage/conf.py,sha256=wozXzU5Do9S0mtjjGc5ruF556G2-ZT4GJa3YLT_-Phg,4693
+airflow/providers/openlineage/get_provider_info.py,sha256=ypUFlQXsC6s-cA7OdslwUaxhjaYIslbP_OILdb9CVNQ,7072
+airflow/providers/openlineage/sqlparser.py,sha256=-FGWWK0Xu6XkGSXcfn7PXsWIe0Y0fwe-3hivHg7emLA,15308
+airflow/providers/openlineage/extractors/__init__.py,sha256=I0X4f6zUniclyD9zT0DFHRImpCpJVP4MkPJT3cd7X5I,1081
+airflow/providers/openlineage/extractors/base.py,sha256=o6z8bXwNor1hwcUzezJ8LIPynR_BqXkP-qtwEgLtD2Q,5476
+airflow/providers/openlineage/extractors/bash.py,sha256=m4hLvDV4-zX4gp8apRuhpAR3Uakr8UOUxf-thTWmOxw,2563
+airflow/providers/openlineage/extractors/manager.py,sha256=9TyszMLAsgPS9NETWq7fPJjxcbTFk47x4kd1NRGCvsw,10315
+airflow/providers/openlineage/extractors/python.py,sha256=EQXCj2aHr2XXw0pNxeX-ii8UQFCoqkdf40ozqmA5d58,3151
+airflow/providers/openlineage/plugins/__init__.py,sha256=9hdXHABrVpkbpjZgUft39kOFL2xSGeG4GEua0Hmelus,785
+airflow/providers/openlineage/plugins/adapter.py,sha256=d_HczG_nXMwAHdGD-CO4baVfCc9ROcY0zQUWIZRF_Sw,16917
+airflow/providers/openlineage/plugins/facets.py,sha256=Z6dsz0rv-3VbRaGZJxW_T7Dak2k0ROGF0YrR_1awxZ0,2644
+airflow/providers/openlineage/plugins/listener.py,sha256=LrqvvGL4nzMNeha6PVbtylxp8gru3iKrkQltuQD2k8o,14092
+airflow/providers/openlineage/plugins/macros.py,sha256=QowPc9cc_unV-NLxBwm32OmWETA9pOucWguSeK92SSc,3076
+airflow/providers/openlineage/plugins/openlineage.py,sha256=rsRUW_zpXVAglzsgQRv5T9VWYY7CMQl0qRWm8-3oqDA,1678
+airflow/providers/openlineage/utils/__init__.py,sha256=9hdXHABrVpkbpjZgUft39kOFL2xSGeG4GEua0Hmelus,785
+airflow/providers/openlineage/utils/selective_enable.py,sha256=JVTmXdQknBL-9N0drFDkVMf1HCf8C6nbITVaP4-5ba4,3072
+airflow/providers/openlineage/utils/sql.py,sha256=7tEK0zVfIe7v3NI6oyv62x0KAS3sl8Ajfhqob8MdiX8,9366
+airflow/providers/openlineage/utils/utils.py,sha256=WFMdRsuArqqrgjsmFGb_ljIWV6ry-EGkTPZzy5aiG4Q,14036
+apache_airflow_providers_openlineage-1.8.0.dist-info/entry_points.txt,sha256=GAx0_i2OeZzqaiiiYuA-xchICDXiCT5kVqpKSxsOjt4,214
+apache_airflow_providers_openlineage-1.8.0.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
+apache_airflow_providers_openlineage-1.8.0.dist-info/METADATA,sha256=cpXm9kSCT2wFTHbw9s6ZOBuNYq02RMhRRyrZMoTXXqY,6368
+apache_airflow_providers_openlineage-1.8.0.dist-info/RECORD,,

apache_airflow_providers_openlineage-1.7.1.dist-info/RECORD

@@ -1,24 +0,0 @@
-airflow/providers/openlineage/LICENSE,sha256=ywUBpKZc7Jb96rVt5I3IDbg7dIJAbUSHkuoDcF3jbH4,13569
-airflow/providers/openlineage/__init__.py,sha256=Xc1UFto3ZKaoNfnpJpkK8cxkSAtXxGbxhpZ624JXDko,1586
-airflow/providers/openlineage/conf.py,sha256=Y76TUM_YwQtn-_081wQicZPTe_8bXH8jNafx-GACgeo,3398
-airflow/providers/openlineage/get_provider_info.py,sha256=a_A_2VPU8M2vHZ5CX0_8yUawYEiFieMa3g5tmi3pEnU,6626
-airflow/providers/openlineage/sqlparser.py,sha256=-FGWWK0Xu6XkGSXcfn7PXsWIe0Y0fwe-3hivHg7emLA,15308
-airflow/providers/openlineage/extractors/__init__.py,sha256=I0X4f6zUniclyD9zT0DFHRImpCpJVP4MkPJT3cd7X5I,1081
-airflow/providers/openlineage/extractors/base.py,sha256=sj2KS23ocX7LAbkDiR53otkFg1qqEg41PyBivdc-kyM,5070
-airflow/providers/openlineage/extractors/bash.py,sha256=lE7BH9vipRg9jGloPIE6y6wcHw_BbTvGBasfa4PfDBc,2412
-airflow/providers/openlineage/extractors/manager.py,sha256=wrhsculNW8Pj3BKofT3wDkCqiOFKXmxi-nBd9AifTh4,9996
-airflow/providers/openlineage/extractors/python.py,sha256=1iCC4_Due500ulkHmc_qvt8JGzxxb6suLeYS2FRYDlc,2999
-airflow/providers/openlineage/plugins/__init__.py,sha256=9hdXHABrVpkbpjZgUft39kOFL2xSGeG4GEua0Hmelus,785
-airflow/providers/openlineage/plugins/adapter.py,sha256=YcVf_mC6ZTJEb3soRMzb96fypmWZB19M07-mn5Nh-Gc,14634
-airflow/providers/openlineage/plugins/facets.py,sha256=Z6dsz0rv-3VbRaGZJxW_T7Dak2k0ROGF0YrR_1awxZ0,2644
-airflow/providers/openlineage/plugins/listener.py,sha256=lw9IGw_JL_EP_FEVfKmR8JJuDz8xyQFCibgQF2kdHOg,11624
-airflow/providers/openlineage/plugins/macros.py,sha256=QowPc9cc_unV-NLxBwm32OmWETA9pOucWguSeK92SSc,3076
-airflow/providers/openlineage/plugins/openlineage.py,sha256=Owlbpp8puiww-4Wh6B46vYK2vLoGVK48qOW7RyZF188,1625
-airflow/providers/openlineage/utils/__init__.py,sha256=9hdXHABrVpkbpjZgUft39kOFL2xSGeG4GEua0Hmelus,785
-airflow/providers/openlineage/utils/selective_enable.py,sha256=JVTmXdQknBL-9N0drFDkVMf1HCf8C6nbITVaP4-5ba4,3072
-airflow/providers/openlineage/utils/sql.py,sha256=7tEK0zVfIe7v3NI6oyv62x0KAS3sl8Ajfhqob8MdiX8,9366
-airflow/providers/openlineage/utils/utils.py,sha256=duT_rXHQuVFUIbMCplGGw0OI0RN0DAXU8oo8FaqcREg,13285
-apache_airflow_providers_openlineage-1.7.1.dist-info/entry_points.txt,sha256=GAx0_i2OeZzqaiiiYuA-xchICDXiCT5kVqpKSxsOjt4,214
-apache_airflow_providers_openlineage-1.7.1.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
-apache_airflow_providers_openlineage-1.7.1.dist-info/METADATA,sha256=2ZflQLoDUko_JC2iEjy_b3NnjSrhMKwWpzZnP_dIc1o,6368
-apache_airflow_providers_openlineage-1.7.1.dist-info/RECORD,,