added custom metric sample

.gitignore

@@ -1,3 +1,5 @@
 .venv
 .idea
 __pycache__
+.vscode
+.DS_Store

README.md

@@ -61,6 +61,7 @@ Some examples require extra dependencies. See each sample's directory for specif
 * [context_propagation](context_propagation) - Context propagation through workflows/activities via interceptor.
 * [custom_converter](custom_converter) - Use a custom payload converter to handle custom types.
 * [custom_decorator](custom_decorator) - Custom decorator to auto-heartbeat a long-running activity.
+* [custom_metric](custom_metric) - Custom metric to record the workflow type in the activity schedule to start latency.
 * [dsl](dsl) - DSL workflow that executes steps defined in a YAML file.
 * [encryption](encryption) - Apply end-to-end encryption for all input/output.
 * [gevent_async](gevent_async) - Combine gevent and Temporal.

custom_metric/README.md

@@ -0,0 +1,33 @@
+# Custom Metric
+
+1. Run the server with `temporal server start-dev`
+2. Run the client with `uv run custom_metric/client.py`
+3. Run the workflow worker with `uv run custom_metric/workflow_worker.py`
+4. Run the activity worker with `uv run custom_metric/activity_worker.py`
+5. Go to `http://127.0.0.1:9090/metrics` in your browser
+
+You'll get something like the following:
+
+```txt
+custom_activity_schedule_to_start_latency_bucket{activity_type="print_message",namespace="default",service_name="temporal-core-sdk",task_queue="custom-metric-task-queue",workflow_type="ExecuteActivityWorkflow",le="100"} 0
+custom_activity_schedule_to_start_latency_bucket{activity_type="print_message",namespace="default",service_name="temporal-core-sdk",task_queue="custom-metric-task-queue",workflow_type="ExecuteActivityWorkflow",le="500"} 0
+custom_activity_schedule_to_start_latency_bucket{activity_type="print_message",namespace="default",service_name="temporal-core-sdk",task_queue="custom-metric-task-queue",workflow_type="ExecuteActivityWorkflow",le="1000"} 0
+custom_activity_schedule_to_start_latency_bucket{activity_type="print_message",namespace="default",service_name="temporal-core-sdk",task_queue="custom-metric-task-queue",workflow_type="ExecuteActivityWorkflow",le="5000"} 0
+custom_activity_schedule_to_start_latency_bucket{activity_type="print_message",namespace="default",service_name="temporal-core-sdk",task_queue="custom-metric-task-queue",workflow_type="ExecuteActivityWorkflow",le="10000"} 1
+custom_activity_schedule_to_start_latency_bucket{activity_type="print_message",namespace="default",service_name="temporal-core-sdk",task_queue="custom-metric-task-queue",workflow_type="ExecuteActivityWorkflow",le="100000"} 1
+custom_activity_schedule_to_start_latency_bucket{activity_type="print_message",namespace="default",service_name="temporal-core-sdk",task_queue="custom-metric-task-queue",workflow_type="ExecuteActivityWorkflow",le="1000000"} 1
+custom_activity_schedule_to_start_latency_bucket{activity_type="print_message",namespace="default",service_name="temporal-core-sdk",task_queue="custom-metric-task-queue",workflow_type="ExecuteActivityWorkflow",le="+Inf"} 1
+custom_activity_schedule_to_start_latency_sum{activity_type="print_message",namespace="default",service_name="temporal-core-sdk",task_queue="custom-metric-task-queue",workflow_type="ExecuteActivityWorkflow"} 6336
+custom_activity_schedule_to_start_latency_count{activity_type="print_message",namespace="default",service_name="temporal-core-sdk",task_queue="custom-metric-task-queue",workflow_type="ExecuteActivityWorkflow"} 1
+...
+temporal_activity_schedule_to_start_latency_bucket{namespace="default",service_name="temporal-core-sdk",task_queue="custom-metric-task-queue",le="100"} 0
+temporal_activity_schedule_to_start_latency_bucket{namespace="default",service_name="temporal-core-sdk",task_queue="custom-metric-task-queue",le="500"} 0
+temporal_activity_schedule_to_start_latency_bucket{namespace="default",service_name="temporal-core-sdk",task_queue="custom-metric-task-queue",le="1000"} 0
+temporal_activity_schedule_to_start_latency_bucket{namespace="default",service_name="temporal-core-sdk",task_queue="custom-metric-task-queue",le="5000"} 0
+temporal_activity_schedule_to_start_latency_bucket{namespace="default",service_name="temporal-core-sdk",task_queue="custom-metric-task-queue",le="10000"} 1
+temporal_activity_schedule_to_start_latency_bucket{namespace="default",service_name="temporal-core-sdk",task_queue="custom-metric-task-queue",le="100000"} 1
+temporal_activity_schedule_to_start_latency_bucket{namespace="default",service_name="temporal-core-sdk",task_queue="custom-metric-task-queue",le="1000000"} 1
+temporal_activity_schedule_to_start_latency_bucket{namespace="default",service_name="temporal-core-sdk",task_queue="custom-metric-task-queue",le="+Inf"} 1
+temporal_activity_schedule_to_start_latency_sum{namespace="default",service_name="temporal-core-sdk",task_queue="custom-metric-task-queue"} 6336
+temporal_activity_schedule_to_start_latency_count{namespace="default",service_name="temporal-core-sdk",task_queue="custom-metric-task-queue"} 1
+```

