openlineage-prefect 0.0.1b3__tar.gz

openlineage_prefect-0.0.1b3/PKG-INFO

@@ -0,0 +1,81 @@
+Metadata-Version: 2.3
+Name: openlineage-prefect
+Version: 0.0.1b3
+Summary: OpenLineage integration with Prefect
+Keywords: openlineage,prefect
+Author: OpenLineage
+License: Apache-2.0
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: prefect>=3.8.5
+Requires-Dist: openlineage-python>=1.53.0
+Requires-Dist: mypy ; extra == 'dev'
+Requires-Dist: openlineage-python ; extra == 'dev'
+Requires-Dist: pillow ; extra == 'dev'
+Requires-Dist: pre-commit ; extra == 'dev'
+Requires-Dist: pytest>=8.3 ; extra == 'dev'
+Requires-Dist: pytest-asyncio ; extra == 'dev'
+Requires-Dist: pytest-cov ; extra == 'dev'
+Requires-Dist: pytest-env ; extra == 'dev'
+Requires-Dist: pytest-timeout>=2.3.1 ; extra == 'dev'
+Requires-Dist: pytest-xdist ; extra == 'dev'
+Requires-Python: >=3.12
+Project-URL: Homepage, https://openlineage.io/
+Project-URL: Source, https://github.com/OpenLineage/OpenLineage/tree/main/integration/prefect
+Provides-Extra: dev
+Description-Content-Type: text/markdown
+
+# Openlineage Prefect
+
+## Basic Configuration
+
+At a minimum, define a namespace, Prefect API URL and transport consisting of a type, URL and endpoint. All three can be supplied using environment variables.
+
+For example:
+
+```sh
+export OPENLINEAGE_NAMESPACE='prefect_test' &&
+export OPENLINEAGE__TRANSPORT__TYPE='http' &&
+export OPENLINEAGE__TRANSPORT__URL='http://lineageconsumer.com:5000' &&
+export OPENLINEAGE__TRANSPORT__ENDPOINT='/api/v1/lineage' &&
+export PREFECT_API_URL='http://prefecthost.com:4200/api'
+```
+
+For more details about OpenLineage transport options and how to configure them, consult the [OpenLineage Python Client Documentation](https://openlineage.io/docs/client/python/).
+
+## Execution
+
+Import the `openlineage_prefect` package and execute `collect_and_process_runs()` asynchronously in its own process.
+
+For example:
+
+```py
+import asyncio
+import openlineage_prefect
+from openlineage_prefect.prefect_adapter.listener import PrefectOpenLineageListener
+
+async def main():
+    await PrefectOpenLineageListener().collect_and_process_runs()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## Datasets
+
+The integration looks for datasets in Prefect Artifacts. To attach input and output datasets to job runs, use `create_table_artifact()` from the Artifact library. Provide a namespace, typically the dataset URI, and name to the adapter via an artifact's `table` and `description`, respectively. Distinguish the type of dataset by appending `_output` or `_input` to the description.
+
+For example:
+
+```py
+ol_table = [{"database_uri":"duckdb:///customers_db", "table":"customers"}]
+
+create_table_artifact(
+    key="upstream-insert",
+    table=ol_table,
+    description="ol-dataset_output"
+)
+```

openlineage_prefect-0.0.1b3/README.md

@@ -0,0 +1,51 @@
+# Openlineage Prefect
+
+## Basic Configuration
+
+At a minimum, define a namespace, Prefect API URL and transport consisting of a type, URL and endpoint. All three can be supplied using environment variables.
+
+For example:
+
+```sh
+export OPENLINEAGE_NAMESPACE='prefect_test' &&
+export OPENLINEAGE__TRANSPORT__TYPE='http' &&
+export OPENLINEAGE__TRANSPORT__URL='http://lineageconsumer.com:5000' &&
+export OPENLINEAGE__TRANSPORT__ENDPOINT='/api/v1/lineage' &&
+export PREFECT_API_URL='http://prefecthost.com:4200/api'
+```
+
+For more details about OpenLineage transport options and how to configure them, consult the [OpenLineage Python Client Documentation](https://openlineage.io/docs/client/python/).
+
+## Execution
+
+Import the `openlineage_prefect` package and execute `collect_and_process_runs()` asynchronously in its own process.
+
+For example:
+
+```py
+import asyncio
+import openlineage_prefect
+from openlineage_prefect.prefect_adapter.listener import PrefectOpenLineageListener
+
+async def main():
+    await PrefectOpenLineageListener().collect_and_process_runs()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## Datasets
+
+The integration looks for datasets in Prefect Artifacts. To attach input and output datasets to job runs, use `create_table_artifact()` from the Artifact library. Provide a namespace, typically the dataset URI, and name to the adapter via an artifact's `table` and `description`, respectively. Distinguish the type of dataset by appending `_output` or `_input` to the description.
+
+For example:
+
+```py
+ol_table = [{"database_uri":"duckdb:///customers_db", "table":"customers"}]
+
+create_table_artifact(
+    key="upstream-insert",
+    table=ol_table,
+    description="ol-dataset_output"
+)
+```

openlineage_prefect-0.0.1b3/pyproject.toml

@@ -0,0 +1,62 @@
+[build-system]
+requires = ["uv_build >= 0.12.10, <0.13.0"]
+build-backend = "uv_build"
+
+[project]
+name = "openlineage-prefect"
+version = "0.0.1b3"
+description = "OpenLineage integration with Prefect"
+readme = "README.md"
+requires-python = ">=3.12"
+keywords = [
+    "openlineage",
+    "prefect",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+]
+dependencies = [
+    "prefect>=3.8.5",
+    "openlineage-python>=1.53.0",
+]
+
+[[project.authors]]
+name = "OpenLineage"
+
+[project.license]
+text = "Apache-2.0"
+
+[project.optional-dependencies]
+dev = [
+    "mypy",
+    "openlineage-python",
+    "pillow",
+    "pre-commit",
+    "pytest>=8.3",
+    "pytest-asyncio",
+    "pytest-cov",
+    "pytest-env",
+    "pytest-timeout>=2.3.1",
+    "pytest-xdist",
+]
+
+[project.urls]
+Homepage = "https://openlineage.io/"
+Source = "https://github.com/OpenLineage/OpenLineage/tree/main/integration/prefect"
+
+[tool.bumpversion]
+current_version = "0.0.1b3"
+commit = false
+tag = false
+parse = '(?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)(?P<rc>.*)'
+serialize = [
+    "{major}.{minor}.{patch}{rc}",
+    "{major}.{minor}.{patch}",
+]
+
+[tool.bumpversion.files]
+filename = "pyproject.toml"

openlineage_prefect-0.0.1b3/pyproject.toml.orig

@@ -0,0 +1,56 @@
+[build-system]
+requires = ["uv_build >= 0.12.10, <0.13.0"]
+build-backend = "uv_build"
+
+[project]
+name = "openlineage-prefect"
+version = "0.0.1b3"
+description = "OpenLineage integration with Prefect"
+readme = "README.md"
+authors = [{name = "OpenLineage"}]
+license = {text = "Apache-2.0"}
+requires-python = ">=3.12"
+keywords = ["openlineage", "prefect"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+]
+
+dependencies = [
+    "prefect>=3.8.5",
+    "openlineage-python>=1.53.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "mypy",
+    "openlineage-python",
+    "pillow",
+    "pre-commit",
+    "pytest>=8.3",
+    "pytest-asyncio",
+    "pytest-cov",
+    "pytest-env",
+    "pytest-timeout>=2.3.1",
+    "pytest-xdist",
+]
+
+[project.urls]
+Homepage = "https://openlineage.io/"
+Source = "https://github.com/OpenLineage/OpenLineage/tree/main/integration/prefect"
+
+[tool.bumpversion]
+current_version = "0.0.1b3"
+commit = false
+tag = false
+parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)(?P<rc>.*)"
+serialize = [
+    "{major}.{minor}.{patch}{rc}",
+    "{major}.{minor}.{patch}"
+]
+
+[tool.bumpversion.files]
+filename = "pyproject.toml"

