infrahub-server 1.2.0b1__py3-none-any.whl → 1.2.1__py3-none-any.whl

infrahub/telemetry/models.py

@@ -0,0 +1,65 @@
+from pydantic import BaseModel
+
+from .constants import InfrahubType
+
+
+class TelemetryWorkerData(BaseModel):
+    total: int
+    active: int
+
+
+class TelemetryBranchData(BaseModel):
+    total: int
+
+
+class TelemetrySchemaData(BaseModel):
+    node_count: int
+    generic_count: int
+    last_update: str
+
+
+class TelemetryDatabaseServerData(BaseModel):
+    name: str
+    version: str
+
+
+class TelemetryDatabaseSystemInfoData(BaseModel):
+    memory_total: int
+    memory_available: int
+    processor_available: int
+
+
+class TelemetryDatabaseData(BaseModel):
+    database_type: str
+    relationship_count: dict[str, int]
+    node_count: dict[str, int]
+    servers: list[TelemetryDatabaseServerData]
+    system_info: TelemetryDatabaseSystemInfoData | None
+
+
+class TelemetryWorkPoolData(BaseModel):
+    name: str
+    type: str
+    total_workers: int
+    active_workers: int
+
+
+class TelemetryPrefectData(BaseModel):
+    events: dict[str, int]
+    automations: dict[str, int]
+    work_pools: list[TelemetryWorkPoolData]
+
+
+class TelemetryData(BaseModel):
+    deployment_id: str | None
+    execution_time: float | None
+    infrahub_version: str
+    infrahub_type: InfrahubType
+    python_version: str
+    platform: str
+    workers: TelemetryWorkerData
+    branches: TelemetryBranchData
+    features: dict[str, int]
+    schema_info: TelemetrySchemaData
+    database: TelemetryDatabaseData
+    prefect: TelemetryPrefectData

infrahub/telemetry/task_manager.py

@@ -0,0 +1,77 @@
+from typing import Any
+
+from prefect import task
+from prefect.cache_policies import NONE
+from prefect.client.orchestration import PrefectClient, get_client
+from prefect.client.schemas.objects import WorkerStatus
+
+from infrahub.events.utils import get_all_events
+from infrahub.trigger.constants import NAME_SEPARATOR
+from infrahub.trigger.models import TriggerType
+
+from .models import TelemetryPrefectData, TelemetryWorkPoolData
+
+
+@task(name="telemetry-gather-work-pools", task_run_name="Gather Work Pools", cache_policy=NONE)
+async def gather_prefect_work_pools(client: PrefectClient) -> list[TelemetryWorkPoolData]:
+    work_pools = await client.read_work_pools()
+    data: list[TelemetryWorkPoolData] = []
+
+    for pool in work_pools:
+        workers = await client.read_workers_for_work_pool(work_pool_name=pool.name)
+        data.append(
+            TelemetryWorkPoolData(
+                name=pool.name,
+                type=pool.type,
+                total_workers=len(workers),
+                active_workers=len([item for item in workers if item.status == WorkerStatus.ONLINE]),
+            )
+        )
+
+    return data
+
+
+@task(name="telemetry-gather-events", task_run_name="Gather Events", cache_policy=NONE)
+async def gather_prefect_events(client: PrefectClient) -> dict[str, Any]:
+    infrahub_events = get_all_events()
+    events: dict[str, int] = {}
+
+    async def count_events(event_name: str) -> int:
+        payload = {"filter": {"event": {"name": [event_name]}}}
+        response = await client._client.post("/events/count-by/event", json=payload)
+        response.raise_for_status()
+        data = response.json()
+        if not isinstance(data, list) or len(data) == 0:
+            return 0
+        return data[0]["count"]
+
+    for event in infrahub_events:
+        events[event.event_name] = await count_events(event_name=event.event_name)
+
+    return events
+
+
+@task(name="telemetry-gather-automations", task_run_name="Gather Automations", cache_policy=NONE)
+async def gather_prefect_automations(client: PrefectClient) -> dict[str, Any]:
+    automations = await client.read_automations()
+
+    data: dict[str, Any] = {}
+
+    for trigger_type in TriggerType:
+        data[trigger_type.value] = len(
+            [item for item in automations if item.name.startswith(f"{trigger_type.value}{NAME_SEPARATOR}")]
+        )
+
+    return data
+
+
+@task(name="telemetry-gather-prefect-information", task_run_name="Gather Prefect Information", cache_policy=NONE)
+async def gather_prefect_information() -> TelemetryPrefectData:
+    async with get_client(sync_client=False) as client:
+        data = TelemetryPrefectData(
+            work_pools=await gather_prefect_work_pools(client=client),
+            events=await gather_prefect_events(client=client),
+            automations=await gather_prefect_automations(client=client),
+        )
+
+        return data

