diff --git a/composer.json b/composer.json
index 7a93a9e..3720a95 100644
--- a/composer.json
+++ b/composer.json
@@ -18,7 +18,7 @@
     "support": {
         "issues": "https://github.com/friendsofhyperf/components/issues",
         "source": "https://github.com/friendsofhyperf/components",
-        "docs": "https://hyperf.fans",
+        "docs": "https://docs.hdj.me",
         "pull-request": "https://github.com/friendsofhyperf/components/pulls"
     },
     "require": {
@@ -32,7 +32,7 @@
         "hyperf/http-server": "~3.2.0",
         "hyperf/support": "~3.2.0",
         "hyperf/tappable": "~3.2.0",
-        "sentry/sentry": "^4.18.0",
+        "sentry/sentry": "^4.19.0",
         "symfony/polyfill-php85": "^1.33"
     },
     "suggest": {
diff --git a/publish/sentry.php b/publish/sentry.php
index b29c88d..b9e47c5 100644
--- a/publish/sentry.php
+++ b/publish/sentry.php
@@ -40,6 +40,12 @@
     // @see: https://docs.sentry.io/platforms/php/guides/laravel/configuration/options/#enable_logs
     'enable_logs' => env('SENTRY_ENABLE_LOGS', true),
 
+    // @see: https://docs.sentry.io/platforms/php/guides/laravel/configuration/options/#enable_metrics
+    'enable_metrics' => env('SENTRY_ENABLE_METRICS', true),
+    'enable_default_metrics' => env('SENTRY_ENABLE_DEFAULT_METRICS', true),
+    'enable_command_metrics' => env('SENTRY_ENABLE_COMMAND_METRICS', true),
+    'metrics_interval' => (int) env('SENTRY_METRICS_INTERVAL', 10),
+
     'logs_channel_level' => env('SENTRY_LOGS_CHANNEL_LEVEL', Sentry\Logs\LogLevel::debug()),
 
     // @see: https://docs.sentry.io/platforms/php/guides/laravel/configuration/options/#send_default_pii
diff --git a/src/Aspect/SingletonAspect.php b/src/Aspect/SingletonAspect.php
index bcd5594..5c0aec6 100644
--- a/src/Aspect/SingletonAspect.php
+++ b/src/Aspect/SingletonAspect.php
@@ -22,10 +22,13 @@ class SingletonAspect extends AbstractAspect
         \Sentry\EventType::class . '::getInstance',
         \Sentry\MonitorScheduleUnit::class . '::getInstance',
         \Sentry\Integration\IntegrationRegistry::class . '::getInstance',
+        \Sentry\Logs\LogLevel::class . '::getInstance',
+        \Sentry\Metrics\TraceMetrics::class . '::getInstance',
         \Sentry\State\HubAdapter::class . '::getInstance',
         \Sentry\Tracing\SpanStatus::class . '::getInstance',
         \Sentry\Tracing\TransactionSource::class . '::getInstance',
         \Sentry\Transport\ResultStatus::class . '::getInstance',
+        \Sentry\Unit::class . '::getInstance',
     ];
 
     public function process(ProceedingJoinPoint $proceedingJoinPoint)
diff --git a/src/ConfigProvider.php b/src/ConfigProvider.php
index e00948e..58923ad 100644
--- a/src/ConfigProvider.php
+++ b/src/ConfigProvider.php
@@ -26,12 +26,15 @@ public function __invoke(): array
                 Aspect\GuzzleHttpClientAspect::class,
                 Aspect\LoggerAspect::class,
                 Aspect\SingletonAspect::class,
+                Metrics\Aspect\CounterAspect::class,
+                Metrics\Aspect\HistogramAspect::class,
                 Tracing\Aspect\AmqpProducerAspect::class,
                 Tracing\Aspect\AsyncQueueJobMessageAspect::class,
                 Tracing\Aspect\CacheAspect::class,
                 Tracing\Aspect\CoordinatorAspect::class,
                 Tracing\Aspect\CoroutineAspect::class,
                 Tracing\Aspect\DbAspect::class,
+                Tracing\Aspect\DbConnectionAspect::class,
                 Tracing\Aspect\ElasticsearchAspect::class,
                 Tracing\Aspect\ElasticsearchRequestAspect::class,
                 Tracing\Aspect\FilesystemAspect::class,
@@ -40,6 +43,7 @@ public function __invoke(): array
                 Tracing\Aspect\KafkaProducerAspect::class,
                 Tracing\Aspect\RpcAspect::class,
                 Tracing\Aspect\RpcEndpointAspect::class,
+                Tracing\Aspect\RedisConnectionAspect::class,
                 Tracing\Aspect\TraceAnnotationAspect::class,
                 Tracing\Aspect\ViewRenderAspect::class,
             ],
@@ -56,6 +60,14 @@ public function __invoke(): array
                 Listener\SetupSentryListener::class,
                 Listener\EventHandleListener::class => PHP_INT_MAX - 1,
                 Crons\Listener\EventHandleListener::class => PHP_INT_MAX - 1,
+                Metrics\Listener\DBPoolWatcher::class,
+                Metrics\Listener\OnBeforeHandle::class,
+                Metrics\Listener\OnCoroutineServerStart::class,
+                Metrics\Listener\OnMetricFactoryReady::class,
+                Metrics\Listener\OnWorkerStart::class,
+                Metrics\Listener\QueueWatcher::class,
+                Metrics\Listener\RedisPoolWatcher::class,
+                Metrics\Listener\RequestWatcher::class,
                 Tracing\Listener\EventHandleListener::class => PHP_INT_MAX, // !! Make sure it is the first one to handle the event
             ],
             'annotations' => [
diff --git a/src/Constants.php b/src/Constants.php
index a2d9373..87c4991 100644
--- a/src/Constants.php
+++ b/src/Constants.php
@@ -15,19 +15,11 @@ class Constants
 {
     public const TRACE_CARRIER = 'sentry.tracing.trace_carrier';
 
-    public const TRACE_RPC_SERVER_ADDRESS = 'sentry.tracing.rpc.server.address';
-
-    public const TRACE_RPC_SERVER_PORT = 'sentry.tracing.rpc.server.port';
-
-    public const TRACE_ELASTICSEARCH_REQUEST_DATA = 'sentry.tracing.elasticsearch.request.data';
-
-    public const CRON_CHECKIN_ID = 'sentry.crons.checkin_id';
-
-    public const DISABLE_COROUTINE_TRACING = 'sentry.tracing.disable_coroutine_tracing';
-
     public const SENTRY_TRACE = 'sentry-trace';
 
     public const BAGGAGE = 'baggage';
 
     public const TRACEPARENT = 'traceparent';
+
+    public static bool $runningInCommand = false;
 }
diff --git a/src/Crons/Listener/EventHandleListener.php b/src/Crons/Listener/EventHandleListener.php
index a35f691..c083e8d 100644
--- a/src/Crons/Listener/EventHandleListener.php
+++ b/src/Crons/Listener/EventHandleListener.php
@@ -11,9 +11,8 @@
 
 namespace FriendsOfHyperf\Sentry\Crons\Listener;
 
-use FriendsOfHyperf\Sentry\Constants;
 use FriendsOfHyperf\Sentry\Feature;
-use Hyperf\Context\Context;
+use FriendsOfHyperf\Sentry\SentryContext;
 use Hyperf\Contract\ConfigInterface;
 use Hyperf\Contract\StdoutLoggerInterface;
 use Hyperf\Crontab\Event;
@@ -90,13 +89,13 @@ protected function handleCrontabTaskStarting(Event\BeforeExecute $event, array $
             monitorConfig: $monitorConfig,
         );
 
-        Context::set(Constants::CRON_CHECKIN_ID, $checkInId);
+        SentryContext::setCronCheckInId($checkInId);
     }
 
     protected function handleCrontabTaskFinished(Event\AfterExecute $event): void
     {
-        /** @var null|string $checkInId */
-        $checkInId = Context::get(Constants::CRON_CHECKIN_ID);
+        $checkInId = SentryContext::getCronCheckInId();
+
         if (! $checkInId) {
             return;
         }
@@ -113,8 +112,8 @@ protected function handleCrontabTaskFinished(Event\AfterExecute $event): void
 
     protected function handleCrontabTaskFailed(Event\FailToExecute $event): void
     {
-        /** @var null|string $checkInId */
-        $checkInId = Context::get(Constants::CRON_CHECKIN_ID);
+        $checkInId = SentryContext::getCronCheckInId();
+
         if (! $checkInId) {
             return;
         }
diff --git a/src/Factory/ClientBuilderFactory.php b/src/Factory/ClientBuilderFactory.php
index ab50761..19f5608 100644
--- a/src/Factory/ClientBuilderFactory.php
+++ b/src/Factory/ClientBuilderFactory.php
@@ -29,6 +29,9 @@ class ClientBuilderFactory
         'ignore_commands',
         'integrations',
         'logs_channel_level',
+        'enable_default_metrics',
+        'enable_command_metrics',
+        'metrics_interval',
         'transport_channel_size',
         'transport_concurrent_limit',
         'tracing',
diff --git a/src/Feature.php b/src/Feature.php
index 593f8d0..47e5222 100644
--- a/src/Feature.php
+++ b/src/Feature.php
@@ -11,7 +11,6 @@
 
 namespace FriendsOfHyperf\Sentry;
 
-use Hyperf\Context\Context;
 use Hyperf\Contract\ConfigInterface;
 use Sentry\SentrySdk;
 
@@ -31,6 +30,40 @@ public function isBreadcrumbEnabled(string $key, bool $default = true): bool
         return (bool) $this->config->get('sentry.breadcrumbs.' . $key, $default);
     }
 
+    public function isMetricsEnabled(bool $default = true): bool
+    {
+        return (bool) $this->config->get('sentry.enable_metrics', $default);
+    }
+
+    public function isDefaultMetricsEnabled(bool $default = true): bool
+    {
+        if (! $this->isMetricsEnabled()) {
+            return false;
+        }
+
+        return (bool) $this->config->get('sentry.enable_default_metrics', $default);
+    }
+
+    public function isCommandMetricsEnabled(bool $default = true): bool
+    {
+        if (! $this->isMetricsEnabled()) {
+            return false;
+        }
+
+        return (bool) $this->config->get('sentry.enable_command_metrics', $default);
+    }
+
+    public function getMetricsInterval(int $default = 10): int
+    {
+        $interval = (int) $this->config->get('sentry.metrics_interval', $default);
+
+        if ($interval < 5) {
+            return 5;
+        }
+
+        return $interval;
+    }
+
     public function isTracingEnabled(string $key, bool $default = true): bool
     {
         return (bool) $this->config->get('sentry.tracing.' . $key, $default);
@@ -54,14 +87,4 @@ public function isCronsEnabled(): bool
     {
         return (bool) $this->config->get('sentry.crons.enable', true);
     }
-
-    public static function disableCoroutineTracing(): void
-    {
-        Context::set(Constants::DISABLE_COROUTINE_TRACING, true);
-    }
-
-    public static function isDisableCoroutineTracing(): bool
-    {
-        return (bool) Context::get(Constants::DISABLE_COROUTINE_TRACING);
-    }
 }
diff --git a/src/Function.php b/src/Function.php
index bfddc62..9c64787 100644
--- a/src/Function.php
+++ b/src/Function.php
@@ -13,6 +13,7 @@
 
 use FriendsOfHyperf\Sentry\Tracing\Tracer;
 use Hyperf\Context\ApplicationContext;
+use Sentry\Metrics\TraceMetrics;
 use Sentry\State\Scope;
 use Sentry\Tracing\SpanContext;
 use Sentry\Tracing\Transaction;
@@ -26,6 +27,11 @@ function feature(): Feature
     return ApplicationContext::getContainer()->get(Feature::class);
 }
 