custom_metric/activity_worker.py

@@ -0,0 +1,71 @@
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
+
+from temporalio import activity
+from temporalio.client import Client
+from temporalio.runtime import PrometheusConfig, Runtime, TelemetryConfig
+from temporalio.worker import (
+    ActivityInboundInterceptor,
+    ExecuteActivityInput,
+    Interceptor,
+    Worker,
+)
+
+
+class SimpleWorkerInterceptor(Interceptor):
+
+    def intercept_activity(
+        self, next: ActivityInboundInterceptor
+    ) -> ActivityInboundInterceptor:
+        return CustomScheduleToStartInterceptor(next)
+
+
+class CustomScheduleToStartInterceptor(ActivityInboundInterceptor):
+
+    async def execute_activity(self, input: ExecuteActivityInput):
+
+        schedule_to_start = (
+            activity.info().started_time
+            - activity.info().current_attempt_scheduled_time
+        )
+        # Could do the original schedule time instead of current attempt
+        # schedule_to_start_second_option = activity.info().started_time - activity.info().scheduled_time
+
+        meter = activity.metric_meter()
+        histogram = meter.create_histogram_timedelta(
+            "custom_activity_schedule_to_start_latency",
+            description="Time between activity scheduling and start",
+            unit="duration",
+        )
+        histogram.record(
+            schedule_to_start, {"workflow_type": activity.info().workflow_type}
+        )
+        return await self.next.execute_activity(input)
+
+
+@activity.defn
+def print_message():
+    print("in the activity")
+
+
+async def main():
+    runtime = Runtime(
+        telemetry=TelemetryConfig(metrics=PrometheusConfig(bind_address="0.0.0.0:9090"))
+    )
+    client = await Client.connect(
+        "localhost:7233",
+        runtime=runtime,
+    )
+    worker = Worker(
+        client,
+        task_queue="custom-metric-task-queue",
+        activities=[print_message],
+        activity_executor=ThreadPoolExecutor(5),
+        interceptors=[SimpleWorkerInterceptor()],
+    )
+
+    await worker.run()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

custom_metric/client.py

@@ -0,0 +1,23 @@
+import asyncio
+import uuid
+
+from temporalio.client import Client
+
+from custom_metric.workflow_worker import ExecuteActivityWorkflow
+
+
+async def main():
+
+    client = await Client.connect(
+        "localhost:7233",
+    )
+
+    await client.start_workflow(
+        ExecuteActivityWorkflow.run,
+        id="execute-activity-workflow-" + str(uuid.uuid4()),
+        task_queue="custom-metric-task-queue",
+    )
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

custom_metric/workflow_worker.py

@@ -0,0 +1,39 @@
+import asyncio
+from datetime import timedelta
+
+from temporalio import workflow
+from temporalio.client import Client
+from temporalio.worker import Worker
+
+with workflow.unsafe.imports_passed_through():
+    from custom_metric.activity_worker import print_message
+
+
+@workflow.defn
+class ExecuteActivityWorkflow:
+
+    @workflow.run
+    async def run(self):
+        await workflow.execute_activity(
+            print_message,
+            start_to_close_timeout=timedelta(seconds=5),
+        )
+        return None
+
+
+async def main():
+
+    client = await Client.connect(
+        "localhost:7233",
+    )
+    worker = Worker(
+        client,
+        task_queue="custom-metric-task-queue",
+        workflows=[ExecuteActivityWorkflow],
+    )
+
+    await worker.run()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())