infrahub/{tasks/telemetry.py → telemetry/tasks.py}

@@ -12,44 +12,32 @@ from infrahub import __version__, config
 from infrahub.core import registry, utils
 from infrahub.core.branch import Branch
 from infrahub.core.constants import InfrahubKind
-from infrahub.core.graph.schema import GRAPH_SCHEMA
 from infrahub.services import InfrahubServices
 
-TELEMETRY_KIND: str = "community"
-TELEMETRY_VERSION: str = "20240524"
+from .constants import TELEMETRY_KIND, TELEMETRY_VERSION
+from .database import gather_database_information
+from .models import (
+    TelemetryBranchData,
+    TelemetryData,
+    TelemetrySchemaData,
+    TelemetryWorkerData,
+)
+from .task_manager import gather_prefect_information
+from .utils import determine_infrahub_type
 
 
-@task(name="telemetry-gather-db", task_run_name="Gather Database Information", cache_policy=NONE)  # type: ignore[arg-type]
-async def gather_database_information(service: InfrahubServices) -> dict:
-    async with service.database.start_session() as db:
-        data: dict[str, Any] = {
-            "database_type": db.db_type.value,
-            "relationship_count": {"total": await utils.count_relationships(db=db)},
-            "node_count": {"total": await utils.count_nodes(db=db)},
-        }
-
-        for name in GRAPH_SCHEMA["relationships"]:
-            data["relationship_count"][name] = await utils.count_relationships(db=db, label=name)
-
-        for name in GRAPH_SCHEMA["nodes"]:
-            data["node_count"][name] = await utils.count_nodes(db=db, label=name)
-
-        return data
-
-
-@task(name="telemetry-schema-information", task_run_name="Gather Schema Information", cache_policy=NONE)  # type: ignore[arg-type]
-async def gather_schema_information(branch: Branch) -> dict:
-    data: dict[str, Any] = {}
+@task(name="telemetry-schema-information", task_run_name="Gather Schema Information", cache_policy=NONE)
+async def gather_schema_information(branch: Branch) -> TelemetrySchemaData:
     main_schema = registry.schema.get_schema_branch(name=branch.name)
-    data["node_count"] = len(main_schema.node_names)
-    data["generic_count"] = len(main_schema.generic_names)
-    data["last_update"] = branch.schema_changed_at
-
-    return data
+    return TelemetrySchemaData(
+        node_count=len(main_schema.node_names),
+        generic_count=len(main_schema.generic_names),
+        last_update=branch.schema_changed_at or "",
+    )
 
 
-@task(name="telemetry-feature-information", task_run_name="Gather Feature Information", cache_policy=NONE)  # type: ignore[arg-type]
-async def gather_feature_information(service: InfrahubServices) -> dict:
+@task(name="telemetry-feature-information", task_run_name="Gather Feature Information", cache_policy=NONE)
+async def gather_feature_information(service: InfrahubServices) -> dict[str, int]:
     async with service.database.start_session() as db:
         data = {}
         features_to_count = [
@@ -59,7 +47,9 @@ async def gather_feature_information(service: InfrahubServices) -> dict:
             InfrahubKind.GENERICGROUP,
             InfrahubKind.PROFILE,
             InfrahubKind.PROPOSEDCHANGE,
+            InfrahubKind.OBJECTTEMPLATE,
             InfrahubKind.TRANSFORM,
+            InfrahubKind.WEBHOOK,
         ]
         for kind in features_to_count:
             data[kind] = await utils.count_nodes(db=db, label=kind)