+function metrics(): TraceMetrics
+{
+    return TraceMetrics::getInstance();
+}
+
 /**
  * Starts a new Transaction and returns it. This is the entry point to manual tracing instrumentation.
  */
diff --git a/src/Integration.php b/src/Integration.php
index 7d934ba..e26f0e8 100644
--- a/src/Integration.php
+++ b/src/Integration.php
@@ -15,6 +15,7 @@
 use Sentry\Event;
 use Sentry\Integration\IntegrationInterface;
 use Sentry\Logs\Logs;
+use Sentry\Metrics\TraceMetrics;
 use Sentry\SentrySdk;
 use Sentry\State\Scope;
 use Sentry\Tracing\Span;
@@ -111,6 +112,7 @@ public static function flushEvents(): void
             $client->flush();
 
             Logs::getInstance()->flush();
+            TraceMetrics::getInstance()->flush();
         }
     }
 
diff --git a/src/Metrics/Annotation/Counter.php b/src/Metrics/Annotation/Counter.php
new file mode 100644
index 0000000..b4cc6aa
--- /dev/null
+++ b/src/Metrics/Annotation/Counter.php
@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * This file is part of friendsofhyperf/components.
+ *
+ * @link     https://github.com/friendsofhyperf/components
+ * @document https://github.com/friendsofhyperf/components/blob/main/README.md
+ * @contact  huangdijia@gmail.com
+ */
+
+namespace FriendsOfHyperf\Sentry\Metrics\Annotation;
+
+use Attribute;
+use Hyperf\Di\Annotation\AbstractAnnotation;
+
+#[Attribute(Attribute::TARGET_CLASS | Attribute::TARGET_METHOD)]
+class Counter extends AbstractAnnotation
+{
+    public function __construct(public string $name = '')
+    {
+    }
+}
diff --git a/src/Metrics/Annotation/Histogram.php b/src/Metrics/Annotation/Histogram.php
new file mode 100644
index 0000000..4995292
--- /dev/null
+++ b/src/Metrics/Annotation/Histogram.php
@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * This file is part of friendsofhyperf/components.
+ *
+ * @link     https://github.com/friendsofhyperf/components
+ * @document https://github.com/friendsofhyperf/components/blob/main/README.md
+ * @contact  huangdijia@gmail.com
+ */
+
+namespace FriendsOfHyperf\Sentry\Metrics\Annotation;
+
+use Attribute;
+use Hyperf\Di\Annotation\AbstractAnnotation;
+
+#[Attribute(Attribute::TARGET_CLASS | Attribute::TARGET_METHOD)]
+class Histogram extends AbstractAnnotation
+{
+    public function __construct(public string $name = '')
+    {
+    }
+}
diff --git a/src/Metrics/Aspect/CounterAspect.php b/src/Metrics/Aspect/CounterAspect.php
new file mode 100644
index 0000000..b6f2591
--- /dev/null
+++ b/src/Metrics/Aspect/CounterAspect.php
@@ -0,0 +1,69 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * This file is part of friendsofhyperf/components.
+ *
+ * @link     https://github.com/friendsofhyperf/components
+ * @document https://github.com/friendsofhyperf/components/blob/main/README.md
+ * @contact  huangdijia@gmail.com
+ */
+
+namespace FriendsOfHyperf\Sentry\Metrics\Aspect;
+
+use FriendsOfHyperf\Sentry\Feature;
+use FriendsOfHyperf\Sentry\Metrics\Annotation\Counter;
+use Hyperf\Di\Aop\AbstractAspect;
+use Hyperf\Di\Aop\ProceedingJoinPoint;
+
+use function FriendsOfHyperf\Sentry\metrics;
+use function Hyperf\Coroutine\defer;
+
+class CounterAspect extends AbstractAspect
+{
+    public array $classes = [];
+
+    public array $annotations = [
+        Counter::class,
+    ];
+
+    public function __construct(protected Feature $feature)
+    {
+    }
+
+    public function process(ProceedingJoinPoint $proceedingJoinPoint): mixed
+    {
+        if ($this->feature->isMetricsEnabled()) {
+            $metadata = $proceedingJoinPoint->getAnnotationMetadata();
+            $source = $this->fromCamelCase($proceedingJoinPoint->className . '::' . $proceedingJoinPoint->methodName);
+
+            /** @var null|Counter $annotation */
+            $annotation = $metadata->method[Counter::class] ?? null;
+
+            if ($annotation) {
+                $name = $annotation->name ?: $source;
+            } else {
+                $name = $source;
+            }
+
+            defer(fn () => metrics()->flush());
+
+            metrics()->count($name, 1, [
+                'class' => $proceedingJoinPoint->className,
+                'method' => $proceedingJoinPoint->methodName,
+            ]);
+        }
+
+        return $proceedingJoinPoint->process();
+    }
+
+    private function fromCamelCase(string $input): string
+    {
+        preg_match_all('!([A-Z][A-Z0-9]*(?=$|[A-Z][a-z0-9])|[A-Za-z][a-z0-9]+)!', $input, $matches);
+        $ret = $matches[0];
+        foreach ($ret as &$match) {
+            $match = $match == strtoupper($match) ? strtolower($match) : lcfirst($match);
+        }
+        return implode('_', $ret);
+    }
+}
diff --git a/src/Metrics/Aspect/HistogramAspect.php b/src/Metrics/Aspect/HistogramAspect.php
new file mode 100644
index 0000000..50845cf
--- /dev/null
+++ b/src/Metrics/Aspect/HistogramAspect.php
@@ -0,0 +1,70 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * This file is part of friendsofhyperf/components.
+ *
+ * @link     https://github.com/friendsofhyperf/components
+ * @document https://github.com/friendsofhyperf/components/blob/main/README.md
+ * @contact  huangdijia@gmail.com
+ */
+
+namespace FriendsOfHyperf\Sentry\Metrics\Aspect;
+
+use FriendsOfHyperf\Sentry\Feature;
+use FriendsOfHyperf\Sentry\Metrics\Annotation\Histogram;
+use FriendsOfHyperf\Sentry\Metrics\Timer;
+use Hyperf\Di\Aop\AbstractAspect;
+use Hyperf\Di\Aop\ProceedingJoinPoint;
+
+use function Hyperf\Coroutine\defer;
+use function Hyperf\Tappable\tap;
+
+class HistogramAspect extends AbstractAspect
+{
+    public array $classes = [];
+
+    public array $annotations = [
+        Histogram::class,
+    ];
+
+    public function __construct(protected Feature $feature)
+    {
+    }
+
+    public function process(ProceedingJoinPoint $proceedingJoinPoint): mixed
+    {
+        if (! $this->feature->isMetricsEnabled()) {
+            return $proceedingJoinPoint->process();
+        }
+
+        $metadata = $proceedingJoinPoint->getAnnotationMetadata();
+        $source = $this->fromCamelCase($proceedingJoinPoint->className . '::' . $proceedingJoinPoint->methodName);
+        /** @var null|Histogram $annotation */
+        $annotation = $metadata->method[Histogram::class] ?? null;
+        if ($annotation) {
+            $name = $annotation->name ?: $source;
+        } else {
+            $name = $source;
+        }
+
+        $timer = Timer::make($name, [
+            'class' => $proceedingJoinPoint->className,
+            'method' => $proceedingJoinPoint->methodName,
+        ]);
+
+        return tap($proceedingJoinPoint->process(), function () use ($timer) {
+            defer(fn () => $timer->end(true));
+        });
+    }
+
+    private function fromCamelCase(string $input): string
+    {
+        preg_match_all('!([A-Z][A-Z0-9]*(?=$|[A-Z][a-z0-9])|[A-Za-z][a-z0-9]+)!', $input, $matches);
+        $ret = $matches[0];
+        foreach ($ret as &$match) {
+            $match = $match == strtoupper($match) ? strtolower($match) : lcfirst($match);
+        }
+        return implode('_', $ret);
+    }
+}
diff --git a/src/Metrics/CoroutineServerStats.php b/src/Metrics/CoroutineServerStats.php
new file mode 100644
index 0000000..d150366
--- /dev/null
+++ b/src/Metrics/CoroutineServerStats.php
@@ -0,0 +1,56 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * This file is part of friendsofhyperf/components.
+ *
+ * @link     https://github.com/friendsofhyperf/components
+ * @document https://github.com/friendsofhyperf/components/blob/main/README.md
+ * @contact  huangdijia@gmail.com
+ */
+
+namespace FriendsOfHyperf\Sentry\Metrics;
+
+use Hyperf\Contract\Arrayable;
+
+/**
+ * @property int $start_time 服务器启动的时间
+ * @property int $connection_num 当前连接的数量
+ * @property int $accept_count 接受了多少个连接
+ * @property int $close_count 关闭的连接数量
+ * @property int $worker_num 开启了多少个 worker 进程
+ * @property int $idle_worker_num 空闲的 worker 进程数
+ * @property int $task_worker_num 开启了多少个 task_worker 进程【v4.5.7 可用】
+ * @property int $tasking_num 当前正在排队的任务数
+ * @property int $request_count Server 收到的请求次数【只有 onReceive、onMessage、onRequset、onPacket 四种数据请求计算 request_count】
+ * @property int $response_count Server 发送的响应次数【只有 onReceive、onMessage、onRequset、onPacket 四种数据请求计算 response_count】
+ * @property int $dispatch_count Server 发送到 Worker 的包数量【v4.5.7 可用，仅在 SWOOLE_PROCESS 模式下有效】
+ * @property int $worker_request_count 当前 Worker 进程收到的请求次数【worker_request_count 超过 max_request 时工作进程将退出】
+ * @property int $worker_dispatch_count master 进程向当前 Worker 进程投递任务的计数，在 master 进程进行 dispatch 时增加计数
+ * @property int $task_queue_num 消息队列中的 task 数量【用于 Task】
+ * @property int $task_queue_bytes 消息队列的内存占用字节数【用于 Task】
+ * @property int $task_idle_worker_num 空闲的 task 进程数量
+ * @property int $coroutine_num 当前协程数量【用于 Coroutine】，想获取更多信息参考此节
+ */
+class CoroutineServerStats implements Arrayable
+{
+    protected array $stats = [
+        'worker_num' => 1,
+        'idle_worker_num' => 0,
+    ];
+
+    public function __get($name)
+    {
+        return $this->stats[$name] ?? 0;
+    }
+
+    public function __set($name, $value)
+    {
+        $this->stats[$name] = $value;
+    }
+
+    public function toArray(): array
+    {
+        return $this->stats;
+    }
+}
diff --git a/src/Metrics/Event/MetricFactoryReady.php b/src/Metrics/Event/MetricFactoryReady.php
new file mode 100644
index 0000000..bffe095
--- /dev/null
+++ b/src/Metrics/Event/MetricFactoryReady.php
@@ -0,0 +1,19 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * This file is part of friendsofhyperf/components.
+ *
+ * @link     https://github.com/friendsofhyperf/components
+ * @document https://github.com/friendsofhyperf/components/blob/main/README.md
+ * @contact  huangdijia@gmail.com
+ */
+
+namespace FriendsOfHyperf\Sentry\Metrics\Event;
+
+class MetricFactoryReady
+{
+    public function __construct(public int $workerId = 0)
+    {
+    }
+}
diff --git a/src/Metrics/Listener/DBPoolWatcher.php b/src/Metrics/Listener/DBPoolWatcher.php
new file mode 100644
index 0000000..63a890b
--- /dev/null
+++ b/src/Metrics/Listener/DBPoolWatcher.php
@@ -0,0 +1,43 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * This file is part of friendsofhyperf/components.
+ *
+ * @link     https://github.com/friendsofhyperf/components
+ * @document https://github.com/friendsofhyperf/components/blob/main/README.md
+ * @contact  huangdijia@gmail.com
+ */
+
+namespace FriendsOfHyperf\Sentry\Metrics\Listener;
+
+use Hyperf\Contract\ConfigInterface;
+use Hyperf\DbConnection\Pool\PoolFactory;
+use Hyperf\Framework\Event\BeforeWorkerStart;
+use Hyperf\Server\Event\MainCoroutineServerStart;
+
+class DBPoolWatcher extends PoolWatcher
+{
+    public function getPrefix(): string
+    {
+        return 'db';
+    }
+
+    /**
+     * @param object|BeforeWorkerStart|MainCoroutineServerStart $event
+     */
+    public function process(object $event): void
+    {
+        $config = $this->container->get(ConfigInterface::class);
+        $poolNames = array_keys($config->get('databases', ['default' => []]));
+
+        foreach ($poolNames as $poolName) {
+            $workerId = (int) ($event->workerId ?? 0);
+            $pool = $this
+                ->container
+                ->get(PoolFactory::class)
+                ->getPool($poolName);
+            $this->watch($pool, $poolName, $workerId);
+        }
+    }
+}
diff --git a/src/Metrics/Listener/OnBeforeHandle.php b/src/Metrics/Listener/OnBeforeHandle.php
new file mode 100644
index 0000000..995cd66
--- /dev/null
+++ b/src/Metrics/Listener/OnBeforeHandle.php
@@ -0,0 +1,115 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * This file is part of friendsofhyperf/components.
+ *
+ * @link     https://github.com/friendsofhyperf/components
+ * @document https://github.com/friendsofhyperf/components/blob/main/README.md
+ * @contact  huangdijia@gmail.com
+ */
+
+namespace FriendsOfHyperf\Sentry\Metrics\Listener;
+
+use FriendsOfHyperf\Sentry\Constants;
+use FriendsOfHyperf\Sentry\Feature;
+use FriendsOfHyperf\Sentry\Metrics\Traits\MetricSetter;
+use Hyperf\Command\Event\BeforeHandle;
+use Hyperf\Coordinator\CoordinatorManager;
+use Hyperf\Coordinator\Timer;
+use Hyperf\Engine\Coroutine;
+use Hyperf\Event\Contract\ListenerInterface;
+use Sentry\Unit;
+
+use function FriendsOfHyperf\Sentry\metrics;
+
+class OnBeforeHandle implements ListenerInterface
+{
+    use MetricSetter;
+
+    protected Timer $timer;
+
+    public function __construct(protected Feature $feature)
+    {
+        $this->timer = new Timer();
+    }
+
+    public function listen(): array
+    {
+        return [
+            BeforeHandle::class,
+        ];
+    }
+
+    /**
+     * @param object|BeforeHandle $event
+     */
+    public function process(object $event): void
+    {
+        if (
+            ! $event instanceof BeforeHandle
+            || ! $event->getCommand()->getApplication()->isAutoExitEnabled() // Only enable in the command with auto exit.
+            || ! $this->feature->isCommandMetricsEnabled()
+        ) {
+            return;
+        }
+
+        Constants::$runningInCommand = true;
+
+        if (! $this->feature->isDefaultMetricsEnabled()) {
+            return;
+        }
+
+        // The following metrics MUST be collected in worker.
+        $metrics = [
+            'memory_usage',
+            'memory_peak_usage',
+            'gc_runs',
+            'gc_collected',
+            'gc_threshold',
+            'gc_roots',
+            'ru_oublock',
+            'ru_inblock',
+            'ru_msgsnd',
+            'ru_msgrcv',
+            'ru_maxrss',
+            'ru_ixrss',
+            'ru_idrss',
+            'ru_minflt',
+            'ru_majflt',
+            'ru_nsignals',
+            'ru_nvcsw',
+            'ru_nivcsw',
+            'ru_nswap',
+            'ru_utime_tv_usec',
+            'ru_utime_tv_sec',
+            'ru_stime_tv_usec',
+            'ru_stime_tv_sec',
+        ];
+
+        $timerId = $this->timer->tick($this->feature->getMetricsInterval(), function () use ($metrics) {
+            defer(fn () => metrics()->flush());
+
+            $this->trySet('gc_', $metrics, gc_status());
+            $this->trySet('', $metrics, getrusage());
+
+            metrics()->gauge(
+                'memory_usage',
+                (float) memory_get_usage(),
+                ['worker' => '0'],
+                Unit::byte()
+            );
+            metrics()->gauge(
+                'memory_peak_usage',
+                (float) memory_get_peak_usage(),
+                ['worker' => '0'],
+                Unit::byte()
+            );
+        });
+
+        Coroutine::create(function () use ($timerId) {
+            CoordinatorManager::until(\Hyperf\Coordinator\Constants::WORKER_EXIT)->yield();
+            $this->timer->clear($timerId);
+        });
+    }
+}
diff --git a/src/Metrics/Listener/OnCoroutineServerStart.php b/src/Metrics/Listener/OnCoroutineServerStart.php
new file mode 100644
index 0000000..f062877
--- /dev/null
+++ b/src/Metrics/Listener/OnCoroutineServerStart.php
@@ -0,0 +1,128 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * This file is part of friendsofhyperf/components.
+ *
+ * @link     https://github.com/friendsofhyperf/components
+ * @document https://github.com/friendsofhyperf/components/blob/main/README.md
+ * @contact  huangdijia@gmail.com
+ */
+
+namespace FriendsOfHyperf\Sentry\Metrics\Listener;
+
+use FriendsOfHyperf\Sentry\Feature;
+use FriendsOfHyperf\Sentry\Metrics\Event\MetricFactoryReady;
+use FriendsOfHyperf\Sentry\Metrics\Traits\MetricSetter;
+use Hyperf\Coordinator\Constants;
+use Hyperf\Coordinator\CoordinatorManager;
+use Hyperf\Coordinator\Timer;
+use Hyperf\Engine\Coroutine;
+use Hyperf\Event\Contract\ListenerInterface;
+use Hyperf\Server\Event\MainCoroutineServerStart;
+use Psr\Container\ContainerInterface;
+use Psr\EventDispatcher\EventDispatcherInterface;
+use Sentry\Unit;
+
+use function FriendsOfHyperf\Sentry\metrics;
+use function Hyperf\Coroutine\defer;
+
+class OnCoroutineServerStart implements ListenerInterface
+{
+    use MetricSetter;
+
+    private Timer $timer;
+
+    private bool $running = false;
+
+    public function __construct(
+        protected ContainerInterface $container,
+        protected Feature $feature,
+    ) {
+        $this->timer = new Timer();
+    }
+
+    public function listen(): array
+    {
+        return [
+            MainCoroutineServerStart::class,
+        ];
+    }
+
+    /**
+     * @param object|MainCoroutineServerStart $event
+     */
+    public function process(object $event): void
+    {
+        if (! $this->feature->isMetricsEnabled()) {
+            return;
+        }
+
+        if ($this->running) {
+            return;
+        }
+
+        $this->running = true;
+
+        $eventDispatcher = $this->container->get(EventDispatcherInterface::class);
+        $eventDispatcher->dispatch(new MetricFactoryReady());
+
+        if (! $this->feature->isDefaultMetricsEnabled()) {
+            return;
+        }
+
+        // The following metrics MUST be collected in worker.
+        $metrics = [
+            // 'worker_request_count',
+            // 'worker_dispatch_count',
+            'memory_usage',
+            'memory_peak_usage',
+            'gc_runs',
+            'gc_collected',
+            'gc_threshold',
+            'gc_roots',
+            'ru_oublock',
+            'ru_inblock',
+            'ru_msgsnd',
+            'ru_msgrcv',
+            'ru_maxrss',
+            'ru_ixrss',
+            'ru_idrss',
+            'ru_minflt',
+            'ru_majflt',
+            'ru_nsignals',
+            'ru_nvcsw',
+            'ru_nivcsw',
+            'ru_nswap',
+            'ru_utime_tv_usec',
+            'ru_utime_tv_sec',
+            'ru_stime_tv_usec',
+            'ru_stime_tv_sec',
+        ];
+
+        $timerId = $this->timer->tick($this->feature->getMetricsInterval(), function () use ($metrics) {
+            defer(fn () => metrics()->flush());
+
+            $this->trySet('gc_', $metrics, gc_status());
+            $this->trySet('', $metrics, getrusage());
+
+            metrics()->gauge(
+                'memory_usage',
+                (float) memory_get_usage(),
+                ['worker' => '0'],
+                Unit::byte()
+            );
+            metrics()->gauge(
+                'memory_peak_usage',
+                (float) memory_get_peak_usage(),
+                ['worker' => '0'],
+                Unit::byte()
+            );
+        });
+
+        Coroutine::create(function () use ($timerId) {
+            CoordinatorManager::until(Constants::WORKER_EXIT)->yield();
+            $this->timer->clear($timerId);
+        });
+    }
+}
diff --git a/src/Metrics/Listener/OnMetricFactoryReady.php b/src/Metrics/Listener/OnMetricFactoryReady.php
new file mode 100644
index 0000000..153bb50
--- /dev/null
+++ b/src/Metrics/Listener/OnMetricFactoryReady.php
@@ -0,0 +1,140 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * This file is part of friendsofhyperf/components.
+ *
+ * @link     https://github.com/friendsofhyperf/components
+ * @document https://github.com/friendsofhyperf/components/blob/main/README.md
+ * @contact  huangdijia@gmail.com
+ */
+
+namespace FriendsOfHyperf\Sentry\Metrics\Listener;
+
+use FriendsOfHyperf\Sentry\Constants as SentryConstants;
+use FriendsOfHyperf\Sentry\Feature;
+use FriendsOfHyperf\Sentry\Metrics\CoroutineServerStats;
+use FriendsOfHyperf\Sentry\Metrics\Event\MetricFactoryReady;
+use FriendsOfHyperf\Sentry\Metrics\Traits\MetricSetter;
+use Hyperf\Coordinator\Constants;
+use Hyperf\Coordinator\CoordinatorManager;
+use Hyperf\Coordinator\Timer;
+use Hyperf\Engine\Coroutine;
+use Hyperf\Event\Contract\ListenerInterface;
+use Hyperf\Support\System;
+use Psr\Container\ContainerInterface;
+use Sentry\Unit;
+use Swoole\Server as SwooleServer;
+
+use function FriendsOfHyperf\Sentry\metrics;
+use function Hyperf\Coroutine\defer;
+
+class OnMetricFactoryReady implements ListenerInterface
+{
+    use MetricSetter;
+
+    private Timer $timer;
+
+    public function __construct(
+        protected ContainerInterface $container,
+        protected Feature $feature,
+    ) {
+        $this->timer = new Timer();
+    }
+
+    public function listen(): array
+    {
+        return [
+            MetricFactoryReady::class,
+        ];
+    }
+
+    /**
+     * @param object|MetricFactoryReady $event
+     */
+    public function process(object $event): void
+    {
+        if (! $this->feature->isDefaultMetricsEnabled()) {
+            return;
+        }
+
+        $workerId = $event->workerId;
+        $metrics = [
+            'sys_load',
+            'event_num',
+            'signal_listener_num',
+            'aio_task_num',
+            'aio_worker_num',
+            'c_stack_size',
+            'coroutine_num',
+            'coroutine_peak_num',
+            'coroutine_last_cid',
+            'connection_num',
+            'accept_count',
+            'close_count',
+            'worker_num',
+            'idle_worker_num',
+            'tasking_num',
+            'request_count',
+            'timer_num',
+            'timer_round',
+            'swoole_timer_num',
+            'swoole_timer_round',
+            'metric_process_memory_usage',
+            'metric_process_memory_peak_usage',
+        ];
+
+        $serverStatsFactory = null;
+
+        if (! SentryConstants::$runningInCommand) {
+            if ($this->container->has(SwooleServer::class) && $server = $this->container->get(SwooleServer::class)) {
+                if ($server instanceof SwooleServer) {
+                    $serverStatsFactory = fn (): array => $server->stats();
+                }
+            }
+
+            if (! $serverStatsFactory) {
+                $serverStatsFactory = fn (): array => $this->container->get(CoroutineServerStats::class)->toArray();
+            }
+        }
+
+        $timerId = $this->timer->tick($this->feature->getMetricsInterval(), function () use ($metrics, $serverStatsFactory, $workerId) {
+            defer(fn () => metrics()->flush());
+
+            $this->trySet('', $metrics, Coroutine::stats(), $workerId);
+            $this->trySet('timer_', $metrics, Timer::stats(), $workerId);
+
+            if ($serverStatsFactory) {
+                $this->trySet('', $metrics, $serverStatsFactory(), $workerId);
+            }
+
+            if (class_exists('Swoole\Timer')) {
+                $this->trySet('swoole_timer_', $metrics, \Swoole\Timer::stats(), $workerId);
+            }
+
+            $load = sys_getloadavg();
+            metrics()->gauge(
+                'sys_load',
+                round($load[0] / System::getCpuCoresNum(), 2),
+                ['worker' => (string) $workerId],
+            );
+            metrics()->gauge(
+                'metric_process_memory_usage',
+                (float) memory_get_usage(),
+                ['worker' => (string) $workerId],
+                Unit::byte()
+            );
+            metrics()->gauge(
+                'metric_process_memory_peak_usage',
+                (float) memory_get_peak_usage(),
+                ['worker' => (string) $workerId],
+                Unit::byte()
+            );
+        });
+
+        Coroutine::create(function () use ($timerId) {
+            CoordinatorManager::until(Constants::WORKER_EXIT)->yield();
+            $this->timer->clear($timerId);
+        });
+    }
+}
diff --git a/src/Metrics/Listener/OnWorkerStart.php b/src/Metrics/Listener/OnWorkerStart.php
new file mode 100644
index 0000000..2637252
--- /dev/null
+++ b/src/Metrics/Listener/OnWorkerStart.php
@@ -0,0 +1,130 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * This file is part of friendsofhyperf/components.
+ *
+ * @link     https://github.com/friendsofhyperf/components
+ * @document https://github.com/friendsofhyperf/components/blob/main/README.md
+ * @contact  huangdijia@gmail.com
+ */
+
+namespace FriendsOfHyperf\Sentry\Metrics\Listener;
+
+use FriendsOfHyperf\Sentry\Feature;
+use FriendsOfHyperf\Sentry\Metrics\Event\MetricFactoryReady;
+use FriendsOfHyperf\Sentry\Metrics\Traits\MetricSetter;
+use Hyperf\Coordinator\Constants;
+use Hyperf\Coordinator\CoordinatorManager;
+use Hyperf\Coordinator\Timer;
+use Hyperf\Engine\Coroutine;
+use Hyperf\Event\Contract\ListenerInterface;
+use Hyperf\Framework\Event\BeforeWorkerStart;
+use Psr\Container\ContainerInterface;
+use Psr\EventDispatcher\EventDispatcherInterface;
+use Sentry\Unit;
+use Swoole\Server;
+
+use function FriendsOfHyperf\Sentry\metrics;
+use function Hyperf\Coroutine\defer;
+
+class OnWorkerStart implements ListenerInterface
+{
+    use MetricSetter;
+
+    private Timer $timer;
+
+    public function __construct(
+        protected ContainerInterface $container,
+        protected Feature $feature,
+    ) {
+        $this->timer = new Timer();
+    }
+
+    public function listen(): array
+    {
+        return [
+            BeforeWorkerStart::class,
+        ];
+    }
+
+    /**
+     * @param object|BeforeWorkerStart $event
+     */
+    public function process(object $event): void
+    {
+        if (! $this->feature->isDefaultMetricsEnabled()) {
+            return;
+        }
+
+        $workerId = $event->workerId;
+        $eventDispatcher = $this->container->get(EventDispatcherInterface::class);
+        $eventDispatcher->dispatch(new MetricFactoryReady($workerId));
+
+        // The following metrics MUST be collected in worker.
+        $metrics = [
+            'worker_request_count',
+            'worker_dispatch_count',
+            'memory_usage',
+            'memory_peak_usage',
+            'gc_runs',
+            'gc_collected',
+            'gc_threshold',
+            'gc_roots',
+            'ru_oublock',
+            'ru_inblock',
+            'ru_msgsnd',
+            'ru_msgrcv',
+            'ru_maxrss',
+            'ru_ixrss',
+            'ru_idrss',
+            'ru_minflt',
+            'ru_majflt',
+            'ru_nsignals',
+            'ru_nvcsw',
+            'ru_nivcsw',
+            'ru_nswap',
+            'ru_utime_tv_usec',
+            'ru_utime_tv_sec',
+            'ru_stime_tv_usec',
+            'ru_stime_tv_sec',
+        ];
+
+        $timerId = $this->timer->tick($this->feature->getMetricsInterval(), function () use ($metrics, $event) {
+            defer(fn () => metrics()->flush());
+
+            $server = $this->container->get(Server::class);
+            $serverStats = $server->stats();
+            $this->trySet('gc_', $metrics, gc_status());
+            $this->trySet('', $metrics, getrusage());
+
+            metrics()->gauge(
+                'worker_request_count',
+                (float) $serverStats['worker_request_count'],
+                ['worker' => (string) ($event->workerId ?? 0)],
+            );
+            metrics()->gauge(
+                'worker_dispatch_count',
+                (float) $serverStats['worker_dispatch_count'],
+                ['worker' => (string) ($event->workerId ?? 0)],
+            );
+            metrics()->gauge(
+                'memory_usage',
+                (float) memory_get_usage(),
+                ['worker' => (string) ($event->workerId ?? 0)],
+                Unit::byte()
+            );
+            metrics()->gauge(
+                'memory_peak_usage',
+                (float) memory_get_peak_usage(),
+                ['worker' => (string) ($event->workerId ?? 0)],
+                Unit::byte()
+            );
+        });
+
+        Coroutine::create(function () use ($timerId) {
+            CoordinatorManager::until(Constants::WORKER_EXIT)->yield();
+            $this->timer->clear($timerId);
+        });
+    }
+}
diff --git a/src/Metrics/Listener/PoolWatcher.php b/src/Metrics/Listener/PoolWatcher.php
new file mode 100644
index 0000000..5655255
--- /dev/null
+++ b/src/Metrics/Listener/PoolWatcher.php
@@ -0,0 +1,106 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * This file is part of friendsofhyperf/components.
+ *
+ * @link     https://github.com/friendsofhyperf/components
+ * @document https://github.com/friendsofhyperf/components/blob/main/README.md
+ * @contact  huangdijia@gmail.com
+ */
+
+namespace FriendsOfHyperf\Sentry\Metrics\Listener;
+
+use FriendsOfHyperf\Sentry\Feature;
+use Hyperf\Coordinator\Constants;
+use Hyperf\Coordinator\CoordinatorManager;
+use Hyperf\Coordinator\Timer;
+use Hyperf\Engine\Coroutine;
+use Hyperf\Event\Contract\ListenerInterface;
+use Hyperf\Framework\Event\BeforeWorkerStart;
+use Hyperf\Pool\Pool;
+use Hyperf\Server\Event\MainCoroutineServerStart;
+use Psr\Container\ContainerInterface;
+
+use function FriendsOfHyperf\Sentry\metrics;
+use function Hyperf\Coroutine\defer;
+
+abstract class PoolWatcher implements ListenerInterface
+{
+    protected Timer $timer;
+
+    public function __construct(
+        protected ContainerInterface $container,
+        protected Feature $feature,
+    ) {
+        $this->timer = new Timer();
+    }
+
+    /**
+     * @return string[] returns the events that you want to listen
+     */
+    public function listen(): array
+    {
+        return [
+            BeforeWorkerStart::class,
+            MainCoroutineServerStart::class,
+        ];
+    }
+
+    /**
+     * Get the metric name prefix for this pool type (e.g., 'redis', 'mysql').
+     *
+     * @return string The prefix used in metric names like '{prefix}_connections_in_use'
+     */
+    abstract public function getPrefix(): string;
+
+    /**
+     * @param object|BeforeWorkerStart|MainCoroutineServerStart $event
+     */
+    abstract public function process(object $event): void;
+
+    public function watch(Pool $pool, string $poolName, int $workerId): void
+    {
+        if (! $this->feature->isMetricsEnabled()) {
+            return;
+        }
+
+        $timerId = $this->timer->tick($this->feature->getMetricsInterval(), function () use (
+            $pool,
+            $workerId,
+            $poolName
+        ) {
+            defer(fn () => metrics()->flush());
+
+            metrics()->gauge(
+                $this->getPrefix() . '_connections_in_use',
+                (float) $pool->getCurrentConnections(),
+                [
+                    'pool' => $poolName,
+                    'worker' => (string) $workerId,
+                ]
+            );
+            metrics()->gauge(
+                $this->getPrefix() . '_connections_in_waiting',
+                (float) $pool->getConnectionsInChannel(),
+                [
+                    'pool' => $poolName,
+                    'worker' => (string) $workerId,
+                ]
+            );
+            metrics()->gauge(
+                $this->getPrefix() . '_max_connections',
+                (float) $pool->getOption()->getMaxConnections(),
+                [
+                    'pool' => $poolName,
+                    'worker' => (string) $workerId,
+                ]
+            );
+        });
+
+        Coroutine::create(function () use ($timerId) {
+            CoordinatorManager::until(Constants::WORKER_EXIT)->yield();
+            $this->timer->clear($timerId);
+        });
+    }
+}
diff --git a/src/Metrics/Listener/QueueWatcher.php b/src/Metrics/Listener/QueueWatcher.php
new file mode 100644
index 0000000..96f6206
--- /dev/null
+++ b/src/Metrics/Listener/QueueWatcher.php
@@ -0,0 +1,96 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * This file is part of friendsofhyperf/components.
+ *
+ * @link     https://github.com/friendsofhyperf/components
+ * @document https://github.com/friendsofhyperf/components/blob/main/README.md
+ * @contact  huangdijia@gmail.com
+ */
+
+namespace FriendsOfHyperf\Sentry\Metrics\Listener;
+
+use FriendsOfHyperf\Sentry\Feature;
+use FriendsOfHyperf\Sentry\Metrics\Event\MetricFactoryReady;
+use Hyperf\AsyncQueue\Driver\DriverFactory;
+use Hyperf\Contract\ConfigInterface;
+use Hyperf\Coordinator\Constants;
+use Hyperf\Coordinator\CoordinatorManager;
+use Hyperf\Coordinator\Timer;
+use Hyperf\Engine\Coroutine;
+use Hyperf\Event\Contract\ListenerInterface;
+use Psr\Container\ContainerInterface;
+
+use function FriendsOfHyperf\Sentry\metrics;
+use function Hyperf\Coroutine\defer;
+
+class QueueWatcher implements ListenerInterface
+{
+    private Timer $timer;
+
+    public function __construct(
+        protected ContainerInterface $container,
+        protected Feature $feature,
+    ) {
+        $this->timer = new Timer();
+    }
+
+    /**
+     * @return string[] returns the events that you want to listen
+     */
+    public function listen(): array
+    {
+        return [
+            MetricFactoryReady::class,
+        ];
+    }
+
+    /**
+     * @param object|MetricFactoryReady $event
+     */
+    public function process(object $event): void
+    {
+        if (! $this->feature->isMetricsEnabled()) {
+            return;
+        }
+
+        $timerId = $this->timer->tick($this->feature->getMetricsInterval(), function () {
+            defer(fn () => metrics()->flush());
+
+            $config = $this->container->get(ConfigInterface::class);
+            $queues = array_keys($config->get('async_queue', []));
+
+            foreach ($queues as $name) {
+                $queue = $this->container->get(DriverFactory::class)->get($name);
+                $info = $queue->info();
+
+                metrics()->gauge(
+                    'queue_waiting',
+                    (float) $info['waiting'],
+                    ['queue' => $name]
+                );
+                metrics()->gauge(
+                    'queue_delayed',
+                    (float) $info['delayed'],
+                    ['queue' => $name]
+                );
+                metrics()->gauge(
+                    'queue_failed',
+                    (float) $info['failed'],
+                    ['queue' => $name]
+                );
+                metrics()->gauge(
+                    'queue_timeout',
+                    (float) $info['timeout'],
+                    ['queue' => $name]
+                );
+            }
+        });
+
+        Coroutine::create(function () use ($timerId) {
+            CoordinatorManager::until(Constants::WORKER_EXIT)->yield();
+            $this->timer->clear($timerId);
+        });
+    }
+}
diff --git a/src/Metrics/Listener/RedisPoolWatcher.php b/src/Metrics/Listener/RedisPoolWatcher.php
new file mode 100644
index 0000000..0fbe5c1
--- /dev/null
+++ b/src/Metrics/Listener/RedisPoolWatcher.php
@@ -0,0 +1,43 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * This file is part of friendsofhyperf/components.
+ *
+ * @link     https://github.com/friendsofhyperf/components
+ * @document https://github.com/friendsofhyperf/components/blob/main/README.md
+ * @contact  huangdijia@gmail.com
+ */
+
+namespace FriendsOfHyperf\Sentry\Metrics\Listener;
+
+use Hyperf\Contract\ConfigInterface;
+use Hyperf\Framework\Event\BeforeWorkerStart;
+use Hyperf\Redis\Pool\PoolFactory;
+use Hyperf\Server\Event\MainCoroutineServerStart;
+
+class RedisPoolWatcher extends PoolWatcher
+{
+    public function getPrefix(): string
+    {
+        return 'redis';
+    }
+
+    /**
+     * @param object|BeforeWorkerStart|MainCoroutineServerStart $event
+     */
+    public function process(object $event): void
+    {
+        $config = $this->container->get(ConfigInterface::class);
+        $poolNames = array_keys($config->get('redis', ['default' => []]));
+
+        foreach ($poolNames as $poolName) {
+            $workerId = (int) ($event->workerId ?? 0);
+            $pool = $this
+                ->container
+                ->get(PoolFactory::class)
+                ->getPool($poolName);
+            $this->watch($pool, $poolName, $workerId);
+        }
+    }
+}
diff --git a/src/Metrics/Listener/RequestWatcher.php b/src/Metrics/Listener/RequestWatcher.php
new file mode 100644
index 0000000..10bfd66
--- /dev/null
+++ b/src/Metrics/Listener/RequestWatcher.php
@@ -0,0 +1,73 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * This file is part of friendsofhyperf/components.
+ *
+ * @link     https://github.com/friendsofhyperf/components
+ * @document https://github.com/friendsofhyperf/components/blob/main/README.md
+ * @contact  huangdijia@gmail.com
+ */
+
+namespace FriendsOfHyperf\Sentry\Metrics\Listener;
+
+use FriendsOfHyperf\Sentry\Metrics\CoroutineServerStats;
+use FriendsOfHyperf\Sentry\Metrics\Timer;
+use Hyperf\Engine\Coroutine;
+use Hyperf\Event\Contract\ListenerInterface;
+use Hyperf\HttpServer\Event as HttpEvent;
+use Hyperf\HttpServer\Router\Dispatched;
+use Hyperf\RpcServer\Event as RpcEvent;
+use Psr\Http\Message\ServerRequestInterface;
+
+class RequestWatcher implements ListenerInterface
+{
+    public function __construct(protected CoroutineServerStats $stats)
+    {
+    }
+
+    public function listen(): array
+    {
+        return [
+            HttpEvent\RequestReceived::class,
+            HttpEvent\RequestHandled::class,
+            RpcEvent\RequestReceived::class,
+            RpcEvent\RequestHandled::class,
+        ];
+    }
+
+    public function process(object $event): void
+    {
+        if ($event instanceof HttpEvent\RequestReceived || $event instanceof RpcEvent\RequestReceived) {
+            ++$this->stats->accept_count;
+            ++$this->stats->request_count;
+            ++$this->stats->connection_num;
+
+            $request = $event->request;
+            $timer = Timer::make('http_requests', [
+                'request_path' => $this->getPath($request),
+                'request_method' => $request->getMethod(),
+            ]);
+
+            Coroutine::defer(function () use ($timer) {
+                ++$this->stats->close_count;
+                ++$this->stats->response_count;
+                --$this->stats->connection_num;
+
+                $timer->end(true);
+            });
+        }
+    }
+
+    protected function getPath(ServerRequestInterface $request): string
+    {
+        $dispatched = $request->getAttribute(Dispatched::class);
+        if (! $dispatched) {
+            return $request->getUri()->getPath();
+        }
+        if (! $dispatched->handler) {
+            return 'not_found';
+        }
+        return $dispatched->handler->route;
+    }
+}
diff --git a/src/Metrics/Timer.php b/src/Metrics/Timer.php
new file mode 100644
index 0000000..5cdefb5
--- /dev/null
+++ b/src/Metrics/Timer.php
@@ -0,0 +1,62 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * This file is part of friendsofhyperf/components.
+ *
+ * @link     https://github.com/friendsofhyperf/components
+ * @document https://github.com/friendsofhyperf/components/blob/main/README.md
+ * @contact  huangdijia@gmail.com
+ */
+
+namespace FriendsOfHyperf\Sentry\Metrics;
+
+use Sentry\Unit;
+
+use function FriendsOfHyperf\Sentry\metrics;
+
+class Timer
+{
+    public float $startAt;
+
+    protected bool $ended = false;
+
+    public function __construct(
+        protected string $name,
+        protected array $attributes = [],
+        protected ?Unit $unit = null,
+    ) {
+        $this->startAt = microtime(true);
+    }
+
+    public function __destruct()
+    {
+        $this->end();
+    }
+
+    public static function make(
+        string $name,
+        array $attributes = [],
+        ?Unit $unit = null,
+    ): static {
+        return new static($name, $attributes, $unit);
+    }
+
+    public function end(bool $flush = false): void
+    {
+        if ($this->ended) {
+            return;
+        }
+
+        metrics()->distribution(
+            $this->name,
+            (int) ((microtime(true) - $this->startAt) * 1000),
+            $this->attributes,
+            $this->unit ?? Unit::second()
+        );
+
+        $flush && metrics()->flush();
+
+        $this->ended = true;
+    }
+}
diff --git a/src/Metrics/Traits/MetricSetter.php b/src/Metrics/Traits/MetricSetter.php
new file mode 100644
index 0000000..89708ae
--- /dev/null
+++ b/src/Metrics/Traits/MetricSetter.php
@@ -0,0 +1,38 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * This file is part of friendsofhyperf/components.
+ *
+ * @link     https://github.com/friendsofhyperf/components
+ * @document https://github.com/friendsofhyperf/components/blob/main/README.md
+ * @contact  huangdijia@gmail.com
+ */
+
+namespace FriendsOfHyperf\Sentry\Metrics\Traits;
+
+use Sentry\Unit;
+
+use function FriendsOfHyperf\Sentry\metrics;
+
+trait MetricSetter
+{
+    protected function trySet(string $prefix, array $metrics, array $stats, int $workerId = 0, ?Unit $unit = null): void
+    {
+        foreach (array_keys($stats) as $key) {
+            $metricsKey = str_replace('.', '_', $prefix . $key);
+            if (array_key_exists($metricsKey, $metrics)) {
+                metrics()->gauge(
+                    $metricsKey,
+                    (float) $stats[$key],
+                    ['worker' => (string) $workerId],
+                    $unit
+                );
+            }
+        }
+    }
+
+    // protected function spawnDefaultMetrics()
+    // {
+    // }
+}
diff --git a/src/SentryContext.php b/src/SentryContext.php
new file mode 100644
index 0000000..0be693a
--- /dev/null
+++ b/src/SentryContext.php
@@ -0,0 +1,161 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * This file is part of friendsofhyperf/components.
+ *
+ * @link     https://github.com/friendsofhyperf/components
+ * @document https://github.com/friendsofhyperf/components/blob/main/README.md
+ * @contact  huangdijia@gmail.com
+ */
+
+namespace FriendsOfHyperf\Sentry;
+
+use FriendsOfHyperf\Sentry\Util\Carrier;
+use Hyperf\Context\Context;
+use Sentry\Tracing\SpanContext;
+
+class SentryContext
+{
+    public const CTX_CRON_CHECKIN_ID = 'sentry.ctx.crons.checkin_id';
+
+    public const CTX_DISABLE_COROUTINE_TRACING = 'sentry.ctx.coroutine.disabled';
+
+    public const CTX_CARRIER = 'sentry.ctx.carrier';
+
+    public const CTX_ELASTICSEARCH_SPAN_DATA = 'sentry.ctx.elasticsearch.span.data';
+
+    public const CTX_DB_SERVER_ADDRESS = 'sentry.ctx.db.server.address';
+
+    public const CTX_DB_SERVER_PORT = 'sentry.ctx.db.server.port';
+
+    public const CTX_REDIS_SERVER_ADDRESS = 'sentry.ctx.redis.server.address';
+
+    public const CTX_REDIS_SERVER_PORT = 'sentry.ctx.redis.server.port';
+
+    public const CTX_RPC_SERVER_ADDRESS = 'sentry.ctx.rpc.server.address';
+
+    public const CTX_RPC_SERVER_PORT = 'sentry.ctx.rpc.server.port';
+
+    public const CTX_RPC_SPAN_CONTEXT = 'sentry.ctx.rpc.span.context';
+
+    public static function disableTracing(): void
+    {
+        Context::set(self::CTX_DISABLE_COROUTINE_TRACING, true);
+    }
+
+    public static function enableTracing(): void
+    {
+        Context::set(self::CTX_DISABLE_COROUTINE_TRACING, false);
+    }
+
+    public static function isTracingDisabled(): bool
+    {
+        return (bool) Context::get(self::CTX_DISABLE_COROUTINE_TRACING, false);
+    }
+
+    public static function setCronCheckInId(string $checkInId): void
+    {
+        Context::set(self::CTX_CRON_CHECKIN_ID, $checkInId);
+    }
+
+    public static function getCronCheckInId(): ?string
+    {
+        return Context::get(self::CTX_CRON_CHECKIN_ID);
+    }
+
+    public static function setCarrier(Carrier $carrier): void
+    {
+        Context::set(self::CTX_CARRIER, $carrier);
+    }
+
+    public static function getCarrier(?int $coroutineId = null): ?Carrier
+    {
+        return Context::get(self::CTX_CARRIER, coroutineId: $coroutineId);
+    }
+
+    public static function setRedisServerAddress(string $address): void
+    {
+        Context::set(self::CTX_REDIS_SERVER_ADDRESS, $address);
+    }
+
+    public static function getRedisServerAddress(): ?string
+    {
+        return Context::get(self::CTX_REDIS_SERVER_ADDRESS);
+    }
+
+    public static function setRedisServerPort(int $port): void
+    {
+        Context::set(self::CTX_REDIS_SERVER_PORT, $port);
+    }
+
+    public static function getRedisServerPort(): ?int
+    {
+        return Context::get(self::CTX_REDIS_SERVER_PORT);
+    }
+
+    public static function setRpcServerAddress(string $address): void
+    {
+        Context::set(self::CTX_RPC_SERVER_ADDRESS, $address);
+    }
+
+    public static function getRpcServerAddress(): ?string
+    {
+        return Context::get(self::CTX_RPC_SERVER_ADDRESS);
+    }
+
+    public static function setRpcServerPort(int $port): void
+    {
+        Context::set(self::CTX_RPC_SERVER_PORT, $port);
+    }
+
+    public static function getRpcServerPort(): ?int
+    {
+        return Context::get(self::CTX_RPC_SERVER_PORT);
+    }
+
+    public static function setDbServerAddress(string $address): void
+    {
+        Context::set(self::CTX_DB_SERVER_ADDRESS, $address);
+    }
+
+    public static function getDbServerAddress(): ?string
+    {
+        return Context::get(self::CTX_DB_SERVER_ADDRESS);
+    }
+
+    public static function setDbServerPort(int $port): void
+    {
+        Context::set(self::CTX_DB_SERVER_PORT, $port);
+    }
+
+    public static function getDbServerPort(): ?int
+    {
+        return Context::get(self::CTX_DB_SERVER_PORT);
+    }
+
+    public static function setElasticsearchSpanData(array $data): void
+    {
+        Context::set(self::CTX_ELASTICSEARCH_SPAN_DATA, $data);
+    }
+
+    public static function getElasticsearchSpanData(): ?array
+    {
+        return Context::get(self::CTX_ELASTICSEARCH_SPAN_DATA);
+    }
+
+    public static function setRpcSpanContext(SpanContext $spanContext): void
+    {
+        Context::set(self::CTX_RPC_SPAN_CONTEXT, $spanContext);
+    }
+
+    public static function getRpcSpanContext(): ?SpanContext
+    {
+        return Context::get(self::CTX_RPC_SPAN_CONTEXT);
+    }
+
+    public static function destroyRpcSpanContext(): void
+    {
+        Context::destroy(self::CTX_RPC_SPAN_CONTEXT);
+    }
+}
diff --git a/src/Tracing/Aspect/AsyncQueueJobMessageAspect.php b/src/Tracing/Aspect/AsyncQueueJobMessageAspect.php
index d52bf5f..d56d5b4 100644
--- a/src/Tracing/Aspect/AsyncQueueJobMessageAspect.php
+++ b/src/Tracing/Aspect/AsyncQueueJobMessageAspect.php
@@ -13,6 +13,7 @@
 
 use FriendsOfHyperf\Sentry\Constants;
 use FriendsOfHyperf\Sentry\Feature;
