diff --git a/apps/event-queue/src/events/deployment-variables.ts b/apps/event-queue/src/events/deployment-variables.ts
index 4e93b2bcf..1afa49911 100644
--- a/apps/event-queue/src/events/deployment-variables.ts
+++ b/apps/event-queue/src/events/deployment-variables.ts
@@ -1,65 +1,146 @@
 import type { Event } from "@ctrlplane/events";
 
+import { makeWithSpan, trace } from "@ctrlplane/logger";
+
 import type { Handler } from ".";
 import { OperationPipeline } from "../workspace/pipeline.js";
 import { WorkspaceManager } from "../workspace/workspace.js";
 
-export const newDeploymentVariable: Handler<
-  Event.DeploymentVariableCreated
-> = async (event) => {
-  const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
-  if (ws == null) return;
-  await OperationPipeline.update(ws)
-    .deploymentVariable(event.payload)
-    .dispatch();
-};
+const newDeploymentVariableTracer = trace.getTracer("new-deployment-variable");
+const withNewDeploymentVariableSpan = makeWithSpan(newDeploymentVariableTracer);
+
+export const newDeploymentVariable: Handler<Event.DeploymentVariableCreated> =
+  withNewDeploymentVariableSpan(
+    "new-deployment-variable",
+    async (span, event) => {
+      span.setAttribute("event.type", event.eventType);
+      span.setAttribute("deployment-variable.id", event.payload.id);
+      span.setAttribute("deployment.id", event.payload.deploymentId);
+      span.setAttribute("workspace.id", event.workspaceId);
+      const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
+      if (ws == null) return;
+      await OperationPipeline.update(ws)
+        .deploymentVariable(event.payload)
+        .dispatch();
+    },
+  );
+
+const updatedDeploymentVariableTracer = trace.getTracer(
+  "updated-deployment-variable",
+);
+const withUpdatedDeploymentVariableSpan = makeWithSpan(
+  updatedDeploymentVariableTracer,
+);
+
+export const updatedDeploymentVariable: Handler<Event.DeploymentVariableUpdated> =
+  withUpdatedDeploymentVariableSpan(
+    "updated-deployment-variable",
+    async (span, event) => {
+      span.setAttribute("event.type", event.eventType);
+      span.setAttribute("deployment-variable.id", event.payload.current.id);
+      span.setAttribute("deployment.id", event.payload.current.deploymentId);
+      span.setAttribute("workspace.id", event.workspaceId);
+      const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
+      if (ws == null) return;
+      await OperationPipeline.update(ws)
+        .deploymentVariable(event.payload.current)
+        .dispatch();
+    },
+  );
+
+const deletedDeploymentVariableTracer = trace.getTracer(
+  "deleted-deployment-variable",
+);
+const withDeletedDeploymentVariableSpan = makeWithSpan(
+  deletedDeploymentVariableTracer,
+);
+
+export const deletedDeploymentVariable: Handler<Event.DeploymentVariableDeleted> =
+  withDeletedDeploymentVariableSpan(
+    "deleted-deployment-variable",
+    async (span, event) => {
+      span.setAttribute("event.type", event.eventType);
+      span.setAttribute("deployment-variable.id", event.payload.id);
+      span.setAttribute("deployment.id", event.payload.deploymentId);
+      span.setAttribute("workspace.id", event.workspaceId);
+      const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
+      if (ws == null) return;
+      await OperationPipeline.delete(ws)
+        .deploymentVariable(event.payload)
+        .dispatch();
+    },
+  );
+
+const newDeploymentVariableValueTracer = trace.getTracer(
+  "new-deployment-variable-value",
+);
+const withNewDeploymentVariableValueSpan = makeWithSpan(
+  newDeploymentVariableValueTracer,
+);
 