@@ -67,37 +57,39 @@ async def gather_feature_information(service: InfrahubServices) -> dict:
         return data
 
 
-@task(name="telemetry-gather-data", task_run_name="Gather Anonynous Data", cache_policy=NONE)  # type: ignore[arg-type]
-async def gather_anonymous_telemetry_data(service: InfrahubServices) -> dict:
+@task(name="telemetry-gather-data", task_run_name="Gather Anonynous Data", cache_policy=NONE)
+async def gather_anonymous_telemetry_data(service: InfrahubServices) -> TelemetryData:
     start_time = time.time()
 
     default_branch = registry.get_branch_from_registry()
     workers = await service.component.list_workers(branch=default_branch.name, schema_hash=False)
 
-    data: dict[str, Any] = {
-        "deployment_id": registry.id,
-        "execution_time": None,
-        "infrahub_version": __version__,
-        "python_version": platform.python_version(),
-        "platform": platform.machine(),
-        "workers": {
-            "total": len(workers),
-            "active": len([w for w in workers if w.active]),
-        },
-        "branches": {
-            "total": len(registry.branch),
-        },
-        "features": await gather_feature_information(service=service),
-        "schema": await gather_schema_information(branch=default_branch),
-        "database": await gather_database_information(service=service),
-    }
-
-    data["execution_time"] = time.time() - start_time
+    data = TelemetryData(
+        deployment_id=registry.id,
+        execution_time=None,
+        infrahub_version=__version__,
+        infrahub_type=determine_infrahub_type(),
+        python_version=platform.python_version(),
+        platform=platform.machine(),
+        workers=TelemetryWorkerData(
+            total=len(workers),
+            active=len([w for w in workers if w.active]),
+        ),
+        branches=TelemetryBranchData(
+            total=len(registry.branch),
+        ),
+        features=await gather_feature_information(service=service),
+        schema_info=await gather_schema_information(branch=default_branch),
+        database=await gather_database_information(db=service.database),
+        prefect=await gather_prefect_information(),
+    )
+
+    data.execution_time = time.time() - start_time
 
     return data
 
 
-@task(name="telemetry-post-data", task_run_name="Upload data", retries=5, cache_policy=NONE)  # type: ignore[arg-type]
+@task(name="telemetry-post-data", task_run_name="Upload data", retries=5, cache_policy=NONE)
 async def post_telemetry_data(service: InfrahubServices, url: str, payload: dict[str, Any]) -> None:
     """Send the telemetry data to the specified URL, using HTTP POST."""
     response = await service.http.post(url=url, json=payload)
@@ -114,13 +106,14 @@ async def send_telemetry_push(service: InfrahubServices) -> None:
     log.info(f"Pushing anonymous telemetry data to {config.SETTINGS.main.telemetry_endpoint}...")
 
     data = await gather_anonymous_telemetry_data(service=service)
-    log.info(f"Anonymous usage telemetry gathered in {data['execution_time']} seconds. | {data}")
+    data_dict = data.model_dump(mode="json")
+    log.info(f"Anonymous usage telemetry gathered in {data.execution_time} seconds. | {data_dict}")
 
     payload = {
         "kind": TELEMETRY_KIND,
         "payload_format": TELEMETRY_VERSION,
-        "data": data,
-        "checksum": hashlib.sha256(json.dumps(data).encode()).hexdigest(),
+        "data": data_dict,
+        "checksum": hashlib.sha256(json.dumps(data_dict).encode()).hexdigest(),
     }
 
     await post_telemetry_data(service=service, url=config.SETTINGS.main.telemetry_endpoint, payload=payload)