openlineage_prefect-0.0.1b3/src/openlineage_prefect/__init__.py

@@ -0,0 +1,2 @@
+# Copyright 2018-2026 contributors to the OpenLineage project
+# SPDX-License-Identifier: Apache-2.0

openlineage_prefect-0.0.1b3/src/openlineage_prefect/prefect_adapter/adapter.py

@@ -0,0 +1,190 @@
+# Copyright 2018-2026 contributors to the OpenLineage project
+# SPDX-License-Identifier: Apache-2.0
+
+import logging
+from datetime import datetime
+
+from .facets.run_facets import PrefectDeploymentRunFacet
+from openlineage.client import OpenLineageClient
+from openlineage.client.event_v2 import Dataset
+from openlineage.client.facet import (
+    JobTypeJobFacet,
+    NominalTimeRunFacet,
+    ParentRunFacet,
+)
+from openlineage.client.facet_v2 import job_dependencies_run, processing_engine_run
+from openlineage.client.run import Job, Run, RunEvent, RunState
+
+PRODUCER: str = "https://github.com/OpenLineage/openlineage/integration/prefect"
+
+logger: logging.Logger = logging.getLogger(__name__)
+
+
+class PrefectOpenLineageAdapter:
+    def __init__(self, client: OpenLineageClient | None = None):
+        self.client = client or OpenLineageClient()
+
+    def create_and_emit_flow_event(
+        self,
+        run_id: str,
+        event_type: str,
+        event_time: datetime,
+        flow_name: str | None = None,
+        flow_namespace: str | None = None,
+        prefect_version: str | None = None,
+        deployment_id: str | None = None,
+        deployment_created: str | None = None,
+        deployment_updated: str | None = None,
+        deployment_name: str | None = None,
+    ) -> RunEvent:
+        """Create and emit a flow-level OpenLineage event."""
+
+        match event_type:
+            case "START":
+                event_type = RunState.START
+            case "COMPLETE":
+                event_type = RunState.COMPLETE
+            case "FAILED":
+                event_type = RunState.FAIL
+
+        if deployment_id:
+            run_facets = {
+                "prefectDeployment": PrefectDeploymentRunFacet(
+                    deploymentId=deployment_id,
+                    created=deployment_created,
+                    updated=deployment_updated,
+                    name=deployment_name,
+                ),
+                "processingEngine": processing_engine_run.ProcessingEngineRunFacet(
+                    version=prefect_version, name="Prefect"
+                ),
+            }
+        else:
+            run_facets = {
+                "processingEngine": processing_engine_run.ProcessingEngineRunFacet(
+                    version=prefect_version, name="Prefect"
+                )
+            }
+
+        job_facets = {
+            "jobType": JobTypeJobFacet(
+                processingType="BATCH", integration="Prefect", jobType="FLOW"
+            )
+        }
+
+        run_event = RunEvent(
+            eventType=event_type,
+            eventTime=event_time.isoformat(),
+            run=Run(run_id, run_facets),
+            job=Job(flow_namespace, flow_name, job_facets),
+            producer=PRODUCER,
+        )
+
+        try:
+            self.client.emit(run_event)
+            logger.info("Emitted OpenLineage event successfully.")
+        except Exception:
+            logger.exception("OpenLineage event not sent.")
+
+    def create_and_emit_task_event(
+        self,
+        run_id: str,
+        event_type: str,
+        event_time: datetime,
+        expectedevent_time: datetime | None = None,
+        flow_run_id: str | None = None,
+        flow_name: str | None = None,
+        task_name: str | None  = None,
+        namespace: str | None  = None,
+        job_deps: list | None = None,
+        prefect_version: str | None = None,
+        deployment_id: str | None = None,
+        deployment_created: str | None = None,
+        deployment_updated: str | None = None,
+        deployment_name: str | None = None,
+        input_datasets: list | None = None,
+        output_datasets: list | None = None,
+    ) -> RunEvent:
+        """Create and emit a task-level OpenLineage event."""
+
+        match event_type:
+            case "START":
+                event_type = RunState.START
+            case "COMPLETE":
+                event_type = RunState.COMPLETE
+            case "FAILED":
+                event_type = RunState.FAIL
+
+        if deployment_id:
+            run_facets = {
+                "nominalTime": NominalTimeRunFacet(nominalStartTime=expectedevent_time),
+                "processingEngine": processing_engine_run.ProcessingEngineRunFacet(
+                    version=prefect_version, name="Prefect"
+                ),
+                "parentRun": ParentRunFacet(
+                    run={"run_id": flow_run_id},
+                    job={"namespace": namespace, "name": flow_name},
+                ),
+                "prefectDeployment": PrefectDeploymentRunFacet(
+                    deploymentId=deployment_id,
+                    created=deployment_created,
+                    updated=deployment_updated,
+                    name=deployment_name,
+                ),
+            }
+        else:
+            run_facets = {
+                "nominalTime": NominalTimeRunFacet(nominalStartTime=expectedevent_time),
+                "processingEngine": processing_engine_run.ProcessingEngineRunFacet(
+                    version=prefect_version, name="Prefect"
+                ),
+                "parentRun": ParentRunFacet(
+                    run={"runId": flow_run_id},
+                    job={"namespace": namespace, "name": flow_name},
+                ),
+            }
+
+        if job_deps:
+            upstream_jobs = [
+                job_dependencies_run.JobDependency(
+                    job=job_dependencies_run.JobIdentifier(
+                        namespace=dep["namespace"], name=dep["name"]
+                    )
+                )
+                for dep in job_deps
+            ]
+            run_facets["jobDependencies"] = (
+                job_dependencies_run.JobDependenciesRunFacet(upstream=upstream_jobs)
+            )
+
+        job_facets = {
+            "jobType": JobTypeJobFacet(
+                processingType="BATCH", integration="Prefect", jobType="TASK"
+            )
+        }
+
+        inputs = [
+            Dataset(namespace=dataset["uri"], name=dataset["table"])
+            for dataset in input_datasets
+        ]
+        outputs = [
+            Dataset(namespace=dataset["uri"], name=dataset["table"])
+            for dataset in output_datasets
+        ]
+
+        run_event = RunEvent(
+            eventType=event_type,
+            eventTime=event_time.isoformat(),
+            run=Run(run_id, run_facets),
+            job=Job(namespace, task_name, job_facets),
+            producer=PRODUCER,
+            inputs=inputs,
+            outputs=outputs,
+        )
+
+        try:
+            self.client.emit(run_event)
+            logger.info("Emitted OpenLineage event successfully.")
+        except Exception:
+            logger.exception("OpenLineage event not sent.")
+