+use FriendsOfHyperf\Sentry\SentryContext;
 use FriendsOfHyperf\Sentry\Util\Carrier;
 use Hyperf\AsyncQueue\Driver\RedisDriver;
 use Hyperf\Context\Context;
@@ -77,7 +78,7 @@ public function handlePush(ProceedingJoinPoint $proceedingJoinPoint)
 
         /** @var \Hyperf\AsyncQueue\Driver\Driver $driver */
         $driver = $proceedingJoinPoint->getInstance();
-        $messageId = method_exists($job, 'getId') ? $job->getId() : SentryUid::generate();
+        $messageId = method_exists($job, 'getId') ? call_user_func([$job, 'getId']) : SentryUid::generate();
         $destinationName = Context::get('sentry.messaging.destination.name', 'default');
         $bodySize = (fn ($job) => strlen($this->packer->pack($job)))->call($driver, $job);
         $data = [
@@ -106,7 +107,7 @@ function (Scope $scope) use ($proceedingJoinPoint, $messageId, $destinationName,
                     $carrier = Carrier::fromArray([])->with($extra);
                 }
 
-                Context::set(Constants::TRACE_CARRIER, $carrier);
+                SentryContext::setCarrier($carrier);
 
                 return $proceedingJoinPoint->process();
             },