infrahub/telemetry/utils.py

@@ -0,0 +1,11 @@
+import importlib.metadata
+
+from .constants import InfrahubType
+
+
+def determine_infrahub_type() -> InfrahubType:
+    try:
+        importlib.metadata.version("infrahub-enterprise")
+        return InfrahubType.ENTERPRISE
+    except importlib.metadata.PackageNotFoundError:
+        return InfrahubType.COMMUNITY

infrahub/trace.py

@@ -9,7 +9,7 @@ from opentelemetry.exporter.otlp.proto.http.trace_exporter import (
 )
 from opentelemetry.sdk.resources import Resource
 from opentelemetry.sdk.trace import TracerProvider
-from opentelemetry.sdk.trace.export import BatchSpanProcessor, ConsoleSpanExporter
+from opentelemetry.sdk.trace.export import BatchSpanProcessor, ConsoleSpanExporter, SpanExporter
 from opentelemetry.trace import StatusCode
 
 from infrahub.worker import WORKER_IDENTITY
@@ -19,7 +19,7 @@ def get_current_span_with_context() -> trace.Span:
     return trace.get_current_span()
 
 
-def get_traceid() -> str:
+def get_traceid() -> str | None:
     current_span = get_current_span_with_context()
     trace_id = current_span.get_span_context().trace_id
     if trace_id == 0:
@@ -63,7 +63,7 @@ def create_tracer_provider(
 ) -> TracerProvider:
     # Create a BatchSpanProcessor exporter based on the type
     if exporter_type == "console":
-        exporter = ConsoleSpanExporter()
+        exporter: SpanExporter = ConsoleSpanExporter()
     elif exporter_type == "otlp":
         if not exporter_endpoint:
             raise ValueError("Exporter type is set to otlp but endpoint is not set")