openlineage_prefect-0.0.1b3/src/openlineage_prefect/prefect_adapter/facets/PrefectDeploymentRunFacet.json

@@ -0,0 +1,46 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://github.com/OpenLineage/openlineage/integration/facets/PrefectDeploymentRunFacet.json",
+  "$defs": {
+    "PrefectDeploymentRunFacet": {
+      "allOf": [
+        {
+          "$ref": "https://openlineage.io/spec/2-0-2/OpenLineage.json#/$defs/RunFacet"
+        },
+        {
+          "type": "object",
+          "properties": {
+            "deploymentId": {
+              "description": "The ID of the Prefect deployment",
+              "type": "string"
+            },
+            "created": {
+              "description": "An [ISO-8601](https://en.wikipedia.org/wiki/ISO_8601) timestamp representing when the deployment was created",
+              "type": "string",
+              "format": "date-time",
+              "example": "2020-12-17T03:00:00.000Z"
+            },
+            "updated": {
+              "description": "An [ISO-8601](https://en.wikipedia.org/wiki/ISO_8601) timestamp representing when the deployment was last updated",
+              "type": "string",
+              "format": "date-time",
+              "example": "2020-12-17T04:00:00.000Z"
+            },
+            "name": {
+              "description": "The name of the Prefect deployment",
+              "type": "string"
+            }
+          },
+          "required": ["deploymentId", "created", "updated", "name"]
+        }
+      ],
+      "type": "object"
+    }
+  },
+  "type": "object",
+  "properties": {
+    "PrefectDeploymentRunFacet": {
+      "$ref": "#/$defs/PrefectDeploymentRunFacet"
+    }
+  }
+}