@@ -140,7 +141,7 @@ protected function buildSpanDataOfRedisDriver(RedisDriver $driver): array
     protected function handleSerialize(ProceedingJoinPoint $proceedingJoinPoint)
     {
         return with($proceedingJoinPoint->process(), function ($result) {
-            if (is_array($result) && $carrier = Context::get(Constants::TRACE_CARRIER)) {
+            if (is_array($result) && $carrier = SentryContext::getCarrier()) {
                 $result[Constants::TRACE_CARRIER] = $carrier->toJson();
             }
 
@@ -156,7 +157,7 @@ protected function handleUnserialize(ProceedingJoinPoint $proceedingJoinPoint)
         $carrier = $data['job'] ?? null;
 
         if ($carrier) {
-            Context::set(Constants::TRACE_CARRIER, Carrier::fromJson($carrier));
+            SentryContext::setCarrier(Carrier::fromJson($carrier));
         }
 
         return $proceedingJoinPoint->process();
diff --git a/src/Tracing/Aspect/CoroutineAspect.php b/src/Tracing/Aspect/CoroutineAspect.php
index 0d08c22..bc01701 100644
--- a/src/Tracing/Aspect/CoroutineAspect.php
+++ b/src/Tracing/Aspect/CoroutineAspect.php
@@ -13,6 +13,7 @@
 
 use FriendsOfHyperf\Sentry\Feature;
 use FriendsOfHyperf\Sentry\Integration;
+use FriendsOfHyperf\Sentry\SentryContext;
 use FriendsOfHyperf\Sentry\Util\CoroutineBacktraceHelper;
 use Hyperf\Context\Context;
 use Hyperf\Di\Aop\AbstractAspect;
@@ -46,7 +47,7 @@ public function process(ProceedingJoinPoint $proceedingJoinPoint)
     {
         if (
             ! $this->feature->isTracingSpanEnabled('coroutine')
-            || Feature::isDisableCoroutineTracing()
+            || SentryContext::isTracingDisabled()
         ) {
             return $proceedingJoinPoint->process();
         }
diff --git a/src/Tracing/Aspect/DbAspect.php b/src/Tracing/Aspect/DbAspect.php
index f8e9790..94edd63 100644
--- a/src/Tracing/Aspect/DbAspect.php
+++ b/src/Tracing/Aspect/DbAspect.php
@@ -12,30 +12,43 @@
 namespace FriendsOfHyperf\Sentry\Tracing\Aspect;
 
 use FriendsOfHyperf\Sentry\Feature;
+use FriendsOfHyperf\Sentry\SentryContext;
 use FriendsOfHyperf\Sentry\Util\SqlParser;
-use Hyperf\DB\DB;
 use Hyperf\DB\Pool\PoolFactory;
 use Hyperf\Di\Aop\AbstractAspect;
 use Hyperf\Di\Aop\ProceedingJoinPoint;
+use PDO;
 use Psr\Container\ContainerInterface;
 use Sentry\State\Scope;
 use Sentry\Tracing\SpanContext;
+use WeakMap;
 
 use function FriendsOfHyperf\Sentry\trace;
+use function Hyperf\Tappable\tap;
 
 /**
  * @property string $poolName
+ * @property PDO $connection
+ * @property array $config
  */
 class DbAspect extends AbstractAspect
 {
     public array $classes = [
-        DB::class . '::__call',
+        'Hyperf\DB\MySQLConnection::reconnect',
+        'Hyperf\DB\DB::getConnection',
+        'Hyperf\DB\DB::__call',
     ];
 
+    /**
+     * @var WeakMap<\Hyperf\DB\AbstractConnection,array>
+     */
+    private WeakMap $serverCache;
+
     public function __construct(
         protected ContainerInterface $container,
         protected Feature $feature
     ) {
+        $this->serverCache = new WeakMap();
     }
 
     public function process(ProceedingJoinPoint $proceedingJoinPoint)
@@ -44,24 +57,46 @@ public function process(ProceedingJoinPoint $proceedingJoinPoint)
             return $proceedingJoinPoint->process();
         }
 
+        if ($proceedingJoinPoint->methodName === 'reconnect') {
+            return tap($proceedingJoinPoint->process(), function () use ($proceedingJoinPoint) {
+                /** @var \Hyperf\DB\AbstractConnection $connection */
+                $connection = $proceedingJoinPoint->getInstance();
+                $this->serverCache[$connection] = $connection->getConfig();
+            });
+        }
+
+        if ($proceedingJoinPoint->methodName === 'getConnection') {
+            return tap($proceedingJoinPoint->process(), function ($connection) {
+                /** @var \Hyperf\DB\AbstractConnection $connection */
+                $server = $this->serverCache[$connection] ?? null;
+                if ($server !== null) {
+                    SentryContext::setDbServerAddress($server['host'] ?? 'localhost');
+                    SentryContext::setDbServerPort((int) ($server['port'] ?? 3306));
+                }
+            });
+        }
+
         $arguments = $proceedingJoinPoint->arguments['keys'];
-        $poolName = (fn () => $this->poolName)->call($proceedingJoinPoint->getInstance());
-        /** @var \Hyperf\Pool\Pool $pool */
-        $pool = $this->container->get(PoolFactory::class)->getPool($poolName);
         $operation = $arguments['name'];
         $database = '';
         $driver = 'unknown';
-        $table = '';
+
+        /** @var \Hyperf\DB\DB $instance */
+        $instance = $proceedingJoinPoint->getInstance();
+        $poolName = (fn () => $this->poolName)->call($instance);
+        /** @var \Hyperf\Pool\Pool $pool */
+        $pool = $this->container->get(PoolFactory::class)->getPool($poolName);
         if ($pool instanceof \Hyperf\DB\Pool\Pool) {
             $config = $pool->getConfig();
             $database = $config['database'] ?? '';
-            $driver = $config['driver'] ?? 'unknown';
+            $driver = $config['driver'] ?? $driver;
         }
 
         $sql = $arguments['arguments']['query'] ?? '';
         $sqlParse = SqlParser::parse($sql);
         $table = $sqlParse['table'];
         $operation = $sqlParse['operation'];
+
         $data = [
             'db.system' => $driver,
             'db.name' => $database,
@@ -72,8 +107,8 @@ public function process(ProceedingJoinPoint $proceedingJoinPoint)
             'db.pool.max_idle_time' => $pool->getOption()->getMaxIdleTime(),
             'db.pool.idle' => $pool->getConnectionsInChannel(),
             'db.pool.using' => $pool->getCurrentConnections(),
-            // 'server.host' => '',
-            // 'server.port' => '',
+            'server.host' => SentryContext::getDbServerAddress() ?? 'localhost',
+            'server.port' => SentryContext::getDbServerPort() ?? 3306,
         ];
 
         if ($this->feature->isTracingTagEnabled('db.sql.bindings', true)) {
diff --git a/src/Tracing/Aspect/DbConnectionAspect.php b/src/Tracing/Aspect/DbConnectionAspect.php
new file mode 100644
index 0000000..a7e5623
--- /dev/null
+++ b/src/Tracing/Aspect/DbConnectionAspect.php
@@ -0,0 +1,68 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * This file is part of friendsofhyperf/components.
+ *
+ * @link     https://github.com/friendsofhyperf/components
+ * @document https://github.com/friendsofhyperf/components/blob/main/README.md
+ * @contact  huangdijia@gmail.com
+ */
+
+namespace FriendsOfHyperf\Sentry\Tracing\Aspect;
+
+use FriendsOfHyperf\Sentry\Feature;
+use FriendsOfHyperf\Sentry\SentryContext;
+use Hyperf\Context\Context;
+use Hyperf\Di\Aop\AbstractAspect;
+use Hyperf\Di\Aop\ProceedingJoinPoint;
+use WeakMap;
+
+use function Hyperf\Tappable\tap;
+
+class DbConnectionAspect extends AbstractAspect
+{
+    public array $classes = [
+        'Hyperf\Database\Connectors\Connector::createPdoConnection',
+        'Hyperf\Database\Connection::getPdoForSelect',
+        'Hyperf\Database\Connection::getPdo',
+    ];
+
+    private WeakMap $serverCache;
+
+    public function __construct(protected Feature $feature)
+    {
+        $this->serverCache = new WeakMap();
+    }
+
+    public function process(ProceedingJoinPoint $proceedingJoinPoint)
+    {
+        return tap($proceedingJoinPoint->process(), function ($pdo) use ($proceedingJoinPoint) {
+            if (! $this->feature->isTracingSpanEnabled('db')) {
+                return;
+            }
+
+            if ($proceedingJoinPoint->methodName === 'createPdoConnection') {
+                $dsn = $proceedingJoinPoint->arguments['keys']['dsn'] ?? '';
+                $pattern = '/host=([^;]+);port=(\d+);?/';
+                if (preg_match($pattern, $dsn, $matches)) {
+                    $host = $matches[1];
+                    $port = $matches[2];
+                    $this->serverCache[$pdo] = ['host' => $host, 'port' => $port];
+                }
+                return;
+            }
+
+            Context::getOrSet(self::class, function () use ($pdo) {
+                $server = $this->serverCache[$pdo] ?? null;
+
+                if (is_array($server)) {
+                    SentryContext::setDbServerAddress($server['host']);
+                    SentryContext::setDbServerPort((int) $server['port']);
+                }
+
+                return true;
+            });
+        });
+    }
+}
diff --git a/src/Tracing/Aspect/ElasticsearchAspect.php b/src/Tracing/Aspect/ElasticsearchAspect.php
index d842954..b1dc8ac 100644
--- a/src/Tracing/Aspect/ElasticsearchAspect.php
+++ b/src/Tracing/Aspect/ElasticsearchAspect.php
@@ -11,9 +11,8 @@
 
 namespace FriendsOfHyperf\Sentry\Tracing\Aspect;
 
-use FriendsOfHyperf\Sentry\Constants;
 use FriendsOfHyperf\Sentry\Feature;
-use Hyperf\Context\Context;
+use FriendsOfHyperf\Sentry\SentryContext;
 use Hyperf\Di\Aop\AbstractAspect;
 use Hyperf\Di\Aop\ProceedingJoinPoint;
 use Sentry\State\Scope;
@@ -59,8 +58,8 @@ function (Scope $scope) use ($proceedingJoinPoint) {
                         ]);
                     }
 
-                    $data = (array) Context::get(Constants::TRACE_ELASTICSEARCH_REQUEST_DATA, []);
-                    $scope->getSpan()?->setData($data);
+                    $data = SentryContext::getElasticsearchSpanData();
+                    $data && $scope->getSpan()?->setData($data);
                 });
             },
             SpanContext::make()
diff --git a/src/Tracing/Aspect/ElasticsearchRequestAspect.php b/src/Tracing/Aspect/ElasticsearchRequestAspect.php
index c633d65..f9c25da 100644
--- a/src/Tracing/Aspect/ElasticsearchRequestAspect.php
+++ b/src/Tracing/Aspect/ElasticsearchRequestAspect.php
@@ -11,8 +11,8 @@
 
 namespace FriendsOfHyperf\Sentry\Tracing\Aspect;
 
-use FriendsOfHyperf\Sentry\Constants;
-use Hyperf\Context\Context;
+use FriendsOfHyperf\Sentry\Feature;
+use FriendsOfHyperf\Sentry\SentryContext;
 use Hyperf\Di\Aop\AbstractAspect;
 use Hyperf\Di\Aop\ProceedingJoinPoint;
 use Psr\Http\Message\RequestInterface;
@@ -23,19 +23,25 @@ class ElasticsearchRequestAspect extends AbstractAspect
         'Elastic\Elasticsearch\Client::sendRequest',
     ];
 