@@ -76,7 +76,7 @@ def create_tracer_provider(
 
     extra_attributes = {}
     if os.getenv("OTEL_RESOURCE_ATTRIBUTES"):
-        extra_attributes = dict(attr.split("=") for attr in os.getenv("OTEL_RESOURCE_ATTRIBUTES").split(","))
+        extra_attributes = dict(attr.split("=") for attr in os.getenv("OTEL_RESOURCE_ATTRIBUTES", "").split(","))
 
     # Resource can be required for some backends, e.g. Jaeger
     resource = Resource(

infrahub/transformations/tasks.py

@@ -30,7 +30,7 @@ async def transform_python(message: TransformPythonData, service: InfrahubServic
         location=message.transform_location,
         data=message.data,
         client=service.client,
-    )
+    )  # type: ignore[misc]
 
     return transformed_data
 
@@ -49,6 +49,6 @@ async def transform_render_jinja2_template(message: TransformJinjaTemplateData,
 
     rendered_template = await repo.render_jinja2_template.with_options(timeout_seconds=message.timeout)(
         commit=message.commit, location=message.template_location, data={"data": message.data}
-    )
+    )  # type: ignore[misc]
 
     return rendered_template

infrahub/trigger/catalogue.py

@@ -1,16 +1,13 @@
 from infrahub.computed_attribute.triggers import (
     TRIGGER_COMPUTED_ATTRIBUTE_ALL_SCHEMA,
-    TRIGGER_COMPUTED_ATTRIBUTE_PYTHON_CLEAN_BRANCH,
-    TRIGGER_COMPUTED_ATTRIBUTE_PYTHON_SETUP_BRANCH,
     TRIGGER_COMPUTED_ATTRIBUTE_PYTHON_SETUP_COMMIT,
 )
 from infrahub.trigger.models import TriggerDefinition
-from infrahub.webhook.triggers import TRIGGER_WEBHOOK_SETUP_UPDATE
+from infrahub.webhook.triggers import TRIGGER_WEBHOOK_DELETE, TRIGGER_WEBHOOK_SETUP_UPDATE
 
 builtin_triggers: list[TriggerDefinition] = [
     TRIGGER_COMPUTED_ATTRIBUTE_ALL_SCHEMA,
-    TRIGGER_COMPUTED_ATTRIBUTE_PYTHON_CLEAN_BRANCH,
-    TRIGGER_COMPUTED_ATTRIBUTE_PYTHON_SETUP_BRANCH,
     TRIGGER_COMPUTED_ATTRIBUTE_PYTHON_SETUP_COMMIT,
+    TRIGGER_WEBHOOK_DELETE,
     TRIGGER_WEBHOOK_SETUP_UPDATE,
 ]

infrahub/trigger/constants.py

@@ -1,9 +1 @@
-DEPRECATED_STATIC_TRIGGER_NAMES = [
-    "Trigger-branch-create-events",  # used in 1.1.x
-    "Trigger-branch-remove-events",  # used in 1.1.x
-    "Trigger-webhook-update-configuration",  # used in 1.1.x
-    "Trigger-repository-commit-update-event",  # used in 1.1.x
-    "Trigger-schema-update-event",  # used in 1.1.x
-]
-
 NAME_SEPARATOR = "::"

infrahub/trigger/models.py

@@ -10,6 +10,7 @@ from prefect.events.schemas.automations import Posture
 from prefect.events.schemas.events import ResourceSpecification
 from pydantic import BaseModel, Field
 
+from infrahub import __version__
 from infrahub.workflows.models import WorkflowDefinition  # noqa: TC001
 
 from .constants import NAME_SEPARATOR
@@ -21,8 +22,10 @@ if TYPE_CHECKING:
 class TriggerType(str, Enum):
     BUILTIN = "builtin"
     WEBHOOK = "webhook"
+    COMPUTED_ATTR_JINJA2 = "computed_attr_jinja2"
+    COMPUTED_ATTR_PYTHON = "computed_attr_python"
+    COMPUTED_ATTR_PYTHON_QUERY = "computed_attr_python_query"
     # OBJECT = "object"
-    # COMPUTED_ATTR = "computed_attr"
 
 
 class EventTrigger(BaseModel):
@@ -93,6 +96,9 @@ class TriggerDefinition(BaseModel):
         """Return the name of all deployments used by this trigger"""
         return [action.name for action in self.actions]
 
+    def get_description(self) -> str:
+        return f"Automation for Trigger {self.name} of type {self.type.value} (v{__version__})"
+
     def generate_name(self) -> str:
         return f"{self.type.value}{NAME_SEPARATOR}{self.name}"
 
@@ -101,5 +107,12 @@ class TriggerDefinition(BaseModel):
             action.validate_parameters()
 
 
+class TriggerBranchDefinition(TriggerDefinition):
+    branch: str
+
+    def generate_name(self) -> str:
+        return f"{self.type.value}{NAME_SEPARATOR}{self.branch}{NAME_SEPARATOR}{self.name}"
+
+
 class BuiltinTriggerDefinition(TriggerDefinition):
     type: TriggerType = TriggerType.BUILTIN

infrahub/trigger/setup.py

@@ -0,0 +1,90 @@
+from typing import TYPE_CHECKING
+
+from prefect import get_run_logger, task
+from prefect.automations import AutomationCore
+from prefect.cache_policies import NONE
+from prefect.client.orchestration import PrefectClient
+from prefect.client.schemas.filters import DeploymentFilter, DeploymentFilterName
+
+from infrahub.trigger.models import TriggerDefinition
+
+from .models import TriggerType
+
+if TYPE_CHECKING:
+    from uuid import UUID
+
+
+@task(name="trigger-setup", task_run_name="Setup triggers", cache_policy=NONE)  # type: ignore[arg-type]
+async def setup_triggers(
+    client: PrefectClient,
+    triggers: list[TriggerDefinition],
+    trigger_type: TriggerType | None = None,
+) -> None:
+    log = get_run_logger()
+
+    if trigger_type:
+        log.info(f"Setting up triggers of type {trigger_type.value}")
+    else:
+        log.info("Setting up all triggers")
+
+    # -------------------------------------------------------------
+    # Retrieve existing Deployments and Automation from the server
+    # -------------------------------------------------------------
+    deployment_names = list({name for trigger in triggers for name in trigger.get_deployment_names()})
+    deployments = {
+        item.name: item
+        for item in await client.read_deployments(
+            deployment_filter=DeploymentFilter(name=DeploymentFilterName(any_=deployment_names))
+        )
+    }
+    deployments_mapping: dict[str, UUID] = {name: item.id for name, item in deployments.items()}
+    existing_automations = {item.name: item for item in await client.read_automations()}
+
+    # If a trigger type is provided, narrow down the list of existing triggers to know which one to delete
+    if trigger_type:
+        trigger_automations = [
+            item.name for item in await client.read_automations() if item.name.startswith(trigger_type.value)
+        ]
+    else:
+        trigger_automations = [item.name for item in await client.read_automations()]
+
+    trigger_names = [trigger.generate_name() for trigger in triggers]
+
+    log.debug(f"{len(trigger_automations)} existing triggers ({trigger_automations})")
+    log.debug(f"{len(trigger_names)}  triggers to configure ({trigger_names})")
+
+    to_delete = set(trigger_automations) - set(trigger_names)
+    log.debug(f"{len(trigger_names)} triggers to delete ({to_delete})")
+
+    # -------------------------------------------------------------
+    # Create or Update all triggers
+    # -------------------------------------------------------------
+    for trigger in triggers:
+        automation = AutomationCore(
+            name=trigger.generate_name(),
+            description=trigger.get_description(),
+            enabled=True,
+            trigger=trigger.trigger.get_prefect(),
+            actions=[action.get_prefect(mapping=deployments_mapping) for action in trigger.actions],
+        )
+
+        existing_automation = existing_automations.get(trigger.generate_name(), None)
+
+        if existing_automation:
+            await client.update_automation(automation_id=existing_automation.id, automation=automation)
+            log.info(f"{trigger.generate_name()} Updated")
+        else:
+            await client.create_automation(automation=automation)
+            log.info(f"{trigger.generate_name()} Created")
+
+    # -------------------------------------------------------------
+    # Delete Triggers that shouldn't be there
+    # -------------------------------------------------------------
+    for item_to_delete in to_delete:
+        existing_automation = existing_automations.get(item_to_delete)
+
+        if not existing_automation:
+            continue
+
+        await client.delete_automation(automation_id=existing_automation.id)
+        log.info(f"{item_to_delete} Deleted")

infrahub/trigger/tasks.py

@@ -1,91 +1,36 @@
-from typing import TYPE_CHECKING
-
-from prefect import get_run_logger, task
-from prefect.automations import AutomationCore
-from prefect.cache_policies import NONE
-from prefect.client.orchestration import PrefectClient
-from prefect.client.schemas.filters import DeploymentFilter, DeploymentFilterName
-
-from infrahub.trigger.models import TriggerDefinition
-
-# from .catalogue import triggers
-from .models import TriggerType
-
-if TYPE_CHECKING:
-    from uuid import UUID
-
-
-@task(name="trigger-setup", task_run_name="Setup triggers of type {trigger_type.value}", cache_policy=NONE)  # type: ignore[arg-type]
-async def setup_triggers(
-    client: PrefectClient,
-    triggers: list[TriggerDefinition],
-    trigger_type: TriggerType = TriggerType.BUILTIN,
-    deprecated_triggers: list[str] | None = None,
-) -> None:
-    log = get_run_logger()
-
-    # -------------------------------------------------------------
-    # Retrieve existing Deployments and Automation from the server
-    # -------------------------------------------------------------
-    deployment_names = list({name for trigger in triggers for name in trigger.get_deployment_names()})
-    deployments = {
-        item.name: item
-        for item in await client.read_deployments(
-            deployment_filter=DeploymentFilter(name=DeploymentFilterName(any_=deployment_names))
+from prefect import flow
+from prefect.client.orchestration import get_client
+
+from infrahub.computed_attribute.gather import (
+    gather_trigger_computed_attribute_jinja2,
+    gather_trigger_computed_attribute_python,
+)
+from infrahub.services import InfrahubServices  # noqa: TC001  needed for prefect flow
+from infrahub.trigger.catalogue import builtin_triggers
+from infrahub.webhook.gather import gather_trigger_webhook
+
+from .setup import setup_triggers
+
+
+@flow(name="trigger-configure-all", flow_run_name="Configure all triggers")
+async def trigger_configure_all(service: InfrahubServices) -> None:
+    webhook_trigger = await gather_trigger_webhook(db=service.database)
+    computed_attribute_j2_triggers = await gather_trigger_computed_attribute_jinja2()
+    (
+        computed_attribute_python_triggers,
+        computed_attribute_python_query_triggers,
+    ) = await gather_trigger_computed_attribute_python(db=service.database)
+
+    triggers = (
+        computed_attribute_j2_triggers
+        + computed_attribute_python_triggers
+        + computed_attribute_python_query_triggers
+        + builtin_triggers
+        + webhook_trigger
+    )
+
+    async with get_client(sync_client=False) as prefect_client:
+        await setup_triggers(
+            client=prefect_client,
+            triggers=triggers,
         )
-    }
-    deployments_mapping: dict[str, UUID] = {name: item.id for name, item in deployments.items()}
-    existing_automations = {item.name: item for item in await client.read_automations()}
-
-    trigger_automations = [
-        item.name for item in await client.read_automations() if item.name.startswith(trigger_type.value)
-    ]
-    trigger_names = [trigger.generate_name() for trigger in triggers]
-
-    to_delete = set(trigger_automations) - set(trigger_names)
-
-    # -------------------------------------------------------------
-    # Create or Update all triggers
-    # -------------------------------------------------------------
-    for trigger in triggers:
-        automation = AutomationCore(
-            name=trigger.generate_name(),
-            description=trigger.description,
-            enabled=True,
-            trigger=trigger.trigger.get_prefect(),
-            actions=[action.get_prefect(mapping=deployments_mapping) for action in trigger.actions],
-        )
-
-        existing_automation = existing_automations.get(trigger.name, None)
-
-        if existing_automation:
-            await client.update_automation(automation_id=existing_automation.id, automation=automation)
-            log.info(f"{trigger.name} Updated")
-        else:
-            await client.create_automation(automation=automation)
-            log.info(f"{trigger.name} Created")
-
-    # -------------------------------------------------------------
-    # Delete Triggers that shouldn't be there
-    # -------------------------------------------------------------
-    for item_to_delete in to_delete:
-        existing_automation = existing_automations.get(item_to_delete)
-
-        if not existing_automation:
-            continue
-
-        await client.delete_automation(automation_id=existing_automation.id)
-        log.info(f"{item_to_delete} Deleted")
-
-    # -------------------------------------------------------------
-    # Delete Deprecated triggers
-    # -------------------------------------------------------------
-    if deprecated_triggers:
-        for trigger_name in deprecated_triggers:
-            existing_automation = existing_automations.get(trigger_name)
-
-            if not existing_automation:
-                continue
-
-            await client.delete_automation(automation_id=existing_automation.id)
-            log.info(f"{trigger_name} Deleted")