openlineage_prefect-0.0.1b3/src/openlineage_prefect/prefect_adapter/facets/run_facets.py

@@ -0,0 +1,30 @@
+# Copyright 2018-2026 contributors to the OpenLineage project
+# SPDX-License-Identifier: Apache-2.0
+
+import attr
+from openlineage.client.facet import BaseFacet
+
+
+@attr.define
+class PrefectDeploymentRunFacet(BaseFacet):
+    deploymentId: str
+    created: str
+    updated: str
+    name: str
+
+    def __init__(self, deploymentId, created, updated, name):
+        super().__init__()
+        self.deploymentId = deploymentId
+        self.created = created
+        self.updated = updated
+        self.name = name
+
+    @staticmethod
+    def _get_schema() -> str:
+        return "https://raw.githubusercontent.com/OpenLineage/openlineage/integration/prefect/facets/PrefectDeploymentRunFacet.json"
+
+    @staticmethod
+    def _get_producer() -> str:
+        return (
+            "https://github.com/OpenLineage/openlineage/integration/prefect"
+        )

openlineage_prefect-0.0.1b3/src/openlineage_prefect/prefect_adapter/listener.py

@@ -0,0 +1,382 @@
+# Copyright 2018-2026 contributors to the OpenLineage project
+# SPDX-License-Identifier: Apache-2.0
+
+import ast
+import asyncio
+import logging
+import os
+from datetime import datetime
+
+from .adapter import PrefectOpenLineageAdapter
+from openlineage.client.uuid import generate_static_uuid
+
+from prefect import client
+from prefect.client.orchestration import get_client
+from prefect.events.clients import get_events_subscriber
+from prefect.events.filters import EventFilter, EventNameFilter
+from prefect.events.schemas.events import Event
+from prefect.exceptions import ObjectNotFound, PrefectHTTPStatusError
+
+JOB_NAMESPACE: str = os.environ.get("OPENLINEAGE_NAMESPACE", "default")
+
+logger: logging.Logger = logging.getLogger(__name__)
+
+
+class PrefectOpenLineageListener:
+    def __init__(
+        self,
+        client: client = None,
+        adapter: PrefectOpenLineageAdapter = None,
+    ):
+        self.client = client or get_client()
+        self.ol_adapter = adapter or PrefectOpenLineageAdapter()
+
+    def build_run_id(
+        self, execution_time: datetime, run_name: str, namespace: str
+    ) -> str:
+        """
+        Build a deterministic UUID for the OpenLineage run based on the execution
+        time, run name, and namespace.
+        """
+
+        return str(
+            generate_static_uuid(
+                instant=execution_time,
+                data=f"{namespace}.{run_name}".encode(),
+            )
+        )
+
+    async def get_deployment_and_flow_info(self, flow_run_id: str) -> tuple:
+        flow_run = await self.client.read_flow_run(flow_run_id)
+        flow_id = flow_run.flow_id
+        flow = await self.client.read_flow(flow_id)
+        flow_name = flow.name
+
+        try:
+            deployment = await self.client.read_deployment(flow_run.deployment_id)
+            try:
+                ns = deployment.job_variables["env"]["OPENLINEAGE_NAMESPACE"]
+            except KeyError:
+                ns = JOB_NAMESPACE
+                logger.info(
+                    "OPENLINEAGE_NAMESPACE deployment variable not found. Using \
+                    OPENLINEAGE_NAMESPACE env variable."
+                )
+                if JOB_NAMESPACE == "default":
+                    logger.info(
+                        "OPENLINEAGE_NAMESPACE env variable not set. Namespace will be 'default.'"
+                    )
+            return (
+                str(deployment.id),
+                flow_run.start_time,
+                deployment.created.isoformat(),
+                deployment.updated.isoformat(),
+                deployment.name,
+                ns,
+                flow_name,
+            )
+
+        except AttributeError:
+            logger.info("Deployment not found for flow run: %s", flow_run_id)
+            ns = JOB_NAMESPACE
+            logger.info(
+                "OPENLINEAGE_NAMESPACE deployment variable not found. Using \
+                OPENLINEAGE_NAMESPACE env variable."
+            )
+            if JOB_NAMESPACE == "default":
+                logger.info(
+                    "OPENLINEAGE_NAMESPACE env variable not set. Namespace will be 'default.'"
+                )
+
+            return (None, flow_run.start_time, None, None, None, ns, flow_name)
+
+    async def get_prefect_version(self) -> str | None:
+        """Retrieve the Prefect version from the Prefect API."""
+
+        try:
+            response = await self.client._client.get("/admin/version")
+            return response.json()
+        except TypeError:
+            logger.info(
+                "Cannot get the Prefect version. Did you set the PREFECT_API_URL?"
+            )
+
+    async def get_flow_ns(self, flow_run_id: str) -> str:
+        """
+        Looks for OPENLINEAGE_NAMESPACE job env variable in deployment.
+        """
+        flow_run = await self.client.read_flow_run(flow_run_id)
+        try:
+            deployment = await self.client.read_deployment(flow_run.deployment_id)
+            try:
+                ns = deployment.job_variables["env"]["OPENLINEAGE_NAMESPACE"]
+            except KeyError:
+                ns = JOB_NAMESPACE
+                logger.info(
+                    "OPENLINEAGE_NAMESPACE deployment variable not found. Using \
+                    OPENLINEAGE_NAMESPACE env variable."
+                )
+                if JOB_NAMESPACE == "default":
+                    logger.info(
+                        "OPENLINEAGE_NAMESPACE env variable not found. Namespace will be 'default.'"
+                    )
+            return ns
+        except AttributeError:
+            logger.info("Deployment not found for flow run: %s", flow_run_id)
+            logger.info(
+                "OPENLINEAGE_NAMESPACE deployment variable not found. Using \
+                OPENLINEAGE_NAMESPACE env variable."
+            )
+            if JOB_NAMESPACE == "default":
+                logger.info(
+                    "OPENLINEAGE_NAMESPACE env variable not found. Namespace will be 'default.'"
+                )
+            return JOB_NAMESPACE
+
+    async def get_job_ns(self, task_run_id: str) -> str:
+        """Look for the OPENLINEAGE_NAMESPACE job env variable in the parent deployment."""
+
+        task_run = await self.client.read_task_run(task_run_id)
+        return await self.get_flow_ns(task_run.flow_run_id)
+
+    async def get_flow_run_start_time(self, flow_run_id: str) -> datetime:
+        """Retrieve the start time of a flow run."""
+
+        flow_run = await self.client.read_flow_run(flow_run_id)
+        return flow_run.start_time
+
+    async def get_artifacts_by_task_run(self, run_id: str) -> list[dict]:
+        """Retrieve artifacts associated with a given task run ID."""
+        payload = {"artifacts": {"task_run_id": {"any_": [run_id]}}}
+        response = await self.client._client.post("/artifacts/filter", json=payload)
+        if response.status_code == 200:
+            dataset_info = []
+            artifacts = response.json()
+            for artifact in artifacts:
+                if artifact["description"] and "ol-dataset" in artifact["description"]:
+                    dataset_type = artifact["description"].split("_")[-1].lower()
+                    data_list = ast.literal_eval(artifact["data"])
+                    uri = data_list[0]["database_uri"].lower()
+                    table = data_list[0]["table"].lower()
+                    dataset_info.append(
+                        {"uri": uri, "table": table, "dataset_type": dataset_type}
+                    )
+            return dataset_info
+        logger.info("No datasets found for task run.")
+        return []
+
+    async def get_parent_runs(
+        self, payload: dict, prefect_task_run_id: str
+    ) -> list[dict]:
+        """Retrieve the parent runs for a given task run."""
+
+        try:
+            parent_runs = []
+            task_parents = payload["task_run"]["task_inputs"]["__parents__"]
+            for parent in task_parents:
+                task_run_id: str | None = (
+                    parent["id"] if parent["input_type"] == "task_run" else None
+                )
+                if task_run_id:
+                    parent_namespace: dict = await self.get_job_ns(task_run_id)
+                    parent_run = await self.client.read_task_run(task_run_id)
+                    parent_name = parent_run.name[0:-4]
+                    parent_run_id = self.build_run_id(
+                        parent_run.start_time, parent_name, parent_namespace
+                    )
+                    parent_runs.append(
+                        {
+                            "name": parent_name,
+                            "namespace": parent_namespace,
+                            "id": parent_run_id,
+                        }
+                    )
+            return parent_runs
+        except KeyError:
+            logger.info("No task parents found for %s", prefect_task_run_id)
+            return []
+
+    async def collect_and_process_flow_runs(
+        self, prefect_version: str, event: Event, event_state: str
+    ) -> None:
+        """Retrieve the flow runs for a given event and emit OpenLineage events."""
+
+        for res in event.related:
+            if res["prefect.resource.role"] == "flow":
+                flow_name = res["prefect.resource.name"]
+                prefect_flow_run_id = event.resource.id.split(".")[-1]
+                event_time: datetime = datetime.fromisoformat(
+                    event.resource["prefect.state-timestamp"]
+                )
+                deployment_and_flow_info = await self.get_deployment_and_flow_info(
+                    prefect_flow_run_id
+                )
+                deployment_id = deployment_and_flow_info[0]
+                start_time: datetime = deployment_and_flow_info[1]
+                deployment_created = deployment_and_flow_info[2]
+                deployment_updated = deployment_and_flow_info[3]
+                deployment_name = deployment_and_flow_info[4]
+                flow_namespace = deployment_and_flow_info[5]
+                try:
+                    ol_flow_run_id: str = self.build_run_id(
+                        start_time, flow_name, flow_namespace
+                    )
+                except AttributeError:
+                    logger.info(
+                        "No Prefect run found for %s. OpenLineage event will not be emitted.",
+                        prefect_flow_run_id,
+                    )
+                    continue
+
+                self.ol_adapter.create_and_emit_flow_event(
+                    run_id=ol_flow_run_id,
+                    event_type=event_state,
+                    event_time=event_time,
+                    flow_name=flow_name,
+                    flow_namespace=flow_namespace,
+                    prefect_version=prefect_version,
+                    deployment_id=deployment_id,
+                    deployment_created=deployment_created,
+                    deployment_updated=deployment_updated,
+                    deployment_name=deployment_name,
+                )
+
+    async def collect_and_process_task_runs(
+        self, prefect_version: str, event: Event, event_state: str
+    ) -> None:
+        """Retrieve the task runs for a given event and emit OpenLineage events."""
+
+        task_name = event.resource.name[0:-4]
+        event_time = datetime.fromisoformat(event.resource["prefect.state-timestamp"])
+        expected_start_time = event.payload["task_run"]["expected_start_time"]
+        prefect_task_run_id = event.resource.id.split(".")[-1]
+        try:
+            task_run = await self.client.read_task_run(prefect_task_run_id)
+            namespace = await self.get_job_ns(prefect_task_run_id)
+
+            # Skip task runs without a start time
+            if task_run.start_time:
+                run_start_time = task_run.start_time
+            else:
+                logger.warning(
+                    "No start time found for task run %s. An event will not be emitted.",
+                    prefect_task_run_id,
+                )
+                return
+
+            ol_task_run_id: str = self.build_run_id(
+                run_start_time, task_name, namespace
+            )
+
+            # Get datasets from Prefect Artifacts
+            datasets = await self.get_artifacts_by_task_run(prefect_task_run_id)
+            input_datasets = [
+                dataset for dataset in datasets if dataset["dataset_type"] == "input"
+            ]
+            output_datasets = [
+                dataset for dataset in datasets if dataset["dataset_type"] == "output"
+            ]
+
+            # Get job dependencies (Prefect "parents") info for JobDependenciesRunFacet
+            parent_runs = await self.get_parent_runs(event.payload, prefect_task_run_id)
+
+            # Get flow run info for ParentRunFacet
+            for res in event.related:
+                if res["prefect.resource.role"] == "flow-run":
+                    flow_run_id = res["prefect.resource.id"].split(".")[-1]
+                    deployment_and_flow_info = await self.get_deployment_and_flow_info(
+                        flow_run_id
+                    )
+                    deployment_id = deployment_and_flow_info[0]
+                    deployment_created = deployment_and_flow_info[2]
+                    deployment_updated = deployment_and_flow_info[3]
+                    deployment_name = deployment_and_flow_info[4]
+                    flow_name = deployment_and_flow_info[6]
+                    flow_start_time = deployment_and_flow_info[1]
+                    try:
+                        ol_flow_run_id: str = self.build_run_id(
+                            flow_start_time, flow_name, namespace
+                        )
+                    except AttributeError:
+                        logger.info(
+                            "No Prefect run found for %s. ParentRunFacet will not be included.",
+                            flow_run_id,
+                        )
+                        continue
+
+            self.ol_adapter.create_and_emit_task_event(
+                run_id=ol_task_run_id,
+                event_type=event_state,
+                event_time=event_time,
+                expectedevent_time=expected_start_time,
+                flow_run_id=ol_flow_run_id,
+                flow_name=flow_name,
+                task_name=task_name,
+                namespace=namespace,
+                job_deps=parent_runs,
+                prefect_version=prefect_version,
+                deployment_id=deployment_id,
+                deployment_created=deployment_created,
+                deployment_updated=deployment_updated,
+                deployment_name=deployment_name,
+                input_datasets=input_datasets,
+                output_datasets=output_datasets,
+            )
+        except (PrefectHTTPStatusError, ObjectNotFound):
+            logger.info(
+                "No Prefect run found for %s, will not attempt to create OpenLineage event.",
+                prefect_task_run_id,
+            )
+
+    async def collect_and_process_runs(self) -> None:
+        """Collect and process Prefect events."""
+
+        try:
+            os.environ.get("PREFECT_API_URL")
+        except TypeError:
+            logger.warning("PREFECT_API_URL not set. Prefect events will not be received.")
+            return
+
+        filter_criteria = EventFilter(
+            event=EventNameFilter(
+                prefix=[
+                    "prefect.task-run.",
+                    "prefect.flow-run.",
+                    "prefect.asset.materialization.",
+                ]
+            )
+        )
+
+        async with get_events_subscriber(filter=filter_criteria) as subscriber, self.client:
+            prefect_version = await self.get_prefect_version()
+
+            async for event in subscriber:
+                entity_type = event.event.split(".")[1]
+                prefect_state = event.event.split(".")[-1]
+
+                if prefect_state in ["Running", "Completed", "Failed"]:
+                    match prefect_state:
+                        case "Running":
+                            event_state = "START"
+                        case "Completed":
+                            event_state = "COMPLETE"
+                        case "Failed":
+                            event_state = "FAILED"
+
+                    if entity_type == "flow-run":
+                        await self.collect_and_process_flow_runs(
+                            prefect_version, event, event_state
+                        )
+
+                    if entity_type == "task-run":
+                        await self.collect_and_process_task_runs(
+                            prefect_version, event, event_state
+                        )
+
+
+async def main():
+    await PrefectOpenLineageListener().collect_and_process_runs()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())