-export const updatedDeploymentVariable: Handler<
-  Event.DeploymentVariableUpdated
-> = async (event) => {
-  const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
-  if (ws == null) return;
-  await OperationPipeline.update(ws)
-    .deploymentVariable(event.payload.current)
-    .dispatch();
-};
+export const newDeploymentVariableValue: Handler<Event.DeploymentVariableValueCreated> =
+  withNewDeploymentVariableValueSpan(
+    "new-deployment-variable-value",
+    async (span, event) => {
+      span.setAttribute("deployment-variable-value.id", event.payload.id);
+      span.setAttribute("deployment-variable.id", event.payload.variableId);
+      span.setAttribute("workspace.id", event.workspaceId);
+      const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
+      if (ws == null) return;
+      await OperationPipeline.update(ws)
+        .deploymentVariableValue(event.payload)
+        .dispatch();
+    },
+  );
 
-export const deletedDeploymentVariable: Handler<
-  Event.DeploymentVariableDeleted
-> = async (event) => {
-  const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
-  if (ws == null) return;
-  await OperationPipeline.update(ws)
-    .deploymentVariable(event.payload)
-    .dispatch();
-};
+const updatedDeploymentVariableValueTracer = trace.getTracer(
+  "updated-deployment-variable-value",
+);
+const withUpdatedDeploymentVariableValueSpan = makeWithSpan(
+  updatedDeploymentVariableValueTracer,
+);
 
-export const newDeploymentVariableValue: Handler<
-  Event.DeploymentVariableValueCreated
-> = async (event) => {
-  const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
-  if (ws == null) return;
-  await OperationPipeline.update(ws)
-    .deploymentVariableValue(event.payload)
-    .dispatch();
-};
+export const updatedDeploymentVariableValue: Handler<Event.DeploymentVariableValueUpdated> =
+  withUpdatedDeploymentVariableValueSpan(
+    "updated-deployment-variable-value",
+    async (span, event) => {
+      span.setAttribute("event.type", event.eventType);
+      span.setAttribute(
+        "deployment-variable-value.id",
+        event.payload.current.id,
+      );
+      span.setAttribute(
+        "deployment-variable.id",
+        event.payload.current.variableId,
+      );
+      span.setAttribute("workspace.id", event.workspaceId);
+      const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
+      if (ws == null) return;
+      await OperationPipeline.update(ws)
+        .deploymentVariableValue(event.payload.current)
+        .dispatch();
+    },
+  );
 
-export const updatedDeploymentVariableValue: Handler<
-  Event.DeploymentVariableValueUpdated
-> = async (event) => {
-  const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
-  if (ws == null) return;
-  await OperationPipeline.update(ws)
-    .deploymentVariableValue(event.payload.current)
-    .dispatch();
-};
+const deletedDeploymentVariableValueTracer = trace.getTracer(
+  "deleted-deployment-variable-value",
+);
+const withDeletedDeploymentVariableValueSpan = makeWithSpan(
+  deletedDeploymentVariableValueTracer,
+);
 
-export const deletedDeploymentVariableValue: Handler<
-  Event.DeploymentVariableValueDeleted
-> = async (event) => {
-  const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
-  if (ws == null) return;
-  await OperationPipeline.update(ws)
-    .deploymentVariableValue(event.payload)
-    .dispatch();
-};
+export const deletedDeploymentVariableValue: Handler<Event.DeploymentVariableValueDeleted> =
+  withDeletedDeploymentVariableValueSpan(
+    "deleted-deployment-variable-value",
+    async (span, event) => {
+      span.setAttribute("event.type", event.eventType);
+      span.setAttribute("deployment-variable-value.id", event.payload.id);
+      span.setAttribute("deployment-variable.id", event.payload.variableId);
+      span.setAttribute("workspace.id", event.workspaceId);
+      const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
+      if (ws == null) return;
+      await OperationPipeline.delete(ws)
+        .deploymentVariableValue(event.payload)
+        .dispatch();
+    },
+  );
diff --git a/apps/event-queue/src/events/deployment-versions.ts b/apps/event-queue/src/events/deployment-versions.ts
index f480da748..bda2ebcdd 100644
--- a/apps/event-queue/src/events/deployment-versions.ts
+++ b/apps/event-queue/src/events/deployment-versions.ts
@@ -1,10 +1,15 @@
 import type * as schema from "@ctrlplane/db/schema";
 import type { Event } from "@ctrlplane/events";
 