+    public function __construct(protected Feature $feature)
+    {
+    }
+
     public function process(ProceedingJoinPoint $proceedingJoinPoint)
     {
-        $arguments = $proceedingJoinPoint->arguments['keys'] ?? [];
-        $request = $arguments['request'] ?? null;
-
-        if ($request instanceof RequestInterface) {
-            $data = [
-                'server.address' => $request->getUri()->getHost(),
-                'server.port' => $request->getUri()->getPort(),
-                'http.request.method' => $request->getMethod(),
-                'url.full' => $this->getFullUrl($request),
-            ];
-            Context::set(Constants::TRACE_ELASTICSEARCH_REQUEST_DATA, $data);
+        if ($this->feature->isTracingSpanEnabled('elasticsearch')) {
+            $arguments = $proceedingJoinPoint->arguments['keys'] ?? [];
+            $request = $arguments['request'] ?? null;
+
+            if ($request instanceof RequestInterface) {
+                $data = [
+                    'server.address' => $request->getUri()->getHost(),
+                    'server.port' => $request->getUri()->getPort(),
+                    'http.request.method' => $request->getMethod(),
+                    'url.full' => $this->getFullUrl($request),
+                ];
+                SentryContext::setElasticsearchSpanData($data);
+            }
         }
 
         return $proceedingJoinPoint->process();
diff --git a/src/Tracing/Aspect/GrpcAspect.php b/src/Tracing/Aspect/GrpcAspect.php
index 4ea0888..0dcd896 100644
--- a/src/Tracing/Aspect/GrpcAspect.php
+++ b/src/Tracing/Aspect/GrpcAspect.php
@@ -15,6 +15,8 @@
 use FriendsOfHyperf\Sentry\Feature;
 use Hyperf\Di\Aop\AbstractAspect;
 use Hyperf\Di\Aop\ProceedingJoinPoint;
+use Hyperf\GrpcClient\BaseClient;
+use Hyperf\GrpcClient\GrpcClient;
 use Sentry\SentrySdk;
 use Sentry\State\Scope;
 use Sentry\Tracing\SpanContext;
@@ -38,12 +40,20 @@ public function process(ProceedingJoinPoint $proceedingJoinPoint)
             return $proceedingJoinPoint->process();
         }
 
+        /** @var BaseClient $instance */
+        $instance = $proceedingJoinPoint->getInstance();
+        /** @var GrpcClient $grpcClient */
+        $grpcClient = $instance->_getGrpcClient();
+        [$serverAddress, $serverPort] = (fn () => [$this->host ?? null, $this->port ?? null])->call($grpcClient);
+
         $method = $proceedingJoinPoint->arguments['keys']['method'];
         $options = $proceedingJoinPoint->arguments['keys']['options'];
         $data = [
             'rpc.system' => 'grpc',
             'rpc.method' => $method,
             'rpc.options' => $options,
+            'server.address' => (string) ($serverAddress ?? 'unknown'),
+            'server.port' => $serverPort,
         ];
 
         $parent = SentrySdk::getCurrentHub()->getSpan();
diff --git a/src/Tracing/Aspect/GuzzleHttpClientAspect.php b/src/Tracing/Aspect/GuzzleHttpClientAspect.php
index 1080a7c..39035f6 100644
--- a/src/Tracing/Aspect/GuzzleHttpClientAspect.php
+++ b/src/Tracing/Aspect/GuzzleHttpClientAspect.php
@@ -66,7 +66,7 @@ public function process(ProceedingJoinPoint $proceedingJoinPoint)
         }
 
         return trace(
-            function (Scope $scope) use ($proceedingJoinPoint, $options, $guzzleConfig) {
+            function (Scope $scope) use ($proceedingJoinPoint, $options, $guzzleConfig, $request) {
                 if ($span = $scope->getSpan()) {
                     // Inject trace context
                     $options['headers'] = array_replace($options['headers'] ?? [], [
@@ -79,7 +79,7 @@ function (Scope $scope) use ($proceedingJoinPoint, $options, $guzzleConfig) {
                     $onStats = $options['on_stats'] ?? null;
 
                     // Add or override the on_stats option to record the request duration.
-                    $proceedingJoinPoint->arguments['keys']['options']['on_stats'] = function (TransferStats $stats) use ($options, $guzzleConfig, $onStats, $span) {
+                    $proceedingJoinPoint->arguments['keys']['options']['on_stats'] = function (TransferStats $stats) use ($options, $guzzleConfig, $onStats, $request, $span) {
                         $request = $stats->getRequest();
                         $uri = $request->getUri();
                         $span->setData([
@@ -100,6 +100,8 @@ function (Scope $scope) use ($proceedingJoinPoint, $options, $guzzleConfig) {
                             'http.guzzle.config' => $guzzleConfig,
                             'http.guzzle.options' => $options ?? [],
                             'duration' => $stats->getTransferTime() * 1000, // in milliseconds
+                            'server.address' => $request->getUri()->getHost(),
+                            'server.port' => $request->getUri()->getPort(),
                         ]);
 
                         if ($response = $stats->getResponse()) {
diff --git a/src/Tracing/Aspect/RedisConnectionAspect.php b/src/Tracing/Aspect/RedisConnectionAspect.php
new file mode 100644
index 0000000..9af7667
--- /dev/null
+++ b/src/Tracing/Aspect/RedisConnectionAspect.php
@@ -0,0 +1,87 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * This file is part of friendsofhyperf/components.
+ *
+ * @link     https://github.com/friendsofhyperf/components
+ * @document https://github.com/friendsofhyperf/components/blob/main/README.md
+ * @contact  huangdijia@gmail.com
+ */
+
+namespace FriendsOfHyperf\Sentry\Tracing\Aspect;
+
+use FriendsOfHyperf\Sentry\Feature;
+use FriendsOfHyperf\Sentry\SentryContext;
+use FriendsOfHyperf\Sentry\Util\RedisClusterKeySlot;
+use Hyperf\Di\Aop\AbstractAspect;
+use Hyperf\Di\Aop\ProceedingJoinPoint;
+use Redis;
+use RedisCluster;
+use WeakMap;
+
+use function Hyperf\Tappable\tap;
+
+class RedisConnectionAspect extends AbstractAspect
+{
+    public array $classes = [
+        'Hyperf\Redis\RedisConnection::__call',
+    ];
+
+    private WeakMap $slotNodeCache;
+
+    public function __construct(protected Feature $feature)
+    {
+        $this->slotNodeCache = new WeakMap();
+    }
+
+    public function process(ProceedingJoinPoint $proceedingJoinPoint)
+    {
+        return tap($proceedingJoinPoint->process(), function ($result) use ($proceedingJoinPoint) {
+            if (! $this->feature->isTracingSpanEnabled('redis')) {
+                return;
+            }
+
+            $redisConnection = $proceedingJoinPoint->getInstance();
+            $connection = (fn () => $this->connection ?? null)->call($redisConnection);
+
+            if ($connection instanceof Redis) { // Redis or RedisSentinel
+                SentryContext::setRedisServerAddress($connection->getHost());
+                SentryContext::setRedisServerPort($connection->getPort());
+            }
+
+            if ($connection instanceof RedisCluster) { // RedisCluster
+                $arguments = $proceedingJoinPoint->arguments['keys']['arguments'] ?? [];
+                $key = $arguments[0] ?? null;
+                if (is_string($key)) {
+                    $node = $this->getClusterNodeBySlot($connection, $key);
+                    if ($node !== null) {
+                        SentryContext::setRedisServerAddress($node['host']);
+                        SentryContext::setRedisServerPort((int) $node['port']);
+                    }
+                }
+            }
+        });
+    }
+
+    private function getClusterNodeBySlot(RedisCluster $rc, string $key)
+    {
+        // $slot = $rc->cluster('CLUSTER', 'KEYSLOT', $key);
+        $slot = RedisClusterKeySlot::get($key);
+        $slots = ($this->slotNodeCache[$rc] ??= $rc->cluster('CLUSTER', 'SLOTS')); // @phpstan-ignore-line
+
+        foreach ($slots as $range) {
+            [$start, $end, $master] = $range;
+            if ($slot >= $start && $slot <= $end) {
+                // $master = [host, port, nodeId]
+                return [
+                    'host' => $master[0],
+                    'port' => $master[1],
+                    'nodeId' => $master[2] ?? null,
+                ];
+            }
+        }
+
+        return null;
+    }
+}
diff --git a/src/Tracing/Aspect/RpcAspect.php b/src/Tracing/Aspect/RpcAspect.php
index 51aa90a..573324e 100644
--- a/src/Tracing/Aspect/RpcAspect.php
+++ b/src/Tracing/Aspect/RpcAspect.php
@@ -13,6 +13,7 @@
 
 use FriendsOfHyperf\Sentry\Constants;
 use FriendsOfHyperf\Sentry\Feature;
+use FriendsOfHyperf\Sentry\SentryContext;
 use FriendsOfHyperf\Sentry\Util\Carrier;
 use Hyperf\Context\Context;
 use Hyperf\Contract\ConfigInterface;
@@ -76,7 +77,7 @@ private function handleGenerateRpcPath(ProceedingJoinPoint $proceedingJoinPoint)
         };
 
         // https://github.com/open-telemetry/semantic-conventions/blob/main/docs/rpc/rpc-spans.md
-        Context::set(static::SPAN_CONTEXT, SpanContext::make()
+        SentryContext::setRpcSpanContext(SpanContext::make()
             ->setOp('rpc.client')
             ->setDescription($path)
             ->setOrigin('auto.rpc')
@@ -91,8 +92,7 @@ private function handleGenerateRpcPath(ProceedingJoinPoint $proceedingJoinPoint)
 
     private function handleSend(ProceedingJoinPoint $proceedingJoinPoint)
     {
-        /** @var null|SpanContext $spanContext */
-        $spanContext = Context::get(static::SPAN_CONTEXT);
+        $spanContext = SentryContext::getRpcSpanContext();
 
         if (! $spanContext) {
             return $proceedingJoinPoint->process();
@@ -116,18 +116,16 @@ function (Scope $scope) use ($proceedingJoinPoint) {
                         if ($this->feature->isTracingTagEnabled('rpc.result')) {
                             $span?->setData(['rpc.result' => $result]);
                         }
-                        if (Context::has(Constants::TRACE_RPC_SERVER_ADDRESS)) {
-                            $span?->setData([
-                                'server.address' => Context::get(Constants::TRACE_RPC_SERVER_ADDRESS),
-                                'server.port' => Context::get(Constants::TRACE_RPC_SERVER_PORT),
-                            ]);
-                        }
+                        $span?->setData([
+                            'server.address' => SentryContext::getRpcServerAddress() ?? 'unknown',
+                            'server.port' => SentryContext::getRpcServerPort() ?? 0,
+                        ]);
                     });
                 },
                 $spanContext
             );
         } finally {
-            Context::destroy(static::SPAN_CONTEXT);
+            SentryContext::destroyRpcSpanContext();
         }
     }
 }
diff --git a/src/Tracing/Aspect/RpcEndpointAspect.php b/src/Tracing/Aspect/RpcEndpointAspect.php
index e83ae8e..8300be1 100644
--- a/src/Tracing/Aspect/RpcEndpointAspect.php
+++ b/src/Tracing/Aspect/RpcEndpointAspect.php
@@ -11,8 +11,8 @@
 
 namespace FriendsOfHyperf\Sentry\Tracing\Aspect;
 
-use FriendsOfHyperf\Sentry\Constants;
-use Hyperf\Context\Context;
+use FriendsOfHyperf\Sentry\Feature;
+use FriendsOfHyperf\Sentry\SentryContext;
 use Hyperf\Di\Aop\AbstractAspect;
 use Hyperf\Di\Aop\ProceedingJoinPoint;
 
@@ -26,18 +26,26 @@ class RpcEndpointAspect extends AbstractAspect
         'Hyperf\JsonRpc\JsonRpcPoolTransporter::getConnection',
     ];
 
+    public function __construct(protected Feature $feature)
+    {
+    }
+
     public function process(ProceedingJoinPoint $proceedingJoinPoint)
     {
         return tap($proceedingJoinPoint->process(), function ($result) {
+            if (! $this->feature->isTracingSpanEnabled('rpc')) {
+                return;
+            }
+
             // RpcMultiplex
             if ($result instanceof \Hyperf\RpcMultiplex\Socket) {
-                Context::set(Constants::TRACE_RPC_SERVER_ADDRESS, $result->getName());
-                Context::set(Constants::TRACE_RPC_SERVER_PORT, $result->getPort());
+                SentryContext::setRpcServerAddress($result->getName());
+                SentryContext::setRpcServerPort($result->getPort());
             }
             // JsonRpcHttpTransporter
             if ($result instanceof \Hyperf\LoadBalancer\Node) {
-                Context::set(Constants::TRACE_RPC_SERVER_ADDRESS, $result->host);
-                Context::set(Constants::TRACE_RPC_SERVER_PORT, $result->port);
+                SentryContext::setRpcServerAddress($result->host);
+                SentryContext::setRpcServerPort($result->port);
             }
             // JsonRpcPoolTransporter
             if ($result instanceof \Hyperf\JsonRpc\Pool\RpcConnection) {
@@ -47,8 +55,8 @@ public function process(ProceedingJoinPoint $proceedingJoinPoint)
                     /** @var null|\Hyperf\Engine\Contract\Socket\SocketOptionInterface $option */
                     $option = $socket->getSocketOption();
                     if ($option instanceof \Hyperf\Engine\Contract\Socket\SocketOptionInterface) {
-                        Context::set(Constants::TRACE_RPC_SERVER_ADDRESS, $option->getHost());
-                        Context::set(Constants::TRACE_RPC_SERVER_PORT, $option->getPort());
+                        SentryContext::setRpcServerAddress($option->getHost());
+                        SentryContext::setRpcServerPort($option->getPort());
                     }
                 }
             }
diff --git a/src/Tracing/Listener/EventHandleListener.php b/src/Tracing/Listener/EventHandleListener.php
index f20fab5..2d8e610 100644
--- a/src/Tracing/Listener/EventHandleListener.php
+++ b/src/Tracing/Listener/EventHandleListener.php
@@ -15,6 +15,7 @@
 use FriendsOfHyperf\Sentry\Constants;
 use FriendsOfHyperf\Sentry\Feature;
 use FriendsOfHyperf\Sentry\Integration;
+use FriendsOfHyperf\Sentry\SentryContext;
 use FriendsOfHyperf\Sentry\Util\Carrier;
 use FriendsOfHyperf\Sentry\Util\CoContainer;
 use FriendsOfHyperf\Sentry\Util\SqlParser;
@@ -22,7 +23,6 @@
 use Hyperf\Amqp\Message\ConsumerMessage;
 use Hyperf\AsyncQueue\Event as AsyncQueueEvent;
 use Hyperf\Command\Event as CommandEvent;
-use Hyperf\Context\Context;
 use Hyperf\Contract\ConfigInterface;
 use Hyperf\Coroutine\Coroutine;
 use Hyperf\Crontab\Event as CrontabEvent;
@@ -192,6 +192,8 @@ protected function handleDbQueryExecuted(DbEvent\QueryExecuted $event): void
             'db.pool.max_idle_time' => $pool->getOption()->getMaxIdleTime(),
             'db.pool.idle' => $pool->getConnectionsInChannel(),
             'db.pool.using' => $pool->getCurrentConnections(),
+            'server.address' => SentryContext::getDbServerAddress() ?? 'localhost',
+            'server.port' => SentryContext::getDbServerPort() ?? 3306,
         ];
 
         if ($this->feature->isTracingTagEnabled('db.sql.bindings', true)) {
@@ -496,6 +498,8 @@ function (Scope $scope) use ($event) {
                     'db.redis.pool.idle' => $pool->getConnectionsInChannel(),
                     'db.redis.pool.using' => $pool->getCurrentConnections(),
                     'duration' => $event->time * 1000,
+                    'server.address' => SentryContext::getRedisServerAddress() ?? 'localhost',
+                    'server.port' => SentryContext::getRedisServerPort() ?? 6379,
                 ])
                 ->setStartTimestamp(microtime(true) - $event->time / 1000)
         );
@@ -568,7 +572,7 @@ protected function handleAmqpMessageProcessing(AmqpEvent\BeforeConsume $event):
             $applicationHeaders = $amqpMessage->has('application_headers') ? $amqpMessage->get('application_headers') : null;
             if ($applicationHeaders && isset($applicationHeaders[Constants::TRACE_CARRIER])) {
                 $carrier = Carrier::fromJson($applicationHeaders[Constants::TRACE_CARRIER]);
-                Context::set(Constants::TRACE_CARRIER, $carrier);
+                SentryContext::setCarrier($carrier);
             }
         }
 
@@ -638,7 +642,7 @@ protected function handleKafkaMessageProcessing(KafkaEvent\BeforeConsume $event)
             foreach ($message->getHeaders() as $header) {
                 if ($header->getHeaderKey() === Constants::TRACE_CARRIER) {
                     $carrier = Carrier::fromJson($header->getValue());
-                    Context::set(Constants::TRACE_CARRIER, $carrier);
+                    SentryContext::setCarrier($carrier);
                     break;
                 }
             }
@@ -694,8 +698,7 @@ protected function handleAsyncQueueJobProcessing(AsyncQueueEvent\BeforeHandle $e
             return;
         }
 
-        /** @var null|Carrier $carrier */
-        $carrier = Context::get(Constants::TRACE_CARRIER, null, Coroutine::parentId());
+        $carrier = SentryContext::getCarrier(Coroutine::parentId());
         $job = $event->getMessage()->job();
 
         $transaction = startTransaction(
diff --git a/src/Util/RedisClusterKeySlot.php b/src/Util/RedisClusterKeySlot.php
new file mode 100644
index 0000000..bc87676
--- /dev/null
+++ b/src/Util/RedisClusterKeySlot.php
@@ -0,0 +1,69 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * This file is part of friendsofhyperf/components.
+ *
+ * @link     https://github.com/friendsofhyperf/components
+ * @document https://github.com/friendsofhyperf/components/blob/main/README.md
+ * @contact  huangdijia@gmail.com
+ */
+
+namespace FriendsOfHyperf\Sentry\Util;
+
+class RedisClusterKeySlot
+{
+    private static array $crc16tab = [
+        0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
+        0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
+        0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
+        0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE,
+        0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485,
+        0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D,
+        0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4,
+        0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC,
+        0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
+        0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B,
+        0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12,
+        0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A,
+        0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41,
+        0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49,
+        0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70,
+        0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78,
+        0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F,
+        0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
+        0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E,
+        0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256,
+        0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D,
+        0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
+        0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C,
+        0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634,
+        0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB,
+        0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3,
+        0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
+        0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92,
+        0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9,
+        0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1,
+        0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8,
+        0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0,
+    ];
+
+    public static function get(string $key): int
+    {
+        // 处理 hash tag
+        if (preg_match('/\{(.+?)\}/', $key, $m)) {
+            $key = $m[1];
+        }
+
+        // 计算 CRC16
+        $crc = 0;
+        $len = strlen($key);
+
+        for ($i = 0; $i < $len; ++$i) {
+            $crc = (($crc << 8) ^ self::$crc16tab[(($crc >> 8) ^ ord($key[$i])) & 0xFF]) & 0xFFFF;
+        }
+
+        // 得到 slot
+        return $crc % 16384;
+    }
+}