+import { makeWithSpan, trace } from "@ctrlplane/logger";
+
 import type { Handler } from ".";
 import { OperationPipeline } from "../workspace/pipeline.js";
 import { WorkspaceManager } from "../workspace/workspace.js";
 
+const newDeploymentVersionTracer = trace.getTracer("new-deployment-version");
+const withNewDeploymentVersionSpan = makeWithSpan(newDeploymentVersionTracer);
+
 const getDeploymentVersionWithDates = (
   deploymentVersion: schema.DeploymentVersion,
 ) => {
@@ -12,37 +17,69 @@ const getDeploymentVersionWithDates = (
   return { ...deploymentVersion, createdAt };
 };
 
-export const newDeploymentVersion: Handler<
-  Event.DeploymentVersionCreated
-> = async (event) => {
-  const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
-  if (ws == null) return;
-  const deploymentVersion = getDeploymentVersionWithDates(event.payload);
-  await OperationPipeline.update(ws)
-    .deploymentVersion(deploymentVersion)
-    .dispatch();
-};
+export const newDeploymentVersion: Handler<Event.DeploymentVersionCreated> =
+  withNewDeploymentVersionSpan(
+    "new-deployment-version",
+    async (span, event) => {
+      span.setAttribute("event.type", event.eventType);
+      span.setAttribute("deployment-version.id", event.payload.id);
+      span.setAttribute("deployment.id", event.payload.deploymentId);
+      span.setAttribute("workspace.id", event.workspaceId);
+      const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
+      if (ws == null) return;
+      const deploymentVersion = getDeploymentVersionWithDates(event.payload);
+      await OperationPipeline.update(ws)
+        .deploymentVersion(deploymentVersion)
+        .dispatch();
+    },
+  );
+
+const updatedDeploymentVersionTracer = trace.getTracer(
+  "updated-deployment-version",
+);
+const withUpdatedDeploymentVersionSpan = makeWithSpan(
+  updatedDeploymentVersionTracer,
+);
 
-export const updatedDeploymentVersion: Handler<
-  Event.DeploymentVersionUpdated
-> = async (event) => {
-  const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
-  if (ws == null) return;
-  const deploymentVersion = getDeploymentVersionWithDates(
-    event.payload.current,
+export const updatedDeploymentVersion: Handler<Event.DeploymentVersionUpdated> =
+  withUpdatedDeploymentVersionSpan(
+    "updated-deployment-version",
+    async (span, event) => {
+      span.setAttribute("event.type", event.eventType);
+      span.setAttribute("deployment-version.id", event.payload.current.id);
+      span.setAttribute("deployment.id", event.payload.current.deploymentId);
+      span.setAttribute("workspace.id", event.workspaceId);
+      const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
+      if (ws == null) return;
+      const deploymentVersion = getDeploymentVersionWithDates(
+        event.payload.current,
+      );
+      await OperationPipeline.update(ws)
+        .deploymentVersion(deploymentVersion)
+        .dispatch();
+    },
   );
-  await OperationPipeline.update(ws)
-    .deploymentVersion(deploymentVersion)
-    .dispatch();
-};
 
-export const deletedDeploymentVersion: Handler<
-  Event.DeploymentVersionDeleted
-> = async (event) => {
-  const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
-  if (ws == null) return;
-  const deploymentVersion = getDeploymentVersionWithDates(event.payload);
-  await OperationPipeline.delete(ws)
-    .deploymentVersion(deploymentVersion)
-    .dispatch();
-};
+const deletedDeploymentVersionTracer = trace.getTracer(
+  "deleted-deployment-version",
+);
+const withDeletedDeploymentVersionSpan = makeWithSpan(
+  deletedDeploymentVersionTracer,
+);
+
+export const deletedDeploymentVersion: Handler<Event.DeploymentVersionDeleted> =
+  withDeletedDeploymentVersionSpan(
+    "deleted-deployment-version",
+    async (span, event) => {
+      span.setAttribute("event.type", event.eventType);
+      span.setAttribute("deployment-version.id", event.payload.id);
+      span.setAttribute("deployment.id", event.payload.deploymentId);
+      span.setAttribute("workspace.id", event.workspaceId);
+      const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
+      if (ws == null) return;
+      const deploymentVersion = getDeploymentVersionWithDates(event.payload);
+      await OperationPipeline.delete(ws)
+        .deploymentVersion(deploymentVersion)
+        .dispatch();
+    },
+  );
diff --git a/apps/event-queue/src/events/deployments.ts b/apps/event-queue/src/events/deployments.ts
index 43c093a58..ef9858647 100644
--- a/apps/event-queue/src/events/deployments.ts
+++ b/apps/event-queue/src/events/deployments.ts
@@ -1,31 +1,48 @@
 import type { Event } from "@ctrlplane/events";
 
+import { makeWithSpan, trace } from "@ctrlplane/logger";
+
 import type { Handler } from ".";
 import { OperationPipeline } from "../workspace/pipeline.js";
 import { WorkspaceManager } from "../workspace/workspace.js";
 
-export const newDeployment: Handler<Event.DeploymentCreated> = async (
-  event,
-) => {
-  const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
-  if (ws == null) return;
-  await OperationPipeline.update(ws).deployment(event.payload).dispatch();
-};
-
-export const updatedDeployment: Handler<Event.DeploymentUpdated> = async (
-  event,
-) => {
-  const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
-  if (ws == null) return;
-  await OperationPipeline.update(ws)
-    .deployment(event.payload.current)
-    .dispatch();
-};
-
-export const deletedDeployment: Handler<Event.DeploymentDeleted> = async (
-  event,
-) => {
-  const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
-  if (ws == null) return;
-  await OperationPipeline.delete(ws).deployment(event.payload).dispatch();
-};
+const newDeploymentTracer = trace.getTracer("new-deployment");
+const withNewDeploymentSpan = makeWithSpan(newDeploymentTracer);
+
+export const newDeployment: Handler<Event.DeploymentCreated> =
+  withNewDeploymentSpan("new-deployment", async (span, event) => {
+    span.setAttribute("event.type", event.eventType);
+    span.setAttribute("deployment.id", event.payload.id);
+    span.setAttribute("workspace.id", event.workspaceId);
+    const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
+    if (ws == null) return;
+    await OperationPipeline.update(ws).deployment(event.payload).dispatch();
+  });
+
+const updatedDeploymentTracer = trace.getTracer("updated-deployment");
+const withUpdatedDeploymentSpan = makeWithSpan(updatedDeploymentTracer);
+
+export const updatedDeployment: Handler<Event.DeploymentUpdated> =
+  withUpdatedDeploymentSpan("updated-deployment", async (span, event) => {
+    span.setAttribute("event.type", event.eventType);
+    span.setAttribute("deployment.id", event.payload.current.id);
+    span.setAttribute("workspace.id", event.workspaceId);
+    const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
+    if (ws == null) return;
+    await OperationPipeline.update(ws)
+      .deployment(event.payload.current)
+      .dispatch();
+  });
+
+const deletedDeploymentTracer = trace.getTracer("deleted-deployment");
+const withDeletedDeploymentSpan = makeWithSpan(deletedDeploymentTracer);
+
+export const deletedDeployment: Handler<Event.DeploymentDeleted> =
+  withDeletedDeploymentSpan("deleted-deployment", async (span, event) => {
+    span.setAttribute("event.type", event.eventType);
+    span.setAttribute("deployment.id", event.payload.id);
+    span.setAttribute("workspace.id", event.workspaceId);
+    const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
+    if (ws == null) return;
+    await OperationPipeline.delete(ws).deployment(event.payload).dispatch();
+  });
diff --git a/apps/event-queue/src/events/environments.ts b/apps/event-queue/src/events/environments.ts
index f1456562b..f5cfb049f 100644
--- a/apps/event-queue/src/events/environments.ts
+++ b/apps/event-queue/src/events/environments.ts
@@ -1,33 +1,50 @@
 import type { Event } from "@ctrlplane/events";
 
+import { makeWithSpan, trace } from "@ctrlplane/logger";
+
 import type { Handler } from ".";
 import { OperationPipeline } from "../workspace/pipeline.js";
 import { WorkspaceManager } from "../workspace/workspace.js";
 
-export const newEnvironment: Handler<Event.EnvironmentCreated> = async (
-  event,
-) => {
-  const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
-  if (ws == null) return;
-  const createdAt = new Date(event.payload.createdAt);
-  const environment = { ...event.payload, createdAt };
-  await OperationPipeline.update(ws).environment(environment).dispatch();
-};
-
-export const updatedEnvironment: Handler<Event.EnvironmentUpdated> = async (
-  event,
-) => {
-  const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
-  if (ws == null) return;
-  const createdAt = new Date(event.payload.current.createdAt);
-  const environment = { ...event.payload.current, createdAt };
-  await OperationPipeline.update(ws).environment(environment).dispatch();
-};
-
-export const deletedEnvironment: Handler<Event.EnvironmentDeleted> = async (
-  event,
-) => {
-  const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
-  if (ws == null) return;
-  await OperationPipeline.delete(ws).environment(event.payload).dispatch();
-};
+const newEnvironmentTracer = trace.getTracer("new-environment");
+const withNewEnvironmentSpan = makeWithSpan(newEnvironmentTracer);
+
+export const newEnvironment: Handler<Event.EnvironmentCreated> =
+  withNewEnvironmentSpan("new-environment", async (span, event) => {
+    span.setAttribute("event.type", event.eventType);
+    span.setAttribute("environment.id", event.payload.id);
+    span.setAttribute("workspace.id", event.workspaceId);
+    const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
+    if (ws == null) return;
+    const createdAt = new Date(event.payload.createdAt);
+    const environment = { ...event.payload, createdAt };
+    await OperationPipeline.update(ws).environment(environment).dispatch();
+  });
+
+const updatedEnvironmentTracer = trace.getTracer("updated-environment");
+const withUpdatedEnvironmentSpan = makeWithSpan(updatedEnvironmentTracer);
+
+export const updatedEnvironment: Handler<Event.EnvironmentUpdated> =
+  withUpdatedEnvironmentSpan("updated-environment", async (span, event) => {
+    span.setAttribute("event.type", event.eventType);
+    span.setAttribute("environment.id", event.payload.current.id);
+    span.setAttribute("workspace.id", event.workspaceId);
+    const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
+    if (ws == null) return;
+    const createdAt = new Date(event.payload.current.createdAt);
+    const environment = { ...event.payload.current, createdAt };
+    await OperationPipeline.update(ws).environment(environment).dispatch();
+  });
+
+const deletedEnvironmentTracer = trace.getTracer("deleted-environment");
+const withDeletedEnvironmentSpan = makeWithSpan(deletedEnvironmentTracer);
+
+export const deletedEnvironment: Handler<Event.EnvironmentDeleted> =
+  withDeletedEnvironmentSpan("deleted-environment", async (span, event) => {
+    span.setAttribute("event.type", event.eventType);
+    span.setAttribute("environment.id", event.payload.id);
+    span.setAttribute("workspace.id", event.workspaceId);
+    const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
+    if (ws == null) return;
+    await OperationPipeline.delete(ws).environment(event.payload).dispatch();
+  });
diff --git a/apps/event-queue/src/events/job.ts b/apps/event-queue/src/events/job.ts
index e2ae0fafa..6e3559791 100644
--- a/apps/event-queue/src/events/job.ts
+++ b/apps/event-queue/src/events/job.ts
@@ -1,6 +1,8 @@
 import type * as schema from "@ctrlplane/db/schema";
 import type { Event } from "@ctrlplane/events";
 
+import { makeWithSpan, trace } from "@ctrlplane/logger";
+
 import type { Handler } from ".";
 import { OperationPipeline } from "../workspace/pipeline.js";
 import { WorkspaceManager } from "../workspace/workspace.js";
@@ -14,10 +16,18 @@ const getJobWithDates = (job: schema.Job) => {
   return { ...job, createdAt, updatedAt, startedAt, completedAt };
 };
 
-export const updateJob: Handler<Event.JobUpdated> = async (event) => {
-  const { current } = event.payload;
-  const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
-  if (ws == null) return;
-  const job = getJobWithDates(current);
-  await OperationPipeline.update(ws).job(job).dispatch();
-};
+const updatedJobTracer = trace.getTracer("updated-job");
+const withUpdatedJobSpan = makeWithSpan(updatedJobTracer);
+
+export const updateJob: Handler<Event.JobUpdated> = withUpdatedJobSpan(
+  "updated-job",
+  async (span, event) => {
+    span.setAttribute("event.type", event.eventType);
+    span.setAttribute("job.id", event.payload.current.id);
+    span.setAttribute("workspace.id", event.workspaceId);
+    const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
+    if (ws == null) return;
+    const job = getJobWithDates(event.payload.current);
+    await OperationPipeline.update(ws).job(job).dispatch();
+  },
+);
diff --git a/apps/event-queue/src/events/policy.ts b/apps/event-queue/src/events/policy.ts
index b870ece64..ff10217df 100644
--- a/apps/event-queue/src/events/policy.ts
+++ b/apps/event-queue/src/events/policy.ts
@@ -1,5 +1,7 @@
 import type { Event, FullPolicy } from "@ctrlplane/events";
 
+import { makeWithSpan, trace } from "@ctrlplane/logger";
+
 import type { Handler } from ".";
 import { OperationPipeline } from "../workspace/pipeline.js";
 import { WorkspaceManager } from "../workspace/workspace.js";
@@ -27,30 +29,45 @@ const getPolicyWithDates = (policy: FullPolicy) => {
   };
 };
 
-export const newPolicy: Handler<Event.PolicyCreated> = async (event) => {
-  const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
-  if (ws == null) return;
-  const policy = getPolicyWithDates(event.payload);
-  await OperationPipeline.update(ws).policy(policy).dispatch();
-};
+const newPolicyTracer = trace.getTracer("new-policy");
+const withNewPolicySpan = makeWithSpan(newPolicyTracer);
 
-export const updatedPolicy: Handler<Event.PolicyUpdated> = async (event) => {
-  const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
-  if (ws == null) return;
-  const policy = getPolicyWithDates(event.payload.current);
-  await Promise.all(
-    event.payload.previous.targets.map((target) =>
-      ws.selectorManager.policyTargetReleaseTargetSelector.removeSelector(
-        target,
-      ),
-    ),
-  );
-  await OperationPipeline.update(ws).policy(policy).dispatch();
-};
+export const newPolicy: Handler<Event.PolicyCreated> = withNewPolicySpan(
+  "new-policy",
+  async (span, event) => {
+    span.setAttribute("event.type", event.eventType);
+    span.setAttribute("policy.id", event.payload.id);
+    span.setAttribute("workspace.id", event.workspaceId);
+    const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
+    if (ws == null) return;
+    const policy = getPolicyWithDates(event.payload);
+    await OperationPipeline.update(ws).policy(policy).dispatch();
+  },
+);
 
-export const deletedPolicy: Handler<Event.PolicyDeleted> = async (event) => {
-  const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
-  if (ws == null) return;
-  const policy = getPolicyWithDates(event.payload);
-  await OperationPipeline.delete(ws).policy(policy).dispatch();
-};
+const updatedPolicyTracer = trace.getTracer("updated-policy");
+const withUpdatedPolicySpan = makeWithSpan(updatedPolicyTracer);
+
+export const updatedPolicy: Handler<Event.PolicyUpdated> =
+  withUpdatedPolicySpan("updated-policy", async (span, event) => {
+    span.setAttribute("event.type", event.eventType);
+    span.setAttribute("policy.id", event.payload.current.id);
+    span.setAttribute("workspace.id", event.workspaceId);
+    const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
+    if (ws == null) return;
+    const policy = getPolicyWithDates(event.payload.current);
+    await OperationPipeline.update(ws).policy(policy).dispatch();
+  });
+
+const deletedPolicyTracer = trace.getTracer("deleted-policy");
+const withDeletedPolicySpan = makeWithSpan(deletedPolicyTracer);
+
+export const deletedPolicy: Handler<Event.PolicyDeleted> =
+  withDeletedPolicySpan("deleted-policy", async (span, event) => {
+    span.setAttribute("event.type", event.eventType);
+    span.setAttribute("policy.id", event.payload.id);
+    span.setAttribute("workspace.id", event.workspaceId);
+    const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
+    if (ws == null) return;
+    await OperationPipeline.delete(ws).policy(event.payload).dispatch();
+  });
diff --git a/apps/event-queue/src/events/release-targets.ts b/apps/event-queue/src/events/release-targets.ts
index bbe05d74f..63d4c68aa 100644
--- a/apps/event-queue/src/events/release-targets.ts
+++ b/apps/event-queue/src/events/release-targets.ts
@@ -1,15 +1,22 @@
 import type { Event } from "@ctrlplane/events";
 
+import { makeWithSpan, trace } from "@ctrlplane/logger";
+
 import type { Handler } from ".";
 import { OperationPipeline } from "../workspace/pipeline.js";
 import { WorkspaceManager } from "../workspace/workspace.js";
 
-export const evaluateReleaseTarget: Handler<
-  Event.EvaluateReleaseTarget
-> = async (event) => {
-  const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
-  if (ws == null) return;
-  await OperationPipeline.evaluate(ws)
-    .releaseTargets([event.payload.releaseTarget], event.payload.opts)
-    .dispatch();
-};
+const evaluateReleaseTargetTracer = trace.getTracer("evaluate-release-target");
+const withSpan = makeWithSpan(evaluateReleaseTargetTracer);
+
+export const evaluateReleaseTarget: Handler<Event.EvaluateReleaseTarget> =
+  withSpan("evaluate-release-target", async (span, event) => {
+    span.setAttribute("event.type", event.eventType);
+    span.setAttribute("releaseTarget.id", event.payload.releaseTarget.id);
+    span.setAttribute("workspace.id", event.workspaceId);
+    const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
+    if (ws == null) return;
+    await OperationPipeline.evaluate(ws)
+      .releaseTargets([event.payload.releaseTarget], event.payload.opts)
+      .dispatch();
+  });
diff --git a/apps/event-queue/src/events/resources.ts b/apps/event-queue/src/events/resources.ts
index 1d3dbcbb8..4974a0d92 100644
--- a/apps/event-queue/src/events/resources.ts
+++ b/apps/event-queue/src/events/resources.ts
@@ -19,12 +19,13 @@ const getResourceWithDates = (resource: FullResource) => {
 };
 
 const newResourceTracer = trace.getTracer("new-resource");
-const withSpan = makeWithSpan(newResourceTracer);
+const withNewResourceSpan = makeWithSpan(newResourceTracer);
 
-export const newResource: Handler<Event.ResourceCreated> = withSpan(
+export const newResource: Handler<Event.ResourceCreated> = withNewResourceSpan(
   "new-resource",
   async (span, event) => {
     span.setAttribute("resource.id", event.payload.id);
+    span.setAttribute("workspace.id", event.workspaceId);
     const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
     if (ws == null) return;
     const resource = getResourceWithDates(event.payload);
@@ -32,45 +33,89 @@ export const newResource: Handler<Event.ResourceCreated> = withSpan(
   },
 );
 
-export const updatedResource: Handler<Event.ResourceUpdated> = async (
-  event,
-) => {
-  const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
-  if (ws == null) return;
-  const current = getResourceWithDates(event.payload.current);
-  await OperationPipeline.update(ws).resource(current).dispatch();
-};
+const updatedResourceTracer = trace.getTracer("updated-resource");
+const withUpdatedResourceSpan = makeWithSpan(updatedResourceTracer);
 
-export const deletedResource: Handler<Event.ResourceDeleted> = async (
-  event,
-) => {
-  const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
-  if (ws == null) return;
-  await OperationPipeline.delete(ws).resource(event.payload).dispatch();
-};
+export const updatedResource: Handler<Event.ResourceUpdated> =
+  withUpdatedResourceSpan("updated-resource", async (span, event) => {
+    span.setAttribute("resource.id", event.payload.current.id);
+    span.setAttribute("workspace.id", event.workspaceId);
+    const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
+    if (ws == null) return;
+    const current = getResourceWithDates(event.payload.current);
+    await OperationPipeline.update(ws).resource(current).dispatch();
+  });
 
-export const newResourceVariable: Handler<
-  Event.ResourceVariableCreated
-> = async (event) => {
-  const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
-  if (ws == null) return;
-  await OperationPipeline.update(ws).resourceVariable(event.payload).dispatch();
-};
+const deletedResourceTracer = trace.getTracer("deleted-resource");
+const withDeletedResourceSpan = makeWithSpan(deletedResourceTracer);
 
-export const updatedResourceVariable: Handler<
-  Event.ResourceVariableUpdated
-> = async (event) => {
-  const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
-  if (ws == null) return;
-  await OperationPipeline.update(ws)
-    .resourceVariable(event.payload.current)
-    .dispatch();
-};
+export const deletedResource: Handler<Event.ResourceDeleted> =
+  withDeletedResourceSpan("deleted-resource", async (span, event) => {
+    span.setAttribute("resource.id", event.payload.id);
+    span.setAttribute("workspace.id", event.workspaceId);
+    const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
+    if (ws == null) return;
+    await OperationPipeline.delete(ws).resource(event.payload).dispatch();
+  });
 
-export const deletedResourceVariable: Handler<
-  Event.ResourceVariableDeleted
-> = async (event) => {
-  const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
-  if (ws == null) return;
-  await OperationPipeline.delete(ws).resourceVariable(event.payload).dispatch();
-};
+const newResourceVariableTracer = trace.getTracer("new-resource-variable");
+const withNewResourceVariableSpan = makeWithSpan(newResourceVariableTracer);
+
+export const newResourceVariable: Handler<Event.ResourceVariableCreated> =
+  withNewResourceVariableSpan("new-resource-variable", async (span, event) => {
+    span.setAttribute("event.type", event.eventType);
+    span.setAttribute("resource-variable.id", event.payload.id);
+    span.setAttribute("resource.id", event.payload.resourceId);
+    span.setAttribute("workspace.id", event.workspaceId);
+    const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
+    if (ws == null) return;
+    await OperationPipeline.update(ws)
+      .resourceVariable(event.payload)
+      .dispatch();
+  });
+
+const updatedResourceVariableTracer = trace.getTracer(
+  "updated-resource-variable",
+);
+const withUpdatedResourceVariableSpan = makeWithSpan(
+  updatedResourceVariableTracer,
+);
+
+export const updatedResourceVariable: Handler<Event.ResourceVariableUpdated> =
+  withUpdatedResourceVariableSpan(
+    "updated-resource-variable",
+    async (span, event) => {
+      span.setAttribute("event.type", event.eventType);
+      span.setAttribute("resource-variable.id", event.payload.current.id);
+      span.setAttribute("resource.id", event.payload.current.resourceId);
+      span.setAttribute("workspace.id", event.workspaceId);
+      const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
+      if (ws == null) return;
+      await OperationPipeline.update(ws)
+        .resourceVariable(event.payload.current)
+        .dispatch();
+    },
+  );
+
+const deletedResourceVariableTracer = trace.getTracer(
+  "deleted-resource-variable",
+);
+const withDeletedResourceVariableSpan = makeWithSpan(
+  deletedResourceVariableTracer,
+);
+
+export const deletedResourceVariable: Handler<Event.ResourceVariableDeleted> =
+  withDeletedResourceVariableSpan(
+    "deleted-resource-variable",
+    async (span, event) => {
+      span.setAttribute("event.type", event.eventType);
+      span.setAttribute("resource-variable.id", event.payload.id);
+      span.setAttribute("resource.id", event.payload.resourceId);
+      span.setAttribute("workspace.id", event.workspaceId);
+      const ws = await WorkspaceManager.getOrLoad(event.workspaceId);
+      if (ws == null) return;
+      await OperationPipeline.delete(ws)
+        .resourceVariable(event.payload)
+        .dispatch();
+    },
+  );