diff --git a/automq-log-uploader/README.md b/automq-log-uploader/README.md
new file mode 100644
index 0000000000..3de41a344d
--- /dev/null
+++ b/automq-log-uploader/README.md
@@ -0,0 +1,83 @@
+# AutoMQ Log Uploader Module
+
+This module provides asynchronous S3 log upload capability based on Log4j 1.x. Other submodules only need to depend on this module and configure it simply to synchronize logs to object storage. Core components:
+
+- `com.automq.log.uploader.S3RollingFileAppender`: Extends `RollingFileAppender`, pushes log events to the uploader while writing to local files.
+- `com.automq.log.uploader.LogUploader`: Asynchronously buffers, compresses, and uploads logs; supports configuration switches and periodic cleanup.
+- `com.automq.log.uploader.S3LogConfig`/`S3LogConfigProvider`: Abstracts the configuration required for uploading. The default implementation `PropertiesS3LogConfigProvider` reads from `automq-log.properties`.
+
+## Quick Integration
+
+1. Add dependency in your module's `build.gradle`:
+   ```groovy
+   implementation project(':automq-log-uploader')
+   ```
+2. Create `automq-log.properties` in the resources directory (or customize `S3LogConfigProvider`):
+   ```properties
+   log.s3.enable=true
+   log.s3.bucket=0@s3://your-log-bucket?region=us-east-1
+   log.s3.cluster.id=my-cluster
+   log.s3.node.id=1
+   log.s3.selector.type=kafka
+   log.s3.selector.kafka.bootstrap.servers=PLAINTEXT://kafka:9092
+   log.s3.selector.kafka.group.id=automq-log-uploader-my-cluster
+   ```
+3. Reference the Appender in `log4j.properties`:
+   ```properties
+   log4j.appender.s3_uploader=com.automq.log.uploader.S3RollingFileAppender
+   log4j.appender.s3_uploader.File=logs/server.log
+   log4j.appender.s3_uploader.MaxFileSize=100MB
+   log4j.appender.s3_uploader.MaxBackupIndex=10
+   log4j.appender.s3_uploader.layout=org.apache.log4j.PatternLayout
+   log4j.appender.s3_uploader.layout.ConversionPattern=[%d] %p %m (%c)%n
+   ```
+   If you need to customize the configuration provider, you can set:
+   ```properties
+  log4j.appender.s3_uploader.configProviderClass=com.example.CustomS3LogConfigProvider
+  ```
+
+## Key Configuration Description
+
+| Configuration Item | Description |
+| ------ | ---- |
+| `log.s3.enable` | Whether to enable S3 upload function.
+| `log.s3.bucket` | It is recommended to use AutoMQ Bucket URI (e.g. `0@s3://bucket?region=us-east-1&pathStyle=true`). If using a shorthand bucket name, additional fields such as `log.s3.region` need to be provided.
+| `log.s3.cluster.id` / `log.s3.node.id` | Used to construct the object storage path `automq/logs/{cluster}/{node}/{hour}/{uuid}`.
+| `log.s3.selector.type` | Leader election strategy (`static`, `nodeid`, `file`, `kafka`, or custom).
+| `log.s3.primary.node` | Used with `static` strategy to indicate whether the current node is the primary node.
+| `log.s3.selector.kafka.*` | Additional configuration required for Kafka leader election, such as `bootstrap.servers`, `group.id`, etc.
+| `log.s3.active.controller` | **Deprecated**, please use `log.s3.selector.type=static` + `log.s3.primary.node=true`.
+
+The upload schedule can be overridden by environment variables:
+
+- `AUTOMQ_OBSERVABILITY_UPLOAD_INTERVAL`: Maximum upload interval (milliseconds).
+- `AUTOMQ_OBSERVABILITY_CLEANUP_INTERVAL`: Retention period (milliseconds), old objects earlier than this time will be cleaned up.
+
+### Leader Election Strategies
+
+To avoid multiple nodes executing S3 cleanup tasks simultaneously, the log uploader has a built-in leader election mechanism consistent with the OpenTelemetry module:
+
+1. **static**: Specify which node is the leader using `log.s3.primary.node=true|false`.
+2. **nodeid**: Becomes the leader node when `log.s3.node.id` equals `primaryNodeId`, which can be set in the URL or properties with `log.s3.selector.primary.node.id`.
+3. **file**: Uses a shared file for preemptive leader election, configure `log.s3.selector.file.leaderFile=/shared/leader`, `log.s3.selector.file.leaderTimeoutMs=60000`.
+4. **kafka**: Default strategy. All nodes join the same consumer group of a single-partition topic, the node holding the partition becomes the leader. Necessary configuration:
+   ```properties
+   log.s3.selector.type=kafka
+   log.s3.selector.kafka.bootstrap.servers=PLAINTEXT://kafka:9092
+   log.s3.selector.kafka.topic=__automq_log_uploader_leader_cluster1
+   log.s3.selector.kafka.group.id=automq-log-uploader-cluster1
+   ```
+   Advanced parameters such as security (SASL/SSL), timeout, etc. can be provided through `log.s3.selector.kafka.*`.
+5. **custom**: Implement `com.automq.log.uploader.selector.LogUploaderNodeSelectorProvider` and register it through SPI to introduce a custom leader election strategy.
+
+## Extension
+
+If the application already has its own dependency injection/configuration method, you can implement `S3LogConfigProvider` and call it at startup:
+
+```java
+import com.automq.log.uploader.S3RollingFileAppender;
+
+S3RollingFileAppender.setConfigProvider(new CustomConfigProvider());
+```
+
+All `S3RollingFileAppender` instances will share this provider.
diff --git a/automq-log-uploader/build.gradle b/automq-log-uploader/build.gradle
new file mode 100644
index 0000000000..72dd261d03
--- /dev/null
+++ b/automq-log-uploader/build.gradle
@@ -0,0 +1,19 @@
+plugins {
+    id 'java-library'
+}
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    api project(':s3stream')
+
+    implementation project(':clients')
+    implementation libs.reload4j
+    implementation libs.slf4jApi
+    implementation libs.slf4jBridge
+    implementation libs.nettyBuffer
+    implementation libs.guava
+    implementation libs.commonLang
+}
diff --git a/automq-log-uploader/src/main/java/com/automq/log/uploader/DefaultS3LogConfig.java b/automq-log-uploader/src/main/java/com/automq/log/uploader/DefaultS3LogConfig.java
new file mode 100644
index 0000000000..9458212f06
--- /dev/null
+++ b/automq-log-uploader/src/main/java/com/automq/log/uploader/DefaultS3LogConfig.java
@@ -0,0 +1,183 @@
+/*
+ * Copyright 2025, AutoMQ HK Limited.
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.automq.log.uploader;
+
+import com.automq.log.uploader.selector.LogUploaderNodeSelector;
+import com.automq.log.uploader.selector.LogUploaderNodeSelectorFactory;
+import com.automq.stream.s3.operator.BucketURI;
+import com.automq.stream.s3.operator.ObjectStorage;
+import com.automq.stream.s3.operator.ObjectStorageFactory;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Properties;
+
+import static com.automq.log.uploader.LogConfigConstants.*;
+
+public class DefaultS3LogConfig implements S3LogConfig {
+    private static final Logger LOGGER = LoggerFactory.getLogger(DefaultS3LogConfig.class);
+
+    private final Properties props;
+    private ObjectStorage objectStorage;
+    private LogUploaderNodeSelector nodeSelector;
+
+    public DefaultS3LogConfig() {
+        this(null);
+    }
+
+    public DefaultS3LogConfig(Properties overrideProps) {
+        this.props = new Properties();
+        if (overrideProps != null) {
+            this.props.putAll(overrideProps);
+        }
+        if (overrideProps == null) {
+            try (InputStream input = getClass().getClassLoader().getResourceAsStream(LOG_PROPERTIES_FILE)) {
+                if (input != null) {
+                    props.load(input);
+                    LOGGER.info("Loaded log configuration from {}", LOG_PROPERTIES_FILE);
+                } else {
+                    LOGGER.warn("Could not find {}, using default log configurations.", LOG_PROPERTIES_FILE);
+                }
+            } catch (IOException ex) {
+                LOGGER.error("Failed to load log configuration from {}.", LOG_PROPERTIES_FILE, ex);
+            }
+        }
+        initializeNodeSelector();
+    }
+
+    @Override
+    public boolean isEnabled() {
+        return Boolean.parseBoolean(props.getProperty(LOG_S3_ENABLE_KEY, String.valueOf(DEFAULT_LOG_S3_ENABLE)));
+    }
+
+    @Override
+    public String clusterId() {
+        return props.getProperty(LOG_S3_CLUSTER_ID_KEY, DEFAULT_LOG_S3_CLUSTER_ID);
+    }
+
+    @Override
+    public int nodeId() {
+        return Integer.parseInt(props.getProperty(LOG_S3_NODE_ID_KEY, String.valueOf(DEFAULT_LOG_S3_NODE_ID)));
+    }
+
+    @Override
+    public synchronized ObjectStorage objectStorage() {
+        if (this.objectStorage != null) {
+            return this.objectStorage;
+        }
+        String bucket = props.getProperty(LOG_S3_BUCKET_KEY);
+        if (StringUtils.isBlank(bucket)) {
+            LOGGER.error("Mandatory log config '{}' is not set.", LOG_S3_BUCKET_KEY);
+            return null;
+        }
+
+        String normalizedBucket = bucket.trim();
+        if (!normalizedBucket.contains("@")) {
+            String region = props.getProperty(LOG_S3_REGION_KEY);
+            if (StringUtils.isBlank(region)) {
+                LOGGER.error("'{}' must be provided when '{}' is not a full AutoMQ bucket URI.",
+                    LOG_S3_REGION_KEY, LOG_S3_BUCKET_KEY);
+                return null;
+            }
+            String endpoint = props.getProperty(LOG_S3_ENDPOINT_KEY);
+            String accessKey = props.getProperty(LOG_S3_ACCESS_KEY);
+            String secretKey = props.getProperty(LOG_S3_SECRET_KEY);
+
+            StringBuilder builder = new StringBuilder("0@s3://").append(normalizedBucket)
+                .append("?region=").append(region.trim());
+            if (StringUtils.isNotBlank(endpoint)) {
+                builder.append("&endpoint=").append(endpoint.trim());
+            }
+            if (StringUtils.isNotBlank(accessKey) && StringUtils.isNotBlank(secretKey)) {
+                builder.append("&authType=static")
+                    .append("&accessKey=").append(accessKey.trim())
+                    .append("&secretKey=").append(secretKey.trim());
+            }
+            normalizedBucket = builder.toString();
+        }
+
+        BucketURI logBucket = BucketURI.parse(normalizedBucket);
+        this.objectStorage = ObjectStorageFactory.instance().builder(logBucket).threadPrefix("s3-log-uploader").build();
+        return this.objectStorage;
+    }
+
+    @Override
+    public LogUploaderNodeSelector nodeSelector() {
+        if (nodeSelector == null) {
+            initializeNodeSelector();
+        }
+        return nodeSelector;
+    }
+
+    private void initializeNodeSelector() {
+        String selectorType = props.getProperty(LOG_S3_SELECTOR_TYPE_KEY, "static");
+        Map<String, String> selectorConfig = new HashMap<>();
+        Map<String, String> rawConfig = getPropertiesWithPrefix(LOG_S3_SELECTOR_PREFIX);
+        String normalizedType = selectorType == null ? "" : selectorType.toLowerCase(Locale.ROOT);
+        for (Map.Entry<String, String> entry : rawConfig.entrySet()) {
+            String key = entry.getKey();
+            if (normalizedType.length() > 0 && key.toLowerCase(Locale.ROOT).startsWith(normalizedType + ".")) {
+                key = key.substring(normalizedType.length() + 1);
+            }
+            if ("type".equalsIgnoreCase(key) || key.isEmpty()) {
+                continue;
+            }
+            selectorConfig.putIfAbsent(key, entry.getValue());
+        }
+
+        selectorConfig.putIfAbsent("isPrimaryUploader",
+            props.getProperty(LOG_S3_PRIMARY_NODE_KEY,
+                props.getProperty(LOG_S3_ACTIVE_CONTROLLER_KEY, String.valueOf(DEFAULT_LOG_S3_ACTIVE_CONTROLLER))));
+
+        String primaryNodeId = props.getProperty(LOG_S3_SELECTOR_PRIMARY_NODE_ID_KEY);
+        if (StringUtils.isNotBlank(primaryNodeId)) {
+            selectorConfig.putIfAbsent("primaryNodeId", primaryNodeId.trim());
+        }
+
+        try {
+            this.nodeSelector = LogUploaderNodeSelectorFactory.createSelector(selectorType, clusterId(), nodeId(), selectorConfig);
+        } catch (Exception e) {
+            LOGGER.error("Failed to create log uploader selector of type {}", selectorType, e);
+            this.nodeSelector = LogUploaderNodeSelector.staticSelector(false);
+        }
+    }
+
+    private Map<String, String> getPropertiesWithPrefix(String prefix) {
+        Map<String, String> result = new HashMap<>();
+        if (prefix == null || prefix.isEmpty()) {
+            return result;
+        }
+        for (String key : props.stringPropertyNames()) {
+            if (key.startsWith(prefix)) {
+                String trimmed = key.substring(prefix.length());
+                if (!trimmed.isEmpty()) {
+                    result.put(trimmed, props.getProperty(key));
+                }
+            }
+        }
+        return result;
+    }
+}
diff --git a/automq-log-uploader/src/main/java/com/automq/log/uploader/LogConfigConstants.java b/automq-log-uploader/src/main/java/com/automq/log/uploader/LogConfigConstants.java
new file mode 100644
index 0000000000..94c9378d89
--- /dev/null
+++ b/automq-log-uploader/src/main/java/com/automq/log/uploader/LogConfigConstants.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2025, AutoMQ HK Limited.
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.automq.log.uploader;
+
+public class LogConfigConstants {
+    private LogConfigConstants() {
+    }
+
+    public static final String LOG_PROPERTIES_FILE = "automq-log.properties";
+
+    public static final String LOG_S3_ENABLE_KEY = "log.s3.enable";
+    public static final boolean DEFAULT_LOG_S3_ENABLE = false;
+
+    public static final String LOG_S3_BUCKET_KEY = "log.s3.bucket";
+    public static final String LOG_S3_REGION_KEY = "log.s3.region";
+    public static final String LOG_S3_ENDPOINT_KEY = "log.s3.endpoint";
+
+    public static final String LOG_S3_ACCESS_KEY = "log.s3.access.key";
+    public static final String LOG_S3_SECRET_KEY = "log.s3.secret.key";
+
+    public static final String LOG_S3_CLUSTER_ID_KEY = "log.s3.cluster.id";
+    public static final String DEFAULT_LOG_S3_CLUSTER_ID = "automq-cluster";
+
+    public static final String LOG_S3_NODE_ID_KEY = "log.s3.node.id";
+    public static final int DEFAULT_LOG_S3_NODE_ID = 0;
+
+    /**
+     * @deprecated Use selector configuration instead.
+     */
+    @Deprecated
+    public static final String LOG_S3_ACTIVE_CONTROLLER_KEY = "log.s3.active.controller";
+    @Deprecated
+    public static final boolean DEFAULT_LOG_S3_ACTIVE_CONTROLLER = true;
+
+    public static final String LOG_S3_PRIMARY_NODE_KEY = "log.s3.primary.node";
+    public static final String LOG_S3_SELECTOR_PRIMARY_NODE_ID_KEY = "log.s3.selector.primary.node.id";
+    public static final String LOG_S3_SELECTOR_TYPE_KEY = "log.s3.selector.type";
+    public static final String LOG_S3_SELECTOR_PREFIX = "log.s3.selector.";
+}
diff --git a/automq-log-uploader/src/main/java/com/automq/log/uploader/LogRecorder.java b/automq-log-uploader/src/main/java/com/automq/log/uploader/LogRecorder.java
new file mode 100644
index 0000000000..04dc3e6914
--- /dev/null
+++ b/automq-log-uploader/src/main/java/com/automq/log/uploader/LogRecorder.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright 2025, AutoMQ HK Limited.
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.automq.log.uploader;
+
+import org.apache.commons.lang3.StringUtils;
+
+public interface LogRecorder {
+    boolean append(LogEvent event);
+
+    class LogEvent {
+        private final long timestampMillis;
+        private final String level;
+        private final String logger;
+        private final String message;
+        private final String[] stackTrace;
+
+        public LogEvent(long timestampMillis, String level, String logger, String message, String[] stackTrace) {
+            this.timestampMillis = timestampMillis;
+            this.level = level;
+            this.logger = logger;
+            this.message = message;
+            this.stackTrace = stackTrace;
+        }
+
+        public void validate() {
+            if (timestampMillis <= 0) {
+                throw new IllegalArgumentException("Timestamp must be greater than 0");
+            }
+            if (StringUtils.isBlank(level)) {
+                throw new IllegalArgumentException("Level cannot be blank");
+            }
+            if (StringUtils.isBlank(logger)) {
+                throw new IllegalArgumentException("Logger cannot be blank");
+            }
+            if (StringUtils.isBlank(message)) {
+                throw new IllegalArgumentException("Message cannot be blank");
+            }
+        }
+
+        public long timestampMillis() {
+            return timestampMillis;
+        }
+
+        public String level() {
+            return level;
+        }
+
+        public String logger() {
+            return logger;
+        }
+
+        public String message() {
+            return message;
+        }
+
+        public String[] stackTrace() {
+            return stackTrace;
+        }
+    }
+}
diff --git a/automq-log-uploader/src/main/java/com/automq/log/uploader/LogUploader.java b/automq-log-uploader/src/main/java/com/automq/log/uploader/LogUploader.java
new file mode 100644
index 0000000000..8396b028e9
--- /dev/null
+++ b/automq-log-uploader/src/main/java/com/automq/log/uploader/LogUploader.java
@@ -0,0 +1,253 @@
+/*
+ * Copyright 2025, AutoMQ HK Limited.
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.automq.log.uploader;
+
+import com.automq.log.uploader.util.Utils;
+import com.automq.stream.s3.operator.ObjectStorage;
+import com.automq.stream.s3.operator.ObjectStorage.ObjectInfo;
+import com.automq.stream.s3.operator.ObjectStorage.ObjectPath;
+import com.automq.stream.s3.operator.ObjectStorage.WriteOptions;
+import com.google.common.collect.Lists;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.nio.charset.StandardCharsets;
+import java.time.Duration;
+import java.time.Instant;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.time.ZoneOffset;
+import java.time.ZonedDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.List;
+import java.util.Random;
+import java.util.UUID;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+
+public class LogUploader implements LogRecorder {
+    private static final Logger LOGGER = LoggerFactory.getLogger(LogUploader.class);
+
+    public static final int DEFAULT_MAX_QUEUE_SIZE = 64 * 1024;
+    public static final int DEFAULT_BUFFER_SIZE = 16 * 1024 * 1024;
+    public static final int UPLOAD_INTERVAL = System.getenv("AUTOMQ_OBSERVABILITY_UPLOAD_INTERVAL") != null
+        ? Integer.parseInt(System.getenv("AUTOMQ_OBSERVABILITY_UPLOAD_INTERVAL"))
+        : 60 * 1000;
+    public static final int CLEANUP_INTERVAL = System.getenv("AUTOMQ_OBSERVABILITY_CLEANUP_INTERVAL") != null
+        ? Integer.parseInt(System.getenv("AUTOMQ_OBSERVABILITY_CLEANUP_INTERVAL"))
+        : 2 * 60 * 1000;
+    public static final int MAX_JITTER_INTERVAL = 60 * 1000;
+
+    private final BlockingQueue<LogEvent> queue = new LinkedBlockingQueue<>(DEFAULT_MAX_QUEUE_SIZE);
+    private final ByteBuf uploadBuffer = Unpooled.directBuffer(DEFAULT_BUFFER_SIZE);
+    private final Random random = new Random();
+    private volatile long lastUploadTimestamp = System.currentTimeMillis();
+    private volatile long nextUploadInterval = UPLOAD_INTERVAL + random.nextInt(MAX_JITTER_INTERVAL);
+
+    private volatile boolean closed;
+
+    private volatile S3LogConfig config;
+
+    private ObjectStorage objectStorage;
+    private Thread uploadThread;
+    private Thread cleanupThread;
+
+    public LogUploader() {
+    }
+
+    public synchronized void start(S3LogConfig config) {
+        if (this.config != null) {
+            LOGGER.warn("LogUploader is already started.");
+            return;
+        }
+        this.config = config;
+        if (config == null || !config.isEnabled() || config.objectStorage() == null) {
+            LOGGER.warn("LogUploader is disabled due to invalid configuration.");
+            closed = true;
+            return;
+        }
+
+        try {
+            this.objectStorage = config.objectStorage();
+            this.uploadThread = new Thread(new UploadTask());
+            this.uploadThread.setName("log-uploader-upload-thread");
+            this.uploadThread.setDaemon(true);
+            this.uploadThread.start();
+
+            this.cleanupThread = new Thread(new CleanupTask());
+            this.cleanupThread.setName("log-uploader-cleanup-thread");
+            this.cleanupThread.setDaemon(true);
+            this.cleanupThread.start();
+
+            LOGGER.info("LogUploader started successfully.");
+        } catch (Exception e) {
+            LOGGER.error("Failed to start LogUploader", e);
+            closed = true;
+        }
+    }
+
+    public void close() throws InterruptedException {
+        closed = true;
+        if (uploadThread != null) {
+            uploadThread.interrupt();
+            uploadThread.join();
+        }
+        if (cleanupThread != null) {
+            cleanupThread.interrupt();
+            cleanupThread.join();
+        }
+        if (objectStorage != null) {
+            objectStorage.close();
+        }
+    }
+
+    @Override
+    public boolean append(LogEvent event) {
+        if (!closed) {
+            return queue.offer(event);
+        }
+        return false;
+    }
+
+    private class UploadTask implements Runnable {
+
+        private String formatTimestampInMillis(long timestamp) {
+            return ZonedDateTime.ofInstant(Instant.ofEpochMilli(timestamp), ZoneId.systemDefault())
+                .format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS Z"));
+        }
+
+        @Override
+        public void run() {
+            while (!Thread.currentThread().isInterrupted()) {
+                try {
+                    long now = System.currentTimeMillis();
+                    LogEvent event = queue.poll(1, TimeUnit.SECONDS);
+                    if (event != null) {
+                        StringBuilder logLine = new StringBuilder()
+                            .append(formatTimestampInMillis(event.timestampMillis()))
+                            .append(" ")
+                            .append(event.level())
+                            .append(" ")
+                            .append("[").append(event.logger()).append("] ")
+                            .append(event.message())
+                            .append("\n");
+
+                        String[] throwableStrRep = event.stackTrace();
+                        if (throwableStrRep != null) {
+                            for (String stack : throwableStrRep) {
+                                logLine.append(stack).append("\n");
+                            }
+                        }
+
+                        byte[] bytes = logLine.toString().getBytes(StandardCharsets.UTF_8);
+                        if (uploadBuffer.writableBytes() < bytes.length || now - lastUploadTimestamp > nextUploadInterval) {
+                            upload(now);
+                        }
+                        uploadBuffer.writeBytes(bytes);
+                    } else if (closed && queue.isEmpty()) {
+                        upload(now);
+                        break;
+                    } else if (now - lastUploadTimestamp > nextUploadInterval) {
+                        upload(now);
+                    }
+                } catch (InterruptedException e) {
+                    break;
+                } catch (Exception e) {
+                    LOGGER.error("Upload log to s3 failed", e);
+                }
+            }
+        }
+
+        private void upload(long now) {
+            if (uploadBuffer.readableBytes() > 0) {
+                try {
+                    while (!Thread.currentThread().isInterrupted()) {
+                        if (objectStorage == null) {
+                            break;
+                        }
+
+                        try {
+                            String objectKey = getObjectKey();
+                            objectStorage.write(WriteOptions.DEFAULT, objectKey, Utils.compress(uploadBuffer.slice().asReadOnly())).get();
+                            break;
+                        } catch (Exception e) {
+                            LOGGER.warn("Failed to upload logs, will retry", e);
+                            Thread.sleep(1000);
+                        }
+                    }
+                } catch (InterruptedException e) {
+                    Thread.currentThread().interrupt();
+                }
+                uploadBuffer.clear();
+                lastUploadTimestamp = now;
+                nextUploadInterval = UPLOAD_INTERVAL + random.nextInt(MAX_JITTER_INTERVAL);
+            }
+        }
+    }
+
+    private class CleanupTask implements Runnable {
+
+        @Override
+        public void run() {
+            while (!Thread.currentThread().isInterrupted()) {
+                try {
+                    if (closed || !config.isPrimaryUploader()) {
+                        Thread.sleep(Duration.ofMinutes(1).toMillis());
+                        continue;
+                    }
+                    long expiredTime = System.currentTimeMillis() - CLEANUP_INTERVAL;
+
+                    List<ObjectInfo> objects = objectStorage.list(String.format("automq/logs/%s", config.clusterId())).join();
+
+                    if (!objects.isEmpty()) {
+                        List<ObjectPath> keyList = objects.stream()
+                            .filter(object -> object.timestamp() < expiredTime)
+                            .map(object -> new ObjectPath(object.bucketId(), object.key()))
+                            .collect(Collectors.toList());
+
+                        if (!keyList.isEmpty()) {
+                            CompletableFuture<?>[] deleteFutures = Lists.partition(keyList, 1000)
+                                .stream()
+                                .map(objectStorage::delete)
+                                .toArray(CompletableFuture[]::new);
+                            CompletableFuture.allOf(deleteFutures).join();
+                        }
+                    }
+
+                    Thread.sleep(Duration.ofMinutes(1).toMillis());
+                } catch (InterruptedException e) {
+                    break;
+                } catch (Exception e) {
+                    LOGGER.error("Cleanup s3 logs failed", e);
+                }
+            }
+        }
+    }
+
+    private String getObjectKey() {
+        String hour = LocalDateTime.now(ZoneOffset.UTC).format(DateTimeFormatter.ofPattern("yyyyMMddHH"));
+        return String.format("automq/logs/%s/%s/%s/%s", config.clusterId(), config.nodeId(), hour, UUID.randomUUID());
+    }
+}
diff --git a/automq-log-uploader/src/main/java/com/automq/log/uploader/PropertiesS3LogConfigProvider.java b/automq-log-uploader/src/main/java/com/automq/log/uploader/PropertiesS3LogConfigProvider.java
new file mode 100644
index 0000000000..c3dde10645
--- /dev/null
+++ b/automq-log-uploader/src/main/java/com/automq/log/uploader/PropertiesS3LogConfigProvider.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright 2025, AutoMQ HK Limited.
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.automq.log.uploader;
+
+/**
+ * Default provider that loads configuration from {@code automq-log.properties} on the classpath.
+ */
+public class PropertiesS3LogConfigProvider implements S3LogConfigProvider {
+    @Override
+    public S3LogConfig get() {
+        return new DefaultS3LogConfig();
+    }
+}
diff --git a/automq-log-uploader/src/main/java/com/automq/log/uploader/S3LogConfig.java b/automq-log-uploader/src/main/java/com/automq/log/uploader/S3LogConfig.java
new file mode 100644
index 0000000000..1686a89efb
--- /dev/null
+++ b/automq-log-uploader/src/main/java/com/automq/log/uploader/S3LogConfig.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright 2025, AutoMQ HK Limited.
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.automq.log.uploader;
+
+import com.automq.log.uploader.selector.LogUploaderNodeSelector;
+import com.automq.stream.s3.operator.ObjectStorage;
+
+public interface S3LogConfig {
+    boolean isEnabled();
+
+    String clusterId();
+
+    int nodeId();
+
+    ObjectStorage objectStorage();
+
+    LogUploaderNodeSelector nodeSelector();
+
+    default boolean isPrimaryUploader() {
+        LogUploaderNodeSelector selector = nodeSelector();
+        return selector != null && selector.isPrimaryUploader();
+    }
+}
diff --git a/automq-log-uploader/src/main/java/com/automq/log/uploader/S3LogConfigProvider.java b/automq-log-uploader/src/main/java/com/automq/log/uploader/S3LogConfigProvider.java
new file mode 100644
index 0000000000..012c6c06bf
--- /dev/null
+++ b/automq-log-uploader/src/main/java/com/automq/log/uploader/S3LogConfigProvider.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2025, AutoMQ HK Limited.
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.automq.log.uploader;
+
+/**
+ * Provides {@link S3LogConfig} instances for the log uploader module.
+ */
+public interface S3LogConfigProvider {
+
+    /**
+     * @return a configured {@link S3LogConfig} instance, or {@code null} if the uploader should stay disabled.
+     */
+    S3LogConfig get();
+}
diff --git a/automq-log-uploader/src/main/java/com/automq/log/uploader/S3RollingFileAppender.java b/automq-log-uploader/src/main/java/com/automq/log/uploader/S3RollingFileAppender.java
new file mode 100644
index 0000000000..ddec90659e
--- /dev/null
+++ b/automq-log-uploader/src/main/java/com/automq/log/uploader/S3RollingFileAppender.java
@@ -0,0 +1,205 @@
+/*
+ * Copyright 2025, AutoMQ HK Limited.
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.automq.log.uploader;
+
+import org.apache.commons.lang3.StringUtils;
+import org.apache.log4j.RollingFileAppender;
+import org.apache.log4j.spi.LoggingEvent;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class S3RollingFileAppender extends RollingFileAppender {
+    public static final String CONFIG_PROVIDER_PROPERTY = "automq.log.s3.config.provider";
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(S3RollingFileAppender.class);
+    private static final Object INIT_LOCK = new Object();
+
+    private static volatile LogUploader logUploaderInstance;
+    private static volatile S3LogConfigProvider configProvider;
+    private static volatile boolean initializationPending;
+
+    private String configProviderClass;
+
+    public S3RollingFileAppender() {
+        super();
+    }
+
+    /**
+     * Allows programmatic override of the LogUploader instance.
+     * Useful for testing or complex dependency injection scenarios.
+     *
+     * @param uploader The LogUploader instance to use.
+     */
+    public static void setLogUploader(LogUploader uploader) {
+        synchronized (INIT_LOCK) {
+            logUploaderInstance = uploader;
+        }
+    }
+
+    /**
+     * Programmatically sets the configuration provider to be used by all {@link S3RollingFileAppender} instances.
+     */
+    public static void setConfigProvider(S3LogConfigProvider provider) {
+        synchronized (INIT_LOCK) {
+            configProvider = provider;
+        }
+        triggerInitialization();
+    }
+
+    /**
+     * Setter used by Log4j property configuration to specify a custom {@link S3LogConfigProvider} implementation.
+     */
+    public void setConfigProviderClass(String configProviderClass) {
+        this.configProviderClass = configProviderClass;
+    }
+
+    @Override
+    public void activateOptions() {
+        super.activateOptions();
+        initializeUploader();
+    }
+
+    private void initializeUploader() {
+        if (logUploaderInstance != null) {
+            return;
+        }
+        synchronized (INIT_LOCK) {
+            if (logUploaderInstance != null) {
+                return;
+            }
+            try {
+                S3LogConfigProvider provider = resolveProvider();
+                if (provider == null) {
+                    LOGGER.info("No S3LogConfigProvider available; S3 log upload remains disabled.");
+                    initializationPending = true;
+                    return;
+                }
+                S3LogConfig config = provider.get();
+                if (config == null || !config.isEnabled() || config.objectStorage() == null) {
+                    LOGGER.info("S3 log upload is disabled by configuration.");
+                    initializationPending = config == null;
+                    return;
+                }
+
+                LogUploader uploader = new LogUploader();
+                uploader.start(config);
+                logUploaderInstance = uploader;
+                initializationPending = false;
+
+                Runtime.getRuntime().addShutdownHook(new Thread(() -> {
+                    try {
+                        uploader.close();
+                    } catch (InterruptedException e) {
+                        Thread.currentThread().interrupt();
+                        LOGGER.warn("Failed to close LogUploader gracefully", e);
+                    }
+                }));
+                LOGGER.info("S3RollingFileAppender initialized successfully using provider {}.",
+                    provider.getClass().getName());
+            } catch (Exception e) {
+                LOGGER.error("Failed to initialize S3RollingFileAppender", e);
+                initializationPending = true;
+            }
+        }
+    }
+
+    public static void triggerInitialization() {
+        S3LogConfigProvider provider;
+        synchronized (INIT_LOCK) {
+            if (logUploaderInstance != null) {
+                return;
+            }
+            provider = configProvider;
+        }
+        if (provider == null) {
+            initializationPending = true;
+            return;
+        }
+        new S3RollingFileAppender().initializeUploader();
+    }
+
+    private S3LogConfigProvider resolveProvider() {
+        S3LogConfigProvider provider = configProvider;
+        if (provider != null) {
+            return provider;
+        }
+
+        synchronized (INIT_LOCK) {
+            if (configProvider != null) {
+                return configProvider;
+            }
+
+            String providerClassName = configProviderClass;
+            if (StringUtils.isBlank(providerClassName)) {
+                providerClassName = System.getProperty(CONFIG_PROVIDER_PROPERTY);
+            }
+
+            if (StringUtils.isNotBlank(providerClassName)) {
+                provider = instantiateProvider(providerClassName.trim());
+                if (provider == null) {
+                    LOGGER.warn("Falling back to default configuration provider because {} could not be instantiated.",
+                        providerClassName);
+                }
+            }
+
+            if (provider == null) {
+                provider = new PropertiesS3LogConfigProvider();
+            }
+
+            configProvider = provider;
+            return provider;
+        }
+    }
+
+    private S3LogConfigProvider instantiateProvider(String providerClassName) {
+        try {
+            Class<?> clazz = Class.forName(providerClassName);
+            Object instance = clazz.getDeclaredConstructor().newInstance();
+            if (!(instance instanceof S3LogConfigProvider)) {
+                LOGGER.error("Class {} does not implement S3LogConfigProvider.", providerClassName);
+                return null;
+            }
+            return (S3LogConfigProvider) instance;
+        } catch (Exception e) {
+            LOGGER.error("Failed to instantiate S3LogConfigProvider {}", providerClassName, e);
+            return null;
+        }
+    }
+
+    @Override
+    protected void subAppend(LoggingEvent event) {
+        super.subAppend(event);
+        if (!closed && logUploaderInstance != null) {
+            LogRecorder.LogEvent logEvent = new LogRecorder.LogEvent(
+                event.getTimeStamp(),
+                event.getLevel().toString(),
+                event.getLoggerName(),
+                event.getRenderedMessage(),
+                event.getThrowableStrRep());
+
+            try {
+                logEvent.validate();
+                logUploaderInstance.append(logEvent);
+            } catch (IllegalArgumentException e) {
+                errorHandler.error("Failed to validate and append log event", e, 0);
+            }
+        }
+    }
+}
diff --git a/automq-log-uploader/src/main/java/com/automq/log/uploader/selector/LogUploaderNodeSelector.java b/automq-log-uploader/src/main/java/com/automq/log/uploader/selector/LogUploaderNodeSelector.java
new file mode 100644
index 0000000000..a3a690cff4
--- /dev/null
+++ b/automq-log-uploader/src/main/java/com/automq/log/uploader/selector/LogUploaderNodeSelector.java
@@ -0,0 +1,22 @@
+package com.automq.log.uploader.selector;
+
+/**
+ * Determines whether the current node should act as the primary S3 log uploader.
+ */
+public interface LogUploaderNodeSelector {
+
+    /**
+     * @return {@code true} if the current node should upload and clean up logs in S3.
+     */
+    boolean isPrimaryUploader();
+
+    /**
+     * Creates a selector with a static boolean decision.
+     *
+     * @param primary whether this node should be primary
+     * @return selector returning the static decision
+     */
+    static LogUploaderNodeSelector staticSelector(boolean primary) {
+        return () -> primary;
+    }
+}
diff --git a/automq-log-uploader/src/main/java/com/automq/log/uploader/selector/LogUploaderNodeSelectorFactory.java b/automq-log-uploader/src/main/java/com/automq/log/uploader/selector/LogUploaderNodeSelectorFactory.java
new file mode 100644
index 0000000000..d3e459a743
--- /dev/null
+++ b/automq-log-uploader/src/main/java/com/automq/log/uploader/selector/LogUploaderNodeSelectorFactory.java
@@ -0,0 +1,74 @@
+package com.automq.log.uploader.selector;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.Map;
+import java.util.ServiceLoader;
+
+/**
+ * Factory that resolves node selectors from configuration.
+ */
+public final class LogUploaderNodeSelectorFactory {
+    private static final Logger LOGGER = LoggerFactory.getLogger(LogUploaderNodeSelectorFactory.class);
+    private static final Map<String, LogUploaderNodeSelectorProvider> PROVIDERS = new HashMap<>();
+
+    static {
+        ServiceLoader<LogUploaderNodeSelectorProvider> loader = ServiceLoader.load(LogUploaderNodeSelectorProvider.class);
+        for (LogUploaderNodeSelectorProvider provider : loader) {
+            String type = provider.getType();
+            if (type != null) {
+                PROVIDERS.put(type.toLowerCase(Locale.ROOT), provider);
+                LOGGER.info("Loaded LogUploaderNodeSelectorProvider for type {}", type);
+            }
+        }
+    }
+
+    private LogUploaderNodeSelectorFactory() {
+    }
+
+    public static LogUploaderNodeSelector createSelector(String typeString,
+                                                         String clusterId,
+                                                         int nodeId,
+                                                         Map<String, String> config) {
+        LogUploaderNodeSelectorType type = LogUploaderNodeSelectorType.fromString(typeString);
+        switch (type) {
+            case STATIC:
+                boolean isPrimary = Boolean.parseBoolean(config.getOrDefault("isPrimaryUploader", "false"));
+                return LogUploaderNodeSelectors.staticSelector(isPrimary);
+            case NODE_ID:
+                int primaryNodeId = Integer.parseInt(config.getOrDefault("primaryNodeId", "0"));
+                return LogUploaderNodeSelectors.nodeIdSelector(nodeId, primaryNodeId);
+            case FILE:
+                String leaderFile = config.getOrDefault("leaderFile", "/tmp/log-uploader-leader");
+                long timeoutMs = Long.parseLong(config.getOrDefault("leaderTimeoutMs", "60000"));
+                return LogUploaderNodeSelectors.fileLeaderElectionSelector(leaderFile, nodeId, timeoutMs);
+            case CUSTOM:
+                LogUploaderNodeSelectorProvider provider = PROVIDERS.get(typeString.toLowerCase(Locale.ROOT));
+                if (provider != null) {
+                    try {
+                        return provider.createSelector(clusterId, nodeId, config);
+                    } catch (Exception e) {
+                        LOGGER.error("Failed to create selector of type {}", typeString, e);
+                    }
+                }
+                LOGGER.warn("Unsupported log uploader selector type {}, falling back to static=false", typeString);
+                return LogUploaderNodeSelector.staticSelector(false);
+            default:
+                return LogUploaderNodeSelector.staticSelector(false);
+        }
+    }
+
+    public static boolean isSupported(String typeString) {
+        if (typeString == null) {
+            return true;
+        }
+        LogUploaderNodeSelectorType type = LogUploaderNodeSelectorType.fromString(typeString);
+        if (type != LogUploaderNodeSelectorType.CUSTOM) {
+            return true;
+        }
+        return PROVIDERS.containsKey(typeString.toLowerCase(Locale.ROOT));
+    }
+}
diff --git a/automq-log-uploader/src/main/java/com/automq/log/uploader/selector/LogUploaderNodeSelectorProvider.java b/automq-log-uploader/src/main/java/com/automq/log/uploader/selector/LogUploaderNodeSelectorProvider.java
new file mode 100644
index 0000000000..8edfde1ded
--- /dev/null
+++ b/automq-log-uploader/src/main/java/com/automq/log/uploader/selector/LogUploaderNodeSelectorProvider.java
@@ -0,0 +1,25 @@
+package com.automq.log.uploader.selector;
+
+import java.util.Map;
+
+/**
+ * Service Provider Interface for custom log uploader node selection strategies.
+ */
+public interface LogUploaderNodeSelectorProvider {
+
+    /**
+     * @return the selector type identifier (case insensitive)
+     */
+    String getType();
+
+    /**
+     * Creates a selector based on the supplied configuration.
+     *
+     * @param clusterId logical cluster identifier
+     * @param nodeId    numeric node identifier
+     * @param config    additional selector configuration
+     * @return selector instance
+     * @throws Exception if creation fails
+     */
+    LogUploaderNodeSelector createSelector(String clusterId, int nodeId, Map<String, String> config) throws Exception;
+}
diff --git a/automq-log-uploader/src/main/java/com/automq/log/uploader/selector/LogUploaderNodeSelectorType.java b/automq-log-uploader/src/main/java/com/automq/log/uploader/selector/LogUploaderNodeSelectorType.java
new file mode 100644
index 0000000000..e955c25172
--- /dev/null
+++ b/automq-log-uploader/src/main/java/com/automq/log/uploader/selector/LogUploaderNodeSelectorType.java
@@ -0,0 +1,42 @@
+package com.automq.log.uploader.selector;
+
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.Map;
+
+/**
+ * Supported selector types.
+ */
+public enum LogUploaderNodeSelectorType {
+    STATIC("static"),
+    NODE_ID("nodeid"),
+    FILE("file"),
+    CUSTOM(null);
+
+    private static final Map<String, LogUploaderNodeSelectorType> LOOKUP = new HashMap<>();
+
+    static {
+        for (LogUploaderNodeSelectorType value : values()) {
+            if (value.type != null) {
+                LOOKUP.put(value.type, value);
+            }
+        }
+    }
+
+    private final String type;
+
+    LogUploaderNodeSelectorType(String type) {
+        this.type = type;
+    }
+
+    public String getType() {
+        return type;
+    }
+
+    public static LogUploaderNodeSelectorType fromString(String type) {
+        if (type == null) {
+            return STATIC;
+        }
+        return LOOKUP.getOrDefault(type.toLowerCase(Locale.ROOT), CUSTOM);
+    }
+}
diff --git a/automq-log-uploader/src/main/java/com/automq/log/uploader/selector/LogUploaderNodeSelectors.java b/automq-log-uploader/src/main/java/com/automq/log/uploader/selector/LogUploaderNodeSelectors.java
new file mode 100644
index 0000000000..ba92980ea4
--- /dev/null
+++ b/automq-log-uploader/src/main/java/com/automq/log/uploader/selector/LogUploaderNodeSelectors.java
@@ -0,0 +1,85 @@
+package com.automq.log.uploader.selector;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * Utility methods providing built-in selector implementations.
+ */
+public final class LogUploaderNodeSelectors {
+    private static final Logger LOGGER = LoggerFactory.getLogger(LogUploaderNodeSelectors.class);
+
+    private LogUploaderNodeSelectors() {
+    }
+
+    public static LogUploaderNodeSelector staticSelector(boolean isPrimary) {
+        return LogUploaderNodeSelector.staticSelector(isPrimary);
+    }
+
+    public static LogUploaderNodeSelector nodeIdSelector(int currentNodeId, int primaryNodeId) {
+        return () -> currentNodeId == primaryNodeId;
+    }
+
+    public static LogUploaderNodeSelector fileLeaderElectionSelector(String leaderFilePath,
+                                                                     int nodeId,
+                                                                     long leaderTimeoutMs) {
+        Path path = Paths.get(leaderFilePath);
+        AtomicBoolean isLeader = new AtomicBoolean(false);
+
+        Thread leaderThread = new Thread(() -> {
+            while (!Thread.currentThread().isInterrupted()) {
+                try {
+                    boolean claimed = attemptToClaimLeadership(path, nodeId, leaderTimeoutMs);
+                    isLeader.set(claimed);
+                    Thread.sleep(Math.max(leaderTimeoutMs / 2, 1000));
+                } catch (InterruptedException e) {
+                    Thread.currentThread().interrupt();
+                } catch (Exception e) {
+                    LOGGER.warn("File leader election failed", e);
+                    isLeader.set(false);
+                    try {
+                        Thread.sleep(1000);
+                    } catch (InterruptedException ie) {
+                        Thread.currentThread().interrupt();
+                    }
+                }
+            }
+        }, "log-uploader-file-selector");
+        leaderThread.setDaemon(true);
+        leaderThread.start();
+
+        return isLeader::get;
+    }
+
+    private static boolean attemptToClaimLeadership(Path leaderFilePath, int nodeId, long leaderTimeoutMs) throws IOException {
+        Files.createDirectories(leaderFilePath.getParent());
+        if (Files.exists(leaderFilePath)) {
+            List<String> lines = Files.readAllLines(leaderFilePath);
+            if (!lines.isEmpty()) {
+                String[] parts = lines.get(0).split(":");
+                if (parts.length == 2) {
+                    int currentLeader = Integer.parseInt(parts[0]);
+                    long ts = Long.parseLong(parts[1]);
+                    if (System.currentTimeMillis() - ts <= leaderTimeoutMs) {
+                        return currentLeader == nodeId;
+                    }
+                }
+            }
+        }
+        String content = nodeId + ":" + System.currentTimeMillis();
+        Files.write(leaderFilePath, content.getBytes());
+        List<String> lines = Files.readAllLines(leaderFilePath);
+        if (!lines.isEmpty()) {
+            String[] parts = lines.get(0).split(":");
+            return parts.length == 2 && Integer.parseInt(parts[0]) == nodeId;
+        }
+        return false;
+    }
+}
diff --git a/automq-log-uploader/src/main/java/com/automq/log/uploader/selector/kafka/KafkaLogLeaderSelectorProvider.java b/automq-log-uploader/src/main/java/com/automq/log/uploader/selector/kafka/KafkaLogLeaderSelectorProvider.java
new file mode 100644
index 0000000000..4e2cf38dba
--- /dev/null
+++ b/automq-log-uploader/src/main/java/com/automq/log/uploader/selector/kafka/KafkaLogLeaderSelectorProvider.java
@@ -0,0 +1,383 @@
+package com.automq.log.uploader.selector.kafka;
+
+import com.automq.log.uploader.selector.LogUploaderNodeSelector;
+import com.automq.log.uploader.selector.LogUploaderNodeSelectorProvider;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.kafka.clients.admin.Admin;
+import org.apache.kafka.clients.admin.AdminClientConfig;
+import org.apache.kafka.clients.admin.CreateTopicsOptions;
+import org.apache.kafka.clients.admin.NewTopic;
+import org.apache.kafka.clients.consumer.ConsumerConfig;
+import org.apache.kafka.clients.consumer.ConsumerRebalanceListener;
+import org.apache.kafka.clients.consumer.KafkaConsumer;
+import org.apache.kafka.clients.consumer.OffsetResetStrategy;
+import org.apache.kafka.common.TopicPartition;
+import org.apache.kafka.common.config.TopicConfig;
+import org.apache.kafka.common.errors.TopicExistsException;
+import org.apache.kafka.common.errors.WakeupException;
+import org.apache.kafka.common.serialization.ByteArrayDeserializer;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.time.Duration;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Properties;
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * Leader election based on Kafka consumer group membership.
+ */
+public class KafkaLogLeaderSelectorProvider implements LogUploaderNodeSelectorProvider {
+    private static final Logger LOGGER = LoggerFactory.getLogger(KafkaLogLeaderSelectorProvider.class);
+
+    public static final String TYPE = "kafka";
+
+    private static final String DEFAULT_TOPIC_PREFIX = "__automq_log_uploader_leader_";
+    private static final String DEFAULT_GROUP_PREFIX = "automq-log-uploader-";
+    private static final String DEFAULT_CLIENT_PREFIX = "automq-log-uploader";
+
+    private static final long DEFAULT_TOPIC_RETENTION_MS = TimeUnit.MINUTES.toMillis(30);
+    private static final int DEFAULT_POLL_INTERVAL_MS = 1000;
+    private static final long DEFAULT_RETRY_BACKOFF_MS = TimeUnit.SECONDS.toMillis(5);
+    private static final int DEFAULT_SESSION_TIMEOUT_MS = 10000;
+    private static final int DEFAULT_HEARTBEAT_INTERVAL_MS = 3000;
+
+    private static final Set<String> RESERVED_KEYS;
+
+    static {
+        Set<String> keys = new HashSet<>();
+        Collections.addAll(keys,
+            "bootstrap.servers",
+            "topic",
+            "group.id",
+            "client.id",
+            "auto.create.topic",
+            "topic.partitions",
+            "topic.replication.factor",
+            "topic.retention.ms",
+            "poll.interval.ms",
+            "retry.backoff.ms",
+            "session.timeout.ms",
+            "heartbeat.interval.ms",
+            "request.timeout.ms"
+        );
+        RESERVED_KEYS = Collections.unmodifiableSet(keys);
+    }
+
+    @Override
+    public String getType() {
+        return TYPE;
+    }
+
+    @Override
+    public LogUploaderNodeSelector createSelector(String clusterId, int nodeId, Map<String, String> config) throws Exception {
+        KafkaSelectorConfig selectorConfig = KafkaSelectorConfig.from(clusterId, nodeId, config);
+        KafkaSelector selector = new KafkaSelector(selectorConfig);
+        selector.start();
+        return selector;
+    }
+
+    private static final class KafkaSelector implements LogUploaderNodeSelector {
+        private final KafkaSelectorConfig config;
+        private final AtomicBoolean isLeader = new AtomicBoolean(false);
+        private final AtomicBoolean running = new AtomicBoolean(true);
+
+        private volatile KafkaConsumer<byte[], byte[]> consumer;
+
+        KafkaSelector(KafkaSelectorConfig config) {
+            this.config = config;
+        }
+
+        void start() {
+            Thread thread = new Thread(this::runLoop,
+                String.format(Locale.ROOT, "log-uploader-kafka-selector-%s-%d", config.clusterId, config.nodeId));
+            thread.setDaemon(true);
+            thread.start();
+            Runtime.getRuntime().addShutdownHook(new Thread(this::shutdown,
+                String.format(Locale.ROOT, "log-uploader-kafka-selector-shutdown-%s-%d", config.clusterId, config.nodeId)));
+        }
+
+        private void runLoop() {
+            while (running.get()) {
+                try {
+                    ensureTopicExists();
+                    runConsumer();
+                } catch (WakeupException e) {
+                    if (!running.get()) {
+                        break;
+                    }
+                    LOGGER.warn("Kafka selector interrupted unexpectedly", e);
+                    sleep(config.retryBackoffMs);
+                } catch (Exception e) {
+                    if (!running.get()) {
+                        break;
+                    }
+                    LOGGER.warn("Kafka selector loop failed: {}", e.getMessage(), e);
+                    sleep(config.retryBackoffMs);
+                }
+            }
+        }
+
+        private void runConsumer() {
+            Properties consumerProps = config.buildConsumerProps();
+            try (KafkaConsumer<byte[], byte[]> kafkaConsumer =
+                     new KafkaConsumer<>(consumerProps, new ByteArrayDeserializer(), new ByteArrayDeserializer())) {
+                this.consumer = kafkaConsumer;
+                ConsumerRebalanceListener listener = new LeaderRebalanceListener();
+                kafkaConsumer.subscribe(Collections.singletonList(config.topic), listener);
+                LOGGER.info("Kafka log selector subscribed to topic {} with group {}", config.topic, config.groupId);
+                while (running.get()) {
+                    kafkaConsumer.poll(Duration.ofMillis(config.pollIntervalMs));
+                }
+            } finally {
+                this.consumer = null;
+                demote();
+            }
+        }
+
+        private void ensureTopicExists() throws Exception {
+            if (!config.autoCreateTopic) {
+                return;
+            }
+            Properties adminProps = config.buildAdminProps();
+            try (Admin admin = Admin.create(adminProps)) {
+                NewTopic topic = new NewTopic(config.topic, config.topicPartitions, config.topicReplicationFactor);
+                Map<String, String> topicConfig = new HashMap<>();
+                if (config.topicRetentionMs > 0) {
+                    topicConfig.put(TopicConfig.RETENTION_MS_CONFIG, String.valueOf(config.topicRetentionMs));
+                }
+                if (!topicConfig.isEmpty()) {
+                    topic.configs(topicConfig);
+                }
+                admin.createTopics(Collections.singleton(topic), new CreateTopicsOptions().validateOnly(false)).all().get();
+                LOGGER.info("Kafka log selector ensured topic {} exists", config.topic);
+            } catch (TopicExistsException ignored) {
+                // already exists
+            } catch (Exception e) {
+                if (e instanceof InterruptedException) {
+                    Thread.currentThread().interrupt();
+                    throw e;
+                }
+                Throwable cause = e.getCause();
+                if (!(cause instanceof TopicExistsException)) {
+                    throw e;
+                }
+            }
+        }
+
+        @Override
+        public boolean isPrimaryUploader() {
+            return isLeader.get();
+        }
+
+        private void promote() {
+            if (isLeader.compareAndSet(false, true)) {
+                LOGGER.info("Node {} became primary log uploader for cluster {}", config.nodeId, config.clusterId);
+            }
+        }
+
+        private void demote() {
+            if (isLeader.getAndSet(false)) {
+                LOGGER.info("Node {} lost log uploader leadership for cluster {}", config.nodeId, config.clusterId);
+            }
+        }
+
+        private void shutdown() {
+            if (running.compareAndSet(true, false)) {
+                KafkaConsumer<byte[], byte[]> current = consumer;
+                if (current != null) {
+                    current.wakeup();
+                }
+            }
+        }
+
+        private void sleep(long millis) {
+            try {
+                Thread.sleep(millis);
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+            }
+        }
+
+        private class LeaderRebalanceListener implements ConsumerRebalanceListener {
+            @Override
+            public void onPartitionsRevoked(Collection<TopicPartition> partitions) {
+                if (!partitions.isEmpty()) {
+                    LOGGER.debug("Kafka log selector revoked partitions {}", partitions);
+                }
+                demote();
+            }
+
+            @Override
+            public void onPartitionsAssigned(Collection<TopicPartition> partitions) {
+                if (!partitions.isEmpty()) {
+                    promote();
+                }
+            }
+        }
+    }
+
+    private static final class KafkaSelectorConfig {
+        private final String clusterId;
+        private final int nodeId;
+        private final String bootstrapServers;
+        private final String topic;
+        private final String groupId;
+        private final String clientId;
+        private final boolean autoCreateTopic;
+        private final int topicPartitions;
+        private final short topicReplicationFactor;
+        private final long topicRetentionMs;
+        private final int pollIntervalMs;
+        private final long retryBackoffMs;
+        private final int sessionTimeoutMs;
+        private final int heartbeatIntervalMs;
+        private final int requestTimeoutMs;
+        private final Properties clientOverrides;
+
+        private KafkaSelectorConfig(Builder builder) {
+            this.clusterId = builder.clusterId;
+            this.nodeId = builder.nodeId;
+            this.bootstrapServers = builder.bootstrapServers;
+            this.topic = builder.topic;
+            this.groupId = builder.groupId;
+            this.clientId = builder.clientId;
+            this.autoCreateTopic = builder.autoCreateTopic;
+            this.topicPartitions = builder.topicPartitions;
+            this.topicReplicationFactor = builder.topicReplicationFactor;
+            this.topicRetentionMs = builder.topicRetentionMs;
+            this.pollIntervalMs = builder.pollIntervalMs;
+            this.retryBackoffMs = builder.retryBackoffMs;
+            this.sessionTimeoutMs = builder.sessionTimeoutMs;
+            this.heartbeatIntervalMs = builder.heartbeatIntervalMs;
+            this.requestTimeoutMs = builder.requestTimeoutMs;
+            this.clientOverrides = builder.clientOverrides;
+        }
+
+        static KafkaSelectorConfig from(String clusterId, int nodeId, Map<String, String> rawConfig) {
+            Map<String, String> config = rawConfig == null ? Collections.emptyMap() : rawConfig;
+            String bootstrapServers = findBootstrapServers(config);
+            if (StringUtils.isBlank(bootstrapServers)) {
+                throw new IllegalArgumentException("Kafka selector requires 'bootstrap.servers'");
+            }
+            String normalizedCluster = StringUtils.isBlank(clusterId) ? "default" : clusterId;
+            Builder builder = new Builder();
+            builder.clusterId = clusterId;
+            builder.nodeId = nodeId;
+            builder.bootstrapServers = bootstrapServers;
+            builder.topic = config.getOrDefault("topic", DEFAULT_TOPIC_PREFIX + normalizedCluster);
+            builder.groupId = config.getOrDefault("group.id", DEFAULT_GROUP_PREFIX + normalizedCluster);
+            builder.clientId = config.getOrDefault("client.id", DEFAULT_CLIENT_PREFIX + "-" + normalizedCluster + "-" + nodeId);
+            builder.autoCreateTopic = Boolean.parseBoolean(config.getOrDefault("auto.create.topic", "true"));
+            builder.topicPartitions = parseInt(config.get("topic.partitions"), 1, 1);
+            builder.topicReplicationFactor = (short) parseInt(config.get("topic.replication.factor"), 1, 1);
+            builder.topicRetentionMs = parseLong(config.get("topic.retention.ms"), DEFAULT_TOPIC_RETENTION_MS);
+            builder.pollIntervalMs = parseInt(config.get("poll.interval.ms"), DEFAULT_POLL_INTERVAL_MS, 100);
+            builder.retryBackoffMs = parseLong(config.get("retry.backoff.ms"), DEFAULT_RETRY_BACKOFF_MS);
+            builder.sessionTimeoutMs = parseInt(config.get("session.timeout.ms"), DEFAULT_SESSION_TIMEOUT_MS, 1000);
+            builder.heartbeatIntervalMs = parseInt(config.get("heartbeat.interval.ms"), DEFAULT_HEARTBEAT_INTERVAL_MS, 500);
+            builder.requestTimeoutMs = parseInt(config.get("request.timeout.ms"), 15000, 1000);
+            builder.clientOverrides = extractOverrides(config);
+            return builder.build();
+        }
+
+        Properties buildConsumerProps() {
+            Properties props = new Properties();
+            props.putAll(clientOverrides);
+            props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers);
+            props.put(ConsumerConfig.GROUP_ID_CONFIG, groupId);
+            props.put(ConsumerConfig.CLIENT_ID_CONFIG, clientId + "-consumer");
+            props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, "false");
+            props.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, OffsetResetStrategy.EARLIEST.name().toLowerCase(Locale.ROOT));
+            props.put(ConsumerConfig.SESSION_TIMEOUT_MS_CONFIG, sessionTimeoutMs);
+            props.put(ConsumerConfig.HEARTBEAT_INTERVAL_MS_CONFIG, heartbeatIntervalMs);
+            props.put(ConsumerConfig.MAX_POLL_INTERVAL_MS_CONFIG, Math.max(pollIntervalMs * 3, 3000));
+            props.put(ConsumerConfig.REQUEST_TIMEOUT_MS_CONFIG, requestTimeoutMs);
+            props.put(ConsumerConfig.ALLOW_AUTO_CREATE_TOPICS_CONFIG, "false");
+            props.putIfAbsent(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, ByteArrayDeserializer.class.getName());
+            props.putIfAbsent(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, ByteArrayDeserializer.class.getName());
+            return props;
+        }
+
+        Properties buildAdminProps() {
+            Properties props = new Properties();
+            props.putAll(clientOverrides);
+            props.put(AdminClientConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers);
+            props.put(AdminClientConfig.CLIENT_ID_CONFIG, clientId + "-admin");
+            props.put(AdminClientConfig.REQUEST_TIMEOUT_MS_CONFIG, requestTimeoutMs);
+            return props;
+        }
+
+        private static Properties extractOverrides(Map<String, String> config) {
+            Properties props = new Properties();
+            for (Map.Entry<String, String> entry : config.entrySet()) {
+                if (RESERVED_KEYS.contains(entry.getKey())) {
+                    continue;
+                }
+                props.put(entry.getKey(), entry.getValue());
+            }
+            return props;
+        }
+
+        private static String findBootstrapServers(Map<String, String> config) {
+            String value = config.get("bootstrap.servers");
+            if (StringUtils.isNotBlank(value)) {
+                return value;
+            }
+            return config.get("bootstrapServers");
+        }
+
+        private static int parseInt(String value, int defaultValue, int minimum) {
+            if (StringUtils.isBlank(value)) {
+                return defaultValue;
+            }
+            try {
+                int parsed = Integer.parseInt(value.trim());
+                return Math.max(parsed, minimum);
+            } catch (NumberFormatException e) {
+                return defaultValue;
+            }
+        }
+
+        private static long parseLong(String value, long defaultValue) {
+            if (StringUtils.isBlank(value)) {
+                return defaultValue;
+            }
+            try {
+                return Long.parseLong(value.trim());
+            } catch (NumberFormatException e) {
+                return defaultValue;
+            }
+        }
+
+        private static final class Builder {
+            private String clusterId;
+            private int nodeId;
+            private String bootstrapServers;
+            private String topic;
+            private String groupId;
+            private String clientId;
+            private boolean autoCreateTopic;
+            private int topicPartitions;
+            private short topicReplicationFactor;
+            private long topicRetentionMs;
+            private int pollIntervalMs;
+            private long retryBackoffMs;
+            private int sessionTimeoutMs;
+            private int heartbeatIntervalMs;
+            private int requestTimeoutMs;
+            private Properties clientOverrides = new Properties();
+
+            private KafkaSelectorConfig build() {
+                return new KafkaSelectorConfig(this);
+            }
+        }
+    }
+}
diff --git a/automq-log-uploader/src/main/java/com/automq/log/uploader/util/Utils.java b/automq-log-uploader/src/main/java/com/automq/log/uploader/util/Utils.java
new file mode 100644
index 0000000000..acd3d7b7d4
--- /dev/null
+++ b/automq-log-uploader/src/main/java/com/automq/log/uploader/util/Utils.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2025, AutoMQ HK Limited.
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.automq.log.uploader.util;
+
+import com.automq.stream.s3.ByteBufAlloc;
+import io.netty.buffer.ByteBuf;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.zip.GZIPInputStream;
+import java.util.zip.GZIPOutputStream;
+
+public class Utils {
+
+    private Utils() {
+    }
+
+    public static ByteBuf compress(ByteBuf input) throws IOException {
+        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
+        try (GZIPOutputStream gzipOutputStream = new GZIPOutputStream(byteArrayOutputStream)) {
+            byte[] buffer = new byte[input.readableBytes()];
+            input.readBytes(buffer);
+            gzipOutputStream.write(buffer);
+        }
+
+        ByteBuf compressed = ByteBufAlloc.byteBuffer(byteArrayOutputStream.size());
+        compressed.writeBytes(byteArrayOutputStream.toByteArray());
+        return compressed;
+    }
+
+    public static ByteBuf decompress(ByteBuf input) throws IOException {
+        byte[] compressedData = new byte[input.readableBytes()];
+        input.readBytes(compressedData);
+        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(compressedData);
+
+        try (GZIPInputStream gzipInputStream = new GZIPInputStream(byteArrayInputStream);
+             ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream()) {
+            byte[] buffer = new byte[1024];
+            int bytesRead;
+            while ((bytesRead = gzipInputStream.read(buffer)) != -1) {
+                byteArrayOutputStream.write(buffer, 0, bytesRead);
+            }
+
+            byte[] uncompressedData = byteArrayOutputStream.toByteArray();
+            ByteBuf output = ByteBufAlloc.byteBuffer(uncompressedData.length);
+            output.writeBytes(uncompressedData);
+            return output;
+        }
+    }
+}
diff --git a/automq-log-uploader/src/main/resources/META-INF/services/com.automq.log.uploader.selector.LogUploaderNodeSelectorProvider b/automq-log-uploader/src/main/resources/META-INF/services/com.automq.log.uploader.selector.LogUploaderNodeSelectorProvider
new file mode 100644
index 0000000000..ad1ce25af0
--- /dev/null
+++ b/automq-log-uploader/src/main/resources/META-INF/services/com.automq.log.uploader.selector.LogUploaderNodeSelectorProvider
@@ -0,0 +1 @@
+com.automq.log.uploader.selector.kafka.KafkaLogLeaderSelectorProvider
diff --git a/build.gradle b/build.gradle
index 86545f9cb3..e13d867d8b 100644
--- a/build.gradle
+++ b/build.gradle
@@ -260,12 +260,12 @@ subprojects {
 
   tasks.withType(JavaCompile) {
     options.encoding = 'UTF-8'
-    options.compilerArgs << "-Xlint:all"
-    // temporary exclusions until all the warnings are fixed
-    if (!project.path.startsWith(":connect") && !project.path.startsWith(":storage"))
-      options.compilerArgs << "-Xlint:-rawtypes"
-    options.compilerArgs << "-Xlint:-serial"
-    options.compilerArgs << "-Xlint:-try"
+//    options.compilerArgs << "-Xlint:all"
+//    // temporary exclusions until all the warnings are fixed
+//    if (!project.path.startsWith(":connect") && !project.path.startsWith(":storage"))
+//      options.compilerArgs << "-Xlint:-rawtypes"
+//    options.compilerArgs << "-Xlint:-serial"
+//    options.compilerArgs << "-Xlint:-try"
     // AutoMQ inject start
     // TODO: remove me, when upgrade to 4.x
 //    options.compilerArgs << "-Werror"
@@ -840,6 +840,13 @@ tasks.create(name: "jarConnect", dependsOn: connectPkgs.collect { it + ":jar" })
 
 tasks.create(name: "testConnect", dependsOn: connectPkgs.collect { it + ":test" }) {}
 
+// OpenTelemetry related tasks
+tasks.create(name: "jarOpenTelemetry", dependsOn: ":opentelemetry:jar") {}
+
+tasks.create(name: "testOpenTelemetry", dependsOn: ":opentelemetry:test") {}
+
+tasks.create(name: "buildOpenTelemetry", dependsOn: [":opentelemetry:jar", ":opentelemetry:test"]) {}
+
 project(':server') {
   base {
     archivesName = "kafka-server"
@@ -1251,6 +1258,8 @@ project(':core') {
     from(project(':trogdor').jar) { into("libs/") }
     from(project(':trogdor').configurations.runtimeClasspath) { into("libs/") }
     from(project(':automq-shell').jar) { into("libs/") }
+    from(project(':opentelemetry').jar) { into("libs/") }
+    from(project(':opentelemetry').configurations.runtimeClasspath) { into("libs/") }
     from(project(':automq-shell').configurations.runtimeClasspath) { into("libs/") }
     from(project(':shell').jar) { into("libs/") }
     from(project(':shell').configurations.runtimeClasspath) { into("libs/") }
@@ -2482,7 +2491,7 @@ project(':trogdor') {
     from (configurations.runtimeClasspath) {
       exclude('kafka-clients*')
     }
-    into "$buildDir/dependant-libs-${versions.scala}"
+    into "$buildDir/dependant-libs"
     duplicatesStrategy 'exclude'
   }
 
@@ -3451,6 +3460,8 @@ project(':connect:runtime') {
     api project(':clients')
     api project(':connect:json')
     api project(':connect:transforms')
+    api project(':opentelemetry')
+    implementation project(':automq-log-uploader')
 
     implementation libs.slf4jApi
     implementation libs.reload4j
diff --git a/config/connect-log4j.properties b/config/connect-log4j.properties
index 61b2ac331d..506409624d 100644
--- a/config/connect-log4j.properties
+++ b/config/connect-log4j.properties
@@ -24,7 +24,8 @@ log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
 # location of the log files (e.g. ${kafka.logs.dir}/connect.log). The `MaxFileSize` option specifies the maximum size of the log file,
 # and the `MaxBackupIndex` option specifies the number of backup files to keep.
 #
-log4j.appender.connectAppender=org.apache.log4j.RollingFileAppender
+log4j.appender.connectAppender=com.automq.log.uploader.S3RollingFileAppender
+log4j.appender.connectAppender.configProviderClass=org.apache.kafka.connect.automq.ConnectS3LogConfigProvider
 log4j.appender.connectAppender.MaxFileSize=10MB
 log4j.appender.connectAppender.MaxBackupIndex=11
 log4j.appender.connectAppender.File=${kafka.logs.dir}/connect.log
diff --git a/connect/runtime/README.md b/connect/runtime/README.md
new file mode 100644
index 0000000000..096dabedb3
--- /dev/null
+++ b/connect/runtime/README.md
@@ -0,0 +1,229 @@
+# Kafka Connect OpenTelemetry Metrics Integration
+
+## Overview
+
+This integration allows Kafka Connect to export metrics through the AutoMQ OpenTelemetry module, enabling unified observability across your Kafka ecosystem.
+
+## Configuration
+
+### 1. Enable the MetricsReporter
+
+Add the following to your Kafka Connect configuration file (`connect-distributed.properties` or `connect-standalone.properties`):
+
+```properties
+# Enable OpenTelemetry MetricsReporter
+metric.reporters=org.apache.kafka.connect.automq.OpenTelemetryMetricsReporter
+
+# OpenTelemetry configuration
+opentelemetry.metrics.enabled=true
+opentelemetry.metrics.prefix=kafka.connect
+
+# Optional: Filter metrics
+opentelemetry.metrics.include.pattern=.*connector.*|.*task.*|.*worker.*
+opentelemetry.metrics.exclude.pattern=.*jmx.*|.*debug.*
+```
+
+### 2. AutoMQ Telemetry Configuration
+
+Ensure the AutoMQ telemetry is properly configured. Add these properties to your application configuration:
+
+```properties
+# Telemetry export configuration
+automq.telemetry.exporter.uri=prometheus://localhost:9090
+# or for OTLP: automq.telemetry.exporter.uri=otlp://localhost:4317
+
+# Service identification
+service.name=kafka-connect
+service.instance.id=connect-worker-1
+
+# Export settings
+automq.telemetry.exporter.interval.ms=30000
+automq.telemetry.metric.cardinality.limit=10000
+```
+
+## S3 Log Upload
+
+Kafka Connect bundles the AutoMQ log uploader so that worker logs can be streamed to S3 together with in-cluster cleanup. The uploader reuses the same leader election mechanism as the metrics, using Kafka by default, and requires no additional configuration.
+
+### Worker Configuration
+
+Add the following properties to your worker configuration (ConfigMap, properties file, etc.):
+
+```properties
+# Enable S3 log upload
+log.s3.enable=true
+log.s3.bucket=0@s3://your-log-bucket?region=us-east-1
+
+# Optional overrides (defaults shown)
+log.s3.selector.type=kafka
+log.s3.selector.kafka.bootstrap.servers=${bootstrap.servers}
+log.s3.selector.kafka.topic=__automq_connect_log_leader_${group.id}
+log.s3.selector.kafka.group.id=automq-log-uploader-${group.id}
+# Provide credentials if the bucket URI does not embed them
+# log.s3.access.key=...
+# log.s3.secret.key=...
+```
+
+`log.s3.node.id` defaults to a hash of the pod hostname if not provided, ensuring objects are partitioned per worker. For `static` or `nodeid` leader election, you can explicitly set:
+
+```properties
+log.s3.selector.type=static
+log.s3.primary.node=true   # Set true only on the primary node, false on others
+```
+
+### Log4j Integration
+
+`config/connect-log4j.properties` has switched `connectAppender` to `com.automq.log.uploader.S3RollingFileAppender` and specifies `org.apache.kafka.connect.automq.ConnectS3LogConfigProvider` as the config provider. As long as you enable `log.s3.enable=true` and configure the bucket info in the worker config, log upload will be automatically initialized with the Connect process; if not set or returns `log.s3.enable=false`, the uploader remains disabled.
+
+## Programmatic Usage
+
+### 1. Initialize Telemetry Manager
+
+```java
+import com.automq.opentelemetry.AutoMQTelemetryManager;
+import java.util.Properties;
+
+// Initialize AutoMQ telemetry before starting Kafka Connect
+Properties telemetryProps = new Properties();
+telemetryProps.setProperty("automq.telemetry.exporter.uri", "prometheus://localhost:9090");
+telemetryProps.setProperty("service.name", "kafka-connect");
+telemetryProps.setProperty("service.instance.id", "worker-1");
+
+// Initialize singleton instance
+AutoMQTelemetryManager.initializeInstance(telemetryProps);
+
+// Now start Kafka Connect - it will automatically use the OpenTelemetryMetricsReporter
+```
+
+### 2. Shutdown
+
+```java
+// When shutting down your application
+AutoMQTelemetryManager.shutdownInstance();
+```
+
+## Exported Metrics
+
+The integration automatically converts Kafka Connect metrics to OpenTelemetry format:
+
+### Metric Naming Convention
+- **Format**: `kafka.connect.{group}.{metric_name}`
+- **Example**: `kafka.connect.connector.task.batch.size.avg` → `kafka.connect.connector_task_batch_size_avg`
+
+### Metric Types
+- **Counters**: Metrics containing "total", "count", "error", "failure"
+- **Gauges**: All other numeric metrics (rates, averages, sizes, etc.)
+
+### Attributes
+Kafka metric tags are converted to OpenTelemetry attributes:
+- `connector` → `connector`
+- `task` → `task`
+- `worker-id` → `worker_id`
+- Plus standard attributes: `metric.group`, `service.name`, `service.instance.id`
+
+## Example Metrics
+
+Common Kafka Connect metrics that will be exported:
+
+```
+# Connector metrics
+kafka.connect.connector.startup.attempts.total
+kafka.connect.connector.startup.success.total
+kafka.connect.connector.startup.failure.total
+
+# Task metrics  
+kafka.connect.connector.task.batch.size.avg
+kafka.connect.connector.task.batch.size.max
+kafka.connect.connector.task.offset.commit.avg.time.ms
+
+# Worker metrics
+kafka.connect.worker.connector.count
+kafka.connect.worker.task.count
+kafka.connect.worker.connector.startup.attempts.total
+```
+
+## Configuration Options
+
+### OpenTelemetry MetricsReporter Options
+
+| Property | Description | Default | Example |
+|----------|-------------|---------|---------|
+| `opentelemetry.metrics.enabled` | Enable/disable metrics export | `true` | `false` |
+| `opentelemetry.metrics.prefix` | Metric name prefix | `kafka.connect` | `my.connect` |
+| `opentelemetry.metrics.include.pattern` | Regex for included metrics | All metrics | `.*connector.*` |
+| `opentelemetry.metrics.exclude.pattern` | Regex for excluded metrics | None | `.*jmx.*` |
+
+### AutoMQ Telemetry Options
+
+| Property | Description | Default |
+|----------|-------------|---------|
+| `automq.telemetry.exporter.uri` | Exporter endpoint | Empty |
+| `automq.telemetry.exporter.interval.ms` | Export interval | `60000` |
+| `automq.telemetry.metric.cardinality.limit` | Max metric cardinality | `20000` |
+
+## Monitoring Examples
+
+### Prometheus Queries
+
+```promql
+# Connector count by worker
+kafka_connect_worker_connector_count
+
+# Task failure rate
+rate(kafka_connect_connector_task_startup_failure_total[5m])
+
+# Average batch processing time
+kafka_connect_connector_task_batch_size_avg
+
+# Connector startup success rate
+rate(kafka_connect_connector_startup_success_total[5m]) / 
+rate(kafka_connect_connector_startup_attempts_total[5m])
+```
+
+### Grafana Dashboard
+
+Common panels to create:
+
+1. **Connector Health**: Count of running/failed connectors
+2. **Task Performance**: Batch size, processing time, throughput
+3. **Error Rates**: Failed startups, task failures
+4. **Resource Usage**: Combined with JVM metrics from AutoMQ telemetry
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Metrics not appearing**
+   ```
+   Check logs for: "AutoMQTelemetryManager is not initialized"
+   Solution: Ensure AutoMQTelemetryManager.initializeInstance() is called before Connect starts
+   ```
+
+2. **High cardinality warnings**
+   ```
+   Solution: Use include/exclude patterns to filter metrics
+   ```
+
+3. **Missing dependencies**
+   ```
+   Ensure connect-runtime depends on the opentelemetry module
+   ```
+
+### Debug Logging
+
+Enable debug logging to troubleshoot:
+
+```properties
+log4j.logger.org.apache.kafka.connect.automq=DEBUG
+log4j.logger.com.automq.opentelemetry=DEBUG
+```
+
+## Integration with Existing Monitoring
+
+This integration works alongside:
+- Existing JMX metrics (not replaced)
+- Kafka broker metrics via AutoMQ telemetry
+- Application-specific metrics
+- Third-party monitoring tools
+
+The OpenTelemetry integration provides a unified export path while preserving existing monitoring setups.
diff --git a/connect/runtime/src/main/java/org/apache/kafka/connect/automq/ConnectLogUploader.java b/connect/runtime/src/main/java/org/apache/kafka/connect/automq/ConnectLogUploader.java
new file mode 100644
index 0000000000..fb409cfe11
--- /dev/null
+++ b/connect/runtime/src/main/java/org/apache/kafka/connect/automq/ConnectLogUploader.java
@@ -0,0 +1,33 @@
+package org.apache.kafka.connect.automq;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Map;
+import java.util.Properties;
+
+/**
+ * Initializes the AutoMQ S3 log uploader for Kafka Connect.
+ */
+public final class ConnectLogUploader {
+    private static Logger getLogger() {
+        return LoggerFactory.getLogger(ConnectLogUploader.class);
+    }    
+    
+    private ConnectLogUploader() {
+    }
+
+    public static void initialize(Map<String, String> workerProps) {
+        Properties props = new Properties();
+        if (workerProps != null) {
+            workerProps.forEach((k, v) -> {
+                if (k != null && v != null) {
+                    props.put(k, v);
+                }
+            });
+        }
+        ConnectS3LogConfigProvider.initialize(props);
+        com.automq.log.uploader.S3RollingFileAppender.triggerInitialization();
+        getLogger().info("Initialized Connect S3 log uploader context");
+    }
+}
diff --git a/connect/runtime/src/main/java/org/apache/kafka/connect/automq/ConnectS3LogConfigProvider.java b/connect/runtime/src/main/java/org/apache/kafka/connect/automq/ConnectS3LogConfigProvider.java
new file mode 100644
index 0000000000..15d77c3e81
--- /dev/null
+++ b/connect/runtime/src/main/java/org/apache/kafka/connect/automq/ConnectS3LogConfigProvider.java
@@ -0,0 +1,174 @@
+package org.apache.kafka.connect.automq;
+
+import com.automq.log.uploader.DefaultS3LogConfig;
+import com.automq.log.uploader.LogConfigConstants;
+import com.automq.log.uploader.S3LogConfig;
+import com.automq.log.uploader.S3LogConfigProvider;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.net.InetAddress;
+import java.util.Map;
+import java.util.Properties;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+
+/**
+ * Provides S3 log uploader configuration for Kafka Connect workers.
+ */
+public class ConnectS3LogConfigProvider implements S3LogConfigProvider {
+    private static Logger getLogger() {
+        return LoggerFactory.getLogger(ConnectS3LogConfigProvider.class);
+    }
+    private static final AtomicReference<Properties> CONFIG = new AtomicReference<>();
+    private static final long WAIT_TIMEOUT_MS = TimeUnit.SECONDS.toMillis(10);
+    private static final CountDownLatch INIT = new CountDownLatch(1);
+
+    public static void initialize(Properties workerProps) {
+        try {
+            if (workerProps == null) {
+                CONFIG.set(null);
+                return;
+            }
+            Properties copy = new Properties();
+            for (Map.Entry<Object, Object> entry : workerProps.entrySet()) {
+                if (entry.getKey() != null && entry.getValue() != null) {
+                    copy.put(entry.getKey(), entry.getValue());
+                }
+            }
+            CONFIG.set(copy);
+        } finally {
+            INIT.countDown();
+        }
+        getLogger().info("Initializing ConnectS3LogConfigProvider");
+    }
+
+    @Override
+    public S3LogConfig get() {
+        
+        try {
+            if (!INIT.await(WAIT_TIMEOUT_MS, TimeUnit.MILLISECONDS)) {
+                getLogger().warn("S3 log uploader config not initialized within timeout; uploader disabled.");
+            }
+        } catch (InterruptedException ie) {
+            Thread.currentThread().interrupt();
+            getLogger().warn("Interrupted while waiting for S3 log uploader config; uploader disabled.");
+            return null;
+        }
+
+        Properties source = CONFIG.get();
+        if (source == null) {
+            getLogger().warn("S3 log upload configuration was not provided; uploader disabled.");
+            return null;
+        }
+
+        Properties effective = buildEffectiveProperties(source);
+        if (!Boolean.parseBoolean(effective.getProperty(LogConfigConstants.LOG_S3_ENABLE_KEY, "false"))) {
+            getLogger().info("S3 log uploader is disabled via {}", LogConfigConstants.LOG_S3_ENABLE_KEY);
+            return null;
+        }
+        return new DefaultS3LogConfig(effective);
+    }
+
+    private Properties buildEffectiveProperties(Properties workerProps) {
+        Properties effective = new Properties();
+        workerProps.forEach((k, v) -> effective.put(String.valueOf(k), String.valueOf(v)));
+
+        copyIfPresent(workerProps, "automq.log.s3.bucket", effective, LogConfigConstants.LOG_S3_BUCKET_KEY);
+        copyIfPresent(workerProps, "automq.log.s3.enable", effective, LogConfigConstants.LOG_S3_ENABLE_KEY);
+        copyIfPresent(workerProps, "automq.log.s3.region", effective, LogConfigConstants.LOG_S3_REGION_KEY);
+        copyIfPresent(workerProps, "automq.log.s3.endpoint", effective, LogConfigConstants.LOG_S3_ENDPOINT_KEY);
+        copyIfPresent(workerProps, "automq.log.s3.access.key", effective, LogConfigConstants.LOG_S3_ACCESS_KEY);
+        copyIfPresent(workerProps, "automq.log.s3.secret.key", effective, LogConfigConstants.LOG_S3_SECRET_KEY);
+        copyIfPresent(workerProps, "automq.log.s3.primary.node", effective, LogConfigConstants.LOG_S3_PRIMARY_NODE_KEY);
+        copyIfPresent(workerProps, "automq.log.s3.selector.type", effective, LogConfigConstants.LOG_S3_SELECTOR_TYPE_KEY);
+        copyIfPresent(workerProps, "automq.log.s3.selector.primary.node.id", effective, LogConfigConstants.LOG_S3_SELECTOR_PRIMARY_NODE_ID_KEY);
+
+        // Default cluster ID
+        if (!effective.containsKey(LogConfigConstants.LOG_S3_CLUSTER_ID_KEY)) {
+            String groupId = workerProps.getProperty("group.id", LogConfigConstants.DEFAULT_LOG_S3_CLUSTER_ID);
+            effective.setProperty(LogConfigConstants.LOG_S3_CLUSTER_ID_KEY, groupId);
+        }
+
+        // Default node ID
+        if (!effective.containsKey(LogConfigConstants.LOG_S3_NODE_ID_KEY)) {
+            String nodeId = resolveNodeId(workerProps);
+            effective.setProperty(LogConfigConstants.LOG_S3_NODE_ID_KEY, nodeId);
+        }
+
+        // Selector defaults
+        if (!effective.containsKey(LogConfigConstants.LOG_S3_SELECTOR_TYPE_KEY)) {
+            effective.setProperty(LogConfigConstants.LOG_S3_SELECTOR_TYPE_KEY, "kafka");
+        }
+
+        String selectorPrefix = LogConfigConstants.LOG_S3_SELECTOR_PREFIX;
+        String bootstrapKey = selectorPrefix + "kafka.bootstrap.servers";
+        if (!effective.containsKey(bootstrapKey)) {
+            String bootstrap = workerProps.getProperty("automq.log.s3.selector.kafka.bootstrap.servers",
+                workerProps.getProperty("bootstrap.servers"));
+            if (!isBlank(bootstrap)) {
+                effective.setProperty(bootstrapKey, bootstrap);
+            }
+        }
+
+        String clusterId = effective.getProperty(LogConfigConstants.LOG_S3_CLUSTER_ID_KEY, "connect");
+        String groupKey = selectorPrefix + "kafka.group.id";
+        if (!effective.containsKey(groupKey)) {
+            effective.setProperty(groupKey, "automq-log-uploader-" + clusterId);
+        }
+
+        String topicKey = selectorPrefix + "kafka.topic";
+        if (!effective.containsKey(topicKey)) {
+            effective.setProperty(topicKey, "__automq_connect_log_leader_" + clusterId.replaceAll("[^A-Za-z0-9_-]", ""));
+        }
+
+        String clientKey = selectorPrefix + "kafka.client.id";
+        if (!effective.containsKey(clientKey)) {
+            effective.setProperty(clientKey, "automq-log-uploader-client-" + effective.getProperty(LogConfigConstants.LOG_S3_NODE_ID_KEY));
+        }
+
+        String autoCreateKey = selectorPrefix + "kafka.auto.create.topic";
+        effective.putIfAbsent(autoCreateKey, "true");
+
+        // Map any existing selector.* overrides from worker props
+        for (String name : workerProps.stringPropertyNames()) {
+            if (name.startsWith(selectorPrefix)) {
+                effective.setProperty(name, workerProps.getProperty(name));
+            }
+        }
+
+        return effective;
+    }
+
+    private void copyIfPresent(Properties src, String srcKey, Properties dest, String destKey) {
+        String value = src.getProperty(srcKey);
+        if (!isBlank(value)) {
+            dest.setProperty(destKey, value.trim());
+        }
+    }
+
+    private String resolveNodeId(Properties workerProps) {
+        String fromConfig = workerProps.getProperty(LogConfigConstants.LOG_S3_NODE_ID_KEY);
+        if (!isBlank(fromConfig)) {
+            return fromConfig.trim();
+        }
+        String env = System.getenv("CONNECT_NODE_ID");
+        if (!isBlank(env)) {
+            return env.trim();
+        }
+        String host = workerProps.getProperty("automq.log.s3.node.hostname");
+        if (isBlank(host)) {
+            try {
+                host = InetAddress.getLocalHost().getHostName();
+            } catch (Exception e) {
+                host = System.getenv().getOrDefault("HOSTNAME", "0");
+            }
+        }
+        return Integer.toString(Math.abs(host.hashCode()));
+    }
+
+    private boolean isBlank(String value) {
+        return value == null || value.trim().isEmpty();
+    }
+}
diff --git a/connect/runtime/src/main/java/org/apache/kafka/connect/automq/MetricsIntegrate.java b/connect/runtime/src/main/java/org/apache/kafka/connect/automq/MetricsIntegrate.java
new file mode 100644
index 0000000000..f2b57adb60
--- /dev/null
+++ b/connect/runtime/src/main/java/org/apache/kafka/connect/automq/MetricsIntegrate.java
@@ -0,0 +1,12 @@
+package org.apache.kafka.connect.automq;
+
+import com.automq.opentelemetry.AutoMQTelemetryManager;
+
+public class MetricsIntegrate {
+    
+    AutoMQTelemetryManager autoMQTelemetryManager;
+    
+    public MetricsIntegrate(AutoMQTelemetryManager autoMQTelemetryManager) {
+        this.autoMQTelemetryManager = autoMQTelemetryManager;
+    }
+}
diff --git a/connect/runtime/src/main/java/org/apache/kafka/connect/automq/OpenTelemetryMetricsReporter.java b/connect/runtime/src/main/java/org/apache/kafka/connect/automq/OpenTelemetryMetricsReporter.java
new file mode 100644
index 0000000000..2b91aa9151
--- /dev/null
+++ b/connect/runtime/src/main/java/org/apache/kafka/connect/automq/OpenTelemetryMetricsReporter.java
@@ -0,0 +1,352 @@
+/*
+ * Copyright 2025, AutoMQ HK Limited.
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.kafka.connect.automq;
+
+import com.automq.opentelemetry.AutoMQTelemetryManager;
+import io.opentelemetry.api.common.Attributes;
+import io.opentelemetry.api.common.AttributesBuilder;
+import io.opentelemetry.api.metrics.DoubleGauge;
+import io.opentelemetry.api.metrics.LongCounter;
+import io.opentelemetry.api.metrics.Meter;
+import org.apache.kafka.common.MetricName;
+import org.apache.kafka.common.metrics.KafkaMetric;
+import org.apache.kafka.common.metrics.MetricsReporter;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * A MetricsReporter implementation that bridges Kafka Connect metrics to OpenTelemetry.
+ * 
+ * <p>This reporter integrates with the AutoMQ OpenTelemetry module to export Kafka Connect
+ * metrics through various exporters (Prometheus, OTLP, etc.). It automatically converts
+ * Kafka metrics to OpenTelemetry instruments based on metric types and provides proper
+ * labeling and naming conventions.
+ * 
+ * <p>Key features:
+ * <ul>
+ *   <li>Automatic metric type detection and conversion</li>
+ *   <li>Support for gauges and counters</li>
+ *   <li>Proper attribute mapping from Kafka metric tags</li>
+ *   <li>Integration with AutoMQ telemetry infrastructure</li>
+ *   <li>Configurable metric filtering</li>
+ * </ul>
+ * 
+ * <p>Configuration options:
+ * <ul>
+ *   <li>{@code opentelemetry.metrics.enabled} - Enable/disable OpenTelemetry metrics (default: true)</li>
+ *   <li>{@code opentelemetry.metrics.prefix} - Prefix for metric names (default: "kafka.connect")</li>
+ *   <li>{@code opentelemetry.metrics.include.pattern} - Regex pattern for included metrics</li>
+ *   <li>{@code opentelemetry.metrics.exclude.pattern} - Regex pattern for excluded metrics</li>
+ * </ul>
+ */
+public class OpenTelemetryMetricsReporter implements MetricsReporter {
+    private static final Logger LOGGER = LoggerFactory.getLogger(OpenTelemetryMetricsReporter.class);
+    
+    private static final String ENABLED_CONFIG = "opentelemetry.metrics.enabled";
+    private static final String PREFIX_CONFIG = "opentelemetry.metrics.prefix";
+    private static final String INCLUDE_PATTERN_CONFIG = "opentelemetry.metrics.include.pattern";
+    private static final String EXCLUDE_PATTERN_CONFIG = "opentelemetry.metrics.exclude.pattern";
+    
+    private static final String DEFAULT_PREFIX = "kafka.connect";
+    
+    private boolean enabled = true;
+    private String metricPrefix = DEFAULT_PREFIX;
+    private String includePattern = null;
+    private String excludePattern = null;
+    
+    private Meter meter;
+    private final Map<String, DoubleGauge> gauges = new ConcurrentHashMap<>();
+    private final Map<String, LongCounter> counters = new ConcurrentHashMap<>();
+    private final Map<String, Double> lastValues = new ConcurrentHashMap<>();
+    
+    public static void initializeTelemetry(Properties props) {
+        AutoMQTelemetryManager.initializeInstance(props);
+        LOGGER.info("OpenTelemetryMetricsReporter initialized");
+    }
+    
+    @Override
+    public void configure(Map<String, ?> configs) {
+        // Parse configuration
+        Object enabledObj = configs.get(ENABLED_CONFIG);
+        if (enabledObj != null) {
+            enabled = Boolean.parseBoolean(enabledObj.toString());
+        }
+        
+        Object prefixObj = configs.get(PREFIX_CONFIG);
+        if (prefixObj != null) {
+            metricPrefix = prefixObj.toString();
+        }
+        
+        Object includeObj = configs.get(INCLUDE_PATTERN_CONFIG);
+        if (includeObj != null) {
+            includePattern = includeObj.toString();
+        }
+        
+        Object excludeObj = configs.get(EXCLUDE_PATTERN_CONFIG);
+        if (excludeObj != null) {
+            excludePattern = excludeObj.toString();
+        }
+        
+        LOGGER.info("OpenTelemetryMetricsReporter configured - enabled: {}, prefix: {}, include: {}, exclude: {}", 
+                   enabled, metricPrefix, includePattern, excludePattern);
+    }
+
+    @Override
+    public void init(List<KafkaMetric> metrics) {
+        if (!enabled) {
+            LOGGER.info("OpenTelemetryMetricsReporter is disabled");
+            return;
+        }
+        
+        try {
+            // Get the OpenTelemetry meter from AutoMQTelemetryManager
+            // This assumes the telemetry manager is already initialized
+            meter = AutoMQTelemetryManager.getInstance().getMeter();
+            if (meter == null) {
+                LOGGER.warn("AutoMQTelemetryManager is not initialized, OpenTelemetry metrics will not be available");
+                enabled = false;
+                return;
+            }
+            
+            // Register initial metrics
+            for (KafkaMetric metric : metrics) {
+                registerMetric(metric);
+            }
+            
+            LOGGER.info("OpenTelemetryMetricsReporter initialized with {} metrics", metrics.size());
+        } catch (Exception e) {
+            LOGGER.error("Failed to initialize OpenTelemetryMetricsReporter", e);
+            enabled = false;
+        }
+    }
+
+    @Override
+    public void metricChange(KafkaMetric metric) {
+        if (!enabled || meter == null) {
+            return;
+        }
+        
+        try {
+            registerMetric(metric);
+        } catch (Exception e) {
+            LOGGER.warn("Failed to register metric change for {}", metric.metricName(), e);
+        }
+    }
+
+    @Override
+    public void metricRemoval(KafkaMetric metric) {
+        if (!enabled) {
+            return;
+        }
+        
+        try {
+            String metricKey = buildMetricKey(metric.metricName());
+            gauges.remove(metricKey);
+            counters.remove(metricKey);
+            lastValues.remove(metricKey);
+            LOGGER.debug("Removed metric: {}", metricKey);
+        } catch (Exception e) {
+            LOGGER.warn("Failed to remove metric {}", metric.metricName(), e);
+        }
+    }
+
+    @Override
+    public void close() {
+        LOGGER.info("OpenTelemetryMetricsReporter closed");
+    }
+    
+    private void registerMetric(KafkaMetric metric) {
+        LOGGER.info("OpenTelemetryMetricsReporter Registering metric {}", metric.metricName());
+        MetricName metricName = metric.metricName();
+        String metricKey = buildMetricKey(metricName);
+        
+        // Apply filtering
+        if (!shouldIncludeMetric(metricKey)) {
+            return;
+        }
+        
+        Object value = metric.metricValue();
+        if (!(value instanceof Number)) {
+            LOGGER.debug("Skipping non-numeric metric: {}", metricKey);
+            return;
+        }
+        
+        double numericValue = ((Number) value).doubleValue();
+        Attributes attributes = buildAttributes(metricName);
+        
+        // Determine metric type and register accordingly
+        if (isCounterMetric(metricName)) {
+            registerCounter(metricKey, metricName, numericValue, attributes);
+        } else {
+            registerGauge(metricKey, metricName, numericValue, attributes);
+        }
+    }
+    
+    private void registerGauge(String metricKey, MetricName metricName, double value, Attributes attributes) {
+        DoubleGauge gauge = gauges.computeIfAbsent(metricKey, k -> {
+            String description = buildDescription(metricName);
+            String unit = determineUnit(metricName);
+            return meter.gaugeBuilder(metricKey)
+                       .setDescription(description)
+                       .setUnit(unit)
+                       .build();
+        });
+        
+        // Record the value
+        gauge.set(value, attributes);
+        lastValues.put(metricKey, value);
+        LOGGER.debug("Updated gauge {} = {}", metricKey, value);
+    }
+    
+    private void registerCounter(String metricKey, MetricName metricName, double value, Attributes attributes) {
+        LongCounter counter = counters.computeIfAbsent(metricKey, k -> {
+            String description = buildDescription(metricName);
+            String unit = determineUnit(metricName);
+            return meter.counterBuilder(metricKey)
+                       .setDescription(description)
+                       .setUnit(unit)
+                       .build();
+        });
+        
+        // For counters, we need to track delta values
+        Double lastValue = lastValues.get(metricKey);
+        if (lastValue != null) {
+            double delta = value - lastValue;
+            if (delta > 0) {
+                counter.add((long) delta, attributes);
+                LOGGER.debug("Counter {} increased by {}", metricKey, delta);
+            }
+        }
+        lastValues.put(metricKey, value);
+    }
+    
+    private String buildMetricKey(MetricName metricName) {
+        StringBuilder sb = new StringBuilder(metricPrefix);
+        sb.append(".");
+        
+        // Add group if present
+        if (metricName.group() != null && !metricName.group().isEmpty()) {
+            sb.append(metricName.group().replace("-", "_").toLowerCase());
+            sb.append(".");
+        }
+        
+        // Add name
+        sb.append(metricName.name().replace("-", "_").toLowerCase());
+        
+        return sb.toString();
+    }
+    
+    private Attributes buildAttributes(MetricName metricName) {
+        AttributesBuilder builder = Attributes.builder();
+        
+        // Add metric tags as attributes
+        Map<String, String> tags = metricName.tags();
+        if (tags != null) {
+            for (Map.Entry<String, String> entry : tags.entrySet()) {
+                String key = entry.getKey();
+                String value = entry.getValue();
+                if (key != null && value != null) {
+                    builder.put(sanitizeAttributeKey(key), value);
+                }
+            }
+        }
+        
+        // Add standard attributes
+        if (metricName.group() != null) {
+            builder.put("metric.group", metricName.group());
+        }
+        
+        return builder.build();
+    }
+    
+    private String sanitizeAttributeKey(String key) {
+        // Replace invalid characters for attribute keys
+        return key.replace("-", "_").replace(".", "_").toLowerCase();
+    }
+    
+    private String buildDescription(MetricName metricName) {
+        StringBuilder description = new StringBuilder();
+        description.append("Kafka Connect metric: ");
+        
+        if (metricName.group() != null) {
+            description.append(metricName.group()).append(" - ");
+        }
+        
+        description.append(metricName.name());
+        
+        return description.toString();
+    }
+    
+    private String determineUnit(MetricName metricName) {
+        String name = metricName.name().toLowerCase();
+        
+        if (name.contains("time") || name.contains("latency") || name.contains("duration")) {
+            if (name.contains("ms") || name.contains("millisecond")) {
+                return "ms";
+            } else if (name.contains("ns") || name.contains("nanosecond")) {
+                return "ns";
+            } else {
+                return "s";
+            }
+        } else if (name.contains("byte") || name.contains("size")) {
+            return "bytes";
+        } else if (name.contains("rate") || name.contains("per-sec")) {
+            return "1/s";
+        } else if (name.contains("percent") || name.contains("ratio")) {
+            return "%";
+        } else if (name.contains("count") || name.contains("total")) {
+            return "1";
+        }
+        
+        return "1"; // Default unit
+    }
+    
+    private boolean isCounterMetric(MetricName metricName) {
+        String name = metricName.name().toLowerCase();
+        String group = metricName.group() != null ? metricName.group().toLowerCase() : "";
+        
+        // Identify counter-like metrics
+        return name.contains("total") || 
+               name.contains("count") ||
+               name.contains("error") ||
+               name.contains("failure") ||
+               name.endsWith("-total") ||
+               group.contains("error");
+    }
+    
+    private boolean shouldIncludeMetric(String metricKey) {
+        // Apply exclude pattern first
+        if (excludePattern != null && metricKey.matches(excludePattern)) {
+            return false;
+        }
+        
+        // Apply include pattern if specified
+        if (includePattern != null) {
+            return metricKey.matches(includePattern);
+        }
+        
+        return true;
+    }
+}
diff --git a/connect/runtime/src/main/java/org/apache/kafka/connect/cli/AbstractConnectCli.java b/connect/runtime/src/main/java/org/apache/kafka/connect/cli/AbstractConnectCli.java
index 5cfa300baf..627d2d701d 100644
--- a/connect/runtime/src/main/java/org/apache/kafka/connect/cli/AbstractConnectCli.java
+++ b/connect/runtime/src/main/java/org/apache/kafka/connect/cli/AbstractConnectCli.java
@@ -19,6 +19,8 @@
 import org.apache.kafka.common.utils.Exit;
 import org.apache.kafka.common.utils.Time;
 import org.apache.kafka.common.utils.Utils;
+import org.apache.kafka.connect.automq.ConnectLogUploader;
+import org.apache.kafka.connect.automq.OpenTelemetryMetricsReporter;
 import org.apache.kafka.connect.connector.policy.ConnectorClientConfigOverridePolicy;
 import org.apache.kafka.connect.runtime.Connect;
 import org.apache.kafka.connect.runtime.Herder;
@@ -36,6 +38,7 @@
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.Map;
+import java.util.Properties;
 
 /**
  * Common initialization logic for Kafka Connect, intended for use by command line utilities
@@ -45,7 +48,9 @@
  */
 public abstract class AbstractConnectCli<H extends Herder, T extends WorkerConfig> {
 
-    private static final Logger log = LoggerFactory.getLogger(AbstractConnectCli.class);
+    private static Logger getLogger() {
+        return LoggerFactory.getLogger(AbstractConnectCli.class);
+    }
     private final String[] args;
     private final Time time = Time.SYSTEM;
 
@@ -83,7 +88,6 @@ protected abstract H createHerder(T config, String workerId, Plugins plugins,
      */
     public void run() {
         if (args.length < 1 || Arrays.asList(args).contains("--help")) {
-            log.info("Usage: {}", usage());
             Exit.exit(1);
         }
 
@@ -92,6 +96,14 @@ public void run() {
             Map<String, String> workerProps = !workerPropsFile.isEmpty() ?
                     Utils.propsToStringMap(Utils.loadProps(workerPropsFile)) : Collections.emptyMap();
             String[] extraArgs = Arrays.copyOfRange(args, 1, args.length);
+            
+            // Initialize S3 log uploader and OpenTelemetry with worker properties
+            ConnectLogUploader.initialize(workerProps);
+
+            Properties telemetryProps = new Properties();
+            telemetryProps.putAll(workerProps);
+            OpenTelemetryMetricsReporter.initializeTelemetry(telemetryProps);
+            
             Connect<H> connect = startConnect(workerProps);
             processExtraArgs(connect, extraArgs);
 
@@ -99,7 +111,7 @@ public void run() {
             connect.awaitStop();
 
         } catch (Throwable t) {
-            log.error("Stopping due to error", t);
+            getLogger().error("Stopping due to error", t);
             Exit.exit(2);
         }
     }
@@ -111,17 +123,17 @@ public void run() {
      * @return a started instance of {@link Connect}
      */
     public Connect<H> startConnect(Map<String, String> workerProps) {
-        log.info("Kafka Connect worker initializing ...");
+        getLogger().info("Kafka Connect worker initializing ...");
         long initStart = time.hiResClockMs();
 
         WorkerInfo initInfo = new WorkerInfo();
         initInfo.logAll();
 
-        log.info("Scanning for plugin classes. This might take a moment ...");
+        getLogger().info("Scanning for plugin classes. This might take a moment ...");
         Plugins plugins = new Plugins(workerProps);
         plugins.compareAndSwapWithDelegatingLoader();
         T config = createConfig(workerProps);
-        log.debug("Kafka cluster ID: {}", config.kafkaClusterId());
+        getLogger().debug("Kafka cluster ID: {}", config.kafkaClusterId());
 
         RestClient restClient = new RestClient(config);
 
@@ -138,11 +150,11 @@ public Connect<H> startConnect(Map<String, String> workerProps) {
         H herder = createHerder(config, workerId, plugins, connectorClientConfigOverridePolicy, restServer, restClient);
 
         final Connect<H> connect = new Connect<>(herder, restServer);
-        log.info("Kafka Connect worker initialization took {}ms", time.hiResClockMs() - initStart);
+        getLogger().info("Kafka Connect worker initialization took {}ms", time.hiResClockMs() - initStart);
         try {
             connect.start();
         } catch (Exception e) {
-            log.error("Failed to start Connect", e);
+            getLogger().error("Failed to start Connect", e);
             connect.stop();
             Exit.exit(3);
         }
diff --git a/connect/runtime/src/main/java/org/apache/kafka/connect/runtime/OTelMetricsReporter.java b/connect/runtime/src/main/java/org/apache/kafka/connect/runtime/OTelMetricsReporter.java
new file mode 100644
index 0000000000..72a0b56fb0
--- /dev/null
+++ b/connect/runtime/src/main/java/org/apache/kafka/connect/runtime/OTelMetricsReporter.java
@@ -0,0 +1,195 @@
+package org.apache.kafka.connect.runtime;
+
+import org.apache.kafka.common.MetricName;
+import org.apache.kafka.common.metrics.KafkaMetric;
+import org.apache.kafka.common.metrics.MetricsContext;
+import org.apache.kafka.common.metrics.MetricsReporter;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import io.opentelemetry.api.OpenTelemetry;
+import io.opentelemetry.api.common.Attributes;
+import io.opentelemetry.api.common.AttributesBuilder;
+import io.opentelemetry.api.metrics.Meter;
+import io.opentelemetry.api.metrics.ObservableDoubleGauge;
+
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * A Kafka MetricsReporter that bridges Kafka metrics to OpenTelemetry.
+ * This reporter registers all metrics as observable gauges with OpenTelemetry,
+ * which will call back to get the latest values when metrics collection occurs.
+ */
+public class OTelMetricsReporter implements MetricsReporter {
+
+    private static final Logger log = LoggerFactory.getLogger(OTelMetricsReporter.class);
+    
+    // Store all metrics for retrieval during OTel callbacks
+    private final Map<MetricName, KafkaMetric> metrics = new ConcurrentHashMap<>();
+    
+    // Group metrics by group for easier registration with OTel
+    private final Map<String, Map<MetricName, KafkaMetric>> metricsByGroup = new ConcurrentHashMap<>();
+    
+    // Keep track of registered gauges to prevent duplicate registration
+    private final Map<String, ObservableDoubleGauge> registeredGauges = new ConcurrentHashMap<>();
+    
+    private Meter meter;
+    private boolean initialized = false;
+
+    @Override
+    public void configure(Map<String, ?> configs) {
+        log.info("Configuring OTelMetricsReporter");
+    }
+
+    /**
+     * Initialize OpenTelemetry meter and register metrics
+     */
+    public void initOpenTelemetry(OpenTelemetry openTelemetry) {
+        if (initialized) {
+            return;
+        }
+        
+        this.meter = openTelemetry.getMeter("kafka-connect-metrics");
+        log.info("OTelMetricsReporter initialized with OpenTelemetry meter");
+        
+        // Register all metrics that were already added before OpenTelemetry was initialized
+        registerMetricsWithOTel();
+        
+        initialized = true;
+    }
+
+    @Override
+    public void init(List<KafkaMetric> metrics) {
+        log.info("Initializing OTelMetricsReporter with {} metrics", metrics.size());
+        for (KafkaMetric metric : metrics) {
+            addMetricToCollections(metric);
+        }
+        
+        // If meter is already available, register metrics
+        if (meter != null) {
+            registerMetricsWithOTel();
+        }
+    }
+
+    private void addMetricToCollections(KafkaMetric metric) {
+        MetricName metricName = metric.metricName();
+        metrics.put(metricName, metric);
+        
+        // Group by metric group
+        metricsByGroup
+            .computeIfAbsent(metricName.group(), k -> new ConcurrentHashMap<>())
+            .put(metricName, metric);
+    }
+
+    private void registerMetricsWithOTel() {
+        if (meter == null) {
+            log.warn("Cannot register metrics with OpenTelemetry - meter not initialized");
+            return;
+        }
+        
+        // Register each group of metrics as an observable gauge collection
+        for (Map.Entry<String, Map<MetricName, KafkaMetric>> entry : metricsByGroup.entrySet()) {
+            String group = entry.getKey();
+            Map<MetricName, KafkaMetric> groupMetrics = entry.getValue();
+            
+            // Register the gauge for this group if not already registered
+            String gaugeKey = "kafka.connect." + group;
+            if (!registeredGauges.containsKey(gaugeKey)) {
+                ObservableDoubleGauge gauge = meter
+                    .gaugeBuilder(gaugeKey)
+                    .setDescription("Kafka Connect metrics for " + group)
+                    .setUnit("1") // Default unit
+                    .buildWithCallback(measurement -> {
+                        // Get the latest values for all metrics in this group
+                        Map<MetricName, KafkaMetric> currentGroupMetrics = metricsByGroup.get(group);
+                        if (currentGroupMetrics != null) {
+                            for (Map.Entry<MetricName, KafkaMetric> metricEntry : currentGroupMetrics.entrySet()) {
+                                MetricName name = metricEntry.getKey();
+                                KafkaMetric kafkaMetric = metricEntry.getValue();
+                                
+                                try {
+                                    // Convert metric value to double
+                                    double value = convertToDouble(kafkaMetric.metricValue());
+                                    
+                                    // Build attributes from metric tags
+                                    AttributesBuilder attributes = Attributes.builder();
+                                    attributes.put("name", name.name());
+                                    
+                                    // Add all tags as attributes
+                                    for (Map.Entry<String, String> tag : name.tags().entrySet()) {
+                                        attributes.put(tag.getKey(), tag.getValue());
+                                    }
+                                    
+                                    // Record the measurement
+                                    measurement.record(value, attributes.build());
+                                } catch (Exception e) {
+                                    log.warn("Error recording metric {}: {}", name, e.getMessage());
+                                }
+                            }
+                        }
+                    });
+                
+                registeredGauges.put(gaugeKey, gauge);
+                log.info("Registered gauge for metric group: {}", group);
+            }
+        }
+    }
+
+    private double convertToDouble(Object value) {
+        if (value == null) {
+            return 0.0;
+        }
+        
+        if (value instanceof Number) {
+            return ((Number) value).doubleValue();
+        }
+        
+        if (value instanceof Boolean) {
+            return ((Boolean) value) ? 1.0 : 0.0;
+        }
+        
+        return 0.0;
+    }
+
+    @Override
+    public void metricChange(KafkaMetric metric) {
+        addMetricToCollections(metric);
+        
+        // If already initialized with OTel, register new metrics
+        if (meter != null && !registeredGauges.containsKey("kafka.connect." + metric.metricName().group())) {
+            registerMetricsWithOTel();
+        }
+    }
+
+    @Override
+    public void metricRemoval(KafkaMetric metric) {
+        MetricName metricName = metric.metricName();
+        metrics.remove(metricName);
+        
+        Map<MetricName, KafkaMetric> groupMetrics = metricsByGroup.get(metricName.group());
+        if (groupMetrics != null) {
+            groupMetrics.remove(metricName);
+            if (groupMetrics.isEmpty()) {
+                metricsByGroup.remove(metricName.group());
+            }
+        }
+        
+        log.debug("Removed metric: {}", metricName);
+    }
+
+    @Override
+    public void close() {
+        log.info("Closing OTelMetricsReporter");
+        metrics.clear();
+        metricsByGroup.clear();
+        registeredGauges.clear();
+    }
+
+    @Override
+    public void contextChange(MetricsContext metricsContext) {
+        // Add context labels as attributes if needed
+        log.info("Metrics context changed: {}", metricsContext.contextLabels());
+    }
+}
diff --git a/gradle/dependencies.gradle b/gradle/dependencies.gradle
index 1be9de6d03..119fecec50 100644
--- a/gradle/dependencies.gradle
+++ b/gradle/dependencies.gradle
@@ -178,7 +178,7 @@ versions += [
   jna:"5.2.0",
   guava:"32.0.1-jre",
   hdrHistogram:"2.1.12",
-  nettyTcnativeBoringSsl: "2.0.65.Final",
+  nettyTcnativeBoringSsl: "2.0.69.Final",
   avro: "1.11.4",
   confluentSchema: "7.8.0",
   iceberg: "1.6.1",
diff --git a/gradle/spotbugs-exclude.xml b/gradle/spotbugs-exclude.xml
index 310d9902d9..2d804620be 100644
--- a/gradle/spotbugs-exclude.xml
+++ b/gradle/spotbugs-exclude.xml
@@ -601,7 +601,8 @@ For a detailed description of spotbugs bug categories, see https://spotbugs.read
     <Match>
         <Or>
             <Class name="org.apache.kafka.jmh.util.ByteUtilsBenchmark$BaseBenchmarkState"/>
-            <Class name="com.automq.shell.log.LogUploader"/>
+            <Class name="com.automq.log.LogUploader"/>
+            <Class name="com.automq.log.uploader.LogUploader"/>
             <Class name="com.automq.shell.metrics.S3MetricsExporter"/>
         </Or>
         <!-- Suppress warning because JMH code is used to instantiate Random() once per Trial. This is done to ensure
diff --git a/opentelemetry/README.md b/opentelemetry/README.md
new file mode 100644
index 0000000000..c39c340ea3
--- /dev/null
+++ b/opentelemetry/README.md
@@ -0,0 +1,559 @@
+# AutoMQ OpenTelemetry Module
+
+##├── exporter/
+│   ├── MetricsExporter.java       # Exporter interface
+│   ├── MetricsExporterURI.java    # URI parser
+│   ├── OTLPMetricsExporter.java   # OTLP exporter implementation
+│   ├── PrometheusMetricsExporter.java # Prometheus exporter implementation
+│   ├── remotewrite/               # Remote Write exporter implementation
+│   │   ├── PromConsts.java        # Prometheus constants
+│   │   ├── PromLabels.java        # Label management for Prometheus format
+│   │   ├── PromTimeSeries.java    # Time series data structures
+│   │   ├── PromUtils.java         # Prometheus utility functions
+│   │   ├── RemoteWriteExporter.java # Main remote write exporter
+│   │   ├── RemoteWriteMetricsExporter.java # Metrics exporter adapter
+│   │   ├── RemoteWriteRequestMarshaller.java # Request marshalling
+│   │   ├── RemoteWriteURI.java    # URI parsing for remote write
+│   │   └── auth/                  # Authentication support
+│   │       ├── AuthType.java      # Authentication type enum
+│   │       ├── AuthUtils.java     # Authentication utilities
+│   │       ├── AwsSigV4Auth.java  # AWS SigV4 authentication
+│   │       ├── AwsSigV4Interceptor.java
+│   │       ├── AwsSigV4Signer.java
+│   │       ├── AzureADAuth.java   # Azure AD authentication
+│   │       ├── AzureADInterceptor.java
+│   │       ├── AzureCloudConst.java
+│   │       ├── BasicAuth.java     # HTTP Basic authentication
+│   │   │   ├── BasicAuthInterceptor.java
+│   │       ├── BearerAuthInterceptor.java # Bearer token authentication
+│   │       ├── BearerTokenAuth.java
+│   │       └── RemoteWriteAuth.java # Authentication interface
+│   └── s3/                        # S3 metrics exporter implementationiew
+
+The AutoMQ OpenTelemetry module is a telemetry data collection and export component based on OpenTelemetry SDK, specifically designed for AutoMQ Kafka. This module provides unified telemetry data management capabilities, supporting the collection of JVM metrics, JMX metrics, and Yammer metrics, and can export data to Prometheus, OTLP-compatible backend systems, or S3-compatible storage.
+
+## Core Features
+
+### 1. Metrics Collection
+- **JVM Metrics**: Automatically collect JVM runtime metrics including CPU, memory pools, garbage collection, threads, etc.
+- **JMX Metrics**: Define and collect JMX Bean metrics through configuration files
+- **Yammer Metrics**: Bridge existing Kafka Yammer metrics system to OpenTelemetry
+
+### 2. Multiple Exporter Support
+- **Prometheus**: Expose metrics in Prometheus format through HTTP server
+- **OTLP**: Support both gRPC and HTTP/Protobuf protocols for exporting to OTLP backends
+- **Remote Write**: Support Prometheus Remote Write protocol for direct integration with time-series databases
+- **S3**: Export metrics to S3-compatible object storage systems
+
+### 3. Flexible Configuration
+- Support parameter settings through Properties configuration files
+- Configurable export intervals, compression methods, timeout values, etc.
+- Support metric cardinality limits to control memory usage
+
+## Module Structure
+
+```
+com.automq.opentelemetry/
+├── AutoMQTelemetryManager.java    # Main management class for initialization and lifecycle
+├── TelemetryConfig.java           # Configuration management class
+├── TelemetryConstants.java        # Constants definition
+├── common/
+│   └── MetricsUtils.java          # Metrics utility class
+├── exporter/
+│   ├── MetricsExporter.java       # Exporter interface
+│   ├── MetricsExporterURI.java    # URI parser
+│   ���── OTLPMetricsExporter.java   # OTLP exporter implementation
+│   ├── PrometheusMetricsExporter.java # Prometheus exporter implementation
+│   └── s3/                        # S3 metrics exporter implementation
+│       ├── CompressionUtils.java  # Utility for data compression
+│       ├── PrometheusUtils.java   # Utilities for Prometheus format
+│       ├── S3MetricsConfig.java   # Configuration interface
+│       ├── S3MetricsExporter.java # S3 metrics exporter implementation
+│       ├── S3MetricsExporterAdapter.java # Adapter to handle S3 metrics export
+│       ├── UploaderNodeSelector.java # Interface for node selection logic
+│       └── UploaderNodeSelectors.java # Factory for node selector implementations
+└── yammer/
+    ├── DeltaHistogram.java        # Delta histogram implementation
+    ├── OTelMetricUtils.java       # OpenTelemetry metrics utilities
+    ├── YammerMetricsProcessor.java # Yammer metrics processor
+    └── YammerMetricsReporter.java  # Yammer metrics reporter
+```
+
+## Quick Start
+
+### 1. Basic Usage
+
+```java
+import com.automq.opentelemetry.AutoMQTelemetryManager;
+import java.util.Properties;
+
+// Create configuration
+Properties props = new Properties();
+props.setProperty("automq.telemetry.exporter.uri", "prometheus://localhost:9090");
+props.setProperty("service.name", "automq-kafka");
+props.setProperty("service.instance.id", "broker-1");
+
+// Initialize telemetry manager
+AutoMQTelemetryManager telemetryManager = new AutoMQTelemetryManager(props);
+telemetryManager.init();
+
+// Start Yammer metrics reporting (optional)
+MetricsRegistry yammerRegistry = // Get Kafka's Yammer registry
+telemetryManager.startYammerMetricsReporter(yammerRegistry);
+
+// Application running...
+
+// Shutdown telemetry system
+telemetryManager.shutdown();
+```
+
+### 2. Get Meter Instance
+
+```java
+// Get OpenTelemetry Meter for custom metrics
+Meter meter = telemetryManager.getMeter();
+
+// Create custom metrics
+LongCounter requestCounter = meter
+    .counterBuilder("http_requests_total")
+    .setDescription("Total number of HTTP requests")
+    .build();
+
+requestCounter.add(1, Attributes.of(AttributeKey.stringKey("method"), "GET"));
+```
+
+## Configuration
+
+### Basic Configuration
+
+| Configuration | Description | Default Value | Example |
+|---------------|-------------|---------------|---------|
+| `automq.telemetry.exporter.uri` | Exporter URI | Empty (no export) | `prometheus://localhost:9090` |
+| `service.name` | Service name | `unknown-service` | `automq-kafka` |
+| `service.instance.id` | Service instance ID | `unknown-instance` | `broker-1` |
+
+### Exporter Configuration
+
+#### Prometheus Exporter
+```properties
+# Prometheus HTTP server configuration
+automq.telemetry.exporter.uri=prometheus://localhost:9090
+```
+
+#### OTLP Exporter
+```properties
+# OTLP exporter configuration
+automq.telemetry.exporter.uri=otlp://localhost:4317
+automq.telemetry.exporter.interval.ms=60000
+automq.telemetry.exporter.otlp.protocol=grpc
+automq.telemetry.exporter.otlp.compression=gzip
+automq.telemetry.exporter.otlp.timeout.ms=30000
+```
+
+#### Remote Write Exporter
+```properties
+# Basic Remote Write configuration
+automq.telemetry.exporter.uri=remote_write://prometheus.example.com:9090/api/v1/write
+automq.telemetry.exporter.interval.ms=30000
+
+# With authentication
+# Basic Auth:
+automq.telemetry.exporter.uri=rw://username:password@prometheus.example.com:9090/api/v1/write
+
+# Bearer Token:
+automq.telemetry.exporter.uri=rw://token@prometheus.example.com:9090/api/v1/write?authType=bearer
+
+# AWS SigV4 (for Amazon Managed Prometheus):
+automq.telemetry.exporter.uri=rw://ACCESS_KEY:SECRET_KEY@aps-workspaces.us-west-2.amazonaws.com/workspaces/ws-xxx/api/v1/remote_write?authType=aws&region=us-west-2
+
+# Azure AD:
+automq.telemetry.exporter.uri=rw://CLIENT_ID:CLIENT_SECRET@prometheus.monitor.azure.com/api/v1/write?authType=azure&tenantId=TENANT_ID&cloud=azure_public
+```
+
+#### S3 Metrics Exporter
+```properties
+# S3 metrics exporter configuration
+automq.telemetry.exporter.uri=s3://access-key:secret-key@my-bucket.s3.amazonaws.com
+automq.telemetry.exporter.interval.ms=60000
+automq.telemetry.s3.cluster.id=cluster-1
+automq.telemetry.s3.node.id=1
+automq.telemetry.s3.primary.node=true
+```
+
+Example usage with S3 exporter:
+
+```java
+// Create configuration for S3 metrics export
+Properties props = new Properties();
+props.setProperty("automq.telemetry.exporter.uri", "s3://access-key:secret-key@my-bucket.s3.amazonaws.com");
+props.setProperty("automq.telemetry.s3.cluster.id", "my-kafka-cluster");
+props.setProperty("automq.telemetry.s3.node.id", "1");
+props.setProperty("automq.telemetry.s3.primary.node", "true");  // Only one node should be set to true
+props.setProperty("service.name", "automq-kafka");
+props.setProperty("service.instance.id", "broker-1");
+
+// Initialize telemetry manager with S3 export
+AutoMQTelemetryManager telemetryManager = new AutoMQTelemetryManager(props);
+telemetryManager.init();
+
+// Application running...
+
+// Shutdown telemetry system
+telemetryManager.shutdown();
+```
+
+### S3 Metrics Exporter Configuration
+
+The S3 Metrics Exporter allows you to export metrics data to S3-compatible storage systems, with support for different node selection strategies to ensure only one node uploads metrics data in a cluster environment.
+
+#### URI Format
+
+```
+s3://<access-key>:<secret-key>@<bucket-name>?endpoint=<endpoint>&<other-parameters>
+```
+
+S3 bucket URI format description:
+```
+s3://<bucket-name>?region=<region>[&endpoint=<endpoint>][&pathStyle=<enablePathStyle>][&authType=<authType>][&accessKey=<accessKey>][&secretKey=<secretKey>][&checksumAlgorithm=<checksumAlgorithm>]
+```
+
+- **pathStyle**: `true|false`. Object storage access path style. Set to true when using MinIO.
+- **authType**: `instance|static`. When set to instance, instance profile is used for authentication. When set to static, accessKey and secretKey are obtained from the URL or system environment variables KAFKA_S3_ACCESS_KEY/KAFKA_S3_SECRET_KEY.
+
+Simplified format is also supported, with credentials in the user info part:
+```
+s3://<access-key>:<secret-key>@<bucket-name>?endpoint=<endpoint>&<other-parameters>
+```
+
+Examples:
+- `s3://accessKey:secretKey@metrics-bucket?endpoint=https://s3.amazonaws.com`
+- `s3://metrics-bucket?region=us-west-2&authType=instance`
+
+#### Configuration Properties
+
+| Configuration | Description | Default Value |
+|---------------|-------------|---------------|
+| `automq.telemetry.s3.cluster.id` | Cluster identifier | `automq-cluster` |
+| `automq.telemetry.s3.node.id` | Node identifier | `0` |
+| `automq.telemetry.s3.primary.node` | Whether this node is the primary uploader | `false` |
+| `automq.telemetry.s3.selector.type` | Node selection strategy type | `static` |
+| `automq.telemetry.s3.bucket` | S3 bucket URI | None |
+
+#### Node Selection Strategies
+
+In a multi-node cluster, typically only one node should upload metrics to S3 to avoid duplication. The S3 Metrics Exporter provides several built-in node selection strategies through the `UploaderNodeSelector` interface:
+
+1. **Static Selection** (`static`)
+
+   Uses a static configuration to determine which node uploads metrics.
+
+   ```properties
+   automq.telemetry.s3.selector.type=static
+   automq.telemetry.s3.primary.node=true
+   ```
+
+2. **Node ID Based Selection** (`nodeid`)
+
+   Selects the node with a specific node ID as the primary uploader.
+
+   ```properties
+   automq.telemetry.s3.selector.type=nodeid
+   # Additional parameters
+   # primaryNodeId=1  # Can be specified in URI query parameters if needed
+   ```
+
+3. **File-Based Leader Election** (`file`)
+
+   Uses a file on a shared filesystem to implement simple leader election.
+
+   ```properties
+   automq.telemetry.s3.selector.type=file
+   # Additional parameters (can be specified in URI query parameters)
+   # leaderFile=/path/to/leader-file
+   # leaderTimeoutMs=60000
+   ```
+
+4. **Kafka-based Leader Election** (`kafka`)
+
+   Leverages Kafka consumer group partition assignment. All nodes join the same consumer group and subscribe to a single-partition topic; the node that holds the partition becomes the primary uploader while others stay on standby.
+
+   ```properties
+   automq.telemetry.s3.selector.type=kafka
+   # Recommended to configure using the automq.telemetry.s3.selector.kafka. prefix
+   automq.telemetry.s3.selector.kafka.bootstrap.servers=PLAINTEXT://kafka:9092
+   automq.telemetry.s3.selector.kafka.topic=__automq_telemetry_s3_leader_connect
+   automq.telemetry.s3.selector.kafka.group.id=automq-telemetry-s3-connect
+   automq.telemetry.s3.selector.kafka.topic.replication.factor=3
+   automq.telemetry.s3.selector.kafka.security.protocol=SASL_PLAINTEXT
+   automq.telemetry.s3.selector.kafka.sasl.mechanism=SCRAM-SHA-512
+   automq.telemetry.s3.selector.kafka.sasl.jaas.config=org.apache.kafka.common.security.scram.ScramLoginModule required username="connect" password="change-me";
+   ```
+
+   **Key points**
+
+   - `bootstrap.servers` (required): Kafka cluster endpoints used for election.
+   - `topic`, `group.id`, `client.id` (optional): default to values derived from `clusterId`/`nodeId` if omitted.
+   - Topic management parameters such as `topic.replication.factor`, `topic.partitions`, and `topic.retention.ms` can be overridden with the same prefix.
+   - Any additional Kafka client settings (security protocol, SASL/SSL options, timeouts, etc.) can be supplied via `automq.telemetry.s3.selector.kafka.<property>`.
+
+   The selector automatically creates the election topic (1 partition by default) and keeps a background consumer alive. When the leader stops, Kafka triggers a rebalance and another node immediately takes over without requiring shared storage.
+
+5. **Custom SPI-based Selectors**
+
+   The system supports custom node selection strategies through Java's ServiceLoader SPI mechanism.
+
+   ```properties
+   automq.telemetry.s3.selector.type=custom-type-name
+   # Additional custom parameters as needed
+   ```
+
+#### Custom Node Selection using SPI
+
+You can implement custom node selection strategies by implementing the `UploaderNodeSelectorProvider` interface and registering it using Java's ServiceLoader mechanism:
+
+1. **Implement the Provider Interface**
+
+   ```java
+   public class CustomSelectorProvider implements UploaderNodeSelectorProvider {
+       @Override
+       public String getType() {
+           return "custom-type"; // The selector type to use in configuration
+       }
+       
+       @Override
+       public UploaderNodeSelector createSelector(String clusterId, int nodeId, Map<String, String> config) {
+           // Create and return your custom selector implementation
+           return new CustomSelector(config);
+       }
+   }
+   
+   public class CustomSelector implements UploaderNodeSelector {
+       public CustomSelector(Map<String, String> config) {
+           // Initialize your selector with the configuration
+       }
+       
+       @Override
+       public boolean isPrimaryUploader() {
+           // Implement your custom logic
+           return /* your decision logic */;
+       }
+   }
+   ```
+
+2. **Register the Provider**
+
+   Create a file at `META-INF/services/com.automq.opentelemetry.exporter.s3.UploaderNodeSelectorProvider` containing the fully qualified class name of your provider:
+
+   ```
+   com.example.CustomSelectorProvider
+   ```
+
+3. **Configure the Custom Selector**
+
+   ```properties
+   automq.telemetry.exporter.s3.selector.type=custom-type
+   # Any additional parameters your custom selector needs
+   ```
+
+### Example Configurations
+
+#### Single Node Setup
+
+```properties
+automq.telemetry.exporter.uri=s3://accessKey:secretKey@metrics-bucket?endpoint=https://s3.amazonaws.com
+automq.telemetry.exporter.s3.cluster.id=my-cluster
+automq.telemetry.exporter.s3.node.id=1
+automq.telemetry.exporter.s3.primary.node=true
+automq.telemetry.exporter.s3.selector.type=static
+```
+
+#### Multi-Node Cluster with Node ID Selection
+
+```properties
+# Configuration for all nodes
+automq.telemetry.exporter.uri=s3://accessKey:secretKey@metrics-bucket?endpoint=https://s3.amazonaws.com
+automq.telemetry.exporter.s3.cluster.id=my-cluster
+automq.telemetry.exporter.s3.selector.type=nodeid
+
+# Node 1 (primary uploader)
+automq.telemetry.exporter.s3.node.id=1
+# Node-specific URI parameters
+# ?primaryNodeId=1
+
+# Node 2 
+automq.telemetry.exporter.s3.node.id=2
+```
+
+#### Multi-Node Cluster with File-Based Leader Election
+
+```properties
+# All nodes have the same configuration
+automq.telemetry.exporter.uri=s3://accessKey:secretKey@metrics-bucket?endpoint=https://s3.amazonaws.com&leaderFile=/path/to/shared/leader-file
+automq.telemetry.exporter.s3.cluster.id=my-cluster
+automq.telemetry.exporter.s3.selector.type=file
+# Each node has a unique ID
+# Node 1
+automq.telemetry.exporter.s3.node.id=1
+# Node 2
+# automq.telemetry.exporter.s3.node.id=2
+```
+
+### Advanced Configuration
+
+| Configuration | Description | Default Value |
+|---------------|-------------|---------------|
+| `automq.telemetry.exporter.interval.ms` | Export interval (milliseconds) | `60000` |
+| `automq.telemetry.exporter.otlp.protocol` | OTLP protocol | `grpc` |
+| `automq.telemetry.exporter.otlp.compression` | OTLP compression method | `none` |
+| `automq.telemetry.exporter.otlp.timeout.ms` | OTLP timeout (milliseconds) | `30000` |
+| `automq.telemetry.s3.cluster.id` | Cluster ID for S3 metrics | `automq-cluster` |
+| `automq.telemetry.s3.node.id` | Node ID for S3 metrics | `0` |
+| `automq.telemetry.s3.primary.node` | Whether this node should upload metrics | `false` |
+| `automq.telemetry.jmx.config.paths` | JMX config file paths (comma-separated) | Empty |
+| `automq.telemetry.metric.cardinality.limit` | Metric cardinality limit | `20000` |
+
+### JMX Metrics Configuration
+
+Define JMX metrics collection rules through YAML configuration files:
+
+```properties
+automq.telemetry.jmx.config.paths=/jmx-config.yaml,/kafka-jmx.yaml
+```
+
+#### Configuration File Requirements
+
+1. **Directory Requirements**:
+   - Configuration files must be placed in the project's classpath (e.g., `src/main/resources` directory)
+   - Support subdirectory structure, e.g., `/config/jmx-metrics.yaml`
+
+2. **Path Format**:
+   - Paths must start with `/` to indicate starting from classpath root
+   - Multiple configuration files separated by commas
+
+3. **File Format**:
+   - Use YAML format (`.yaml` or `.yml` extension)
+   - Filenames can be customized, meaningful names are recommended
+
+#### Recommended Directory Structure
+
+```
+src/main/resources/
+├── jmx-kafka-broker.yaml      # Kafka Broker metrics configuration
+├── jmx-kafka-consumer.yaml    # Kafka Consumer metrics configuration
+├── jmx-kafka-producer.yaml    # Kafka Producer metrics configuration
+└── config/
+    ├── custom-jmx.yaml        # Custom JMX metrics configuration
+    └── third-party-jmx.yaml   # Third-party component JMX configuration
+```
+
+JMX configuration file example (`jmx-config.yaml`):
+```yaml
+rules:
+  - bean: kafka.server:type=BrokerTopicMetrics,name=MessagesInPerSec
+    metricAttribute:
+      name: kafka_server_broker_topic_messages_in_per_sec
+      description: Messages in per second
+      unit: "1/s"
+    attributes:
+      - name: topic
+        value: topic
+```
+
+## Supported Metric Types
+
+### 1. JVM Metrics
+- Memory usage (heap memory, non-heap memory, memory pools)
+- CPU usage
+- Garbage collection statistics
+- Thread states
+
+### 2. Kafka Metrics
+Through Yammer metrics bridging, supports the following types of Kafka metrics:
+- `BytesInPerSec` - Bytes input per second
+- `BytesOutPerSec` - Bytes output per second  
+- `Size` - Log size (for identifying idle partitions)
+
+### 3. Custom Metrics
+Support creating custom metrics through OpenTelemetry API:
+- Counter
+- Gauge
+- Histogram
+- UpDownCounter
+
+## Best Practices
+
+### 1. Production Environment Configuration
+```properties
+# Service identification
+service.name=automq-kafka
+service.instance.id=${HOSTNAME}
+
+# Prometheus export
+automq.telemetry.exporter.uri=prometheus://0.0.0.0:9090
+
+# S3 Metrics export (optional)
+# automq.telemetry.exporter.uri=s3://access-key:secret-key@my-bucket.s3.amazonaws.com
+# automq.telemetry.s3.cluster.id=production-cluster
+# automq.telemetry.s3.node.id=${NODE_ID}
+# automq.telemetry.s3.primary.node=true (only for one node in the cluster)
+
+# Metric cardinality control
+automq.telemetry.metric.cardinality.limit=10000
+
+# JMX metrics (configure as needed)
+automq.telemetry.jmx.config.paths=/kafka-broker-jmx.yaml
+```
+
+### 2. Development Environment Configuration
+```properties
+# Local development
+service.name=automq-kafka-dev
+service.instance.id=local-dev
+
+# OTLP export to local Jaeger
+automq.telemetry.exporter.uri=otlp://localhost:4317
+automq.telemetry.exporter.interval.ms=10000
+```
+
+### 3. Resource Management
+- Set appropriate metric cardinality limits to avoid memory leaks
+- Call `shutdown()` method when application closes to release resources
+- Monitor exporter health status
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Metrics not exported**
+   - Check if `automq.telemetry.exporter.uri` configuration is correct
+   - Verify target endpoint is reachable
+   - Check error messages in logs
+
+2. **JMX metrics missing**
+   - Confirm JMX configuration file path is correct
+   - Check YAML configuration file format
+   - Verify JMX Bean exists
+
+3. **High memory usage**
+   - Lower `automq.telemetry.metric.cardinality.limit` value
+   - Check for high cardinality labels
+   - Consider increasing export interval
+
+### Logging Configuration
+
+Enable debug logging for more information:
+```properties
+logging.level.com.automq.opentelemetry=DEBUG
+logging.level.io.opentelemetry=INFO
+```
+
+## Dependencies
+
+- Java 8+
+- OpenTelemetry SDK 1.30+
+- Apache Commons Lang3
+- SLF4J logging framework
+
+## License
+
+This module is open source under the Apache License 2.0.
diff --git a/opentelemetry/build.gradle b/opentelemetry/build.gradle
new file mode 100644
index 0000000000..41d2394d4a
--- /dev/null
+++ b/opentelemetry/build.gradle
@@ -0,0 +1,153 @@
+plugins {
+  id 'application'
+  id 'checkstyle'
+  id('com.google.protobuf') version '0.9.4'
+}
+
+project(':opentelemetry') {
+  archivesBaseName="opentelemetry"
+}
+
+repositories {
+  mavenCentral()
+}
+
+dependencies {
+  // OpenTelemetry core dependencies
+  api libs.opentelemetryJava8
+  api libs.opentelemetryOshi
+  api libs.opentelemetrySdk
+  api libs.opentelemetrySdkMetrics
+  api libs.opentelemetryExporterLogging
+  api libs.opentelemetryExporterProm
+  api libs.opentelemetryExporterOTLP
+  api libs.opentelemetryJmx
+
+  // Logging dependencies
+  api libs.slf4jApi
+  api libs.slf4jBridge  // 添加 SLF4J Bridge 依赖
+  api libs.reload4j
+
+  api libs.commonLang
+
+  // Yammer metrics (for integration)
+  api 'com.yammer.metrics:metrics-core:2.2.0'
+
+  implementation(project(':s3stream')) {
+    exclude(group: 'io.opentelemetry', module: '*')
+    exclude(group: 'io.opentelemetry.instrumentation', module: '*')
+    exclude(group: 'io.opentelemetry.proto', module: '*')
+    exclude(group: 'io.netty', module: 'netty-tcnative-boringssl-static')
+    exclude(group: 'com.github.jnr', module: '*')
+    exclude(group: 'org.aspectj', module: '*')
+    exclude(group: 'net.java.dev.jna', module: '*')
+    exclude(group: 'net.sourceforge.argparse4j', module: '*')
+    exclude(group: 'com.bucket4j', module: '*')
+    exclude(group: 'com.yammer.metrics', module: '*')
+    exclude(group: 'com.github.spotbugs', module: '*')
+    exclude(group: 'software.amazon.awssdk', module: '*')
+    exclude(group: 'org.apache.kafka.shaded', module: '*')
+  }
+  implementation libs.nettyBuffer
+  implementation libs.nettyBuffer
+  implementation libs.jacksonDatabind
+  implementation libs.guava
+  implementation project(':clients')
+
+  // Test dependencies
+  testImplementation libs.junitJupiter
+  testImplementation libs.mockitoCore
+  testImplementation libs.slf4jReload4j
+
+  testRuntimeOnly libs.junitPlatformLanucher
+
+  implementation('io.opentelemetry:opentelemetry-sdk:1.40.0')
+  implementation("io.opentelemetry.semconv:opentelemetry-semconv:1.25.0-alpha")
+  implementation("io.opentelemetry.instrumentation:opentelemetry-runtime-telemetry-java8:2.6.0-alpha")
+  implementation('com.google.protobuf:protobuf-java:3.25.5')
+  implementation('org.xerial.snappy:snappy-java:1.1.10.5')
+
+  implementation('com.squareup.okhttp3:okhttp:4.12.0')
+  implementation('software.amazon.awssdk:http-auth-aws:2.29.26')
+  implementation('software.amazon.awssdk:sts:2.29.26')
+
+  //---- azure ----
+  implementation platform('com.azure:azure-sdk-bom:1.2.30')
+  implementation('com.azure:azure-identity')
+  implementation('com.azure:azure-core')
+  implementation('com.azure.resourcemanager:azure-resourcemanager-compute:2.48.0')
+  implementation('com.azure.resourcemanager:azure-resourcemanager-resources:2.48.0')
+  implementation('com.azure:azure-storage-blob')
+  implementation('com.azure:azure-storage-blob-batch')
+  implementation('com.azure:azure-security-keyvault-certificates')
+  implementation('com.azure:azure-security-keyvault-keys')
+  implementation('com.azure:azure-security-keyvault-secrets')
+}
+
+task createVersionFile() {
+  def receiptFile = file("$buildDir/kafka/$buildVersionFileName")
+  inputs.property "commitId", commitId
+  inputs.property "version", version
+  outputs.file receiptFile
+
+  doLast {
+    def data = [
+      commitId: commitId,
+      version: version,
+    ]
+
+    receiptFile.parentFile.mkdirs()
+    def content = data.entrySet().collect { "$it.key=$it.value" }.sort().join("\n")
+    receiptFile.setText(content, "ISO-8859-1")
+  }
+}
+
+jar {
+  dependsOn createVersionFile
+  from("$buildDir") {
+    include "kafka/$buildVersionFileName"
+  }
+}
+
+clean.doFirst {
+  delete "$buildDir/kafka/"
+}
+
+checkstyle {
+  configProperties=checkstyleConfigProperties("import-control-server.xml")
+}
+
+javadoc {
+  enabled=false
+}
+
+protobuf {
+  protoc {
+    // The artifact spec for the Protobuf Compiler
+    artifact = 'com.google.protobuf:protoc:3.25.5'
+  }
+
+  generateProtoTasks {
+    ofSourceSet('test').each { task ->
+      task.builtins {
+        java {}
+      }
+    }
+  }
+}
+
+sourceSets {
+  main {
+    java {
+      srcDirs 'build/generated/source/proto/main/java'
+    }
+  }
+  test {
+    proto {
+      srcDir 'src/test/resources/proto'
+    }
+    java {
+      srcDirs 'build/generated/source/proto/test/java'
+    }
+  }
+}
diff --git a/opentelemetry/src/main/java/com/automq/opentelemetry/AutoMQTelemetryManager.java b/opentelemetry/src/main/java/com/automq/opentelemetry/AutoMQTelemetryManager.java
new file mode 100644
index 0000000000..28608c52be
--- /dev/null
+++ b/opentelemetry/src/main/java/com/automq/opentelemetry/AutoMQTelemetryManager.java
@@ -0,0 +1,261 @@
+package com.automq.opentelemetry;
+
+import com.automq.opentelemetry.exporter.MetricsExporter;
+import com.automq.opentelemetry.exporter.MetricsExporterURI;
+import com.automq.opentelemetry.yammer.YammerMetricsReporter;
+import com.yammer.metrics.core.MetricsRegistry;
+import io.opentelemetry.api.OpenTelemetry;
+import io.opentelemetry.api.baggage.propagation.W3CBaggagePropagator;
+import io.opentelemetry.api.common.Attributes;
+import io.opentelemetry.api.common.AttributesBuilder;
+import io.opentelemetry.api.metrics.Meter;
+import io.opentelemetry.api.trace.propagation.W3CTraceContextPropagator;
+import io.opentelemetry.context.propagation.ContextPropagators;
+import io.opentelemetry.context.propagation.TextMapPropagator;
+import io.opentelemetry.instrumentation.jmx.engine.JmxMetricInsight;
+import io.opentelemetry.instrumentation.jmx.engine.MetricConfiguration;
+import io.opentelemetry.instrumentation.jmx.yaml.RuleParser;
+import io.opentelemetry.instrumentation.runtimemetrics.java8.Cpu;
+import io.opentelemetry.instrumentation.runtimemetrics.java8.GarbageCollector;
+import io.opentelemetry.instrumentation.runtimemetrics.java8.MemoryPools;
+import io.opentelemetry.instrumentation.runtimemetrics.java8.Threads;
+import io.opentelemetry.sdk.OpenTelemetrySdk;
+import io.opentelemetry.sdk.metrics.SdkMeterProvider;
+import io.opentelemetry.sdk.metrics.SdkMeterProviderBuilder;
+import io.opentelemetry.sdk.metrics.export.MetricReader;
+import io.opentelemetry.sdk.metrics.internal.SdkMeterProviderUtil;
+import io.opentelemetry.sdk.resources.Resource;
+import org.apache.commons.lang3.tuple.Pair;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.slf4j.bridge.SLF4JBridgeHandler;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Properties;
+
+/**
+ * The main manager for AutoMQ telemetry.
+ * This class is responsible for initializing, configuring, and managing the lifecycle of all
+ * telemetry components, including the OpenTelemetry SDK, metric exporters, and various metric sources.
+ */
+public class AutoMQTelemetryManager {
+    private static final Logger LOGGER = LoggerFactory.getLogger(AutoMQTelemetryManager.class);
+    
+    // Singleton instance support
+    private static volatile AutoMQTelemetryManager instance;
+    private static final Object lock = new Object();
+
+    private final TelemetryConfig config;
+    private final List<MetricReader> metricReaders = new ArrayList<>();
+    private final List<AutoCloseable> autoCloseableList;
+    private OpenTelemetrySdk openTelemetrySdk;
+    private YammerMetricsReporter yammerReporter;
+
+    /**
+     * Constructs a new Telemetry Manager with the given configuration.
+     *
+     * @param props Configuration properties.
+     */
+    public AutoMQTelemetryManager(Properties props) {
+        this.config = new TelemetryConfig(props);
+        this.autoCloseableList = new ArrayList<>();
+        // Redirect JUL from OpenTelemetry SDK to SLF4J for unified logging
+        SLF4JBridgeHandler.removeHandlersForRootLogger();
+        SLF4JBridgeHandler.install();
+    }
+
+    /**
+     * Gets the singleton instance of AutoMQTelemetryManager.
+     * Returns null if no instance has been initialized.
+     *
+     * @return the singleton instance, or null if not initialized
+     */
+    public static AutoMQTelemetryManager getInstance() {
+        return instance;
+    }
+
+    /**
+     * Initializes the singleton instance with the given configuration.
+     * This method should be called before any other components try to access the instance.
+     *
+     * @param props Configuration properties
+     * @return the initialized singleton instance
+     */
+    public static AutoMQTelemetryManager initializeInstance(Properties props) {
+        if (instance == null) {
+            synchronized (lock) {
+                if (instance == null) {
+                    instance = new AutoMQTelemetryManager(props);
+                    instance.init();
+                    LOGGER.info("AutoMQTelemetryManager singleton instance initialized");
+                }
+            }
+        }
+        return instance;
+    }
+
+    /**
+     * Shuts down the singleton instance and releases all resources.
+     */
+    public static void shutdownInstance() {
+        if (instance != null) {
+            synchronized (lock) {
+                if (instance != null) {
+                    instance.shutdown();
+                    instance = null;
+                    LOGGER.info("AutoMQTelemetryManager singleton instance shutdown");
+                }
+            }
+        }
+    }
+
+    /**
+     * Initializes the telemetry system. This method sets up the OpenTelemetry SDK,
+     * configures exporters, and registers JVM and JMX metrics.
+     */
+    public void init() {
+        SdkMeterProvider meterProvider = buildMeterProvider();
+
+        this.openTelemetrySdk = OpenTelemetrySdk.builder()
+                .setMeterProvider(meterProvider)
+                .setPropagators(ContextPropagators.create(TextMapPropagator.composite(
+                        W3CTraceContextPropagator.getInstance(), W3CBaggagePropagator.getInstance())))
+                .buildAndRegisterGlobal();
+
+        // Register JVM and JMX metrics
+        registerJvmMetrics(openTelemetrySdk);
+        registerJmxMetrics(openTelemetrySdk);
+
+        LOGGER.info("AutoMQ Telemetry Manager initialized successfully.");
+    }
+
+    private SdkMeterProvider buildMeterProvider() {
+        AttributesBuilder attrsBuilder = Attributes.builder()
+                .put(TelemetryConstants.SERVICE_NAME_KEY, config.getServiceName())
+                .put(TelemetryConstants.SERVICE_INSTANCE_ID_KEY, config.getInstanceId())
+                .put(TelemetryConstants.HOST_NAME_KEY, config.getHostName())
+                // Add attributes for Prometheus compatibility
+                .put(TelemetryConstants.PROMETHEUS_JOB_KEY, config.getServiceName())
+                .put(TelemetryConstants.PROMETHEUS_INSTANCE_KEY, config.getInstanceId());
+
+        for (Pair<String, String> label : config.getBaseLabels()) {
+            attrsBuilder.put(label.getKey(), label.getValue());
+        }
+
+        Resource resource = Resource.getDefault().merge(Resource.create(attrsBuilder.build()));
+        SdkMeterProviderBuilder meterProviderBuilder = SdkMeterProvider.builder().setResource(resource);
+
+        // Configure exporters from URI
+        MetricsExporterURI exporterURI = buildMetricsExporterURI(config);
+        for (MetricsExporter exporter : exporterURI.getMetricsExporters()) {
+            MetricReader reader = exporter.asMetricReader();
+            metricReaders.add(reader);
+            SdkMeterProviderUtil.registerMetricReaderWithCardinalitySelector(meterProviderBuilder, reader,
+                    instrumentType -> config.getMetricCardinalityLimit());
+        }
+
+        return meterProviderBuilder.build();
+    }
+
+    protected MetricsExporterURI buildMetricsExporterURI(TelemetryConfig config) {
+        return MetricsExporterURI.parse(config);
+    }
+
+    private void registerJvmMetrics(OpenTelemetry openTelemetry) {
+        autoCloseableList.addAll(MemoryPools.registerObservers(openTelemetry));
+        autoCloseableList.addAll(Cpu.registerObservers(openTelemetry));
+        autoCloseableList.addAll(GarbageCollector.registerObservers(openTelemetry));
+        autoCloseableList.addAll(Threads.registerObservers(openTelemetry));
+        LOGGER.info("JVM metrics registered.");
+    }
+
+    private void registerJmxMetrics(OpenTelemetry openTelemetry) {
+        List<String> jmxConfigPaths = config.getJmxConfigPaths();
+        if (jmxConfigPaths.isEmpty()) {
+            LOGGER.info("No JMX metric config paths provided, skipping JMX metrics registration.");
+            return;
+        }
+
+        JmxMetricInsight jmxMetricInsight = JmxMetricInsight.createService(openTelemetry, config.getExporterIntervalMs());
+        MetricConfiguration metricConfig = new MetricConfiguration();
+
+        for (String path : jmxConfigPaths) {
+            try (InputStream ins = this.getClass().getResourceAsStream(path)) {
+                if (ins == null) {
+                    LOGGER.error("JMX config file not found in classpath: {}", path);
+                    continue;
+                }
+                RuleParser parser = RuleParser.get();
+                parser.addMetricDefsTo(metricConfig, ins, path);
+            } catch (Exception e) {
+                LOGGER.error("Failed to parse JMX config file: {}", path, e);
+            }
+        }
+
+        jmxMetricInsight.start(metricConfig);
+        // JmxMetricInsight doesn't implement Closeable, but we can create a wrapper
+
+        LOGGER.info("JMX metrics registered with config paths: {}", jmxConfigPaths);
+    }
+
+    /**
+     * Starts reporting metrics from a given Yammer MetricsRegistry.
+     *
+     * @param registry The Yammer registry to bridge metrics from.
+     */
+    public void startYammerMetricsReporter(MetricsRegistry registry) {
+        if (this.openTelemetrySdk == null) {
+            throw new IllegalStateException("TelemetryManager is not initialized. Call init() first.");
+        }
+        if (registry == null) {
+            LOGGER.warn("Yammer MetricsRegistry is null, skipping reporter start.");
+            return;
+        }
+        this.yammerReporter = new YammerMetricsReporter(registry);
+        this.yammerReporter.start(getMeter());
+    }
+
+    public void shutdown() {
+        autoCloseableList.forEach(autoCloseable -> {
+            try {
+                autoCloseable.close();
+            } catch (Exception e) {
+                LOGGER.error("Failed to close auto closeable", e);
+            }
+        });
+        metricReaders.forEach(metricReader -> {
+            metricReader.forceFlush();
+            try {
+                metricReader.close();
+            } catch (IOException e) {
+                LOGGER.error("Failed to close metric reader", e);
+            }
+        });
+        if (openTelemetrySdk != null) {
+            openTelemetrySdk.close();
+        }
+    }
+
+    /**
+     *  get YammerMetricsReporter instance.
+     * @return The YammerMetricsReporter instance.
+     */
+    public YammerMetricsReporter getYammerReporter() {
+        return this.yammerReporter;
+    }
+
+    /**
+     * Gets the default meter from the initialized OpenTelemetry SDK.
+     *
+     * @return The meter instance.
+     */
+    public Meter getMeter() {
+        if (this.openTelemetrySdk == null) {
+            throw new IllegalStateException("TelemetryManager is not initialized. Call init() first.");
+        }
+        return this.openTelemetrySdk.getMeter(TelemetryConstants.TELEMETRY_SCOPE_NAME);
+    }
+}
diff --git a/opentelemetry/src/main/java/com/automq/opentelemetry/TelemetryConfig.java b/opentelemetry/src/main/java/com/automq/opentelemetry/TelemetryConfig.java
new file mode 100644
index 0000000000..dbee1f2fd6
--- /dev/null
+++ b/opentelemetry/src/main/java/com/automq/opentelemetry/TelemetryConfig.java
@@ -0,0 +1,185 @@
+package com.automq.opentelemetry;
+
+import com.automq.stream.s3.operator.BucketURI;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.tuple.Pair;
+
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+/**
+ * Provides strongly-typed access to telemetry configuration properties.
+ * This class centralizes configuration handling for the telemetry module.
+ */
+public class TelemetryConfig {
+
+    private final Properties props;
+
+    public TelemetryConfig(Properties props) {
+        this.props = props != null ? props : new Properties();
+    }
+
+    public String getExporterUri() {
+        return props.getProperty(TelemetryConstants.EXPORTER_URI_KEY, "");
+    }
+
+    public long getExporterIntervalMs() {
+        return Long.parseLong(props.getProperty(TelemetryConstants.EXPORTER_INTERVAL_MS_KEY, "60000"));
+    }
+
+    public String getOtlpProtocol() {
+        return props.getProperty(TelemetryConstants.EXPORTER_OTLP_PROTOCOL_KEY, "grpc");
+    }
+
+    public String getOtlpCompression() {
+        return props.getProperty(TelemetryConstants.EXPORTER_OTLP_COMPRESSION_KEY, "none");
+    }
+
+    public long getOtlpTimeoutMs() {
+        return Long.parseLong(props.getProperty(TelemetryConstants.EXPORTER_OTLP_TIMEOUT_MS_KEY, "30000"));
+    }
+
+    public String getServiceName() {
+        return props.getProperty(TelemetryConstants.SERVICE_NAME_KEY, "unknown-service");
+    }
+
+    public String getInstanceId() {
+        return props.getProperty(TelemetryConstants.SERVICE_INSTANCE_ID_KEY, "unknown-instance");
+    }
+
+    public List<String> getJmxConfigPaths() {
+        String paths = props.getProperty(TelemetryConstants.JMX_CONFIG_PATH_KEY, "");
+        if (paths.isEmpty()) {
+            return Collections.emptyList();
+        }
+        return Stream.of(paths.split(","))
+                .map(String::trim)
+                .filter(s -> !s.isEmpty())
+                .collect(Collectors.toList());
+    }
+
+    public int getMetricCardinalityLimit() {
+        return Integer.parseInt(props.getProperty(TelemetryConstants.METRIC_CARDINALITY_LIMIT_KEY,
+                String.valueOf(TelemetryConstants.DEFAULT_METRIC_CARDINALITY_LIMIT)));
+    }
+
+    public String getHostName() {
+        try {
+            return InetAddress.getLocalHost().getHostName();
+        } catch (UnknownHostException e) {
+            return "unknown-host";
+        }
+    }
+
+    /**
+     * A placeholder for custom labels which might be passed in a different way.
+     * In a real scenario, this might come from a properties prefix.
+     */
+    public List<Pair<String, String>> getBaseLabels() {
+        // This part is hard to abstract without a clear config pattern.
+        // Assuming for now it's empty. The caller can extend this class
+        // or the manager can have a method to add more labels.
+        String baseLabels = props.getProperty(TelemetryConstants.TELEMETRY_METRICS_BASE_LABELS_CONFIG);
+        if (StringUtils.isBlank(baseLabels)) {
+            return Collections.emptyList();
+        }
+        List<Pair<String, String>> labels = new ArrayList<>();
+        for (String label : baseLabels.split(",")) {
+            String[] kv = label.split("=");
+            if (kv.length != 2) {
+                continue;
+            }
+            labels.add(Pair.of(kv[0], kv[1]));
+        }
+        return labels;
+    }
+
+    public BucketURI getMetricsBucket() {
+        String metricsBucket = props.getProperty(TelemetryConstants.S3_BUCKET, "");
+        if (StringUtils.isNotBlank(metricsBucket)) {
+            List<BucketURI> bucketList = BucketURI.parseBuckets(metricsBucket);
+            if (!bucketList.isEmpty()) {
+                return bucketList.get(0);
+            }
+        }
+        return null;
+    }
+    
+    /**
+     * Get a property value with a default.
+     * 
+     * @param key The property key.
+     * @param defaultValue The default value if the property is not set.
+     * @return The property value or default value.
+     */
+    public String getProperty(String key, String defaultValue) {
+        return props.getProperty(key, defaultValue);
+    }
+
+    /**
+     * Returns properties whose keys start with the given prefix.
+     * The returned map contains keys with the prefix removed.
+     *
+     * @param prefix the property key prefix to look for
+     * @return a map of keys (without the prefix) to their values
+     */
+    public Map<String, String> getPropertiesWithPrefix(String prefix) {
+        if (prefix == null || prefix.isEmpty()) {
+            return Collections.emptyMap();
+        }
+
+        Map<String, String> result = new java.util.HashMap<>();
+        for (String key : props.stringPropertyNames()) {
+            if (key.startsWith(prefix)) {
+                String trimmedKey = key.substring(prefix.length());
+                if (!trimmedKey.isEmpty()) {
+                    result.put(trimmedKey, props.getProperty(key));
+                }
+            }
+        }
+        return result;
+    }
+
+    /**
+     * Get the S3 cluster ID.
+     * 
+     * @return The S3 cluster ID.
+     */
+    public String getS3ClusterId() {
+        return props.getProperty(TelemetryConstants.S3_CLUSTER_ID_KEY, "automq-cluster");
+    }
+    
+    /**
+     * Get the S3 node ID.
+     * 
+     * @return The S3 node ID.
+     */
+    public int getS3NodeId() {
+        return Integer.parseInt(props.getProperty(TelemetryConstants.S3_NODE_ID_KEY, "0"));
+    }
+    
+    /**
+     * Check if this node is a primary S3 metrics uploader.
+     * 
+     * @return True if this node is a primary uploader, false otherwise.
+     */
+    public boolean isS3PrimaryNode() {
+        return Boolean.parseBoolean(props.getProperty(TelemetryConstants.S3_PRIMARY_NODE_KEY, "false"));
+    }
+    
+    /**
+     * Get the S3 metrics selector type.
+     * 
+     * @return The selector type, defaults to "static".
+     */
+    public String getS3SelectorType() {
+        return props.getProperty(TelemetryConstants.S3_SELECTOR_TYPE_KEY, "static");
+    }
+}
diff --git a/opentelemetry/src/main/java/com/automq/opentelemetry/TelemetryConstants.java b/opentelemetry/src/main/java/com/automq/opentelemetry/TelemetryConstants.java
new file mode 100644
index 0000000000..3a39a6f68c
--- /dev/null
+++ b/opentelemetry/src/main/java/com/automq/opentelemetry/TelemetryConstants.java
@@ -0,0 +1,100 @@
+package com.automq.opentelemetry;
+
+import io.opentelemetry.api.common.AttributeKey;
+
+/**
+ * Constants for telemetry, including configuration keys, attribute keys, and default values.
+ */
+public class TelemetryConstants {
+
+    //################################################################
+    // Service and Resource Attributes
+    //################################################################
+    public static final String SERVICE_NAME_KEY = "service.name";
+    public static final String SERVICE_INSTANCE_ID_KEY = "service.instance.id";
+    public static final String HOST_NAME_KEY = "host.name";
+    public static final String TELEMETRY_SCOPE_NAME = "automq_for_kafka";
+
+    //################################################################
+    // Exporter Configuration Keys
+    //################################################################
+    /**
+     * The URI for configuring metrics exporters. e.g. prometheus://localhost:9090, otlp://localhost:4317
+     */
+    public static final String EXPORTER_URI_KEY = "automq.telemetry.exporter.uri";
+    /**
+     * The export interval in milliseconds.
+     */
+    public static final String EXPORTER_INTERVAL_MS_KEY = "automq.telemetry.exporter.interval.ms";
+    /**
+     * The OTLP protocol, can be "grpc" or "http/protobuf".
+     */
+    public static final String EXPORTER_OTLP_PROTOCOL_KEY = "automq.telemetry.exporter.otlp.protocol";
+    /**
+     * The OTLP compression method, can be "gzip" or "none".
+     */
+    public static final String EXPORTER_OTLP_COMPRESSION_KEY = "automq.telemetry.exporter.otlp.compression";
+    /**
+     * The timeout for OTLP exporter in milliseconds.
+     */
+    public static final String EXPORTER_OTLP_TIMEOUT_MS_KEY = "automq.telemetry.exporter.otlp.timeout.ms";
+    /**
+     * A comma-separated list of JMX configuration file paths (classpath resources).
+     */
+    public static final String JMX_CONFIG_PATH_KEY = "automq.telemetry.jmx.config.paths";
+
+    //################################################################
+    // Metric Configuration
+    //################################################################
+    /**
+     * The cardinality limit for any single metric.
+     */
+    public static final String METRIC_CARDINALITY_LIMIT_KEY = "automq.telemetry.metric.cardinality.limit";
+    public static final int DEFAULT_METRIC_CARDINALITY_LIMIT = 20000;
+
+    public static final String TELEMETRY_METRICS_BASE_LABELS_CONFIG = "automq.telemetry.metrics.base.labels";
+    public static final String TELEMETRY_METRICS_BASE_LABELS_DOC = "The base labels that will be added to all metrics. The format is key1=value1,key2=value2.";
+
+
+    //################################################################
+    // Prometheus specific Attributes, for compatibility
+    //################################################################
+    public static final String PROMETHEUS_JOB_KEY = "job";
+    public static final String PROMETHEUS_INSTANCE_KEY = "instance";
+
+    //################################################################
+    // Custom Kafka-related Attribute Keys
+    //################################################################
+    public static final AttributeKey<Long> STREAM_ID_KEY = AttributeKey.longKey("streamId");
+    public static final AttributeKey<Long> START_OFFSET_KEY = AttributeKey.longKey("startOffset");
+    public static final AttributeKey<Long> END_OFFSET_KEY = AttributeKey.longKey("endOffset");
+    
+    //################################################################
+    // S3 Metrics Exporter Configuration
+    //################################################################
+    
+    public static final String S3_BUCKET = "automq.telemetry.s3.bucket";
+    public static final String S3_BUCKETS_DOC = "The buckets url with format 0@s3://$bucket?region=$region. \n" +
+            "the full url format for s3 is 0@s3://$bucket?region=$region[&endpoint=$endpoint][&pathStyle=$enablePathStyle][&authType=$authType][&accessKey=$accessKey][&secretKey=$secretKey][&checksumAlgorithm=$checksumAlgorithm]" +
+            "- pathStyle: true|false. The object storage access path style. When using MinIO, it should be set to true.\n" +
+            "- authType: instance|static. When set to instance, it will use instance profile to auth. When set to static, it will get accessKey and secretKey from the url or from system environment KAFKA_S3_ACCESS_KEY/KAFKA_S3_SECRET_KEY.";
+
+
+    /**
+     * The cluster ID for S3 metrics.
+     */
+    public static final String S3_CLUSTER_ID_KEY = "automq.telemetry.s3.cluster.id";
+    /**
+     * The node ID for S3 metrics.
+     */
+    public static final String S3_NODE_ID_KEY = "automq.telemetry.s3.node.id";
+    /**
+     * Whether this node is the primary uploader for S3 metrics.
+     */
+    public static final String S3_PRIMARY_NODE_KEY = "automq.telemetry.s3.primary.node";
+    /**
+     * The selector type for S3 metrics uploader node selection.
+     * Values include: static, nodeid, file, or custom SPI implementations.
+     */
+    public static final String S3_SELECTOR_TYPE_KEY = "automq.telemetry.s3.selector.type";
+}
diff --git a/opentelemetry/src/main/java/com/automq/opentelemetry/common/OTLPCompressionType.java b/opentelemetry/src/main/java/com/automq/opentelemetry/common/OTLPCompressionType.java
new file mode 100644
index 0000000000..4833159149
--- /dev/null
+++ b/opentelemetry/src/main/java/com/automq/opentelemetry/common/OTLPCompressionType.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2025, AutoMQ HK Limited.
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.automq.opentelemetry.common;
+
+public enum OTLPCompressionType {
+    GZIP("gzip"),
+    NONE("none");
+
+    private final String type;
+
+    OTLPCompressionType(String type) {
+        this.type = type;
+    }
+
+    public String getType() {
+        return type;
+    }
+
+    public static OTLPCompressionType fromString(String type) {
+        for (OTLPCompressionType compressionType : OTLPCompressionType.values()) {
+            if (compressionType.getType().equalsIgnoreCase(type)) {
+                return compressionType;
+            }
+        }
+        throw new IllegalArgumentException("Invalid OTLP compression type: " + type);
+    }
+}
diff --git a/opentelemetry/src/main/java/com/automq/opentelemetry/common/OTLPProtocol.java b/opentelemetry/src/main/java/com/automq/opentelemetry/common/OTLPProtocol.java
new file mode 100644
index 0000000000..69f3cd1918
--- /dev/null
+++ b/opentelemetry/src/main/java/com/automq/opentelemetry/common/OTLPProtocol.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2025, AutoMQ HK Limited.
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.automq.opentelemetry.common;
+
+public enum OTLPProtocol {
+    GRPC("grpc"),
+    HTTP("http");
+
+    private final String protocol;
+
+    OTLPProtocol(String protocol) {
+        this.protocol = protocol;
+    }
+
+    public String getProtocol() {
+        return protocol;
+    }
+
+    public static OTLPProtocol fromString(String protocol) {
+        for (OTLPProtocol otlpProtocol : OTLPProtocol.values()) {
+            if (otlpProtocol.getProtocol().equalsIgnoreCase(protocol)) {
+                return otlpProtocol;
+            }
+        }
+        throw new IllegalArgumentException("Invalid OTLP protocol: " + protocol);
+    }
+}
diff --git a/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/MetricsExporter.java b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/MetricsExporter.java
new file mode 100644
index 0000000000..c243ec18c0
--- /dev/null
+++ b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/MetricsExporter.java
@@ -0,0 +1,10 @@
+package com.automq.opentelemetry.exporter;
+
+import io.opentelemetry.sdk.metrics.export.MetricReader;
+
+/**
+ * An interface for metrics exporters, which can be converted to an OpenTelemetry MetricReader.
+ */
+public interface MetricsExporter {
+    MetricReader asMetricReader();
+}
diff --git a/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/MetricsExporterType.java b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/MetricsExporterType.java
new file mode 100644
index 0000000000..4e8883aeef
--- /dev/null
+++ b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/MetricsExporterType.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright 2025, AutoMQ HK Limited.
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.automq.opentelemetry.exporter;
+
+public enum MetricsExporterType {
+    OTLP("otlp"),
+    PROMETHEUS("prometheus"),
+    REMOTE_WRITE("rw"),
+    S3("s3");
+
+    private final String type;
+
+    MetricsExporterType(String type) {
+        this.type = type;
+    }
+
+    public String getType() {
+        return type;
+    }
+
+    public static MetricsExporterType fromString(String type) {
+        for (MetricsExporterType exporterType : MetricsExporterType.values()) {
+            if (exporterType.getType().equalsIgnoreCase(type)) {
+                return exporterType;
+            }
+        }
+        throw new IllegalArgumentException("Invalid metrics exporter type: " + type);
+    }
+}
diff --git a/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/MetricsExporterURI.java b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/MetricsExporterURI.java
new file mode 100644
index 0000000000..a5fa9f0438
--- /dev/null
+++ b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/MetricsExporterURI.java
@@ -0,0 +1,241 @@
+package com.automq.opentelemetry.exporter;
+
+import com.automq.opentelemetry.TelemetryConfig;
+import com.automq.opentelemetry.exporter.remotewrite.RemoteWriteMetricsExporter;
+import com.automq.stream.s3.operator.BucketURI;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.tuple.Pair;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+
+/**
+ * Parses the exporter URI and creates the corresponding MetricsExporter instances.
+ */
+public class MetricsExporterURI {
+    private static final Logger LOGGER = LoggerFactory.getLogger(MetricsExporterURI.class);
+
+    private final List<MetricsExporter> metricsExporters;
+
+    private MetricsExporterURI(List<MetricsExporter> metricsExporters) {
+        this.metricsExporters = metricsExporters != null ? metricsExporters : new ArrayList<>();
+    }
+
+    public List<MetricsExporter> getMetricsExporters() {
+        return metricsExporters;
+    }
+
+    public static MetricsExporterURI parse(TelemetryConfig config) {
+        String uriStr = config.getExporterUri();
+        LOGGER.info("Parsing metrics exporter URI: {}", uriStr);
+        if (StringUtils.isBlank(uriStr)) {
+            LOGGER.info("Metrics exporter URI is not configured, no metrics will be exported.");
+            return new MetricsExporterURI(Collections.emptyList());
+        }
+
+        // Support multiple exporters separated by comma
+        String[] exporterUris = uriStr.split(",");
+        if (exporterUris.length == 0) {
+            return new MetricsExporterURI(Collections.emptyList());
+        }
+
+        List<MetricsExporter> exporters = new ArrayList<>();
+        for (String uri : exporterUris) {
+            if (StringUtils.isBlank(uri)) {
+                continue;
+            }
+            MetricsExporter exporter = parseExporter(config, uri.trim());
+            if (exporter != null) {
+                exporters.add(exporter);
+            }
+        }
+        return new MetricsExporterURI(exporters);
+    }
+
+    public static MetricsExporter parseExporter(TelemetryConfig config, String uriStr) {
+        try {
+            URI uri = new URI(uriStr);
+            String type = uri.getScheme();
+            if (StringUtils.isBlank(type)) {
+                LOGGER.error("Invalid metrics exporter URI: {}, exporter scheme is missing", uriStr);
+                return null;
+            }
+
+            Map<String, List<String>> queries = parseQueryParameters(uri);
+            return parseExporter(config, type, queries, uri);
+        } catch (Exception e) {
+            LOGGER.warn("Parse metrics exporter URI {} failed", uriStr, e);
+            return null;
+        }
+    }
+
+    public static MetricsExporter parseExporter(TelemetryConfig config, String type,
+                                              Map<String, List<String>> queries, URI uri) {
+        MetricsExporterType exporterType = MetricsExporterType.fromString(type);
+        switch (exporterType) {
+            case PROMETHEUS:
+                return buildPrometheusExporter(config, queries, uri);
+            case OTLP:
+                return buildOtlpExporter(config, queries, uri);
+            case S3:
+                return buildS3MetricsExporter(config, queries, uri);
+            case REMOTE_WRITE:
+                return buildRemoteWriteExporter(config.getExporterIntervalMs(), uri.toString());
+            default:
+                LOGGER.warn("Unsupported metrics exporter type: {}", type);
+                return null;
+        }
+    }
+
+    public static MetricsExporter buildRemoteWriteExporter(long intervalMs, String uriStr) {
+        return new RemoteWriteMetricsExporter(intervalMs, uriStr);
+    }
+
+    private static MetricsExporter buildPrometheusExporter(TelemetryConfig config,
+                                                         Map<String, List<String>> queries, URI uri) {
+        // Use query parameters if available, otherwise fall back to URI authority or config defaults
+        String host = getStringFromQuery(queries, "host", uri.getHost());
+        if (StringUtils.isBlank(host)) {
+            host = "localhost";
+        }
+
+        int port = uri.getPort();
+        if (port <= 0) {
+            String portStr = getStringFromQuery(queries, "port", null);
+            if (StringUtils.isNotBlank(portStr)) {
+                try {
+                    port = Integer.parseInt(portStr);
+                } catch (NumberFormatException e) {
+                    LOGGER.warn("Invalid port in query parameters: {}, using default", portStr);
+                    port = 9090;
+                }
+            } else {
+                port = 9090;
+            }
+        }
+
+        return new PrometheusMetricsExporter(host, port, config.getBaseLabels());
+    }
+
+    private static MetricsExporter buildOtlpExporter(TelemetryConfig config,
+                                                     Map<String, List<String>> queries, URI uri) {
+        // Get endpoint from query parameters or construct from URI
+        String endpoint = getStringFromQuery(queries, "endpoint", null);
+        if (StringUtils.isBlank(endpoint)) {
+            endpoint = uri.getScheme() + "://" + uri.getAuthority();
+        }
+
+        // Get protocol from query parameters or config
+        String protocol = getStringFromQuery(queries, "protocol", config.getOtlpProtocol());
+
+        // Get compression from query parameters or config
+        String compression = getStringFromQuery(queries, "compression", config.getOtlpCompression());
+
+        // Get timeout from query parameters or config
+        long timeoutMs = config.getOtlpTimeoutMs();
+        String timeoutStr = getStringFromQuery(queries, "timeout", null);
+        if (StringUtils.isNotBlank(timeoutStr)) {
+            try {
+                timeoutMs = Long.parseLong(timeoutStr);
+            } catch (NumberFormatException e) {
+                LOGGER.warn("Invalid timeout in query parameters: {}, using config default", timeoutStr);
+            }
+        }
+
+        return new OTLPMetricsExporter(config.getExporterIntervalMs(), endpoint, protocol, compression, timeoutMs);
+    }
+
+    private static Map<String, List<String>> parseQueryParameters(URI uri) {
+        Map<String, List<String>> queries = new HashMap<>();
+        String query = uri.getQuery();
+        if (StringUtils.isNotBlank(query)) {
+            String[] pairs = query.split("&");
+            for (String pair : pairs) {
+                String[] keyValue = pair.split("=", 2);
+                if (keyValue.length == 2) {
+                    String key = keyValue[0];
+                    String value = keyValue[1];
+                    queries.computeIfAbsent(key, k -> new ArrayList<>()).add(value);
+                }
+            }
+        }
+        return queries;
+    }
+
+    private static String getStringFromQuery(Map<String, List<String>> queries, String key, String defaultValue) {
+        List<String> values = queries.get(key);
+        if (values != null && !values.isEmpty()) {
+            return values.get(0);
+        }
+        return defaultValue;
+    }
+    
+    private static MetricsExporter buildS3MetricsExporter(TelemetryConfig config,
+                                                         Map<String, List<String>> queries, URI uri) {
+        LOGGER.info("Creating S3 metrics exporter from URI: {}", uri);
+        
+        // Get S3 configuration from config and query parameters
+        String clusterId = config.getS3ClusterId();
+        int nodeId = config.getS3NodeId();
+        int intervalMs = (int)config.getExporterIntervalMs();
+        BucketURI metricsBucket = config.getMetricsBucket();
+        
+        if (metricsBucket == null) {
+            LOGGER.error("S3 bucket configuration is missing for S3 metrics exporter");
+            return null;
+        }
+        
+        List<Pair<String, String>> baseLabels = config.getBaseLabels();
+        
+        // Create node selector based on configuration
+        com.automq.opentelemetry.exporter.s3.UploaderNodeSelector nodeSelector;
+        
+        // Get the selector type from config
+        String selectorTypeString = config.getS3SelectorType();
+        
+        // Convert query parameters to a simple map for the factory
+        Map<String, String> selectorConfig = new HashMap<>();
+        for (Map.Entry<String, List<String>> entry : queries.entrySet()) {
+            if (!entry.getValue().isEmpty()) {
+                selectorConfig.put(entry.getKey(), entry.getValue().get(0));
+            }
+        }
+        
+        // Add isPrimaryUploader from config if not in query parameters
+        if (!selectorConfig.containsKey("isPrimaryUploader")) {
+            selectorConfig.put("isPrimaryUploader", String.valueOf(config.isS3PrimaryNode()));
+        }
+
+        // Merge selector-specific configuration from worker properties using prefix
+        Map<String, String> selectorProps = config.getPropertiesWithPrefix("automq.telemetry.s3.selector.");
+        String normalizedSelectorType = selectorTypeString == null ? "" : selectorTypeString.toLowerCase(Locale.ROOT);
+        for (Map.Entry<String, String> entry : selectorProps.entrySet()) {
+            String key = entry.getKey();
+            if (normalizedSelectorType.length() > 0 && key.toLowerCase(Locale.ROOT).startsWith(normalizedSelectorType + ".")) {
+                key = key.substring(normalizedSelectorType.length() + 1);
+            }
+            if (key.isEmpty() || "type".equalsIgnoreCase(key)) {
+                continue;
+            }
+            selectorConfig.putIfAbsent(key, entry.getValue());
+        }
+
+        // Use the factory to create a node selector with the enum-based approach
+        nodeSelector = com.automq.opentelemetry.exporter.s3.UploaderNodeSelectorFactory
+            .createSelector(selectorTypeString, clusterId, nodeId, selectorConfig);
+        
+        LOGGER.info("S3 metrics configuration: clusterId={}, nodeId={}, bucket={}, selectorType={}", 
+                   clusterId, nodeId, metricsBucket, selectorTypeString);
+        
+        // Create the S3MetricsExporterAdapter with appropriate configuration
+        return new com.automq.opentelemetry.exporter.s3.S3MetricsExporterAdapter(
+            clusterId, nodeId, intervalMs, metricsBucket, baseLabels, nodeSelector);
+    }
+}
diff --git a/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/OTLPMetricsExporter.java b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/OTLPMetricsExporter.java
new file mode 100644
index 0000000000..000ab183f9
--- /dev/null
+++ b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/OTLPMetricsExporter.java
@@ -0,0 +1,83 @@
+package com.automq.opentelemetry.exporter;
+
+import com.automq.opentelemetry.common.OTLPCompressionType;
+import com.automq.opentelemetry.common.OTLPProtocol;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.time.Duration;
+
+import io.opentelemetry.exporter.otlp.http.metrics.OtlpHttpMetricExporter;
+import io.opentelemetry.exporter.otlp.http.metrics.OtlpHttpMetricExporterBuilder;
+import io.opentelemetry.exporter.otlp.metrics.OtlpGrpcMetricExporter;
+import io.opentelemetry.exporter.otlp.metrics.OtlpGrpcMetricExporterBuilder;
+import io.opentelemetry.sdk.metrics.export.MetricReader;
+import io.opentelemetry.sdk.metrics.export.PeriodicMetricReader;
+import io.opentelemetry.sdk.metrics.export.PeriodicMetricReaderBuilder;
+
+public class OTLPMetricsExporter implements MetricsExporter {
+    private static final Logger LOGGER = LoggerFactory.getLogger(OTLPMetricsExporter.class);
+    private final long intervalMs;
+    private final String endpoint;
+    private final OTLPProtocol protocol;
+    private final OTLPCompressionType compression;
+    private final long timeoutMs;
+    // Default timeout for OTLP exporters
+    private static final long DEFAULT_EXPORTER_TIMEOUT_MS = 30000;
+    
+
+    public OTLPMetricsExporter(long intervalMs, String endpoint, String protocol, String compression, long timeoutMs) {
+        if (StringUtils.isBlank(endpoint) || "null".equals(endpoint)) {
+            throw new IllegalArgumentException("OTLP endpoint is required");
+        }
+        this.intervalMs = intervalMs;
+        this.endpoint = endpoint;
+        this.protocol = OTLPProtocol.fromString(protocol);
+        this.compression = OTLPCompressionType.fromString(compression);
+        this.timeoutMs = timeoutMs > 0 ? timeoutMs : DEFAULT_EXPORTER_TIMEOUT_MS;
+        LOGGER.info("OTLPMetricsExporter initialized with endpoint: {}, protocol: {}, compression: {}, intervalMs: {}",
+                endpoint, protocol, compression, intervalMs);
+    }
+
+    public String endpoint() {
+        return endpoint;
+    }
+
+    public OTLPProtocol protocol() {
+        return protocol;
+    }
+
+    public OTLPCompressionType compression() {
+        return compression;
+    }
+
+    public long intervalMs() {
+        return intervalMs;
+    }
+
+    @Override
+    public MetricReader asMetricReader() {
+        PeriodicMetricReaderBuilder builder;
+        switch (protocol) {
+            case GRPC:
+                OtlpGrpcMetricExporterBuilder otlpExporterBuilder = OtlpGrpcMetricExporter.builder()
+                        .setEndpoint(endpoint)
+                        .setCompression(compression.getType())
+                        .setTimeout(Duration.ofMillis(timeoutMs));
+                builder = PeriodicMetricReader.builder(otlpExporterBuilder.build());
+                break;
+            case HTTP:
+                OtlpHttpMetricExporterBuilder otlpHttpExporterBuilder = OtlpHttpMetricExporter.builder()
+                        .setEndpoint(endpoint)
+                        .setCompression(compression.getType())
+                        .setTimeout(Duration.ofMillis(timeoutMs));
+                builder = PeriodicMetricReader.builder(otlpHttpExporterBuilder.build());
+                break;
+            default:
+                throw new IllegalArgumentException("Unsupported OTLP protocol: " + protocol);
+        }
+
+        return builder.setInterval(Duration.ofMillis(intervalMs)).build();
+    }
+}
diff --git a/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/PrometheusMetricsExporter.java b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/PrometheusMetricsExporter.java
new file mode 100644
index 0000000000..801fe568f9
--- /dev/null
+++ b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/PrometheusMetricsExporter.java
@@ -0,0 +1,48 @@
+package com.automq.opentelemetry.exporter;
+
+import com.automq.opentelemetry.TelemetryConstants;
+import org.apache.commons.lang3.tuple.Pair;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import io.opentelemetry.exporter.prometheus.PrometheusHttpServer;
+import io.opentelemetry.sdk.metrics.export.MetricReader;
+
+public class PrometheusMetricsExporter implements MetricsExporter {
+    private static final Logger LOGGER = LoggerFactory.getLogger(PrometheusMetricsExporter.class);
+    private final String host;
+    private final int port;
+    private final Set<String> baseLabelKeys;
+
+    public PrometheusMetricsExporter(String host, int port, List<Pair<String, String>> baseLabels) {
+        if (host == null || host.isEmpty()) {
+            throw new IllegalArgumentException("Illegal Prometheus host");
+        }
+        if (port <= 0) {
+            throw new IllegalArgumentException("Illegal Prometheus port");
+        }
+        this.host = host;
+        this.port = port;
+        this.baseLabelKeys = baseLabels.stream().map(Pair::getKey).collect(Collectors.toSet());
+        LOGGER.info("PrometheusMetricsExporter initialized with host: {}, port: {}", host, port);
+    }
+
+    @Override
+    public MetricReader asMetricReader() {
+        return PrometheusHttpServer.builder()
+            .setHost(host)
+            .setPort(port)
+            // This filter is to align with the original behavior, allowing only specific resource attributes
+            // to be converted to prometheus labels.
+            .setAllowedResourceAttributesFilter(resourceAttributeKey ->
+                TelemetryConstants.PROMETHEUS_JOB_KEY.equals(resourceAttributeKey)
+                    || TelemetryConstants.PROMETHEUS_INSTANCE_KEY.equals(resourceAttributeKey)
+                    || TelemetryConstants.HOST_NAME_KEY.equals(resourceAttributeKey)
+                    || baseLabelKeys.contains(resourceAttributeKey))
+            .build();
+    }
+}
diff --git a/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/PromConsts.java b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/PromConsts.java
new file mode 100644
index 0000000000..5d437b249b
--- /dev/null
+++ b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/PromConsts.java
@@ -0,0 +1,14 @@
+package com.automq.opentelemetry.exporter.remotewrite;
+
+public class PromConsts {
+    public static final String NAME_LABEL = "__name__";
+    public static final String PROM_JOB_LABEL = "job";
+    public static final String PROM_INSTANCE_LABEL = "instance";
+    public static final String METRIC_NAME_SUFFIX_SUM = "_sum";
+    public static final String METRIC_NAME_SUFFIX_COUNT = "_count";
+    public static final String METRIC_NAME_SUFFIX_BUCKET = "_bucket";
+    public static final String LABEL_NAME_LE = "le";
+    public static final String LABEL_NAME_QUANTILE = "quantile";
+    public static final String LABEL_VALUE_INF = "+Inf";
+    public static final String AWS_PROMETHEUS_SERVICE_NAME = "aps";
+}
diff --git a/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/PromLabels.java b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/PromLabels.java
new file mode 100644
index 0000000000..0e302983e9
--- /dev/null
+++ b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/PromLabels.java
@@ -0,0 +1,73 @@
+package com.automq.opentelemetry.exporter.remotewrite;
+
+import com.automq.opentelemetry.telemetry.RemoteWrite;
+import io.opentelemetry.api.common.Attributes;
+import io.opentelemetry.sdk.metrics.data.MetricData;
+import io.opentelemetry.semconv.ResourceAttributes;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.TreeMap;
+
+public class PromLabels {
+    // sorted by key in alphabetical order
+    private final Map<String, String> kvPairs;
+    private int hashcode;
+
+    private PromLabels(Map<String, String> kvPairs) {
+        this.kvPairs = kvPairs;
+    }
+
+    public static PromLabels fromOTLPMetric(String name, MetricData metricData, Attributes attr) {
+        return fromOTLPMetric(name, metricData, attr, Collections.emptyMap());
+    }
+
+    public static PromLabels fromOTLPMetric(String name, MetricData metricData, Attributes attr, Map<String, String> extra) {
+        Map<String, String> labels = new TreeMap<>();
+        labels.put(PromConsts.NAME_LABEL, name);
+        metricData.getResource().getAttributes().forEach((k, v) -> {
+            if (k.equals(ResourceAttributes.SERVICE_NAME)) {
+                labels.put(PromConsts.PROM_JOB_LABEL, v.toString());
+            } else if (k.equals(ResourceAttributes.SERVICE_INSTANCE_ID)) {
+                labels.put(PromConsts.PROM_INSTANCE_LABEL, v.toString());
+            } else {
+                labels.put(PromUtils.normalizeLabel(k.toString()), v.toString());
+            }
+        });
+        attr.forEach((k, v) -> labels.put(PromUtils.normalizeLabel(k.getKey()), v.toString()));
+        extra.forEach((k, v) -> labels.put(PromUtils.normalizeLabel(k), v));
+        return new PromLabels(labels);
+    }
+
+    public List<RemoteWrite.Label> toLabels() {
+        List<RemoteWrite.Label> labels = new ArrayList<>();
+        kvPairs.forEach((k, v) -> labels.add(RemoteWrite.Label.newBuilder().setName(k).setValue(v).build()));
+        return labels;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o)
+            return true;
+        if (o == null || getClass() != o.getClass())
+            return false;
+        PromLabels other = (PromLabels) o;
+        return Objects.equals(kvPairs, other.kvPairs);
+    }
+
+    @Override
+    public int hashCode() {
+        int result = this.hashcode;
+        if (result == 0) {
+            result = 1;
+            result = result * 1000003;
+            result ^= kvPairs.hashCode();
+            this.hashcode = result;
+        }
+
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/PromTimeSeries.java b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/PromTimeSeries.java
new file mode 100644
index 0000000000..dd0cbe90c8
--- /dev/null
+++ b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/PromTimeSeries.java
@@ -0,0 +1,30 @@
+package com.automq.opentelemetry.exporter.remotewrite;
+
+
+import com.automq.opentelemetry.telemetry.RemoteWrite;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+
+public class PromTimeSeries {
+    private final List<RemoteWrite.Label> labels;
+    private final List<RemoteWrite.Sample> samples;
+
+    public PromTimeSeries(List<RemoteWrite.Label> labels) {
+        this.labels = labels;
+        this.samples = new ArrayList<>();
+    }
+
+    public void addSample(RemoteWrite.Sample sample) {
+        samples.add(sample);
+    }
+
+    public RemoteWrite.TimeSeries build() {
+        samples.sort(Comparator.comparingLong(RemoteWrite.Sample::getTimestamp));
+        return RemoteWrite.TimeSeries.newBuilder()
+            .addAllLabels(labels)
+            .addAllSamples(samples)
+            .build();
+    }
+}
diff --git a/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/PromUtils.java b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/PromUtils.java
new file mode 100644
index 0000000000..d548f7ce74
--- /dev/null
+++ b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/PromUtils.java
@@ -0,0 +1,31 @@
+package com.automq.opentelemetry.exporter.remotewrite;
+
+import com.automq.opentelemetry.exporter.s3.PrometheusUtils;
+import io.opentelemetry.sdk.metrics.data.MetricData;
+import io.opentelemetry.sdk.metrics.data.MetricDataType;
+
+public class PromUtils {
+
+    public static String normalizeMetricName(MetricData metricData) {
+        return PrometheusUtils.mapMetricsName(metricData.getName(), metricData.getUnit(), isCounter(metricData), isGauge(metricData));
+    }
+
+    private static boolean isCounter(MetricData metricData) {
+        if (metricData.getType() == MetricDataType.DOUBLE_SUM) {
+            return metricData.getDoubleSumData().isMonotonic();
+        }
+        if (metricData.getType() == MetricDataType.LONG_SUM) {
+            return metricData.getLongSumData().isMonotonic();
+        }
+        return false;
+    }
+
+    private static boolean isGauge(MetricData metricData) {
+        return metricData.getType() == MetricDataType.LONG_GAUGE || metricData.getType() == MetricDataType.DOUBLE_GAUGE;
+    }
+
+    public static String normalizeLabel(String labelKey) {
+        return labelKey.replaceAll("[^a-zA-Z0-9_]", "_");
+    }
+
+}
diff --git a/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/RemoteWriteExporter.java b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/RemoteWriteExporter.java
new file mode 100644
index 0000000000..b0731ffce0
--- /dev/null
+++ b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/RemoteWriteExporter.java
@@ -0,0 +1,201 @@
+package com.automq.opentelemetry.exporter.remotewrite;
+
+import com.automq.opentelemetry.telemetry.RemoteWrite;
+import io.opentelemetry.sdk.common.CompletableResultCode;
+import io.opentelemetry.sdk.metrics.InstrumentType;
+import io.opentelemetry.sdk.metrics.data.AggregationTemporality;
+import io.opentelemetry.sdk.metrics.data.MetricData;
+import io.opentelemetry.sdk.metrics.export.MetricExporter;
+import okhttp3.Call;
+import okhttp3.Callback;
+import okhttp3.MediaType;
+import okhttp3.OkHttpClient;
+import okhttp3.Request;
+import okhttp3.RequestBody;
+import okhttp3.Response;
+import okhttp3.ResponseBody;
+import org.jetbrains.annotations.NotNull;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.xerial.snappy.Snappy;
+
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLSocketFactory;
+import javax.net.ssl.TrustManager;
+import javax.net.ssl.X509TrustManager;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+public class RemoteWriteExporter implements MetricExporter {
+    private static final Logger LOGGER = LoggerFactory.getLogger(RemoteWriteExporter.class);
+    private final OkHttpClient client;
+    private final String endpoint;
+    private final int maxBatchSize;
+
+    public RemoteWriteExporter(RemoteWriteURI uri) {
+        if (uri == null) {
+            throw new IllegalArgumentException("Remote write URI is required");
+        }
+        this.endpoint = uri.endpoint();
+        this.maxBatchSize = uri.maxBatchSize();
+        OkHttpClient.Builder clientBuilder = new OkHttpClient.Builder();
+        if (uri.auth() != null) {
+            try {
+                clientBuilder.addNetworkInterceptor(uri.auth().createInterceptor());
+            } catch (IllegalArgumentException e) {
+                LOGGER.error("Failed to create remote write authenticator", e);
+            }
+        }
+        if (uri.insecureSkipVerify()) {
+            skipTLSVerification(clientBuilder);
+        }
+        this.client = clientBuilder.build();
+    }
+
+    private void skipTLSVerification(OkHttpClient.Builder builder) {
+        try {
+            // Create a trust manager that does not validate certificate chains
+            final TrustManager[] trustAllCerts = new TrustManager[]{
+                new X509TrustManager() {
+
+                    @Override
+                    public void checkClientTrusted(java.security.cert.X509Certificate[] chain, String authType) {
+                    }
+
+                    @Override
+                    public void checkServerTrusted(java.security.cert.X509Certificate[] chain, String authType) {
+                    }
+
+                    @Override
+                    public java.security.cert.X509Certificate[] getAcceptedIssuers() {
+                        return new java.security.cert.X509Certificate[]{};
+                    }
+                }
+            };
+
+            // Install the all-trusting trust manager
+            final SSLContext sslContext = SSLContext.getInstance("SSL");
+            sslContext.init(null, trustAllCerts, new java.security.SecureRandom());
+            // Create a ssl socket factory with the all-trusting manager
+            final SSLSocketFactory sslSocketFactory = sslContext.getSocketFactory();
+            builder.sslSocketFactory(sslSocketFactory, (X509TrustManager) trustAllCerts[0]);
+            // Trust all hostnames
+            builder.hostnameVerifier((hostname, session) -> true);
+            LOGGER.warn("TLS verification is disabled");
+        } catch (Exception e) {
+            LOGGER.error("Failed to skip TLS verification", e);
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Override
+    public CompletableResultCode export(@NotNull Collection<MetricData> collection) {
+        LOGGER.info("Exporting remote writes to remote write endpoint");
+        LOGGER.info("Endpoint: {}", endpoint);
+        LOGGER.info("collection size: {}", collection.size());
+        LOGGER.info("collection: {}", collection);
+        RemoteWriteRequestMarshaller marshaller = new RemoteWriteRequestMarshaller();
+        Collection<RemoteWrite.TimeSeries> timeSeries;
+        CompletableResultCode code;
+        try {
+            timeSeries = marshaller.fromMetrics(collection);
+            code = sendBatchRequests(timeSeries);
+        } catch (Exception e) {
+            LOGGER.error("Failed to export metrics", e);
+            return CompletableResultCode.ofFailure();
+        }
+        return code;
+    }
+
+    private CompletableResultCode sendBatchRequests(Collection<RemoteWrite.TimeSeries> timeSeries) {
+        LOGGER.info("Sending batch requests");
+        LOGGER.info("timeSeries: {}", timeSeries);
+        long currentSize = 0;
+        List<CompletableResultCode> codes = new ArrayList<>();
+        RemoteWrite.WriteRequest.Builder requestBuilder = RemoteWrite.WriteRequest.newBuilder();
+        for (RemoteWrite.TimeSeries ts : timeSeries) {
+            long batchSize = ts.getSerializedSize();
+            if (currentSize + batchSize > this.maxBatchSize) {
+                CompletableResultCode code = new CompletableResultCode();
+                codes.add(code);
+                try {
+                    sendRequest(requestBuilder.build(), code);
+                } catch (IOException e) {
+                    LOGGER.error("Failed to send remote write request", e);
+                    code.fail();
+                }
+                requestBuilder = RemoteWrite.WriteRequest.newBuilder();
+                currentSize = 0;
+            } else {
+                requestBuilder.addTimeseries(ts);
+                currentSize += batchSize;
+            }
+        }
+        if (currentSize > 0) {
+            CompletableResultCode code = new CompletableResultCode();
+            codes.add(code);
+            try {
+                sendRequest(requestBuilder.build(), code);
+            } catch (IOException e) {
+                LOGGER.error("Failed to send remote write request", e);
+                code.fail();
+            }
+        }
+        return CompletableResultCode.ofAll(codes);
+    }
+
+    private void sendRequest(RemoteWrite.WriteRequest writeRequest, CompletableResultCode code) throws IOException {
+        LOGGER.info("Sending remote write request");
+        byte[] compressed = Snappy.compress(writeRequest.toByteArray());
+        MediaType mediaType = MediaType.parse("application/x-protobuf");
+        RequestBody body = RequestBody.create(compressed, mediaType);
+        Request request = new Request.Builder()
+            .url(endpoint)
+            .addHeader("Content-Encoding", "snappy")
+            .addHeader("User-Agent", "automq-exporter/1.1.0")
+            .addHeader("X-Prometheus-Remote-Write-Version", "0.1.0")
+            .post(body)
+            .build();
+        
+        LOGGER.info("Sending remote write request:{},{}", request.body(), request.url());
+        client.newCall(request).enqueue(new Callback() {
+
+            @Override
+            public void onFailure(@NotNull Call call, @NotNull IOException e) {
+                LOGGER.error("Failed to send remote write request", e);
+                code.fail();
+            }
+
+            @Override
+            public void onResponse(@NotNull Call call, @NotNull Response response) throws IOException {
+                try (ResponseBody body = response.body()) {
+                    LOGGER.info("Received remote write response:{}", response.body().string());
+                    if (response.code() >= 200 && response.code() <= 299) {
+                        code.succeed();
+                        return;
+                    }
+                    LOGGER.error("Remote write request not success, code: {}, resp: {}", response.code(),
+                        body == null ? "" : body.string());
+                    code.fail();
+                }
+            }
+        });
+    }
+
+    @Override
+    public CompletableResultCode flush() {
+        return CompletableResultCode.ofSuccess();
+    }
+
+    @Override
+    public CompletableResultCode shutdown() {
+        return CompletableResultCode.ofSuccess();
+    }
+
+    @Override
+    public AggregationTemporality getAggregationTemporality(@NotNull InstrumentType type) {
+        return AggregationTemporality.CUMULATIVE;
+    }
+}
diff --git a/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/RemoteWriteMetricsExporter.java b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/RemoteWriteMetricsExporter.java
new file mode 100644
index 0000000000..20e7017436
--- /dev/null
+++ b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/RemoteWriteMetricsExporter.java
@@ -0,0 +1,42 @@
+package com.automq.opentelemetry.exporter.remotewrite;
+
+import com.automq.opentelemetry.exporter.MetricsExporter;
+import io.opentelemetry.sdk.metrics.export.MetricReader;
+import io.opentelemetry.sdk.metrics.export.PeriodicMetricReader;
+import io.opentelemetry.sdk.metrics.export.PeriodicMetricReaderBuilder;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.time.Duration;
+
+public class RemoteWriteMetricsExporter implements MetricsExporter {
+    private static final Logger LOGGER = LoggerFactory.getLogger(RemoteWriteMetricsExporter.class);
+    private final long intervalMs;
+    private final RemoteWriteURI remoteWriteURI;
+
+    public RemoteWriteMetricsExporter(long intervalMs, String remoteWriteURIStr) {
+        if (StringUtils.isBlank(remoteWriteURIStr)) {
+            throw new IllegalArgumentException("Remote write URI is required");
+        }
+        this.intervalMs = intervalMs;
+        this.remoteWriteURI = RemoteWriteURI.parse(remoteWriteURIStr);
+        LOGGER.info("RemoteWriteMetricsExporter initialized with remoteWriteURI: {}, intervalMs: {}",
+            remoteWriteURI, intervalMs);
+    }
+
+    public long getIntervalMs() {
+        return intervalMs;
+    }
+
+    public RemoteWriteURI getRemoteWriteURI() {
+        return remoteWriteURI;
+    }
+
+    @Override
+    public MetricReader asMetricReader() {
+        RemoteWriteExporter remoteWriteExporter = new RemoteWriteExporter(remoteWriteURI);
+        PeriodicMetricReaderBuilder builder = PeriodicMetricReader.builder(remoteWriteExporter);
+        return builder.setInterval(Duration.ofMillis(intervalMs)).build();
+    }
+}
diff --git a/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/RemoteWriteRequestMarshaller.java b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/RemoteWriteRequestMarshaller.java
new file mode 100644
index 0000000000..fd246800a4
--- /dev/null
+++ b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/RemoteWriteRequestMarshaller.java
@@ -0,0 +1,131 @@
+package com.automq.opentelemetry.exporter.remotewrite;
+
+import com.automq.opentelemetry.telemetry.RemoteWrite;
+import io.opentelemetry.sdk.metrics.data.DoublePointData;
+import io.opentelemetry.sdk.metrics.data.HistogramPointData;
+import io.opentelemetry.sdk.metrics.data.LongPointData;
+import io.opentelemetry.sdk.metrics.data.MetricData;
+import io.opentelemetry.sdk.metrics.data.SummaryPointData;
+import io.opentelemetry.sdk.metrics.data.ValueAtQuantile;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+
+public class RemoteWriteRequestMarshaller {
+    private final Map<PromLabels, PromTimeSeries> timeSeriesMap = new HashMap<>();
+
+    public Collection<RemoteWrite.TimeSeries> fromMetrics(Collection<MetricData> metrics) {
+        for (MetricData metric : metrics) {
+            switch (metric.getType()) {
+                case LONG_GAUGE:
+                    addLongGauge(metric);
+                    break;
+                case DOUBLE_GAUGE:
+                    addDoubleGauge(metric);
+                    break;
+                case LONG_SUM:
+                    addLongSum(metric);
+                    break;
+                case DOUBLE_SUM:
+                    addDoubleSum(metric);
+                    break;
+                case SUMMARY:
+                    addSummary(metric);
+                    break;
+                case HISTOGRAM:
+                    addHistogram(metric);
+                    break;
+                case EXPONENTIAL_HISTOGRAM:
+                    throw new UnsupportedOperationException("Unsupported metric type: " + metric.getType());
+                default:
+                    break;
+            }
+        }
+        return timeSeriesMap.values().stream().map(PromTimeSeries::build).toList();
+    }
+
+    private void addLongGauge(MetricData metricData) {
+        String baseName = PromUtils.normalizeMetricName(metricData);
+        for (LongPointData data : metricData.getLongGaugeData().getPoints()) {
+            PromLabels labels = PromLabels.fromOTLPMetric(baseName, metricData, data.getAttributes());
+            addSample(labels, data.getValue(), TimeUnit.NANOSECONDS.toMillis(data.getEpochNanos()));
+        }
+    }
+
+    private void addDoubleGauge(MetricData metricData) {
+        String baseName = PromUtils.normalizeMetricName(metricData);
+        for (DoublePointData data : metricData.getDoubleGaugeData().getPoints()) {
+            PromLabels labels = PromLabels.fromOTLPMetric(baseName, metricData, data.getAttributes());
+            addSample(labels, data.getValue(), TimeUnit.NANOSECONDS.toMillis(data.getEpochNanos()));
+        }
+    }
+
+    private void addLongSum(MetricData metricData) {
+        String baseName = PromUtils.normalizeMetricName(metricData);
+        for (LongPointData data : metricData.getLongSumData().getPoints()) {
+            PromLabels labels = PromLabels.fromOTLPMetric(baseName, metricData, data.getAttributes());
+            addSample(labels, data.getValue(), TimeUnit.NANOSECONDS.toMillis(data.getEpochNanos()));
+        }
+    }
+
+    private void addDoubleSum(MetricData metricData) {
+        String baseName = PromUtils.normalizeMetricName(metricData);
+        for (DoublePointData data : metricData.getDoubleSumData().getPoints()) {
+            PromLabels labels = PromLabels.fromOTLPMetric(baseName, metricData, data.getAttributes());
+            addSample(labels, data.getValue(), TimeUnit.NANOSECONDS.toMillis(data.getEpochNanos()));
+        }
+    }
+
+    private void addSummary(MetricData metricData) {
+        String baseName = PromUtils.normalizeMetricName(metricData);
+        for (SummaryPointData data : metricData.getSummaryData().getPoints()) {
+            // add sum metric
+            PromLabels labels = PromLabels.fromOTLPMetric(baseName + PromConsts.METRIC_NAME_SUFFIX_SUM, metricData, data.getAttributes());
+            addSample(labels, data.getSum(), TimeUnit.NANOSECONDS.toMillis(data.getEpochNanos()));
+
+            // add count metric
+            labels = PromLabels.fromOTLPMetric(baseName + PromConsts.METRIC_NAME_SUFFIX_COUNT, metricData, data.getAttributes());
+            addSample(labels, data.getCount(), TimeUnit.NANOSECONDS.toMillis(data.getEpochNanos()));
+
+            // add quantile metrics
+            for (ValueAtQuantile quantileData : data.getValues()) {
+                labels = PromLabels.fromOTLPMetric(baseName, metricData, data.getAttributes(),
+                    Map.of(PromConsts.LABEL_NAME_QUANTILE, Double.toString(quantileData.getQuantile())));
+                addSample(labels, data.getSum(), TimeUnit.NANOSECONDS.toMillis(data.getEpochNanos()));
+            }
+        }
+    }
+
+    public void addHistogram(MetricData metricData) {
+        String baseName = PromUtils.normalizeMetricName(metricData);
+        for (HistogramPointData data : metricData.getHistogramData().getPoints()) {
+            // add sum metric
+            PromLabels labels = PromLabels.fromOTLPMetric(baseName + PromConsts.METRIC_NAME_SUFFIX_SUM, metricData, data.getAttributes());
+            addSample(labels, data.getSum(), TimeUnit.NANOSECONDS.toMillis(data.getEpochNanos()));
+
+            // add count metric
+            labels = PromLabels.fromOTLPMetric(baseName + PromConsts.METRIC_NAME_SUFFIX_COUNT, metricData, data.getAttributes());
+            addSample(labels, data.getCount(), TimeUnit.NANOSECONDS.toMillis(data.getEpochNanos()));
+
+            // add bucket metrics
+            for (int i = 0; i < data.getBoundaries().size() && i < data.getCounts().size(); i++) {
+                labels = PromLabels.fromOTLPMetric(baseName + PromConsts.METRIC_NAME_SUFFIX_BUCKET, metricData, data.getAttributes(),
+                    Map.of(PromConsts.LABEL_NAME_LE, Double.toString(data.getBoundaries().get(i))));
+                addSample(labels, data.getCounts().get(i), TimeUnit.NANOSECONDS.toMillis(data.getEpochNanos()));
+            }
+            labels = PromLabels.fromOTLPMetric(baseName + PromConsts.METRIC_NAME_SUFFIX_BUCKET, metricData, data.getAttributes(),
+                Map.of(PromConsts.LABEL_NAME_LE, PromConsts.LABEL_VALUE_INF));
+            addSample(labels, data.getCount(), TimeUnit.NANOSECONDS.toMillis(data.getEpochNanos()));
+        }
+    }
+
+    private void addSample(PromLabels labels, double value, long timestampMillis) {
+        PromTimeSeries timeSeries = timeSeriesMap.computeIfAbsent(labels, k -> new PromTimeSeries(labels.toLabels()));
+        timeSeries.addSample(RemoteWrite.Sample.newBuilder()
+            .setValue(value)
+            .setTimestamp(timestampMillis)
+            .build());
+    }
+}
diff --git a/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/RemoteWriteURI.java b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/RemoteWriteURI.java
new file mode 100644
index 0000000000..248ae6803d
--- /dev/null
+++ b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/RemoteWriteURI.java
@@ -0,0 +1,148 @@
+package com.automq.opentelemetry.exporter.remotewrite;
+
+import com.automq.opentelemetry.exporter.remotewrite.auth.AuthType;
+import com.automq.opentelemetry.exporter.remotewrite.auth.AwsSigV4Auth;
+import com.automq.opentelemetry.exporter.remotewrite.auth.AzureADAuth;
+import com.automq.opentelemetry.exporter.remotewrite.auth.BasicAuth;
+import com.automq.opentelemetry.exporter.remotewrite.auth.BearerTokenAuth;
+import com.automq.opentelemetry.exporter.remotewrite.auth.RemoteWriteAuth;
+import com.automq.stream.s3.operator.BucketURI;
+import com.automq.stream.utils.URIUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * The remote write URI format:
+ *
+ * <p> 1. Basic Auth: rw://?endpoint=${endpoint}&auth=basic&username=${username}&password=${password}[&header_${headerKey}=${headerValue}]
+ * <p> 2. AWS SigV4:
+ * <ul>
+ *     <li> With AK/SK: rw://?endpoint=${endpoint}&auth=sigv4&region=${region}&accessKey=${ak}&secretKey=${sk}[&header_${headerKey}=${headerValue}]
+ *     <li> With InstanceProfile: rw://?endpoint=${endpoint}&auth=sigv4&region=${region}[&header_${headerKey}=${headerValue}]
+ * </ul>
+ * <p> 3. Bear Token:
+ * <ul>
+ *     <li> rw://?endpoint=${endpoint}&auth=bearer&token=${token}[&header_${headerKey}=${headerValue}]
+ *     <li> rw://?endpoint=${endpoint}&auth=bearer&token=${token}&insecureSkipVerify=true[&header_${headerKey}=${headerValue}]
+ * </ul>
+ * <p> 4. Azure AD:
+ *  * <ul>
+ *  *     <li> With managed identity: rw://?endpoint=${endpoint}&auth=azuread&cloud=${cloud}&clientId=${clientId}[&header_${headerKey}=${headerValue}]
+ *  *     <li> With oauth: rw://?endpoint=${endpoint}&auth=azuread&cloud=${cloud}&clientId=${clientId}&clientSecret=${clientSecret}&tenantId=${tenantId}[&header_${headerKey}=${headerValue}]
+ *  * </ul>
+ *
+ * @param endpoint remote write endpoint
+ * @param insecureSkipVerify whether to skip SSL verification
+ * @param auth remote write auth
+ * @param maxBatchSize max batch size
+ */
+public record RemoteWriteURI(String endpoint, boolean insecureSkipVerify, RemoteWriteAuth auth, int maxBatchSize) {
+    private static final Logger LOGGER = LoggerFactory.getLogger(RemoteWriteURI.class);
+    private static final int DEFAULT_MAX_BATCH_SIZE = 3000000;
+    private static final String DEFAULT_AUTH_TYPE = "no_auth";
+    private static final String ENDPOINT_KEY = "endpoint";
+    private static final String AUTH_TYPE_KEY = "auth";
+    private static final String USERNAME_KEY = "username";
+    private static final String PASSWORD_KEY = "password";
+    private static final String REGION_KEY = "region";
+    private static final String TOKEN_KEY = "token";
+    private static final String INSECURE_SKIP_VERIFY_KEY = "insecureSkipVerify";
+    private static final String MAX_BATCH_SIZE_KEY = "maxBatchSize";
+    private static final String HEADER_PREFIX = "header_";
+    private static final String CLOUD_KEY = "cloud";
+    private static final String CLIENT_ID_KEY = "clientId";
+    private static final String CLIENT_SECRET_KEY = "clientSecret";
+    private static final String TENANT_ID_KEY = "tenantId";
+
+    public RemoteWriteURI {
+        if (!validate(endpoint, auth, maxBatchSize)) {
+            throw new IllegalArgumentException("Illegal remote write uri");
+        }
+    }
+
+    private boolean validate(String endpoint, RemoteWriteAuth auth, int maxBatchSize) {
+        if (StringUtils.isBlank(endpoint)) {
+            LOGGER.error("Remote write endpoint should not be empty");
+            return false;
+        }
+        if (auth != null && !auth.validate()) {
+            LOGGER.error("Remote write auth config validation failed");
+            return false;
+        }
+        if (maxBatchSize <= 0) {
+            LOGGER.error("Remote write maxBatchSize should be positive");
+            return false;
+        }
+        return true;
+    }
+
+    public static RemoteWriteURI parse(String uriStr) {
+        try {
+            URI uri = new URI(uriStr);
+            Map<String, List<String>> queries = URIUtils.splitQuery(uri);
+            String endpoint = URIUtils.getString(queries, ENDPOINT_KEY, "");
+            RemoteWriteAuth remoteWriteAuth = parseAuth(queries);
+            boolean insecureSkipVerify = Boolean.parseBoolean(URIUtils.getString(queries, INSECURE_SKIP_VERIFY_KEY, "false"));
+            int maxBatchSize = Integer.parseInt(URIUtils.getString(queries, MAX_BATCH_SIZE_KEY, String.valueOf(DEFAULT_MAX_BATCH_SIZE)));
+            return new RemoteWriteURI(endpoint, insecureSkipVerify, remoteWriteAuth, maxBatchSize);
+        } catch (URISyntaxException e) {
+            LOGGER.error("Invalid remote write URI: {}", uriStr, e);
+            throw new IllegalArgumentException("Invalid remote write URI " + uriStr);
+        }
+    }
+
+    private static RemoteWriteAuth parseAuth(Map<String, List<String>> queries) {
+        String authTypeStr = URIUtils.getString(queries, AUTH_TYPE_KEY, DEFAULT_AUTH_TYPE);
+        if (authTypeStr.equals(DEFAULT_AUTH_TYPE)) {
+            return null;
+        }
+        AuthType authType = AuthType.fromName(authTypeStr);
+        if (authType == null) {
+            LOGGER.error("Invalid auth type: {}, supported are: {}", authTypeStr, AuthType.getNames());
+            throw new IllegalArgumentException("Invalid auth type " + authTypeStr);
+        }
+        Map<String, String> headers = getHeaders(queries);
+        switch (authType) {
+            case BASIC:
+                String username = URIUtils.getString(queries, USERNAME_KEY, "");
+                String password = URIUtils.getString(queries, PASSWORD_KEY, "");
+                return new BasicAuth(username, password, headers);
+            case SIG_V4:
+                String region = URIUtils.getString(queries, REGION_KEY, "");
+                String accessKey = URIUtils.getString(queries, BucketURI.ACCESS_KEY_KEY, "");
+                String secretKey = URIUtils.getString(queries, BucketURI.SECRET_KEY_KEY, "");
+                return new AwsSigV4Auth(region, accessKey, secretKey, headers);
+            case BEARER:
+                String token = URIUtils.getString(queries, TOKEN_KEY, "");
+                return new BearerTokenAuth(token, headers);
+            case AZURE_AD:
+                String cloud = URIUtils.getString(queries, CLOUD_KEY, "");
+                String clientId = URIUtils.getString(queries, CLIENT_ID_KEY, "");
+                String clientSecret = URIUtils.getString(queries, CLIENT_SECRET_KEY, "");
+                String tenantId = URIUtils.getString(queries, TENANT_ID_KEY, "");
+                return new AzureADAuth(cloud, clientId, clientSecret, tenantId, headers);
+            default:
+                throw new IllegalArgumentException("Unsupported auth type " + authType);
+        }
+    }
+
+    private static Map<String, String> getHeaders(Map<String, List<String>> queries) {
+        Map<String, String> headers = new HashMap<>();
+        for (Map.Entry<String, List<String>> entry : queries.entrySet()) {
+            String key = entry.getKey();
+            if (key.startsWith(HEADER_PREFIX)) {
+                String headerKey = key.substring(HEADER_PREFIX.length());
+                String headerValue = entry.getValue().get(0);
+                headers.put(headerKey, headerValue);
+            }
+        }
+        return headers;
+    }
+}
diff --git a/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/auth/AuthType.java b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/auth/AuthType.java
new file mode 100644
index 0000000000..e1d6a6a60d
--- /dev/null
+++ b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/auth/AuthType.java
@@ -0,0 +1,36 @@
+package com.automq.opentelemetry.exporter.remotewrite.auth;
+
+import java.util.Collection;
+import java.util.Map;
+
+public enum AuthType {
+    BASIC("basic"),
+    SIG_V4("sigv4"),
+    BEARER("bearer"),
+    AZURE_AD("azuread");
+
+    private static final Map<String, AuthType> NAME_TO_AUTH_TYPE = Map.of(
+        "basic", BASIC,
+        "sigv4", SIG_V4,
+        "bearer", BEARER,
+        "azuread", AZURE_AD
+    );
+
+    private final String name;
+
+    AuthType(String name) {
+        this.name = name;
+    }
+
+    public static Collection<String> getNames() {
+        return NAME_TO_AUTH_TYPE.keySet();
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public static AuthType fromName(String name) {
+        return NAME_TO_AUTH_TYPE.get(name);
+    }
+}
diff --git a/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/auth/AuthUtils.java b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/auth/AuthUtils.java
new file mode 100644
index 0000000000..4f1ec6d9f3
--- /dev/null
+++ b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/auth/AuthUtils.java
@@ -0,0 +1,14 @@
+package com.automq.opentelemetry.exporter.remotewrite.auth;
+
+import java.util.Arrays;
+import java.util.stream.Collectors;
+
+public class AuthUtils {
+    public static final String AUTH_HEADER = "Authorization";
+
+    public static String canonicalMIMEHeaderKey(String headerName) {
+        return Arrays.stream(headerName.trim().split("-"))
+            .map(s -> s.isEmpty() ? s : Character.toUpperCase(s.charAt(0)) + s.substring(1).toLowerCase())
+            .collect(Collectors.joining("-"));
+    }
+}
diff --git a/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/auth/AwsSigV4Auth.java b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/auth/AwsSigV4Auth.java
new file mode 100644
index 0000000000..450331990c
--- /dev/null
+++ b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/auth/AwsSigV4Auth.java
@@ -0,0 +1,59 @@
+package com.automq.opentelemetry.exporter.remotewrite.auth;
+
+import okhttp3.Interceptor;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Collections;
+import java.util.Map;
+
+public class AwsSigV4Auth implements RemoteWriteAuth {
+    private static final Logger LOGGER = LoggerFactory.getLogger(AwsSigV4Auth.class);
+    private final String region;
+    private final String accessKey;
+    private final String secretKey;
+    private final Map<String, String> headers;
+
+    public AwsSigV4Auth(String region, String accessKey, String secretKey) {
+        this(region, accessKey, secretKey, Collections.emptyMap());
+    }
+
+    public AwsSigV4Auth(String region, String accessKey, String secretKey, Map<String, String> headers) {
+        this.region = region;
+        this.accessKey = accessKey;
+        this.secretKey = secretKey;
+        this.headers = headers;
+    }
+
+    public String getRegion() {
+        return region;
+    }
+
+    public String getAccessKey() {
+        return accessKey;
+    }
+
+    public String getSecretKey() {
+        return secretKey;
+    }
+
+    @Override
+    public boolean validate() {
+        if (StringUtils.isBlank(region)) {
+            LOGGER.error("Region is required for AWS Sig V4 authentication.");
+            return false;
+        }
+        return true;
+    }
+
+    @Override
+    public AuthType authType() {
+        return AuthType.SIG_V4;
+    }
+
+    @Override
+    public Interceptor createInterceptor() {
+        return new AwsSigV4Interceptor(region, accessKey, secretKey, headers);
+    }
+}
diff --git a/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/auth/AwsSigV4Interceptor.java b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/auth/AwsSigV4Interceptor.java
new file mode 100644
index 0000000000..caeeaf6020
--- /dev/null
+++ b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/auth/AwsSigV4Interceptor.java
@@ -0,0 +1,39 @@
+package com.automq.opentelemetry.exporter.remotewrite.auth;
+
+import okhttp3.Interceptor;
+import okhttp3.Request;
+import okhttp3.Response;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.Map;
+
+public class AwsSigV4Interceptor implements Interceptor {
+    private static final Logger LOGGER = LoggerFactory.getLogger(AwsSigV4Interceptor.class);
+    private final AwsSigV4Signer signer;
+    private final Map<String, String> headers;
+
+    public AwsSigV4Interceptor(String region, String accessKey, String secretKey) {
+        this(region, accessKey, secretKey, Collections.emptyMap());
+    }
+
+    public AwsSigV4Interceptor(String region, String accessKey, String secretKey, Map<String, String> headers) {
+        this.signer = new AwsSigV4Signer(region, accessKey, secretKey);
+        this.headers = headers;
+    }
+
+    @Override
+    public Response intercept(Chain chain) throws IOException {
+        Request.Builder builder = chain.request().newBuilder();
+        headers.forEach(builder::header);
+        Request signedRequest = this.signer.sign(builder.build());
+        if (signedRequest == null) {
+            LOGGER.error("Failed to sign request with AWS Sig V4. Proceeding without signature.");
+            return chain.proceed(chain.request());
+        }
+        return chain.proceed(signedRequest);
+    }
+
+}
diff --git a/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/auth/AwsSigV4Signer.java b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/auth/AwsSigV4Signer.java
new file mode 100644
index 0000000000..b237321376
--- /dev/null
+++ b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/auth/AwsSigV4Signer.java
@@ -0,0 +1,84 @@
+package com.automq.opentelemetry.exporter.remotewrite.auth;
+
+import com.automq.opentelemetry.exporter.remotewrite.PromConsts;
+import okhttp3.Request;
+import okio.Buffer;
+import org.apache.commons.lang3.StringUtils;
+import software.amazon.awssdk.auth.credentials.AwsBasicCredentials;
+import software.amazon.awssdk.auth.credentials.AwsCredentialsProvider;
+import software.amazon.awssdk.auth.credentials.InstanceProfileCredentialsProvider;
+import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider;
+import software.amazon.awssdk.http.SdkHttpMethod;
+import software.amazon.awssdk.http.SdkHttpRequest;
+import software.amazon.awssdk.http.auth.aws.signer.AwsV4HttpSigner;
+import software.amazon.awssdk.http.auth.spi.signer.SignedRequest;
+
+import java.io.IOException;
+import java.util.Optional;
+
+public class AwsSigV4Signer {
+    private final AwsV4HttpSigner signer;
+    private final String region;
+    private final AwsCredentialsProvider credentialsProvider;
+
+    public AwsSigV4Signer(String region, String accessKey, String secretKey) {
+        if (!validateConfig(region)) {
+            throw new IllegalArgumentException("Invalid AWS Sig V4 config");
+        }
+        this.region = region;
+        this.signer = AwsV4HttpSigner.create();
+        this.credentialsProvider = credentialsProvider(accessKey, secretKey);
+    }
+
+    private AwsCredentialsProvider credentialsProvider(String accessKey, String secretKey) {
+        if (!StringUtils.isBlank(accessKey) && !StringUtils.isBlank(secretKey)) {
+            return StaticCredentialsProvider.create(AwsBasicCredentials.create(accessKey, secretKey));
+        }
+        return InstanceProfileCredentialsProvider.builder().build();
+    }
+
+    private boolean validateConfig(String region) {
+        return region != null && !region.isEmpty();
+    }
+
+    public Request sign(Request request) throws IOException {
+        SdkHttpRequest tmpRequest = SdkHttpRequest.builder()
+            .uri(request.url().uri())
+            .method(SdkHttpMethod.fromValue(request.method()))
+            .headers(request.headers().toMultimap())
+            .build();
+        try (Buffer buffer = new Buffer()) {
+            SignedRequest signedRequest;
+            if (request.body() == null) {
+                signedRequest = signer.sign(r -> r
+                    .identity(credentialsProvider.resolveCredentials())
+                    .request(tmpRequest)
+                    .putProperty(AwsV4HttpSigner.PAYLOAD_SIGNING_ENABLED, false)
+                    .putProperty(AwsV4HttpSigner.SERVICE_SIGNING_NAME, PromConsts.AWS_PROMETHEUS_SERVICE_NAME)
+                    .putProperty(AwsV4HttpSigner.REGION_NAME, region));
+            } else {
+                request.body().writeTo(buffer);
+                signedRequest = signer.sign(r -> r
+                    .identity(credentialsProvider.resolveCredentials())
+                    .request(tmpRequest)
+                    .payload(buffer::inputStream)
+                    .putProperty(AwsV4HttpSigner.PAYLOAD_SIGNING_ENABLED, true)
+                    .putProperty(AwsV4HttpSigner.SERVICE_SIGNING_NAME, PromConsts.AWS_PROMETHEUS_SERVICE_NAME)
+                    .putProperty(AwsV4HttpSigner.REGION_NAME, region));
+            }
+            Optional<String> signature = signedRequest.request().firstMatchingHeader(AuthUtils.AUTH_HEADER);
+            if (signature.isPresent()) {
+                Request.Builder builder = request.newBuilder();
+                signedRequest.request().headers().forEach((k, v) -> {
+                    if (v.isEmpty()) {
+                        return;
+                    }
+                    builder.header(AuthUtils.canonicalMIMEHeaderKey(k), v.get(0));
+                });
+                return builder.build();
+            }
+            return null;
+        }
+    }
+}
+
diff --git a/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/auth/AzureADAuth.java b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/auth/AzureADAuth.java
new file mode 100644
index 0000000000..0b4719cf35
--- /dev/null
+++ b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/auth/AzureADAuth.java
@@ -0,0 +1,74 @@
+package com.automq.opentelemetry.exporter.remotewrite.auth;
+
+import okhttp3.Interceptor;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Collections;
+import java.util.Map;
+
+import static com.automq.opentelemetry.exporter.remotewrite.auth.AzureCloudConst.AZURE_CHINA;
+import static com.automq.opentelemetry.exporter.remotewrite.auth.AzureCloudConst.AZURE_GOVERNMENT;
+import static com.automq.opentelemetry.exporter.remotewrite.auth.AzureCloudConst.AZURE_PUBLIC;
+
+public class AzureADAuth implements RemoteWriteAuth {
+    private static final Logger LOGGER = LoggerFactory.getLogger(AzureADAuth.class);
+    private final String cloudAudience;
+    private final String clientId;
+    private final String clientSecret;
+    private final String tenantId;
+    private final Map<String, String> headers;
+
+    public AzureADAuth(String cloud, String clientId, String clientSecret, String tenantId) {
+        this(cloud, clientId, clientSecret, tenantId, Collections.emptyMap());
+    }
+
+    public AzureADAuth(String cloud, String clientId, String clientSecret, String tenantId, Map<String, String> headers) {
+        this.cloudAudience = toCloudAudience(cloud, StringUtils.isBlank(clientSecret));
+        this.clientId = clientId;
+        this.clientSecret = clientSecret;
+        this.tenantId = tenantId;
+        this.headers = headers;
+    }
+
+    public String toCloudAudience(String cloud, boolean isManagedIdentity) {
+        return switch (cloud.toLowerCase()) {
+            case AZURE_CHINA -> isManagedIdentity ? AzureCloudConst.azureChinaAudienceManagedIdentity : AzureCloudConst.azureChinaAudienceClientSecret;
+            case AZURE_PUBLIC -> isManagedIdentity ? AzureCloudConst.azurePublicAudienceManagedIdentity : AzureCloudConst.azurePublicAudienceClientSecret;
+            case AZURE_GOVERNMENT -> isManagedIdentity ? AzureCloudConst.azureGovernmentAudienceManagedIdentity : AzureCloudConst.azureGovernmentAudienceClientSecret;
+            default -> throw new IllegalArgumentException("Unknown Azure cloud: " + cloud);
+        };
+    }
+
+    public String getCloudAudience() {
+        return cloudAudience;
+    }
+
+    public String getClientId() {
+        return clientId;
+    }
+
+    @Override
+    public boolean validate() {
+        if (clientId == null || clientId.isEmpty()) {
+            LOGGER.error("Client ID is required for Azure AD authentication.");
+            return false;
+        }
+        if (cloudAudience == null || cloudAudience.isEmpty()) {
+            LOGGER.error("Cloud audience is required for Azure AD authentication.");
+            return false;
+        }
+        return true;
+    }
+
+    @Override
+    public AuthType authType() {
+        return AuthType.AZURE_AD;
+    }
+
+    @Override
+    public Interceptor createInterceptor() {
+        return new AzureADInterceptor(cloudAudience, clientId, clientSecret, tenantId, headers);
+    }
+}
diff --git a/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/auth/AzureADInterceptor.java b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/auth/AzureADInterceptor.java
new file mode 100644
index 0000000000..3e8af54aca
--- /dev/null
+++ b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/auth/AzureADInterceptor.java
@@ -0,0 +1,81 @@
+package com.automq.opentelemetry.exporter.remotewrite.auth;
+
+import com.azure.core.credential.AccessToken;
+import com.azure.core.credential.TokenCredential;
+import com.azure.core.credential.TokenRequestContext;
+import com.azure.identity.ClientSecretCredentialBuilder;
+import com.azure.identity.DefaultAzureCredentialBuilder;
+import io.netty.util.concurrent.DefaultThreadFactory;
+import okhttp3.Interceptor;
+import okhttp3.Request;
+import okhttp3.Response;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.time.ZoneId;
+import java.util.Collections;
+import java.util.Map;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+
+public class AzureADInterceptor implements Interceptor {
+    private static final Logger LOGGER = LoggerFactory.getLogger(AzureADInterceptor.class);
+    private final ScheduledExecutorService scheduledExecutorService;
+    private final String cloudAudience;
+    private final String clientId;
+    private final String clientSecret;
+    private final String tenantId;
+    private final Map<String, String> headers;
+    private final TokenCredential credential;
+    private volatile String token;
+
+    public AzureADInterceptor(String cloudAudience, String clientId, String clientSecret, String tenantId) {
+        this(cloudAudience, clientId, clientSecret, tenantId, Collections.emptyMap());
+    }
+
+    public AzureADInterceptor(String cloudAudience, String clientId, String clientSecret, String tenantId, Map<String, String> headers) {
+        this.cloudAudience = cloudAudience;
+        this.clientId = clientId;
+        this.clientSecret = clientSecret;
+        this.tenantId = tenantId;
+        this.headers = headers;
+        this.scheduledExecutorService = Executors.newSingleThreadScheduledExecutor(new DefaultThreadFactory("azure-ad-token-refresh"));
+        this.credential = getTokenCredential();
+        refreshToken();
+    }
+
+    private void refreshToken() {
+        // Refresh token logic
+        AccessToken accessToken = this.credential.getTokenSync(new TokenRequestContext().addScopes(cloudAudience));
+        long now = System.currentTimeMillis();
+        this.token = accessToken.getToken();
+        long localExpireTimeMs = accessToken.getExpiresAt().atZoneSameInstant(ZoneId.systemDefault()).toInstant().toEpochMilli();
+        long refreshDelay = (localExpireTimeMs - now) / 2;
+        LOGGER.info("Azure AD token refreshed at {}, expires at {}, refresh delay: {}ms.", now, accessToken.getExpiresAt(), refreshDelay);
+        this.scheduledExecutorService.schedule(this::refreshToken, refreshDelay, TimeUnit.MILLISECONDS);
+    }
+
+    private TokenCredential getTokenCredential() {
+        if (clientSecret != null && !clientSecret.isEmpty()) {
+            return new ClientSecretCredentialBuilder()
+                .clientSecret(clientSecret)
+                .clientId(clientId)
+                .tenantId(tenantId).build();
+        } else {
+            return new DefaultAzureCredentialBuilder()
+                .managedIdentityClientId(clientId)
+                .build();
+        }
+    }
+
+    @Override
+    public Response intercept(Chain chain) throws IOException {
+        Request.Builder builder = chain.request()
+            .newBuilder()
+            .header(AuthUtils.AUTH_HEADER, "Bearer " + token);
+        headers.forEach(builder::header);
+        return chain.proceed(builder.build());
+    }
+}
diff --git a/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/auth/AzureCloudConst.java b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/auth/AzureCloudConst.java
new file mode 100644
index 0000000000..f26df5d920
--- /dev/null
+++ b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/auth/AzureCloudConst.java
@@ -0,0 +1,40 @@
+package com.automq.opentelemetry.exporter.remotewrite.auth;
+
+
+import org.apache.commons.lang3.StringUtils;
+
+public class AzureCloudConst {
+    public static final String AZURE_CHINA = "azurechina";
+    public static final String AZURE_PUBLIC = "azurepublic";
+    public static final String AZURE_GOVERNMENT = "azuregovernment";
+
+    public static String azureChinaAudienceManagedIdentity = System.getenv("AZURE_CHINA_AUDIENCE_MANAGED_IDENTITY");
+    public static String azurePublicAudienceManagedIdentity = System.getenv("AZURE_PUBLIC_AUDIENCE_MANAGED_IDENTITY");
+    public static String azureGovernmentAudienceManagedIdentity = System.getenv("AZURE_GOVERNMENT_AUDIENCE_MANAGED_IDENTITY");
+
+    public static String azureChinaAudienceClientSecret = System.getenv("AZURE_CHINA_AUDIENCE_CLIENT_SECRET");
+    public static String azurePublicAudienceClientSecret = System.getenv("AZURE_PUBLIC_AUDIENCE_CLIENT_SECRET");
+    public static String azureGovernmentAudienceClientSecret = System.getenv("AZURE_GOVERNMENT_AUDIENCE_CLIENT_SECRET");
+
+    static {
+        if (StringUtils.isBlank(azureChinaAudienceManagedIdentity)) {
+            azureChinaAudienceManagedIdentity = "https://monitor.azure.cn";
+        }
+        if (StringUtils.isBlank(azurePublicAudienceManagedIdentity)) {
+            azurePublicAudienceManagedIdentity = "https://monitor.azure.com";
+        }
+        if (StringUtils.isBlank(azureGovernmentAudienceManagedIdentity)) {
+            azureGovernmentAudienceManagedIdentity = "https://monitor.azure.us";
+        }
+
+        if (StringUtils.isBlank(azureChinaAudienceClientSecret)) {
+            azureChinaAudienceClientSecret = "https://monitor.azure.cn//.default";
+        }
+        if (StringUtils.isBlank(azurePublicAudienceClientSecret)) {
+            azurePublicAudienceClientSecret = "https://monitor.azure.com//.default";
+        }
+        if (StringUtils.isBlank(azureGovernmentAudienceClientSecret)) {
+            azureGovernmentAudienceClientSecret = "https://monitor.azure.us//.default";
+        }
+    }
+}
diff --git a/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/auth/BasicAuth.java b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/auth/BasicAuth.java
new file mode 100644
index 0000000000..cb6bb6bbc0
--- /dev/null
+++ b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/auth/BasicAuth.java
@@ -0,0 +1,53 @@
+package com.automq.opentelemetry.exporter.remotewrite.auth;
+
+import okhttp3.Interceptor;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Collections;
+import java.util.Map;
+
+public class BasicAuth implements RemoteWriteAuth {
+    private static final Logger LOGGER = LoggerFactory.getLogger(BasicAuth.class);
+    private final String username;
+    private final String password;
+    private final Map<String, String> headers;
+
+    public BasicAuth(String username, String password) {
+        this(username, password, Collections.emptyMap());
+    }
+
+    public BasicAuth(String username, String password, Map<String, String> headers) {
+        this.username = username;
+        this.password = password;
+        this.headers = headers;
+    }
+
+    public String getUsername() {
+        return username;
+    }
+
+    public String getPassword() {
+        return password;
+    }
+
+    @Override
+    public boolean validate() {
+        if (StringUtils.isBlank(username) || StringUtils.isBlank(password)) {
+            LOGGER.error("Username and password are required for basic authentication.");
+            return false;
+        }
+        return true;
+    }
+
+    @Override
+    public AuthType authType() {
+        return AuthType.BASIC;
+    }
+
+    @Override
+    public Interceptor createInterceptor() {
+        return new BasicAuthInterceptor(username, password, headers);
+    }
+}
diff --git a/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/auth/BasicAuthInterceptor.java b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/auth/BasicAuthInterceptor.java
new file mode 100644
index 0000000000..a4aeda51fd
--- /dev/null
+++ b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/auth/BasicAuthInterceptor.java
@@ -0,0 +1,35 @@
+package com.automq.opentelemetry.exporter.remotewrite.auth;
+
+import okhttp3.Credentials;
+import okhttp3.Interceptor;
+import okhttp3.Request;
+import okhttp3.Response;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.Map;
+
+public class BasicAuthInterceptor implements Interceptor {
+    private final String username;
+    private final String password;
+    private final Map<String, String> headers;
+
+    public BasicAuthInterceptor(String username, String password) {
+        this(username, password, Collections.emptyMap());
+    }
+
+    public BasicAuthInterceptor(String username, String password, Map<String, String> headers) {
+        this.username = username;
+        this.password = password;
+        this.headers = headers;
+    }
+
+    @Override
+    public Response intercept(Chain chain) throws IOException {
+        Request.Builder builder = chain.request()
+            .newBuilder()
+            .header(AuthUtils.AUTH_HEADER, Credentials.basic(username, password));
+        headers.forEach(builder::header);
+        return chain.proceed(builder.build());
+    }
+}
diff --git a/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/auth/BearerAuthInterceptor.java b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/auth/BearerAuthInterceptor.java
new file mode 100644
index 0000000000..9221890fc7
--- /dev/null
+++ b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/auth/BearerAuthInterceptor.java
@@ -0,0 +1,36 @@
+package com.automq.opentelemetry.exporter.remotewrite.auth;
+
+import okhttp3.Interceptor;
+import okhttp3.Request;
+import okhttp3.Response;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.Map;
+
+public class BearerAuthInterceptor implements Interceptor {
+    private final String bearerToken;
+    private final Map<String, String> headers;
+
+    public BearerAuthInterceptor(String token) {
+        this(token, Collections.emptyMap());
+    }
+
+    public BearerAuthInterceptor(String token, Map<String, String> headers) {
+        this.bearerToken = token;
+        this.headers = headers;
+    }
+
+    private boolean validateConfig(String bearerToken) {
+        return bearerToken != null && !bearerToken.isEmpty();
+    }
+
+    @Override
+    public Response intercept(Chain chain) throws IOException {
+        Request.Builder builder = chain.request()
+            .newBuilder()
+            .header("Authorization", "Bearer " + bearerToken);
+        headers.forEach(builder::header);
+        return chain.proceed(builder.build());
+    }
+}
diff --git a/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/auth/BearerTokenAuth.java b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/auth/BearerTokenAuth.java
new file mode 100644
index 0000000000..05adf80e09
--- /dev/null
+++ b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/auth/BearerTokenAuth.java
@@ -0,0 +1,51 @@
+package com.automq.opentelemetry.exporter.remotewrite.auth;
+
+import okhttp3.Interceptor;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Collections;
+import java.util.Map;
+
+public class BearerTokenAuth implements RemoteWriteAuth {
+    private static final Logger LOGGER = LoggerFactory.getLogger(BearerTokenAuth.class);
+    private final String token;
+    private final Map<String, String> headers;
+
+    public BearerTokenAuth(String token) {
+        this(token, Collections.emptyMap());
+    }
+
+    public BearerTokenAuth(String token, Map<String, String> headers) {
+        this.token = token;
+        this.headers = headers;
+    }
+
+    public String getToken() {
+        return token;
+    }
+
+    public Map<String, String> getHeaders() {
+        return headers;
+    }
+
+    @Override
+    public boolean validate() {
+        if (StringUtils.isBlank(token)) {
+            LOGGER.error("Token is required for bearer token authentication.");
+            return false;
+        }
+        return true;
+    }
+
+    @Override
+    public AuthType authType() {
+        return AuthType.BEARER;
+    }
+
+    @Override
+    public Interceptor createInterceptor() {
+        return new BearerAuthInterceptor(token, headers);
+    }
+}
diff --git a/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/auth/RemoteWriteAuth.java b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/auth/RemoteWriteAuth.java
new file mode 100644
index 0000000000..ac50c32aaa
--- /dev/null
+++ b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/remotewrite/auth/RemoteWriteAuth.java
@@ -0,0 +1,9 @@
+package com.automq.opentelemetry.exporter.remotewrite.auth;
+
+import okhttp3.Interceptor;
+
+public interface RemoteWriteAuth {
+    boolean validate();
+    AuthType authType();
+    Interceptor createInterceptor();
+}
diff --git a/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/s3/CompressionUtils.java b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/s3/CompressionUtils.java
new file mode 100644
index 0000000000..20afdd6b36
--- /dev/null
+++ b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/s3/CompressionUtils.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright 2025, AutoMQ HK Limited.
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.automq.opentelemetry.exporter.s3;
+
+import com.automq.stream.s3.ByteBufAlloc;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.zip.GZIPInputStream;
+import java.util.zip.GZIPOutputStream;
+
+import io.netty.buffer.ByteBuf;
+
+/**
+ * Utility class for data compression and decompression.
+ */
+public class CompressionUtils {
+
+    /**
+     * Compress a ByteBuf using GZIP.
+     *
+     * @param input The input ByteBuf to compress.
+     * @return A new ByteBuf containing the compressed data.
+     * @throws IOException If an I/O error occurs during compression.
+     */
+    public static ByteBuf compress(ByteBuf input) throws IOException {
+        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
+        GZIPOutputStream gzipOutputStream = new GZIPOutputStream(byteArrayOutputStream);
+
+        byte[] buffer = new byte[input.readableBytes()];
+        input.readBytes(buffer);
+        gzipOutputStream.write(buffer);
+        gzipOutputStream.close();
+
+        ByteBuf compressed = ByteBufAlloc.byteBuffer(byteArrayOutputStream.size());
+        compressed.writeBytes(byteArrayOutputStream.toByteArray());
+        return compressed;
+    }
+
+    /**
+     * Decompress a GZIP-compressed ByteBuf.
+     *
+     * @param input The compressed ByteBuf to decompress.
+     * @return A new ByteBuf containing the decompressed data.
+     * @throws IOException If an I/O error occurs during decompression.
+     */
+    public static ByteBuf decompress(ByteBuf input) throws IOException {
+        byte[] compressedData = new byte[input.readableBytes()];
+        input.readBytes(compressedData);
+        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(compressedData);
+        GZIPInputStream gzipInputStream = new GZIPInputStream(byteArrayInputStream);
+
+        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
+        byte[] buffer = new byte[1024];
+        int bytesRead;
+        while ((bytesRead = gzipInputStream.read(buffer)) != -1) {
+            byteArrayOutputStream.write(buffer, 0, bytesRead);
+        }
+
+        gzipInputStream.close();
+        byteArrayOutputStream.close();
+
+        byte[] uncompressedData = byteArrayOutputStream.toByteArray();
+        ByteBuf output = ByteBufAlloc.byteBuffer(uncompressedData.length);
+        output.writeBytes(uncompressedData);
+        return output;
+    }
+}
diff --git a/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/s3/PrometheusUtils.java b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/s3/PrometheusUtils.java
new file mode 100644
index 0000000000..d9f9140f81
--- /dev/null
+++ b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/s3/PrometheusUtils.java
@@ -0,0 +1,152 @@
+/*
+ * Copyright 2025, AutoMQ HK Limited.
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.automq.opentelemetry.exporter.s3;
+
+import org.apache.commons.lang3.StringUtils;
+
+/**
+ * Utility class for Prometheus metric and label naming.
+ */
+public class PrometheusUtils {
+    private static final String TOTAL_SUFFIX = "_total";
+
+    /**
+     * Get the Prometheus unit from the OpenTelemetry unit.
+     *
+     * @param unit The OpenTelemetry unit.
+     * @return The Prometheus unit.
+     */
+    public static String getPrometheusUnit(String unit) {
+        if (unit.contains("{")) {
+            return "";
+        }
+        switch (unit) {
+            // Time
+            case "d":
+                return "days";
+            case "h":
+                return "hours";
+            case "min":
+                return "minutes";
+            case "s":
+                return "seconds";
+            case "ms":
+                return "milliseconds";
+            case "us":
+                return "microseconds";
+            case "ns":
+                return "nanoseconds";
+            // Bytes
+            case "By":
+                return "bytes";
+            case "KiBy":
+                return "kibibytes";
+            case "MiBy":
+                return "mebibytes";
+            case "GiBy":
+                return "gibibytes";
+            case "TiBy":
+                return "tibibytes";
+            case "KBy":
+                return "kilobytes";
+            case "MBy":
+                return "megabytes";
+            case "GBy":
+                return "gigabytes";
+            case "TBy":
+                return "terabytes";
+            // SI
+            case "m":
+                return "meters";
+            case "V":
+                return "volts";
+            case "A":
+                return "amperes";
+            case "J":
+                return "joules";
+            case "W":
+                return "watts";
+            case "g":
+                return "grams";
+            // Misc
+            case "Cel":
+                return "celsius";
+            case "Hz":
+                return "hertz";
+            case "1":
+                return "";
+            case "%":
+                return "percent";
+            default:
+                return unit;
+        }
+    }
+
+    /**
+     * Map a metric name to a Prometheus-compatible name.
+     *
+     * @param name The original metric name.
+     * @param unit The metric unit.
+     * @param isCounter Whether the metric is a counter.
+     * @param isGauge Whether the metric is a gauge.
+     * @return The Prometheus-compatible metric name.
+     */
+    public static String mapMetricsName(String name, String unit, boolean isCounter, boolean isGauge) {
+        // Replace "." into "_"
+        name = name.replaceAll("\\.", "_");
+
+        String prometheusUnit = getPrometheusUnit(unit);
+        boolean shouldAppendUnit = StringUtils.isNotBlank(prometheusUnit) && !name.contains(prometheusUnit);
+
+        // append prometheus unit if not null or empty.
+        // unit should be appended before type suffix
+        if (shouldAppendUnit) {
+            name = name + "_" + prometheusUnit;
+        }
+
+        // trim counter's _total suffix so the unit is placed before it.
+        if (isCounter && name.endsWith(TOTAL_SUFFIX)) {
+            name = name.substring(0, name.length() - TOTAL_SUFFIX.length());
+        }
+
+        // replace _total suffix, or add if it wasn't already present.
+        if (isCounter) {
+            name = name + TOTAL_SUFFIX;
+        }
+        // special case - gauge
+        if (unit.equals("1") && isGauge && !name.contains("ratio")) {
+            name = name + "_ratio";
+        }
+        return name;
+    }
+
+    /**
+     * Map a label name to a Prometheus-compatible name.
+     *
+     * @param name The original label name.
+     * @return The Prometheus-compatible label name.
+     */
+    public static String mapLabelName(String name) {
+        if (StringUtils.isBlank(name)) {
+            return "";
+        }
+        return name.replaceAll("\\.", "_");
+    }
+}
diff --git a/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/s3/S3MetricsConfig.java b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/s3/S3MetricsConfig.java
new file mode 100644
index 0000000000..bacb2b0c7f
--- /dev/null
+++ b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/s3/S3MetricsConfig.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright 2025, AutoMQ HK Limited.
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.automq.opentelemetry.exporter.s3;
+
+import com.automq.stream.s3.operator.ObjectStorage;
+
+import org.apache.commons.lang3.tuple.Pair;
+
+import java.util.List;
+
+/**
+ * Configuration interface for S3 metrics exporter.
+ */
+public interface S3MetricsConfig {
+
+    /**
+     * Get the cluster ID.
+     * @return The cluster ID.
+     */
+    String clusterId();
+
+    /**
+     * Check if the current node is a primary node for metrics upload.
+     * @return True if the current node should upload metrics, false otherwise.
+     */
+    boolean isPrimaryUploader();
+
+    /**
+     * Get the node ID.
+     * @return The node ID.
+     */
+    int nodeId();
+
+    /**
+     * Get the object storage instance.
+     * @return The object storage instance.
+     */
+    ObjectStorage objectStorage();
+
+    /**
+     * Get the base labels to include in all metrics.
+     * @return The base labels.
+     */
+    List<Pair<String, String>> baseLabels();
+}
diff --git a/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/s3/S3MetricsExporter.java b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/s3/S3MetricsExporter.java
new file mode 100644
index 0000000000..ad8bfd002f
--- /dev/null
+++ b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/s3/S3MetricsExporter.java
@@ -0,0 +1,371 @@
+/*
+ * Copyright 2025, AutoMQ HK Limited.
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.automq.opentelemetry.exporter.s3;
+
+import com.automq.stream.s3.operator.ObjectStorage;
+import com.automq.stream.s3.operator.ObjectStorage.ObjectInfo;
+import com.automq.stream.s3.operator.ObjectStorage.ObjectPath;
+import com.automq.stream.s3.operator.ObjectStorage.WriteOptions;
+import com.automq.stream.utils.Threads;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ArrayNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import com.google.common.collect.Lists;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.net.InetAddress;
+import java.nio.charset.Charset;
+import java.time.Duration;
+import java.time.LocalDateTime;
+import java.time.ZoneOffset;
+import java.time.format.DateTimeFormatter;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
+import io.opentelemetry.api.common.Attributes;
+import io.opentelemetry.sdk.common.CompletableResultCode;
+import io.opentelemetry.sdk.metrics.InstrumentType;
+import io.opentelemetry.sdk.metrics.data.AggregationTemporality;
+import io.opentelemetry.sdk.metrics.data.HistogramPointData;
+import io.opentelemetry.sdk.metrics.data.MetricData;
+import io.opentelemetry.sdk.metrics.export.MetricExporter;
+
+/**
+ * An S3 metrics exporter that uploads metrics data to S3 buckets.
+ */
+public class S3MetricsExporter implements MetricExporter {
+    private static final Logger LOGGER = LoggerFactory.getLogger(S3MetricsExporter.class);
+
+    public static final int UPLOAD_INTERVAL = System.getenv("AUTOMQ_OBSERVABILITY_UPLOAD_INTERVAL") != null ? Integer.parseInt(System.getenv("AUTOMQ_OBSERVABILITY_UPLOAD_INTERVAL")) : 60 * 1000;
+    public static final int CLEANUP_INTERVAL = System.getenv("AUTOMQ_OBSERVABILITY_CLEANUP_INTERVAL") != null ? Integer.parseInt(System.getenv("AUTOMQ_OBSERVABILITY_CLEANUP_INTERVAL")) : 2 * 60 * 1000;
+    public static final int MAX_JITTER_INTERVAL = 60 * 1000;
+    public static final int DEFAULT_BUFFER_SIZE = 16 * 1024 * 1024;
+
+    private final S3MetricsConfig config;
+    private final Map<String, String> defaultTagMap = new HashMap<>();
+
+    private final ByteBuf uploadBuffer = Unpooled.directBuffer(DEFAULT_BUFFER_SIZE);
+    private final Random random = new Random();
+    private volatile long lastUploadTimestamp = System.currentTimeMillis();
+    private volatile long nextUploadInterval = UPLOAD_INTERVAL + random.nextInt(MAX_JITTER_INTERVAL);
+
+    private final ObjectStorage objectStorage;
+    private final ObjectMapper objectMapper = new ObjectMapper();
+
+    private volatile boolean closed;
+    private final Thread uploadThread;
+    private final Thread cleanupThread;
+
+    /**
+     * Creates a new S3MetricsExporter.
+     * 
+     * @param config The configuration for the S3 metrics exporter.
+     */
+    public S3MetricsExporter(S3MetricsConfig config) {
+        this.config = config;
+        this.objectStorage = config.objectStorage();
+
+        defaultTagMap.put("host_name", getHostName());
+        defaultTagMap.put("job", config.clusterId());
+        defaultTagMap.put("instance", String.valueOf(config.nodeId()));
+        config.baseLabels().forEach(pair -> defaultTagMap.put(PrometheusUtils.mapLabelName(pair.getKey()), pair.getValue()));
+
+        uploadThread = new Thread(new UploadTask());
+        uploadThread.setName("s3-metrics-exporter-upload-thread");
+        uploadThread.setDaemon(true);
+
+        cleanupThread = new Thread(new CleanupTask());
+        cleanupThread.setName("s3-metrics-exporter-cleanup-thread");
+        cleanupThread.setDaemon(true);
+    }
+
+    /**
+     * Starts the exporter threads.
+     */
+    public void start() {
+        uploadThread.start();
+        cleanupThread.start();
+        LOGGER.info("S3MetricsExporter is started");
+    }
+
+    @Override
+    public void close() {
+        MetricExporter.super.close();
+        closed = true;
+        cleanupThread.interrupt();
+        uploadThread.interrupt();
+        LOGGER.info("S3MetricsExporter is closed");
+    }
+
+    private class UploadTask implements Runnable {
+
+        @Override
+        public void run() {
+            while (!closed && !uploadThread.isInterrupted()) {
+                try {
+                    if (uploadBuffer.readableBytes() > 0 && System.currentTimeMillis() - lastUploadTimestamp > nextUploadInterval) {
+                        flush();
+                    }
+                    Thread.sleep(1000);
+                } catch (InterruptedException e) {
+                    break;
+                }
+            }
+        }
+    }
+
+    private class CleanupTask implements Runnable {
+
+        @Override
+        public void run() {
+            while (!Thread.currentThread().isInterrupted()) {
+                try {
+                    if (closed || !config.isPrimaryUploader()) {
+                        Thread.sleep(Duration.ofMinutes(1).toMillis());
+                        continue;
+                    }
+                    long expiredTime = System.currentTimeMillis() - CLEANUP_INTERVAL;
+
+                    List<ObjectInfo> objects = objectStorage.list(String.format("automq/metrics/%s", config.clusterId())).join();
+
+                    if (!objects.isEmpty()) {
+                        List<ObjectPath> keyList = objects.stream()
+                            .filter(object -> object.timestamp() < expiredTime)
+                            .map(object -> new ObjectPath(object.bucketId(), object.key()))
+                            .collect(Collectors.toList());
+
+                        if (!keyList.isEmpty()) {
+                            // Some of s3 implements allow only 1000 keys per request.
+                            CompletableFuture<?>[] deleteFutures = Lists.partition(keyList, 1000)
+                                .stream()
+                                .map(objectStorage::delete)
+                                .toArray(CompletableFuture[]::new);
+                            CompletableFuture.allOf(deleteFutures).join();
+                        }
+                    }
+                    if (Threads.sleep(Duration.ofMinutes(1).toMillis())) {
+                        break;
+                    }
+                } catch (InterruptedException e) {
+                    break;
+                } catch (Exception e) {
+                    LOGGER.error("Cleanup s3 metrics failed", e);
+                    if (Threads.sleep(Duration.ofMinutes(1).toMillis())) {
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
+    private String getHostName() {
+        try {
+            return InetAddress.getLocalHost().getHostName();
+        } catch (Exception e) {
+            LOGGER.error("Failed to get host name", e);
+            return "unknown";
+        }
+    }
+
+    @Override
+    public CompletableResultCode export(Collection<MetricData> metrics) {
+        if (closed) {
+            return CompletableResultCode.ofFailure();
+        }
+
+        try {
+            List<String> lineList = new ArrayList<>();
+            for (MetricData metric : metrics) {
+                switch (metric.getType()) {
+                    case LONG_SUM:
+                        metric.getLongSumData().getPoints().forEach(point ->
+                            lineList.add(serializeCounter(
+                                PrometheusUtils.mapMetricsName(metric.getName(), metric.getUnit(), metric.getLongSumData().isMonotonic(), false),
+                                point.getValue(), point.getAttributes(), point.getEpochNanos())));
+                        break;
+                    case DOUBLE_SUM:
+                        metric.getDoubleSumData().getPoints().forEach(point ->
+                            lineList.add(serializeCounter(
+                                PrometheusUtils.mapMetricsName(metric.getName(), metric.getUnit(), metric.getDoubleSumData().isMonotonic(), false),
+                                point.getValue(), point.getAttributes(), point.getEpochNanos())));
+                        break;
+                    case LONG_GAUGE:
+                        metric.getLongGaugeData().getPoints().forEach(point ->
+                            lineList.add(serializeGauge(
+                                PrometheusUtils.mapMetricsName(metric.getName(), metric.getUnit(), false, true),
+                                point.getValue(), point.getAttributes(), point.getEpochNanos())));
+                        break;
+                    case DOUBLE_GAUGE:
+                        metric.getDoubleGaugeData().getPoints().forEach(point ->
+                            lineList.add(serializeGauge(
+                                PrometheusUtils.mapMetricsName(metric.getName(), metric.getUnit(), false, true),
+                                point.getValue(), point.getAttributes(), point.getEpochNanos())));
+                        break;
+                    case HISTOGRAM:
+                        metric.getHistogramData().getPoints().forEach(point ->
+                            lineList.add(serializeHistogram(
+                                PrometheusUtils.mapMetricsName(metric.getName(), metric.getUnit(), false, false),
+                                point)));
+                        break;
+                    default:
+                }
+            }
+
+            int size = lineList.stream().mapToInt(line -> line.length() + 1 /*the newline character*/).sum();
+            ByteBuf buffer = Unpooled.buffer(size);
+            lineList.forEach(line -> {
+                buffer.writeCharSequence(line, Charset.defaultCharset());
+                buffer.writeCharSequence("\n", Charset.defaultCharset());
+            });
+            synchronized (uploadBuffer) {
+                if (uploadBuffer.writableBytes() < buffer.readableBytes()) {
+                    // Upload the buffer immediately
+                    flush();
+                }
+                uploadBuffer.writeBytes(buffer);
+            }
+        } catch (Exception e) {
+            LOGGER.error("Export metrics to S3 failed", e);
+            return CompletableResultCode.ofFailure();
+        }
+
+        return CompletableResultCode.ofSuccess();
+    }
+
+    @Override
+    public CompletableResultCode flush() {
+        synchronized (uploadBuffer) {
+            if (uploadBuffer.readableBytes() > 0) {
+                try {
+                    objectStorage.write(WriteOptions.DEFAULT, getObjectKey(), CompressionUtils.compress(uploadBuffer.slice().asReadOnly())).get();
+                } catch (Exception e) {
+                    LOGGER.error("Failed to upload metrics to s3", e);
+                    return CompletableResultCode.ofFailure();
+                } finally {
+                    lastUploadTimestamp = System.currentTimeMillis();
+                    nextUploadInterval = UPLOAD_INTERVAL + random.nextInt(MAX_JITTER_INTERVAL);
+                    uploadBuffer.clear();
+                }
+            }
+        }
+        return CompletableResultCode.ofSuccess();
+    }
+
+    @Override
+    public CompletableResultCode shutdown() {
+        objectStorage.close();
+        return CompletableResultCode.ofSuccess();
+    }
+
+    @Override
+    public AggregationTemporality getAggregationTemporality(InstrumentType instrumentType) {
+        return AggregationTemporality.CUMULATIVE;
+    }
+
+    private String getObjectKey() {
+        String hour = LocalDateTime.now(ZoneOffset.UTC).format(DateTimeFormatter.ofPattern("yyyyMMddHH"));
+        return String.format("automq/metrics/%s/%s/%s/%s", config.clusterId(), config.nodeId(), hour, UUID.randomUUID());
+    }
+
+    private String serializeCounter(String name, double value, Attributes attributes, long timestampNanos) {
+        ObjectNode root = objectMapper.createObjectNode();
+        root.put("kind", "absolute");
+
+        root.put("timestamp", TimeUnit.NANOSECONDS.toSeconds(timestampNanos));
+        root.put("name", name);
+        root.set("counter", objectMapper.createObjectNode().put("value", value));
+
+        ObjectNode tags = objectMapper.createObjectNode();
+        defaultTagMap.forEach(tags::put);
+        attributes.forEach((k, v) -> tags.put(PrometheusUtils.mapLabelName(k.getKey()), v.toString()));
+        root.set("tags", tags);
+
+        return root.toString();
+    }
+
+    private String serializeGauge(String name, double value, Attributes attributes, long timestampNanos) {
+        ObjectNode root = objectMapper.createObjectNode();
+        root.put("kind", "absolute");
+
+        root.put("timestamp", TimeUnit.NANOSECONDS.toSeconds(timestampNanos));
+        root.put("name", name);
+        root.set("gauge", objectMapper.createObjectNode().put("value", value));
+
+        ObjectNode tags = objectMapper.createObjectNode();
+        defaultTagMap.forEach(tags::put);
+        attributes.forEach((k, v) -> tags.put(PrometheusUtils.mapLabelName(k.getKey()), v.toString()));
+        root.set("tags", tags);
+
+        return root.toString();
+    }
+
+    private String serializeHistogram(String name, HistogramPointData point) {
+        ObjectNode root = objectMapper.createObjectNode();
+        root.put("kind", "absolute");
+
+        root.put("timestamp", TimeUnit.NANOSECONDS.toSeconds(point.getEpochNanos()));
+        root.put("name", name);
+
+        ObjectNode histogram = objectMapper.createObjectNode();
+        histogram.put("count", point.getCount());
+        histogram.put("sum", point.getSum());
+
+        ArrayNode buckets = objectMapper.createArrayNode();
+        for (int i = 0; i < point.getCounts().size(); i++) {
+            ObjectNode bucket = objectMapper.createObjectNode();
+            bucket.put("count", point.getCounts().get(i));
+            float upperBound = getBucketUpperBound(point, i);
+            if (upperBound == Float.POSITIVE_INFINITY) {
+                bucket.put("upper_limit", Float.MAX_VALUE);
+            } else {
+                bucket.put("upper_limit", upperBound);
+            }
+            buckets.add(bucket);
+        }
+        histogram.set("buckets", buckets);
+        root.set("histogram", histogram);
+
+        ObjectNode tags = objectMapper.createObjectNode();
+        defaultTagMap.forEach(tags::put);
+        point.getAttributes().forEach((k, v) -> tags.put(PrometheusUtils.mapLabelName(k.getKey()), v.toString()));
+        root.set("tags", tags);
+
+        return root.toString();
+    }
+
+    private float getBucketUpperBound(HistogramPointData point, int bucketIndex) {
+        List<Double> boundaries = point.getBoundaries();
+        return (bucketIndex < boundaries.size())
+            ? boundaries.get(bucketIndex).floatValue()
+            : Float.MAX_VALUE;
+    }
+}
diff --git a/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/s3/S3MetricsExporterAdapter.java b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/s3/S3MetricsExporterAdapter.java
new file mode 100644
index 0000000000..4aafac2319
--- /dev/null
+++ b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/s3/S3MetricsExporterAdapter.java
@@ -0,0 +1,120 @@
+/*
+ * Copyright 2025, AutoMQ HK Limited.
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.automq.opentelemetry.exporter.s3;
+
+import com.automq.opentelemetry.exporter.MetricsExporter;
+import com.automq.stream.s3.operator.BucketURI;
+import com.automq.stream.s3.operator.ObjectStorage;
+import com.automq.stream.s3.operator.ObjectStorageFactory;
+
+import org.apache.commons.lang3.tuple.Pair;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.time.Duration;
+import java.util.List;
+
+import io.opentelemetry.sdk.metrics.export.MetricReader;
+import io.opentelemetry.sdk.metrics.export.PeriodicMetricReader;
+
+/**
+ * An adapter class that implements the MetricsExporter interface and uses S3MetricsExporter
+ * for actual metrics exporting functionality.
+ */
+public class S3MetricsExporterAdapter implements MetricsExporter {
+    private static final Logger LOGGER = LoggerFactory.getLogger(S3MetricsExporterAdapter.class);
+
+    private final String clusterId;
+    private final int nodeId;
+    private final int intervalMs;
+    private final BucketURI metricsBucket;
+    private final List<Pair<String, String>> baseLabels;
+    private final UploaderNodeSelector nodeSelector;
+
+    /**
+     * Creates a new S3MetricsExporterAdapter.
+     *
+     * @param clusterId The cluster ID
+     * @param nodeId The node ID
+     * @param intervalMs The interval in milliseconds for metrics export
+     * @param metricsBucket The bucket URI to export metrics to
+     * @param baseLabels The base labels to include with metrics
+     * @param nodeSelector The selector that determines if this node should upload metrics
+     */
+    public S3MetricsExporterAdapter(String clusterId, int nodeId, int intervalMs, BucketURI metricsBucket,
+                                    List<Pair<String, String>> baseLabels, UploaderNodeSelector nodeSelector) {
+        if (metricsBucket == null) {
+            throw new IllegalArgumentException("bucket URI must be provided for s3 metrics exporter");
+        }
+        if (nodeSelector == null) {
+            throw new IllegalArgumentException("node selector must be provided");
+        }
+        this.clusterId = clusterId;
+        this.nodeId = nodeId;
+        this.intervalMs = intervalMs;
+        this.metricsBucket = metricsBucket;
+        this.baseLabels = baseLabels;
+        this.nodeSelector = nodeSelector;
+        LOGGER.info("S3MetricsExporterAdapter initialized with clusterId: {}, nodeId: {}, intervalMs: {}, bucket: {}",
+                clusterId, nodeId, intervalMs, metricsBucket);
+    }
+
+    @Override
+    public MetricReader asMetricReader() {
+        // Create object storage for the bucket
+        ObjectStorage objectStorage = ObjectStorageFactory.instance().builder(metricsBucket).threadPrefix("s3-metric").build();
+
+        S3MetricsConfig metricsConfig = new S3MetricsConfig() {
+            @Override
+            public String clusterId() {
+                return clusterId;
+            }
+
+            @Override
+            public boolean isPrimaryUploader() {
+                return nodeSelector.isPrimaryUploader();
+            }
+
+            @Override
+            public int nodeId() {
+                return nodeId;
+            }
+
+            @Override
+            public ObjectStorage objectStorage() {
+                return objectStorage;
+            }
+
+            @Override
+            public List<Pair<String, String>> baseLabels() {
+                return baseLabels;
+            }
+        };
+
+        // Create and start the S3MetricsExporter
+        S3MetricsExporter s3MetricsExporter = new S3MetricsExporter(metricsConfig);
+        s3MetricsExporter.start();
+
+        // Create and return the periodic metric reader
+        return PeriodicMetricReader.builder(s3MetricsExporter)
+                .setInterval(Duration.ofMillis(intervalMs))
+                .build();
+    }
+}
\ No newline at end of file
diff --git a/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/s3/UploaderNodeSelector.java b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/s3/UploaderNodeSelector.java
new file mode 100644
index 0000000000..0f9355200e
--- /dev/null
+++ b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/s3/UploaderNodeSelector.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2025, AutoMQ HK Limited.
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.automq.opentelemetry.exporter.s3;
+
+/**
+ * An interface for determining which node should be responsible for uploading metrics.
+ * This abstraction allows different implementations of uploader node selection strategies.
+ */
+public interface UploaderNodeSelector {
+    
+    /**
+     * Determines if the current node should be responsible for uploading metrics.
+     * 
+     * @return true if the current node should upload metrics, false otherwise.
+     */
+    boolean isPrimaryUploader();
+    
+    /**
+     * Creates a default UploaderNodeSelector based on static configuration.
+     * 
+     * @param isPrimaryUploader a static boolean value indicating whether this node is the primary uploader
+     * @return a UploaderNodeSelector that returns the static value
+     */
+    static UploaderNodeSelector staticSelector(boolean isPrimaryUploader) {
+        return () -> isPrimaryUploader;
+    }
+}
diff --git a/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/s3/UploaderNodeSelectorFactory.java b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/s3/UploaderNodeSelectorFactory.java
new file mode 100644
index 0000000000..7d5c2c984c
--- /dev/null
+++ b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/s3/UploaderNodeSelectorFactory.java
@@ -0,0 +1,141 @@
+/*
+ * Copyright 2025, AutoMQ HK Limited.
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.automq.opentelemetry.exporter.s3;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.ServiceLoader;
+import java.util.stream.Stream;
+
+/**
+ * Factory for loading UploaderNodeSelector implementations via SPI.
+ * This enables third parties to contribute their own node selection implementations.
+ */
+public class UploaderNodeSelectorFactory {
+    private static final Logger LOGGER = LoggerFactory.getLogger(UploaderNodeSelectorFactory.class);
+    
+    private static final Map<String, UploaderNodeSelectorProvider> PROVIDERS = new HashMap<>();
+    
+    static {
+        // Load providers using SPI
+        ServiceLoader<UploaderNodeSelectorProvider> serviceLoader = ServiceLoader.load(UploaderNodeSelectorProvider.class);
+        for (UploaderNodeSelectorProvider provider : serviceLoader) {
+            String type = provider.getType();
+            LOGGER.info("Loaded UploaderNodeSelectorProvider for type: {}", type);
+            PROVIDERS.put(type.toLowerCase(), provider);
+        }
+    }
+    
+    private UploaderNodeSelectorFactory() {
+        // Utility class, no instances
+    }
+    
+    /**
+     * Creates a node selector based on the specified type and configuration.
+     *
+     * @param typeString The selector type (can be a built-in type or custom type from SPI)
+     * @param clusterId The cluster ID
+     * @param nodeId The node ID
+     * @param config Additional configuration parameters
+     * @return A UploaderNodeSelector instance or null if type is not supported
+     */
+    public static UploaderNodeSelector createSelector(String typeString, String clusterId, int nodeId, Map<String, String> config) {
+        UploaderNodeSelectorType type = UploaderNodeSelectorType.fromString(typeString);
+        
+        // Handle built-in selectors based on the enum type
+        switch (type) {
+            case STATIC:
+                boolean isPrimaryUploader = Boolean.parseBoolean(config.getOrDefault("isPrimaryUploader", "false"));
+                return UploaderNodeSelectors.staticSelector(isPrimaryUploader);
+                
+            case NODE_ID:
+                int primaryNodeId = Integer.parseInt(config.getOrDefault("primaryNodeId", "0"));
+                return UploaderNodeSelectors.nodeIdSelector(nodeId, primaryNodeId);
+                
+            case FILE:
+                String leaderFile = config.getOrDefault("leaderFile", "/tmp/s3-metrics-leader");
+                long timeoutMs = Long.parseLong(config.getOrDefault("leaderTimeoutMs", "60000"));
+                return UploaderNodeSelectors.fileLeaderElectionSelector(leaderFile, nodeId, timeoutMs);
+                
+            case CUSTOM:
+                // For custom types, try to find an SPI provider
+                UploaderNodeSelectorProvider provider = PROVIDERS.get(typeString.toLowerCase());
+                if (provider != null) {
+                    try {
+                        return provider.createSelector(clusterId, nodeId, config);
+                    } catch (Exception e) {
+                        LOGGER.error("Failed to create UploaderNodeSelector of type {} using provider {}", 
+                            typeString, provider.getClass().getName(), e);
+                    }
+                }
+                
+                LOGGER.warn("Unsupported UploaderNodeSelector type: {}. Using static selector with isPrimaryUploader=false", typeString);
+                return UploaderNodeSelectors.staticSelector(false);
+        }
+        
+        // Should never reach here because all enum values are covered
+        return UploaderNodeSelectors.staticSelector(false);
+    }
+    
+    /**
+     * Returns true if the specified selector type is supported.
+     *
+     * @param typeString The selector type to check
+     * @return True if the type is supported, false otherwise
+     */
+    public static boolean isSupported(String typeString) {
+        if (typeString == null) {
+            return false;
+        }
+        
+        // First check built-in types using the enum
+        UploaderNodeSelectorType type = UploaderNodeSelectorType.fromString(typeString);
+        if (type != UploaderNodeSelectorType.CUSTOM) {
+            return true;
+        }
+        
+        // Then check custom SPI providers
+        return PROVIDERS.containsKey(typeString.toLowerCase());
+    }
+    
+    /**
+     * Gets all supported selector types (built-in and from SPI).
+     *
+     * @return Array of supported selector types
+     */
+    public static String[] getSupportedTypes() {
+        // Get built-in types from the enum
+        String[] builtInTypes = Stream.of(UploaderNodeSelectorType.values())
+            .filter(t -> t != UploaderNodeSelectorType.CUSTOM)
+            .map(UploaderNodeSelectorType::getType)
+            .toArray(String[]::new);
+            
+        String[] customTypes = PROVIDERS.keySet().toArray(new String[0]);
+        
+        String[] allTypes = new String[builtInTypes.length + customTypes.length];
+        System.arraycopy(builtInTypes, 0, allTypes, 0, builtInTypes.length);
+        System.arraycopy(customTypes, 0, allTypes, builtInTypes.length, customTypes.length);
+        
+        return allTypes;
+    }
+}
diff --git a/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/s3/UploaderNodeSelectorProvider.java b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/s3/UploaderNodeSelectorProvider.java
new file mode 100644
index 0000000000..da2af6337d
--- /dev/null
+++ b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/s3/UploaderNodeSelectorProvider.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2025, AutoMQ HK Limited.
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.automq.opentelemetry.exporter.s3;
+
+import java.util.Map;
+
+/**
+ * SPI interface for providing custom UploaderNodeSelector implementations.
+ * Third-party libraries can implement this interface and register their implementations
+ * using Java's ServiceLoader mechanism.
+ */
+public interface UploaderNodeSelectorProvider {
+    
+    /**
+     * Returns the type identifier for this selector provider.
+     * This is the string that should be used in configuration to select this provider.
+     * 
+     * @return A unique type identifier for this selector implementation
+     */
+    String getType();
+    
+    /**
+     * Creates a new UploaderNodeSelector instance based on the provided configuration.
+     * 
+     * @param clusterId The cluster ID
+     * @param nodeId The node ID of the current node
+     * @param config Additional configuration parameters
+     * @return A new UploaderNodeSelector instance
+     * @throws Exception If the selector cannot be created
+     */
+    UploaderNodeSelector createSelector(String clusterId, int nodeId, Map<String, String> config) throws Exception;
+}
diff --git a/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/s3/UploaderNodeSelectorType.java b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/s3/UploaderNodeSelectorType.java
new file mode 100644
index 0000000000..25f32d7847
--- /dev/null
+++ b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/s3/UploaderNodeSelectorType.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright 2025, AutoMQ HK Limited.
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.automq.opentelemetry.exporter.s3;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Enum representing the type of uploader node selector.
+ * Provides type safety and common operations for selector types.
+ */
+public enum UploaderNodeSelectorType {
+    /**
+     * Static selector - uses a fixed configuration value.
+     */
+    STATIC("static"),
+    
+    /**
+     * Node ID based selector - selects based on node ID matching.
+     */
+    NODE_ID("nodeid"),
+    
+    /**
+     * File-based leader election selector - uses a file for leader election.
+     */
+    FILE("file"),
+    
+    /**
+     * Custom selector type - used for SPI-provided selectors.
+     */
+    CUSTOM(null);
+    
+    private final String type;
+    private static final Map<String, UploaderNodeSelectorType> TYPE_MAP = new HashMap<>();
+    
+    static {
+        for (UploaderNodeSelectorType value : values()) {
+            if (value != CUSTOM) {
+                TYPE_MAP.put(value.type, value);
+            }
+        }
+    }
+    
+    UploaderNodeSelectorType(String type) {
+        this.type = type;
+    }
+    
+    /**
+     * Gets the string representation of this selector type.
+     * 
+     * @return The type string
+     */
+    public String getType() {
+        return type;
+    }
+    
+    /**
+     * Converts a string to the appropriate selector type enum.
+     * 
+     * @param typeString The type string to convert
+     * @return The matching selector type or CUSTOM if no built-in match
+     */
+    public static UploaderNodeSelectorType fromString(String typeString) {
+        if (typeString == null) {
+            return STATIC; // Default
+        }
+        
+        return TYPE_MAP.getOrDefault(typeString.toLowerCase(), CUSTOM);
+    }
+    
+    /**
+     * Creates a CUSTOM type with a specific value.
+     * 
+     * @param customType The custom type string
+     * @return A CUSTOM type instance
+     */
+    public static UploaderNodeSelectorType customType(String customType) {
+        return CUSTOM;
+    }
+}
diff --git a/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/s3/UploaderNodeSelectors.java b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/s3/UploaderNodeSelectors.java
new file mode 100644
index 0000000000..0efc534329
--- /dev/null
+++ b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/s3/UploaderNodeSelectors.java
@@ -0,0 +1,172 @@
+/*
+ * Copyright 2025, AutoMQ HK Limited.
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.automq.opentelemetry.exporter.s3;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Supplier;
+
+/**
+ * This class provides various implementations of the UploaderNodeSelector interface.
+ */
+public class UploaderNodeSelectors {
+    private static final Logger LOGGER = LoggerFactory.getLogger(UploaderNodeSelectors.class);
+
+    private UploaderNodeSelectors() {
+        // Utility class
+    }
+
+    /**
+     * Creates a selector that uses a static boolean value.
+     *
+     * @param isPrimaryUploader whether this node should be the primary uploader
+     * @return a selector that always returns the provided value
+     */
+    public static UploaderNodeSelector staticSelector(boolean isPrimaryUploader) {
+        return () -> isPrimaryUploader;
+    }
+
+    /**
+     * Creates a selector that uses a supplier to dynamically determine if this node is the primary uploader.
+     *
+     * @param supplier a function that determines if this node is the primary uploader
+     * @return a selector that delegates to the supplier
+     */
+    public static UploaderNodeSelector supplierSelector(Supplier<Boolean> supplier) {
+        return supplier::get;
+    }
+
+    /**
+     * Creates a selector that checks if the current node's ID matches a specific node ID.
+     * If it matches, this node will be considered the primary uploader.
+     *
+     * @param currentNodeId the ID of the current node
+     * @param primaryNodeId the ID of the node that should be the primary uploader
+     * @return a selector based on node ID matching
+     */
+    public static UploaderNodeSelector nodeIdSelector(int currentNodeId, int primaryNodeId) {
+        return () -> currentNodeId == primaryNodeId;
+    }
+
+    /**
+     * Creates a selector that uses a leader election file for multiple nodes.
+     * The node that successfully creates or updates the leader file becomes the primary uploader.
+     * This implementation periodically attempts to claim leadership.
+     *
+     * @param leaderFilePath the path to the leader election file
+     * @param nodeId the ID of the current node
+     * @param leaderTimeoutMs the maximum time in milliseconds before leadership can be claimed by another node
+     * @return a selector based on file-based leader election
+     */
+    public static UploaderNodeSelector fileLeaderElectionSelector(String leaderFilePath, int nodeId, long leaderTimeoutMs) {
+        Path path = Paths.get(leaderFilePath);
+        
+        // Create an atomic reference to track leadership status
+        AtomicBoolean isLeader = new AtomicBoolean(false);
+        
+        // Start a background thread to periodically attempt to claim leadership
+        Thread leaderElectionThread = new Thread(() -> {
+            while (!Thread.currentThread().isInterrupted()) {
+                try {
+                    boolean claimed = attemptToClaimLeadership(path, nodeId, leaderTimeoutMs);
+                    isLeader.set(claimed);
+                    
+                    // Sleep for half the timeout period
+                    Thread.sleep(leaderTimeoutMs / 2);
+                } catch (InterruptedException e) {
+                    Thread.currentThread().interrupt();
+                    break;
+                } catch (Exception e) {
+                    LOGGER.error("Error in leader election", e);
+                    isLeader.set(false);
+                    try {
+                        Thread.sleep(1000);
+                    } catch (InterruptedException ie) {
+                        Thread.currentThread().interrupt();
+                        break;
+                    }
+                }
+            }
+        });
+        
+        leaderElectionThread.setDaemon(true);
+        leaderElectionThread.setName("s3-metrics-leader-election");
+        leaderElectionThread.start();
+        
+        // Return a selector that checks the current leadership status
+        return isLeader::get;
+    }
+    
+    private static boolean attemptToClaimLeadership(Path leaderFilePath, int nodeId, long leaderTimeoutMs) throws IOException {
+        try {
+            // Try to create directory if it doesn't exist
+            Files.createDirectories(leaderFilePath.getParent());
+            
+            // Check if file exists
+            if (Files.exists(leaderFilePath)) {
+                // Read the current leader info
+                List<String> lines = Files.readAllLines(leaderFilePath);
+                if (!lines.isEmpty()) {
+                    String[] parts = lines.get(0).split(":");
+                    if (parts.length == 2) {
+                        int currentLeaderNodeId = Integer.parseInt(parts[0]);
+                        long timestamp = Long.parseLong(parts[1]);
+                        
+                        // Check if the current leader has timed out
+                        if (System.currentTimeMillis() - timestamp <= leaderTimeoutMs) {
+                            // Leader is still active
+                            return currentLeaderNodeId == nodeId;
+                        }
+                    }
+                }
+            }
+            
+            // No leader or leader timed out, try to claim leadership
+            String content = nodeId + ":" + System.currentTimeMillis();
+            Files.write(leaderFilePath, content.getBytes());
+            
+            // Verify leadership was claimed by this node
+            List<String> lines = Files.readAllLines(leaderFilePath);
+            if (!lines.isEmpty()) {
+                String[] parts = lines.get(0).split(":");
+                if (parts.length == 2) {
+                    int currentLeaderNodeId = Integer.parseInt(parts[0]);
+                    return currentLeaderNodeId == nodeId;
+                }
+            }
+            
+            return false;
+        } catch (IOException e) {
+            LOGGER.warn("Failed to claim leadership", e);
+            return false;
+        }
+    }
+}
diff --git a/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/s3/examples/RoundRobinSelectorProvider.java b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/s3/examples/RoundRobinSelectorProvider.java
new file mode 100644
index 0000000000..3d9fb6dacd
--- /dev/null
+++ b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/s3/examples/RoundRobinSelectorProvider.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright 2025, AutoMQ HK Limited.
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.automq.opentelemetry.exporter.s3.examples;
+
+import com.automq.opentelemetry.exporter.s3.UploaderNodeSelector;
+import com.automq.opentelemetry.exporter.s3.UploaderNodeSelectorProvider;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * Example implementation of UploaderNodeSelectorProvider using a simple round-robin approach
+ * for demonstration purposes. In a real environment, this would be in a separate module.
+ */
+public class RoundRobinSelectorProvider implements UploaderNodeSelectorProvider {
+    private static final Logger LOGGER = LoggerFactory.getLogger(RoundRobinSelectorProvider.class);
+    
+    private static final AtomicInteger CURRENT_PRIMARY = new AtomicInteger(0);
+    // 1 minute
+    private static final int DEFAULT_ROTATION_INTERVAL_MS = 60000;
+    
+    @Override
+    public String getType() {
+        return "roundRobin";
+    }
+    
+    @Override
+    public UploaderNodeSelector createSelector(String clusterId, int nodeId, Map<String, String> config) {
+        int rotationIntervalMs = DEFAULT_ROTATION_INTERVAL_MS;
+        if (config.containsKey("rotationIntervalMs")) {
+            try {
+                rotationIntervalMs = Integer.parseInt(config.get("rotationIntervalMs"));
+            } catch (NumberFormatException e) {
+                LOGGER.warn("Invalid rotationIntervalMs value: {}, using default", config.get("rotationIntervalMs"));
+            }
+        }
+        
+        int totalNodes = 1;
+        if (config.containsKey("totalNodes")) {
+            try {
+                totalNodes = Integer.parseInt(config.get("totalNodes"));
+                if (totalNodes < 1) {
+                    LOGGER.warn("Invalid totalNodes value: {}, using 1", totalNodes);
+                    totalNodes = 1;
+                }
+            } catch (NumberFormatException e) {
+                LOGGER.error("Invalid totalNodes value: {}, using 1", config.get("totalNodes"));
+            }
+        }
+        
+        LOGGER.info("Creating round-robin selector for node {} in cluster {} with {} total nodes and rotation interval {}ms",
+            nodeId, clusterId, totalNodes, rotationIntervalMs);
+        
+        return new RoundRobinSelector(nodeId, totalNodes, rotationIntervalMs);
+    }
+    
+    /**
+     * A selector that rotates the primary uploader role among nodes.
+     */
+    private static class RoundRobinSelector implements UploaderNodeSelector {
+        private final int nodeId;
+        private final int totalNodes;
+        private final long rotationIntervalMs;
+        private final long startTimeMs;
+        
+        RoundRobinSelector(int nodeId, int totalNodes, long rotationIntervalMs) {
+            this.nodeId = nodeId;
+            this.totalNodes = totalNodes;
+            this.rotationIntervalMs = rotationIntervalMs;
+            this.startTimeMs = System.currentTimeMillis();
+        }
+        
+        @Override
+        public boolean isPrimaryUploader() {
+            if (totalNodes <= 1) {
+                return true; // If only one node, it's always primary
+            }
+            
+            // Calculate the current primary node based on time
+            long elapsedMs = System.currentTimeMillis() - startTimeMs;
+            int rotations = (int)(elapsedMs / rotationIntervalMs);
+            int currentPrimary = rotations % totalNodes;
+            
+            return nodeId == currentPrimary;
+        }
+    }
+}
diff --git a/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/s3/kafka/KafkaLeaderSelectorProvider.java b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/s3/kafka/KafkaLeaderSelectorProvider.java
new file mode 100644
index 0000000000..df5d824e79
--- /dev/null
+++ b/opentelemetry/src/main/java/com/automq/opentelemetry/exporter/s3/kafka/KafkaLeaderSelectorProvider.java
@@ -0,0 +1,495 @@
+package com.automq.opentelemetry.exporter.s3.kafka;
+
+import com.automq.opentelemetry.exporter.s3.UploaderNodeSelector;
+import com.automq.opentelemetry.exporter.s3.UploaderNodeSelectorProvider;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.kafka.clients.admin.Admin;
+import org.apache.kafka.clients.admin.AdminClientConfig;
+import org.apache.kafka.clients.admin.CreateTopicsOptions;
+import org.apache.kafka.clients.admin.NewTopic;
+import org.apache.kafka.clients.consumer.ConsumerConfig;
+import org.apache.kafka.clients.consumer.ConsumerRebalanceListener;
+import org.apache.kafka.clients.consumer.KafkaConsumer;
+import org.apache.kafka.clients.consumer.OffsetResetStrategy;
+import org.apache.kafka.common.TopicPartition;
+import org.apache.kafka.common.config.TopicConfig;
+import org.apache.kafka.common.errors.TopicExistsException;
+import org.apache.kafka.common.errors.WakeupException;
+import org.apache.kafka.common.serialization.ByteArrayDeserializer;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.time.Duration;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Properties;
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * A UploaderNodeSelectorProvider implementation that relies on Kafka consumer group membership for
+ * leader election. When using a topic with a single partition, only one consumer in the group will
+ * receive the assignment, which becomes the primary uploader. Other consumers act as standbys.
+ */
+public class KafkaLeaderSelectorProvider implements UploaderNodeSelectorProvider {
+    private static final Logger LOGGER = LoggerFactory.getLogger(KafkaLeaderSelectorProvider.class);
+
+    public static final String TYPE = "kafka";
+
+    private static final String DEFAULT_TOPIC_PREFIX = "__automq_telemetry_s3_leader_";
+    private static final String DEFAULT_GROUP_PREFIX = "automq-telemetry-s3-";
+    private static final String DEFAULT_CLIENT_PREFIX = "automq-telemetry-s3";
+
+    private static final long DEFAULT_TOPIC_RETENTION_MS = TimeUnit.MINUTES.toMillis(30);
+    private static final int DEFAULT_POLL_INTERVAL_MS = 1000;
+    private static final long DEFAULT_RETRY_BACKOFF_MS = TimeUnit.SECONDS.toMillis(5);
+    private static final int DEFAULT_SESSION_TIMEOUT_MS = 10000;
+    private static final int DEFAULT_HEARTBEAT_INTERVAL_MS = 3000;
+
+    private static final Set<String> RESERVED_KEYS;
+
+    static {
+        Set<String> keys = new HashSet<>();
+        Collections.addAll(keys,
+            "bootstrap.servers",
+            "topic",
+            "group.id",
+            "client.id",
+            "auto.create.topic",
+            "topic.partitions",
+            "topic.replication.factor",
+            "topic.retention.ms",
+            "poll.interval.ms",
+            "retry.backoff.ms",
+            "session.timeout.ms",
+            "heartbeat.interval.ms",
+            "request.timeout.ms"
+        );
+        RESERVED_KEYS = Collections.unmodifiableSet(keys);
+    }
+
+    @Override
+    public String getType() {
+        return TYPE;
+    }
+
+    @Override
+    public UploaderNodeSelector createSelector(String clusterId, int nodeId, Map<String, String> config) throws Exception {
+        KafkaLeaderElectionConfig electionConfig = KafkaLeaderElectionConfig.from(clusterId, nodeId, config);
+        KafkaLeaderSelector selector = new KafkaLeaderSelector(electionConfig);
+        selector.start();
+        return selector;
+    }
+
+    private static final class KafkaLeaderSelector implements UploaderNodeSelector {
+        private final KafkaLeaderElectionConfig config;
+        private final AtomicBoolean isLeader = new AtomicBoolean(false);
+        private final AtomicBoolean running = new AtomicBoolean(true);
+        private volatile KafkaConsumer<byte[], byte[]> consumer;
+
+        KafkaLeaderSelector(KafkaLeaderElectionConfig config) {
+            this.config = config;
+        }
+
+        void start() {
+            Thread thread = new Thread(this::runElectionLoop,
+                String.format("s3-metrics-kafka-selector-%s-%d", config.clusterId, config.nodeId));
+            thread.setDaemon(true);
+            thread.start();
+            Runtime.getRuntime().addShutdownHook(new Thread(this::shutdown,
+                String.format("s3-metrics-kafka-selector-shutdown-%s-%d", config.clusterId, config.nodeId)));
+        }
+
+        private void runElectionLoop() {
+            while (running.get()) {
+                try {
+                    ensureTopicExists();
+                    runConsumerLoop();
+                } catch (WakeupException e) {
+                    if (!running.get()) {
+                        break;
+                    }
+                    LOGGER.warn("Kafka leader selector interrupted unexpectedly for cluster {} node {}",
+                        config.clusterId, config.nodeId, e);
+                    sleep(config.retryBackoffMs);
+                } catch (Exception e) {
+                    if (!running.get()) {
+                        break;
+                    }
+                    LOGGER.warn("Kafka leader selector loop failed for cluster {} node {}: {}",
+                        config.clusterId, config.nodeId, e.getMessage(), e);
+                    sleep(config.retryBackoffMs);
+                }
+            }
+        }
+
+        private void runConsumerLoop() {
+            Properties consumerProps = config.buildConsumerProperties();
+            try (KafkaConsumer<byte[], byte[]> kafkaConsumer =
+                     new KafkaConsumer<>(consumerProps, new ByteArrayDeserializer(), new ByteArrayDeserializer())) {
+                this.consumer = kafkaConsumer;
+                ConsumerRebalanceListener rebalanceListener = new LeaderElectionRebalanceListener();
+                kafkaConsumer.subscribe(Collections.singletonList(config.topic), rebalanceListener);
+                LOGGER.info("Kafka selector subscribed to topic {} with group {}", config.topic, config.groupId);
+                while (running.get()) {
+                    kafkaConsumer.poll(Duration.ofMillis(config.pollIntervalMs));
+                }
+            } finally {
+                this.consumer = null;
+                demote();
+            }
+        }
+
+        private void ensureTopicExists() throws Exception {
+            if (!config.autoCreateTopic) {
+                return;
+            }
+            Properties adminProps = config.buildAdminProperties();
+            try (Admin admin = Admin.create(adminProps)) {
+                NewTopic newTopic = new NewTopic(config.topic, config.topicPartitions, config.topicReplicationFactor);
+                Map<String, String> topicConfig = new HashMap<>();
+                if (config.topicRetentionMs > 0) {
+                    topicConfig.put(TopicConfig.RETENTION_MS_CONFIG, String.valueOf(config.topicRetentionMs));
+                }
+                if (!topicConfig.isEmpty()) {
+                    newTopic.configs(topicConfig);
+                }
+                CreateTopicsOptions options = new CreateTopicsOptions().validateOnly(false);
+                admin.createTopics(Collections.singleton(newTopic), options).all().get();
+                LOGGER.info("Kafka selector created leader topic {} with partitions={} replicationFactor={}",
+                    config.topic, config.topicPartitions, config.topicReplicationFactor);
+            } catch (TopicExistsException ignored) {
+                // Topic already exists - expected on subsequent runs
+            } catch (Exception e) {
+                if (e instanceof InterruptedException) {
+                    Thread.currentThread().interrupt();
+                    throw e;
+                }
+                Throwable cause = e.getCause();
+                if (!(cause instanceof TopicExistsException)) {
+                    throw e;
+                }
+            }
+        }
+
+        @Override
+        public boolean isPrimaryUploader() {
+            return isLeader.get();
+        }
+
+        private void demote() {
+            if (isLeader.getAndSet(false)) {
+                LOGGER.info("Kafka selector demoted node {} for cluster {}", config.nodeId, config.clusterId);
+            }
+        }
+
+        private void promote() {
+            if (isLeader.compareAndSet(false, true)) {
+                LOGGER.info("Kafka selector elected node {} as primary uploader for cluster {}", config.nodeId, config.clusterId);
+            }
+        }
+
+        private void shutdown() {
+            if (running.compareAndSet(true, false)) {
+                KafkaConsumer<byte[], byte[]> localConsumer = consumer;
+                if (localConsumer != null) {
+                    localConsumer.wakeup();
+                }
+            }
+        }
+
+        private void sleep(long millis) {
+            try {
+                Thread.sleep(millis);
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+            }
+        }
+
+        private class LeaderElectionRebalanceListener implements ConsumerRebalanceListener {
+            @Override
+            public void onPartitionsRevoked(Collection<TopicPartition> partitions) {
+                if (!partitions.isEmpty()) {
+                    LOGGER.info("Kafka selector lost leadership on partitions {}", partitions);
+                }
+                demote();
+            }
+
+            @Override
+            public void onPartitionsAssigned(Collection<TopicPartition> partitions) {
+                if (!partitions.isEmpty()) {
+                    promote();
+                }
+            }
+        }
+    }
+
+    private static final class KafkaLeaderElectionConfig {
+        private final String clusterId;
+        private final int nodeId;
+        private final String bootstrapServers;
+        private final String topic;
+        private final String groupId;
+        private final String clientId;
+        private final boolean autoCreateTopic;
+        private final int topicPartitions;
+        private final short topicReplicationFactor;
+        private final long topicRetentionMs;
+        private final int pollIntervalMs;
+        private final long retryBackoffMs;
+        private final int sessionTimeoutMs;
+        private final int heartbeatIntervalMs;
+        private final int requestTimeoutMs;
+        private final Properties clientOverrides;
+
+        static KafkaLeaderElectionConfig from(String clusterId, int nodeId, Map<String, String> config) {
+            Map<String, String> effectiveConfig = config == null ? Collections.emptyMap() : config;
+
+            String bootstrapServers = findBootstrapServers(effectiveConfig);
+            if (StringUtils.isBlank(bootstrapServers)) {
+                throw new IllegalArgumentException("Kafka selector requires 'bootstrap.servers' configuration");
+            }
+
+            String normalizedClusterId = StringUtils.isBlank(clusterId) ? "default" : clusterId;
+            String topic = effectiveConfig.getOrDefault("topic", DEFAULT_TOPIC_PREFIX + normalizedClusterId);
+            String groupId = effectiveConfig.getOrDefault("group.id", DEFAULT_GROUP_PREFIX + normalizedClusterId);
+            String clientId = effectiveConfig.getOrDefault("client.id",
+                DEFAULT_CLIENT_PREFIX + "-" + normalizedClusterId + "-" + nodeId);
+
+            boolean autoCreateTopic = Boolean.parseBoolean(effectiveConfig.getOrDefault("auto.create.topic", "true"));
+            int partitions = parseInt(effectiveConfig.get("topic.partitions"), 1, 1);
+            short replicationFactor = (short) parseInt(effectiveConfig.get("topic.replication.factor"), 1, 1);
+            long retentionMs = parseLong(effectiveConfig.get("topic.retention.ms"), DEFAULT_TOPIC_RETENTION_MS);
+
+            int pollIntervalMs = parseInt(effectiveConfig.get("poll.interval.ms"), DEFAULT_POLL_INTERVAL_MS, 100);
+            long retryBackoffMs = parseLong(effectiveConfig.get("retry.backoff.ms"), DEFAULT_RETRY_BACKOFF_MS);
+            int sessionTimeoutMs = parseInt(effectiveConfig.get("session.timeout.ms"), DEFAULT_SESSION_TIMEOUT_MS, 1000);
+            int heartbeatIntervalMs = parseInt(effectiveConfig.get("heartbeat.interval.ms"), DEFAULT_HEARTBEAT_INTERVAL_MS, 500);
+            int requestTimeoutMs = parseInt(effectiveConfig.get("request.timeout.ms"), 15000, 1000);
+
+            Properties overrides = extractClientOverrides(effectiveConfig);
+
+            return builder()
+                .clusterId(clusterId)
+                .nodeId(nodeId)
+                .bootstrapServers(bootstrapServers)
+                .topic(topic)
+                .groupId(groupId)
+                .clientId(clientId)
+                .autoCreateTopic(autoCreateTopic)
+                .topicPartitions(partitions)
+                .topicReplicationFactor(replicationFactor)
+                .topicRetentionMs(retentionMs)
+                .pollIntervalMs(pollIntervalMs)
+                .retryBackoffMs(retryBackoffMs)
+                .sessionTimeoutMs(sessionTimeoutMs)
+                .heartbeatIntervalMs(heartbeatIntervalMs)
+                .requestTimeoutMs(requestTimeoutMs)
+                .clientOverrides(overrides)
+                .build();
+        }
+
+        private KafkaLeaderElectionConfig(Builder builder) {
+            this.clusterId = builder.clusterId;
+            this.nodeId = builder.nodeId;
+            this.bootstrapServers = builder.bootstrapServers;
+            this.topic = builder.topic;
+            this.groupId = builder.groupId;
+            this.clientId = builder.clientId;
+            this.autoCreateTopic = builder.autoCreateTopic;
+            this.topicPartitions = builder.topicPartitions;
+            this.topicReplicationFactor = builder.topicReplicationFactor;
+            this.topicRetentionMs = builder.topicRetentionMs;
+            this.pollIntervalMs = builder.pollIntervalMs;
+            this.retryBackoffMs = builder.retryBackoffMs;
+            this.sessionTimeoutMs = builder.sessionTimeoutMs;
+            this.heartbeatIntervalMs = builder.heartbeatIntervalMs;
+            this.requestTimeoutMs = builder.requestTimeoutMs;
+            this.clientOverrides = builder.clientOverrides;
+        }
+
+        Properties buildConsumerProperties() {
+            Properties props = new Properties();
+            props.putAll(clientOverrides);
+            props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers);
+            props.put(ConsumerConfig.GROUP_ID_CONFIG, groupId);
+            props.put(ConsumerConfig.CLIENT_ID_CONFIG, clientId + "-consumer");
+            props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, "false");
+            props.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG,
+                OffsetResetStrategy.EARLIEST.name().toLowerCase(Locale.ROOT));
+            props.put(ConsumerConfig.SESSION_TIMEOUT_MS_CONFIG, sessionTimeoutMs);
+            props.put(ConsumerConfig.HEARTBEAT_INTERVAL_MS_CONFIG, heartbeatIntervalMs);
+            props.put(ConsumerConfig.METADATA_MAX_AGE_CONFIG, String.valueOf(TimeUnit.SECONDS.toMillis(10)));
+            props.put(ConsumerConfig.MAX_POLL_INTERVAL_MS_CONFIG, Math.max(pollIntervalMs * 3, 3000));
+            props.put(ConsumerConfig.REQUEST_TIMEOUT_MS_CONFIG, requestTimeoutMs);
+            props.put(ConsumerConfig.ALLOW_AUTO_CREATE_TOPICS_CONFIG, "false");
+            props.putIfAbsent(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, ByteArrayDeserializer.class.getName());
+            props.putIfAbsent(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, ByteArrayDeserializer.class.getName());
+            return props;
+        }
+
+        Properties buildAdminProperties() {
+            Properties props = new Properties();
+            props.putAll(clientOverrides);
+            props.put(AdminClientConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers);
+            props.put(AdminClientConfig.CLIENT_ID_CONFIG, clientId + "-admin");
+            props.put(AdminClientConfig.REQUEST_TIMEOUT_MS_CONFIG, requestTimeoutMs);
+            return props;
+        }
+
+        private static Properties extractClientOverrides(Map<String, String> config) {
+            Properties props = new Properties();
+            for (Map.Entry<String, String> entry : config.entrySet()) {
+                String key = entry.getKey();
+                if (RESERVED_KEYS.contains(key)) {
+                    continue;
+                }
+                props.put(key, entry.getValue());
+            }
+            return props;
+        }
+
+        private static String findBootstrapServers(Map<String, String> config) {
+            String directValue = config.get("bootstrap.servers");
+            if (StringUtils.isNotBlank(directValue)) {
+                return directValue;
+            }
+            return config.get("bootstrapServers");
+        }
+
+        private static int parseInt(String value, int defaultValue, int minimum) {
+            if (StringUtils.isBlank(value)) {
+                return defaultValue;
+            }
+            try {
+                int parsed = Integer.parseInt(value.trim());
+                return Math.max(parsed, minimum);
+            } catch (NumberFormatException e) {
+                return defaultValue;
+            }
+        }
+
+        private static long parseLong(String value, long defaultValue) {
+            if (StringUtils.isBlank(value)) {
+                return defaultValue;
+            }
+            try {
+                return Long.parseLong(value.trim());
+            } catch (NumberFormatException e) {
+                return defaultValue;
+            }
+        }
+
+        private static Builder builder() {
+            return new Builder();
+        }
+
+        private static final class Builder {
+            private String clusterId;
+            private int nodeId;
+            private String bootstrapServers;
+            private String topic;
+            private String groupId;
+            private String clientId;
+            private boolean autoCreateTopic;
+            private int topicPartitions;
+            private short topicReplicationFactor;
+            private long topicRetentionMs;
+            private int pollIntervalMs;
+            private long retryBackoffMs;
+            private int sessionTimeoutMs;
+            private int heartbeatIntervalMs;
+            private int requestTimeoutMs;
+            private Properties clientOverrides;
+
+            Builder clusterId(String value) {
+                this.clusterId = value;
+                return this;
+            }
+
+            Builder nodeId(int value) {
+                this.nodeId = value;
+                return this;
+            }
+
+            Builder bootstrapServers(String value) {
+                this.bootstrapServers = value;
+                return this;
+            }
+
+            Builder topic(String value) {
+                this.topic = value;
+                return this;
+            }
+
+            Builder groupId(String value) {
+                this.groupId = value;
+                return this;
+            }
+
+            Builder clientId(String value) {
+                this.clientId = value;
+                return this;
+            }
+
+            Builder autoCreateTopic(boolean value) {
+                this.autoCreateTopic = value;
+                return this;
+            }
+
+            Builder topicPartitions(int value) {
+                this.topicPartitions = value;
+                return this;
+            }
+
+            Builder topicReplicationFactor(short value) {
+                this.topicReplicationFactor = value;
+                return this;
+            }
+
+            Builder topicRetentionMs(long value) {
+                this.topicRetentionMs = value;
+                return this;
+            }
+
+            Builder pollIntervalMs(int value) {
+                this.pollIntervalMs = value;
+                return this;
+            }
+
+            Builder retryBackoffMs(long value) {
+                this.retryBackoffMs = value;
+                return this;
+            }
+
+            Builder sessionTimeoutMs(int value) {
+                this.sessionTimeoutMs = value;
+                return this;
+            }
+
+            Builder heartbeatIntervalMs(int value) {
+                this.heartbeatIntervalMs = value;
+                return this;
+            }
+
+            Builder requestTimeoutMs(int value) {
+                this.requestTimeoutMs = value;
+                return this;
+            }
+
+            Builder clientOverrides(Properties value) {
+                this.clientOverrides = value;
+                return this;
+            }
+
+            KafkaLeaderElectionConfig build() {
+                return new KafkaLeaderElectionConfig(this);
+            }
+        }
+    }
+}
diff --git a/opentelemetry/src/main/java/com/automq/opentelemetry/yammer/DeltaHistogram.java b/opentelemetry/src/main/java/com/automq/opentelemetry/yammer/DeltaHistogram.java
new file mode 100644
index 0000000000..8f4fd459f5
--- /dev/null
+++ b/opentelemetry/src/main/java/com/automq/opentelemetry/yammer/DeltaHistogram.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright 2025, AutoMQ HK Limited.
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.automq.opentelemetry.yammer;
+
+import com.yammer.metrics.core.Histogram;
+import com.yammer.metrics.core.Timer;
+
+public class DeltaHistogram {
+    private final Summarize summarize;
+    private long count;
+    private double sum;
+    private double deltaMean;
+
+    public DeltaHistogram(Histogram histogram) {
+        this.summarize = new Summarize(histogram);
+    }
+
+    public DeltaHistogram(Timer timer) {
+        this.summarize = new Summarize(timer);
+    }
+
+    private void update() {
+        if (count == 0) {
+            updateState(summarize.count(), summarize.sum());
+            deltaMean = summarize.mean();
+        } else {
+            long deltaCount = summarize.count() - count;
+            if (deltaCount <= 0) {
+                updateState(summarize.count(), summarize.sum());
+                deltaMean = 0;
+                return;
+            }
+            double deltaSum = summarize.sum() - sum;
+            deltaMean = deltaSum / deltaCount;
+            updateState(summarize.count(), summarize.sum());
+        }
+    }
+
+    private void updateState(long count, double sum) {
+        this.count = count;
+        this.sum = sum;
+    }
+
+    public double getDeltaMean() {
+        update();
+        return deltaMean;
+    }
+
+    public static class Summarize {
+        private final Histogram histogram;
+        private final Timer timer;
+
+        public Summarize(Histogram histogram) {
+            this.histogram = histogram;
+            this.timer = null;
+        }
+
+        public Summarize(Timer timer) {
+            this.histogram = null;
+            this.timer = timer;
+        }
+
+        public long count() {
+            if (histogram != null) {
+                return histogram.count();
+            } else if (timer != null) {
+                return timer.count();
+            }
+            return 0;
+        }
+
+        public double sum() {
+            if (histogram != null) {
+                return histogram.sum();
+            } else if (timer != null) {
+                return timer.sum();
+            }
+            return 0;
+        }
+
+        public double mean() {
+            if (histogram != null) {
+                return histogram.mean();
+            } else if (timer != null) {
+                return timer.mean();
+            }
+            return 0;
+        }
+    }
+}
diff --git a/opentelemetry/src/main/java/com/automq/opentelemetry/yammer/OTelMetricUtils.java b/opentelemetry/src/main/java/com/automq/opentelemetry/yammer/OTelMetricUtils.java
new file mode 100644
index 0000000000..7d58de2661
--- /dev/null
+++ b/opentelemetry/src/main/java/com/automq/opentelemetry/yammer/OTelMetricUtils.java
@@ -0,0 +1,174 @@
+/*
+ * Copyright 2025, AutoMQ HK Limited.
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.automq.opentelemetry.yammer;
+
+import com.yammer.metrics.core.MetricName;
+
+import io.opentelemetry.api.metrics.DoubleGaugeBuilder;
+import io.opentelemetry.api.metrics.Meter;
+
+public class OTelMetricUtils {
+    public static final String REQUEST_TAG_KEY = "request";
+    public static final String TYPE_TAG_KEY = "type";
+    // metric groups
+    private static final String KAFKA_NETWORK_GROUP = "kafka.network";
+    private static final String KAFKA_LOG_GROUP = "kafka.log";
+    private static final String KAFKA_CONTROLLER_GROUP = "kafka.controller";
+
+    // metric types
+    private static final String REQUEST_METRICS_TYPE = "RequestMetrics";
+    private static final String LOG_FLUSH_STATS_TYPE = "LogFlushStats";
+    private static final String CONTROLLER_EVENT_MANAGER_TYPE = "ControllerEventManager";
+
+    // metric names
+    private static final String REQUEST_BYTES = "RequestBytes";
+    private static final String TOTAL_TIME_MS = "TotalTimeMs";
+    private static final String REQUEST_QUEUE_TIME = "RequestQueueTimeMs";
+    private static final String RESPONSE_QUEUE_TIME = "ResponseQueueTimeMs";
+    private static final String LOG_FLUSH_RATE_AND_TIME_MS = "LogFlushRateAndTimeMs";
+    private static final String EVENT_QUEUE_TIME_MS = "EventQueueTimeMs";
+    private static final String EVENT_QUEUE_PROCESSING_TIME_MS = "EventQueueProcessingTimeMs";
+
+    public static boolean isInterestedMetric(MetricName metricName) {
+        if (metricName == null) {
+            return false;
+        }
+        switch (metricName.getGroup()) {
+            case KAFKA_NETWORK_GROUP:
+                return isInterestedNetworkMetric(metricName);
+            case KAFKA_LOG_GROUP:
+                return isInterestedLogMetric(metricName);
+            case KAFKA_CONTROLLER_GROUP:
+                return isInterestedControllerMetric(metricName);
+            default:
+                return false;
+        }
+    }
+
+    public static boolean isInterestedNetworkMetric(MetricName metricName) {
+        if (metricName == null) {
+            return false;
+        }
+        if (REQUEST_METRICS_TYPE.equals(metricName.getType())) {
+            switch (metricName.getName()) {
+                case REQUEST_BYTES:
+                case TOTAL_TIME_MS:
+                case REQUEST_QUEUE_TIME:
+                case RESPONSE_QUEUE_TIME:
+                    return true;
+            }
+        }
+        return false;
+    }
+
+    public static boolean isInterestedLogMetric(MetricName metricName) {
+        if (metricName == null) {
+            return false;
+        }
+        if (LOG_FLUSH_STATS_TYPE.equals(metricName.getType())) {
+            switch (metricName.getName()) {
+                case LOG_FLUSH_RATE_AND_TIME_MS:
+                    return true;
+            }
+        }
+        return false;
+    }
+
+    public static boolean isInterestedControllerMetric(MetricName metricName) {
+        if (metricName == null) {
+            return false;
+        }
+        if (CONTROLLER_EVENT_MANAGER_TYPE.equals(metricName.getType())) {
+            switch (metricName.getName()) {
+                case EVENT_QUEUE_TIME_MS:
+                case EVENT_QUEUE_PROCESSING_TIME_MS:
+                    return true;
+            }
+        }
+        return false;
+    }
+
+    public static String toOTelMetricNamePrefix(MetricName metricName) {
+        if (metricName == null) {
+            throw new IllegalArgumentException("Metric name must not be null");
+        }
+        switch (metricName.getName()) {
+            case REQUEST_BYTES:
+                return "kafka.request.size";
+            case TOTAL_TIME_MS:
+                return "kafka.request.time";
+            case REQUEST_QUEUE_TIME:
+                return  "kafka.request.queue.time";
+            case RESPONSE_QUEUE_TIME:
+                return  "kafka.response.queue.time";
+            case LOG_FLUSH_RATE_AND_TIME_MS:
+                return  "kafka.logs.flush.time";
+            case EVENT_QUEUE_TIME_MS:
+                return  "kafka.event.queue.time";
+            case EVENT_QUEUE_PROCESSING_TIME_MS:
+                return  "kafka.event.queue.processing.time";
+            default:
+                throw new IllegalArgumentException("Unsupported metric name: " + metricName.getName());
+        }
+    }
+
+    public static String toMeanMetricName(MetricName metricName) {
+        return toOTelMetricNamePrefix(metricName) + ".mean";
+    }
+
+    public static DoubleGaugeBuilder toMeanGaugeBuilder(Meter meter, MetricName metricName) {
+        if (meter == null || metricName == null) {
+            throw new IllegalArgumentException("Meter and metric name must not be null");
+        }
+        switch (metricName.getName()) {
+            case REQUEST_BYTES:
+                return meter.gaugeBuilder(toMeanMetricName(metricName))
+                    .setDescription("The mean request size in bytes")
+                    .setUnit("bytes");
+            case TOTAL_TIME_MS:
+                return meter.gaugeBuilder(toMeanMetricName(metricName))
+                    .setDescription("The mean time the broker has taken to service requests")
+                    .setUnit("milliseconds");
+            case REQUEST_QUEUE_TIME:
+                return meter.gaugeBuilder(toMeanMetricName(metricName))
+                    .setDescription("The mean time the broker has taken to dequeue requests")
+                    .setUnit("milliseconds");
+            case RESPONSE_QUEUE_TIME:
+                return meter.gaugeBuilder(toMeanMetricName(metricName))
+                    .setDescription("The mean time the broker has taken to dequeue responses")
+                    .setUnit("milliseconds");
+            case LOG_FLUSH_RATE_AND_TIME_MS:
+                return meter.gaugeBuilder(toMeanMetricName(metricName))
+                    .setDescription("Log flush time - mean")
+                    .setUnit("milliseconds");
+            case EVENT_QUEUE_TIME_MS:
+                return meter.gaugeBuilder(toMeanMetricName(metricName))
+                    .setDescription("The mean time the event waits in the queue")
+                    .setUnit("milliseconds");
+            case EVENT_QUEUE_PROCESSING_TIME_MS:
+                return meter.gaugeBuilder(toMeanMetricName(metricName))
+                    .setDescription("The mean time used to process the event in the event queue")
+                    .setUnit("milliseconds");
+            default:
+                throw new IllegalArgumentException("Unsupported metric name: " + metricName.getName());
+        }
+    }
+
+}
diff --git a/opentelemetry/src/main/java/com/automq/opentelemetry/yammer/YammerMetricsProcessor.java b/opentelemetry/src/main/java/com/automq/opentelemetry/yammer/YammerMetricsProcessor.java
new file mode 100644
index 0000000000..0875ccae2f
--- /dev/null
+++ b/opentelemetry/src/main/java/com/automq/opentelemetry/yammer/YammerMetricsProcessor.java
@@ -0,0 +1,196 @@
+/*
+ * Copyright 2025, AutoMQ HK Limited.
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.automq.opentelemetry.yammer;
+
+
+import com.yammer.metrics.core.Counter;
+import com.yammer.metrics.core.Gauge;
+import com.yammer.metrics.core.Histogram;
+import com.yammer.metrics.core.Metered;
+import com.yammer.metrics.core.MetricName;
+import com.yammer.metrics.core.MetricProcessor;
+import com.yammer.metrics.core.Timer;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+import io.opentelemetry.api.common.Attributes;
+import io.opentelemetry.api.common.AttributesBuilder;
+import io.opentelemetry.api.metrics.Meter;
+
+/**
+ * A metrics processor that bridges Yammer metrics to OpenTelemetry metrics.
+ * 
+ * <p>This processor specifically handles Histogram and Timer metrics from the Yammer metrics
+ * library and converts them to OpenTelemetry gauge metrics that track delta mean values.
+ * It implements the Yammer {@link MetricProcessor} interface to process metrics and creates
+ * corresponding OpenTelemetry metrics with proper attributes derived from the metric scope.
+ * 
+ * <p>The processor:
+ * <ul>
+ *   <li>Converts Yammer Histogram and Timer metrics to OpenTelemetry gauges</li>
+ *   <li>Calculates delta mean values using {@link DeltaHistogram}</li>
+ *   <li>Parses metric scopes to extract attributes for OpenTelemetry metrics</li>
+ *   <li>Maintains a registry of processed metrics for lifecycle management</li>
+ *   <li>Supports metric removal when metrics are no longer needed</li>
+ * </ul>
+ * 
+ * <p>Supported metric types:
+ * <ul>
+ *   <li>{@link Histogram} - Converted to delta mean gauge</li>
+ *   <li>{@link Timer} - Converted to delta mean gauge</li>
+ * </ul>
+ * 
+ * <p>Unsupported metric types (will throw {@link UnsupportedOperationException}):
+ * <ul>
+ *   <li>{@link Counter}</li>
+ *   <li>{@link Gauge}</li>
+ *   <li>{@link Metered}</li>
+ * </ul>
+ * 
+ * <p>Thread Safety: This class is thread-safe and uses concurrent data structures
+ * to handle metrics registration and removal from multiple threads.
+ * 
+ * @see MetricProcessor
+ * @see DeltaHistogram
+ * @see OTelMetricUtils
+ */
+public class YammerMetricsProcessor implements MetricProcessor<Void> {
+    private static final Logger LOGGER = LoggerFactory.getLogger(YammerMetricsProcessor.class);
+    private final Map<String, Map<MetricName, MetricWrapper>> metrics = new ConcurrentHashMap<>();
+    private Meter meter = null;
+
+    public void init(Meter meter) {
+        this.meter = meter;
+    }
+
+    @Override
+    public void processMeter(MetricName name, Metered metered, Void unused) {
+        throw new UnsupportedOperationException("Meter type is not supported");
+    }
+
+    @Override
+    public void processCounter(MetricName name, Counter counter, Void unused) {
+        throw new UnsupportedOperationException("Counter type is not supported");
+    }
+
+    @Override
+    public void processHistogram(MetricName name, Histogram histogram, Void unused) {
+        processDeltaHistogramMetric(name, new DeltaHistogram(histogram));
+    }
+
+    @Override
+    public void processTimer(MetricName name, Timer timer, Void unused) {
+        processDeltaHistogramMetric(name, new DeltaHistogram(timer));
+    }
+
+    private void processDeltaHistogramMetric(MetricName name, DeltaHistogram deltaHistogram) {
+        if (meter == null) {
+            throw new IllegalStateException("Meter is not initialized");
+        }
+        Map<String, String> tags = yammerMetricScopeToTags(name.getScope());
+        AttributesBuilder attrBuilder = Attributes.builder();
+        if (tags != null) {
+            String value = tags.remove(OTelMetricUtils.REQUEST_TAG_KEY);
+            if (value != null) {
+                tags.put(OTelMetricUtils.TYPE_TAG_KEY, value);
+            }
+            tags.forEach(attrBuilder::put);
+        }
+        Attributes attr = attrBuilder.build();
+        String otelMetricName = OTelMetricUtils.toMeanMetricName(name);
+        metrics.compute(otelMetricName, (k, v) -> {
+            if (v == null) {
+                v = new ConcurrentHashMap<>();
+                final Map<MetricName, MetricWrapper> finalV = v;
+                OTelMetricUtils.toMeanGaugeBuilder(meter, name).buildWithCallback(measurement ->
+                    finalV.forEach((metricname, metricWrapper) ->
+                        measurement.record(metricWrapper.mean(), metricWrapper.getAttr())));
+                LOGGER.info("Created delta gauge for metric: {}", otelMetricName);
+            }
+            v.put(name, new MetricWrapper(attr, deltaHistogram));
+            return v;
+        });
+    }
+
+    @Override
+    public void processGauge(MetricName name, Gauge<?> gauge, Void unused) {
+        throw new UnsupportedOperationException("Gauge type is not supported");
+    }
+
+    public void remove(MetricName metricName) {
+        String otelMetricName = OTelMetricUtils.toMeanMetricName(metricName);
+        metrics.compute(otelMetricName, (k, v) -> {
+            if (v != null) {
+                v.remove(metricName);
+                if (v.isEmpty()) {
+                    return null;
+                }
+            }
+            return v;
+        });
+    }
+
+    /**
+     * Convert a yammer metrics scope to a tags map.
+     *
+     * @param scope Scope of the Yammer metric.
+     * @return Empty map for {@code null} scope, {@code null} for scope with keys without a matching value (i.e. unacceptable
+     * scope) (see <a href="https://github.com/linkedin/cruise-control/issues/1296">...</a>), parsed tags otherwise.
+     */
+    public static Map<String, String> yammerMetricScopeToTags(String scope) {
+        if (scope != null) {
+            String[] kv = scope.split("\\.");
+            if (kv.length % 2 != 0) {
+                return null;
+            }
+            Map<String, String> tags = new HashMap<>();
+            for (int i = 0; i < kv.length; i += 2) {
+                tags.put(kv[i], kv[i + 1]);
+            }
+            return tags;
+        } else {
+            return Collections.emptyMap();
+        }
+    }
+
+    static class MetricWrapper {
+        private final Attributes attr;
+        private final DeltaHistogram deltaHistogram;
+
+        public MetricWrapper(Attributes attr, DeltaHistogram deltaHistogram) {
+            this.attr = attr;
+            this.deltaHistogram = deltaHistogram;
+        }
+
+        public Attributes getAttr() {
+            return attr;
+        }
+
+        public double mean() {
+            return this.deltaHistogram.getDeltaMean();
+        }
+    }
+}
diff --git a/opentelemetry/src/main/java/com/automq/opentelemetry/yammer/YammerMetricsReporter.java b/opentelemetry/src/main/java/com/automq/opentelemetry/yammer/YammerMetricsReporter.java
new file mode 100644
index 0000000000..5f0aa622ac
--- /dev/null
+++ b/opentelemetry/src/main/java/com/automq/opentelemetry/yammer/YammerMetricsReporter.java
@@ -0,0 +1,72 @@
+package com.automq.opentelemetry.yammer;
+
+import com.yammer.metrics.core.Metric;
+import com.yammer.metrics.core.MetricName;
+import com.yammer.metrics.core.MetricsRegistry;
+import com.yammer.metrics.core.MetricsRegistryListener;
+import io.opentelemetry.api.metrics.Meter;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.Closeable;
+import java.io.IOException;
+
+/**
+ * A listener that bridges Yammer Histogram metrics to OpenTelemetry.
+ * It listens for new metrics added to a MetricsRegistry and creates corresponding
+ * OTel gauge metrics for mean and max values of histograms.
+ */
+public class YammerMetricsReporter implements MetricsRegistryListener, Closeable {
+    private static final Logger LOGGER = LoggerFactory.getLogger(YammerMetricsReporter.class);
+    private final MetricsRegistry metricsRegistry;
+    private final YammerMetricsProcessor metricsProcessor;
+    private volatile Meter meter;
+
+    public YammerMetricsReporter(MetricsRegistry metricsRegistry) {
+        this.metricsRegistry = metricsRegistry;
+        this.metricsProcessor = new YammerMetricsProcessor();
+    }
+
+    public void start(Meter meter) {
+        this.meter = meter;
+        this.metricsProcessor.init(meter);
+        metricsRegistry.addListener(this);
+        LOGGER.info("OTelHistogramReporter started");
+    }
+
+    @Override
+    public void onMetricAdded(MetricName name, Metric metric) {
+        if (OTelMetricUtils.isInterestedMetric(name)) {
+            if (this.meter == null) {
+                LOGGER.info("Not initialized yet, skipping metric: {}", name);
+                return;
+            }
+            try {
+                metric.processWith(this.metricsProcessor, name, null);
+            } catch (Throwable t) {
+                LOGGER.error("Failed to process metric: {}", name, t);
+            }
+        }
+    }
+
+    @Override
+    public void onMetricRemoved(MetricName name) {
+        try {
+            this.metricsProcessor.remove(name);
+        } catch (Throwable ignored) {
+
+        }
+    }
+
+    @Override
+    public void close() throws IOException {
+        try {
+            // Remove this reporter as a listener from the metrics registry
+            metricsRegistry.removeListener(this);
+            LOGGER.info("YammerMetricsReporter stopped and removed from metrics registry");
+        } catch (Exception e) {
+            LOGGER.error("Error while closing YammerMetricsReporter", e);
+            throw new IOException("Failed to close YammerMetricsReporter", e);
+        }
+    }
+}
\ No newline at end of file
diff --git a/opentelemetry/src/main/proto/common/v1/common.proto b/opentelemetry/src/main/proto/common/v1/common.proto
new file mode 100644
index 0000000000..6d94ace460
--- /dev/null
+++ b/opentelemetry/src/main/proto/common/v1/common.proto
@@ -0,0 +1,81 @@
+// Copyright 2019, OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+syntax = "proto3";
+
+package com.automq.opentelemetry.telemetry.proto.common.v1;
+
+option csharp_namespace = "OpenTelemetry.Proto.Common.V1";
+option java_multiple_files = true;
+option java_package = "com.automq.opentelemetry.telemetry.common.v1";
+option java_outer_classname = "CommonProto";
+option go_package = "go.opentelemetry.io/proto/otlp/common/v1";
+
+// AnyValue is used to represent any type of attribute value. AnyValue may contain a
+// primitive value such as a string or integer or it may contain an arbitrary nested
+// object containing arrays, key-value lists and primitives.
+message AnyValue {
+  // The value is one of the listed fields. It is valid for all values to be unspecified
+  // in which case this AnyValue is considered to be "empty".
+  oneof value {
+    string string_value = 1;
+    bool bool_value = 2;
+    int64 int_value = 3;
+    double double_value = 4;
+    ArrayValue array_value = 5;
+    KeyValueList kvlist_value = 6;
+    bytes bytes_value = 7;
+  }
+}
+
+// ArrayValue is a list of AnyValue messages. We need ArrayValue as a message
+// since oneof in AnyValue does not allow repeated fields.
+message ArrayValue {
+  // Array of values. The array may be empty (contain 0 elements).
+  repeated AnyValue values = 1;
+}
+
+// KeyValueList is a list of KeyValue messages. We need KeyValueList as a message
+// since `oneof` in AnyValue does not allow repeated fields. Everywhere else where we need
+// a list of KeyValue messages (e.g. in Span) we use `repeated KeyValue` directly to
+// avoid unnecessary extra wrapping (which slows down the protocol). The 2 approaches
+// are semantically equivalent.
+message KeyValueList {
+  // A collection of key/value pairs of key-value pairs. The list may be empty (may
+  // contain 0 elements).
+  // The keys MUST be unique (it is not allowed to have more than one
+  // value with the same key).
+  repeated KeyValue values = 1;
+}
+
+// KeyValue is a key-value pair that is used to store Span attributes, Link
+// attributes, etc.
+message KeyValue {
+  string key = 1;
+  AnyValue value = 2;
+}
+
+// InstrumentationScope is a message representing the instrumentation scope information
+// such as the fully qualified name and version. 
+message InstrumentationScope {
+  // An empty instrumentation scope name means the name is unknown.
+  string name = 1;
+  string version = 2;
+
+  // Additional attributes that describe the scope. [Optional].
+  // Attribute keys MUST be unique (it is not allowed to have more than one
+  // attribute with the same key).
+  repeated KeyValue attributes = 3;
+  uint32 dropped_attributes_count = 4;
+}
diff --git a/opentelemetry/src/main/proto/metrics/v1/metrics.proto b/opentelemetry/src/main/proto/metrics/v1/metrics.proto
new file mode 100644
index 0000000000..aad646bf40
--- /dev/null
+++ b/opentelemetry/src/main/proto/metrics/v1/metrics.proto
@@ -0,0 +1,712 @@
+// Copyright 2019, OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+syntax = "proto3";
+
+package com.automq.opentelemetry.telemetry.proto.resource.v1;
+
+import "common/v1/common.proto";
+import "resource/v1/resource.proto";
+
+option csharp_namespace = "OpenTelemetry.Proto.Metrics.V1";
+option java_multiple_files = true;
+option java_package = "com.automq.opentelemetry.telemetry.proto.metrics.v1";
+option java_outer_classname = "MetricsProto";
+option go_package = "go.opentelemetry.io/proto/otlp/metrics/v1";
+
+// MetricsData represents the metrics data that can be stored in a persistent
+// storage, OR can be embedded by other protocols that transfer OTLP metrics
+// data but do not implement the OTLP protocol.
+//
+// MetricsData
+// └─── ResourceMetrics
+//   ├── Resource
+//   ├── SchemaURL
+//   └── ScopeMetrics
+//      ├── Scope
+//      ├── SchemaURL
+//      └── Metric
+//         ├── Name
+//         ├── Description
+//         ├── Unit
+//         └── data
+//            ├── Gauge
+//            ├── Sum
+//            ├── Histogram
+//            ├── ExponentialHistogram
+//            └── Summary
+//
+// The main difference between this message and collector protocol is that
+// in this message there will not be any "control" or "metadata" specific to
+// OTLP protocol.
+//
+// When new fields are added into this message, the OTLP request MUST be updated
+// as well.
+message MetricsData {
+  // An array of ResourceMetrics.
+  // For data coming from a single resource this array will typically contain
+  // one element. Intermediary nodes that receive data from multiple origins
+  // typically batch the data before forwarding further and in that case this
+  // array will contain multiple elements.
+  repeated ResourceMetrics resource_metrics = 1;
+}
+
+// A collection of ScopeMetrics from a Resource.
+message ResourceMetrics {
+  reserved 1000;
+
+  // The resource for the metrics in this message.
+  // If this field is not set then no resource info is known.
+  com.automq.opentelemetry.telemetry.proto.resource.v1.Resource resource = 1;
+
+  // A list of metrics that originate from a resource.
+  repeated ScopeMetrics scope_metrics = 2;
+
+  // The Schema URL, if known. This is the identifier of the Schema that the resource data
+  // is recorded in. To learn more about Schema URL see
+  // https://opentelemetry.io/docs/specs/otel/schemas/#schema-url
+  // This schema_url applies to the data in the "resource" field. It does not apply
+  // to the data in the "scope_metrics" field which have their own schema_url field.
+  string schema_url = 3;
+}
+
+// A collection of Metrics produced by an Scope.
+message ScopeMetrics {
+  // The instrumentation scope information for the metrics in this message.
+  // Semantically when InstrumentationScope isn't set, it is equivalent with
+  // an empty instrumentation scope name (unknown).
+  com.automq.opentelemetry.telemetry.proto.common.v1.InstrumentationScope scope = 1;
+
+  // A list of metrics that originate from an instrumentation library.
+  repeated Metric metrics = 2;
+
+  // The Schema URL, if known. This is the identifier of the Schema that the metric data
+  // is recorded in. To learn more about Schema URL see
+  // https://opentelemetry.io/docs/specs/otel/schemas/#schema-url
+  // This schema_url applies to all metrics in the "metrics" field.
+  string schema_url = 3;
+}
+
+// Defines a Metric which has one or more timeseries.  The following is a
+// brief summary of the Metric data model.  For more details, see:
+//
+//   https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/data-model.md
+//
+// The data model and relation between entities is shown in the
+// diagram below. Here, "DataPoint" is the term used to refer to any
+// one of the specific data point value types, and "points" is the term used
+// to refer to any one of the lists of points contained in the Metric.
+//
+// - Metric is composed of a metadata and data.
+// - Metadata part contains a name, description, unit.
+// - Data is one of the possible types (Sum, Gauge, Histogram, Summary).
+// - DataPoint contains timestamps, attributes, and one of the possible value type
+//   fields.
+//
+//    Metric
+//  +------------+
+//  |name        |
+//  |description |
+//  |unit        |     +------------------------------------+
+//  |data        |---> |Gauge, Sum, Histogram, Summary, ... |
+//  +------------+     +------------------------------------+
+//
+//    Data [One of Gauge, Sum, Histogram, Summary, ...]
+//  +-----------+
+//  |...        |  // Metadata about the Data.
+//  |points     |--+
+//  +-----------+  |
+//                 |      +---------------------------+
+//                 |      |DataPoint 1                |
+//                 v      |+------+------+   +------+ |
+//              +-----+   ||label |label |...|label | |
+//              |  1  |-->||value1|value2|...|valueN| |
+//              +-----+   |+------+------+   +------+ |
+//              |  .  |   |+-----+                    |
+//              |  .  |   ||value|                    |
+//              |  .  |   |+-----+                    |
+//              |  .  |   +---------------------------+
+//              |  .  |                   .
+//              |  .  |                   .
+//              |  .  |                   .
+//              |  .  |   +---------------------------+
+//              |  .  |   |DataPoint M                |
+//              +-----+   |+------+------+   +------+ |
+//              |  M  |-->||label |label |...|label | |
+//              +-----+   ||value1|value2|...|valueN| |
+//                        |+------+------+   +------+ |
+//                        |+-----+                    |
+//                        ||value|                    |
+//                        |+-----+                    |
+//                        +---------------------------+
+//
+// Each distinct type of DataPoint represents the output of a specific
+// aggregation function, the result of applying the DataPoint's
+// associated function of to one or more measurements.
+//
+// All DataPoint types have three common fields:
+// - Attributes includes key-value pairs associated with the data point
+// - TimeUnixNano is required, set to the end time of the aggregation
+// - StartTimeUnixNano is optional, but strongly encouraged for DataPoints
+//   having an AggregationTemporality field, as discussed below.
+//
+// Both TimeUnixNano and StartTimeUnixNano values are expressed as
+// UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January 1970.
+//
+// # TimeUnixNano
+//
+// This field is required, having consistent interpretation across
+// DataPoint types.  TimeUnixNano is the moment corresponding to when
+// the data point's aggregate value was captured.
+//
+// Data points with the 0 value for TimeUnixNano SHOULD be rejected
+// by consumers.
+//
+// # StartTimeUnixNano
+//
+// StartTimeUnixNano in general allows detecting when a sequence of
+// observations is unbroken.  This field indicates to consumers the
+// start time for points with cumulative and delta
+// AggregationTemporality, and it should be included whenever possible
+// to support correct rate calculation.  Although it may be omitted
+// when the start time is truly unknown, setting StartTimeUnixNano is
+// strongly encouraged.
+message Metric {
+  reserved 4, 6, 8;
+
+  // name of the metric.
+  string name = 1;
+
+  // description of the metric, which can be used in documentation.
+  string description = 2;
+
+  // unit in which the metric value is reported. Follows the format
+  // described by http://unitsofmeasure.org/ucum.html.
+  string unit = 3;
+
+  // Data determines the aggregation type (if any) of the metric, what is the
+  // reported value type for the data points, as well as the relatationship to
+  // the time interval over which they are reported.
+  oneof data {
+    Gauge gauge = 5;
+    Sum sum = 7;
+    Histogram histogram = 9;
+    ExponentialHistogram exponential_histogram = 10;
+    Summary summary = 11;
+  }
+
+  // Additional metadata attributes that describe the metric. [Optional].
+  // Attributes are non-identifying.
+  // Consumers SHOULD NOT need to be aware of these attributes.
+  // These attributes MAY be used to encode information allowing
+  // for lossless roundtrip translation to / from another data model.
+  // Attribute keys MUST be unique (it is not allowed to have more than one
+  // attribute with the same key).
+  repeated com.automq.opentelemetry.telemetry.proto.common.v1.KeyValue metadata = 12;
+}
+
+// Gauge represents the type of a scalar metric that always exports the
+// "current value" for every data point. It should be used for an "unknown"
+// aggregation.
+//
+// A Gauge does not support different aggregation temporalities. Given the
+// aggregation is unknown, points cannot be combined using the same
+// aggregation, regardless of aggregation temporalities. Therefore,
+// AggregationTemporality is not included. Consequently, this also means
+// "StartTimeUnixNano" is ignored for all data points.
+message Gauge {
+  repeated NumberDataPoint data_points = 1;
+}
+
+// Sum represents the type of a scalar metric that is calculated as a sum of all
+// reported measurements over a time interval.
+message Sum {
+  repeated NumberDataPoint data_points = 1;
+
+  // aggregation_temporality describes if the aggregator reports delta changes
+  // since last report time, or cumulative changes since a fixed start time.
+  AggregationTemporality aggregation_temporality = 2;
+
+  // If "true" means that the sum is monotonic.
+  bool is_monotonic = 3;
+}
+
+// Histogram represents the type of a metric that is calculated by aggregating
+// as a Histogram of all reported measurements over a time interval.
+message Histogram {
+  repeated HistogramDataPoint data_points = 1;
+
+  // aggregation_temporality describes if the aggregator reports delta changes
+  // since last report time, or cumulative changes since a fixed start time.
+  AggregationTemporality aggregation_temporality = 2;
+}
+
+// ExponentialHistogram represents the type of a metric that is calculated by aggregating
+// as a ExponentialHistogram of all reported double measurements over a time interval.
+message ExponentialHistogram {
+  repeated ExponentialHistogramDataPoint data_points = 1;
+
+  // aggregation_temporality describes if the aggregator reports delta changes
+  // since last report time, or cumulative changes since a fixed start time.
+  AggregationTemporality aggregation_temporality = 2;
+}
+
+// Summary metric data are used to convey quantile summaries,
+// a Prometheus (see: https://prometheus.io/docs/concepts/metric_types/#summary)
+// and OpenMetrics (see: https://github.com/OpenObservability/OpenMetrics/blob/4dbf6075567ab43296eed941037c12951faafb92/protos/prometheus.proto#L45)
+// data type. These data points cannot always be merged in a meaningful way.
+// While they can be useful in some applications, histogram data points are
+// recommended for new applications.
+// Summary metrics do not have an aggregation temporality field. This is
+// because the count and sum fields of a SummaryDataPoint are assumed to be
+// cumulative values.
+message Summary {
+  repeated SummaryDataPoint data_points = 1;
+}
+
+// AggregationTemporality defines how a metric aggregator reports aggregated
+// values. It describes how those values relate to the time interval over
+// which they are aggregated.
+enum AggregationTemporality {
+  // UNSPECIFIED is the default AggregationTemporality, it MUST not be used.
+  AGGREGATION_TEMPORALITY_UNSPECIFIED = 0;
+
+  // DELTA is an AggregationTemporality for a metric aggregator which reports
+  // changes since last report time. Successive metrics contain aggregation of
+  // values from continuous and non-overlapping intervals.
+  //
+  // The values for a DELTA metric are based only on the time interval
+  // associated with one measurement cycle. There is no dependency on
+  // previous measurements like is the case for CUMULATIVE metrics.
+  //
+  // For example, consider a system measuring the number of requests that
+  // it receives and reports the sum of these requests every second as a
+  // DELTA metric:
+  //
+  //   1. The system starts receiving at time=t_0.
+  //   2. A request is received, the system measures 1 request.
+  //   3. A request is received, the system measures 1 request.
+  //   4. A request is received, the system measures 1 request.
+  //   5. The 1 second collection cycle ends. A metric is exported for the
+  //      number of requests received over the interval of time t_0 to
+  //      t_0+1 with a value of 3.
+  //   6. A request is received, the system measures 1 request.
+  //   7. A request is received, the system measures 1 request.
+  //   8. The 1 second collection cycle ends. A metric is exported for the
+  //      number of requests received over the interval of time t_0+1 to
+  //      t_0+2 with a value of 2.
+  AGGREGATION_TEMPORALITY_DELTA = 1;
+
+  // CUMULATIVE is an AggregationTemporality for a metric aggregator which
+  // reports changes since a fixed start time. This means that current values
+  // of a CUMULATIVE metric depend on all previous measurements since the
+  // start time. Because of this, the sender is required to retain this state
+  // in some form. If this state is lost or invalidated, the CUMULATIVE metric
+  // values MUST be reset and a new fixed start time following the last
+  // reported measurement time sent MUST be used.
+  //
+  // For example, consider a system measuring the number of requests that
+  // it receives and reports the sum of these requests every second as a
+  // CUMULATIVE metric:
+  //
+  //   1. The system starts receiving at time=t_0.
+  //   2. A request is received, the system measures 1 request.
+  //   3. A request is received, the system measures 1 request.
+  //   4. A request is received, the system measures 1 request.
+  //   5. The 1 second collection cycle ends. A metric is exported for the
+  //      number of requests received over the interval of time t_0 to
+  //      t_0+1 with a value of 3.
+  //   6. A request is received, the system measures 1 request.
+  //   7. A request is received, the system measures 1 request.
+  //   8. The 1 second collection cycle ends. A metric is exported for the
+  //      number of requests received over the interval of time t_0 to
+  //      t_0+2 with a value of 5.
+  //   9. The system experiences a fault and loses state.
+  //   10. The system recovers and resumes receiving at time=t_1.
+  //   11. A request is received, the system measures 1 request.
+  //   12. The 1 second collection cycle ends. A metric is exported for the
+  //      number of requests received over the interval of time t_1 to
+  //      t_0+1 with a value of 1.
+  //
+  // Note: Even though, when reporting changes since last report time, using
+  // CUMULATIVE is valid, it is not recommended. This may cause problems for
+  // systems that do not use start_time to determine when the aggregation
+  // value was reset (e.g. Prometheus).
+  AGGREGATION_TEMPORALITY_CUMULATIVE = 2;
+}
+
+// DataPointFlags is defined as a protobuf 'uint32' type and is to be used as a
+// bit-field representing 32 distinct boolean flags.  Each flag defined in this
+// enum is a bit-mask.  To test the presence of a single flag in the flags of
+// a data point, for example, use an expression like:
+//
+//   (point.flags & DATA_POINT_FLAGS_NO_RECORDED_VALUE_MASK) == DATA_POINT_FLAGS_NO_RECORDED_VALUE_MASK
+//
+enum DataPointFlags {
+  // The zero value for the enum. Should not be used for comparisons.
+  // Instead use bitwise "and" with the appropriate mask as shown above.
+  DATA_POINT_FLAGS_DO_NOT_USE = 0;
+
+  // This DataPoint is valid but has no recorded value.  This value
+  // SHOULD be used to reflect explicitly missing data in a series, as
+  // for an equivalent to the Prometheus "staleness marker".
+  DATA_POINT_FLAGS_NO_RECORDED_VALUE_MASK = 1;
+
+  // Bits 2-31 are reserved for future use.
+}
+
+// NumberDataPoint is a single data point in a timeseries that describes the
+// time-varying scalar value of a metric.
+message NumberDataPoint {
+  reserved 1;
+
+  // The set of key/value pairs that uniquely identify the timeseries from
+  // where this point belongs. The list may be empty (may contain 0 elements).
+  // Attribute keys MUST be unique (it is not allowed to have more than one
+  // attribute with the same key).
+  repeated com.automq.opentelemetry.telemetry.proto.common.v1.KeyValue attributes = 7;
+
+  // StartTimeUnixNano is optional but strongly encouraged, see the
+  // the detailed comments above Metric.
+  //
+  // Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January
+  // 1970.
+  fixed64 start_time_unix_nano = 2;
+
+  // TimeUnixNano is required, see the detailed comments above Metric.
+  //
+  // Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January
+  // 1970.
+  fixed64 time_unix_nano = 3;
+
+  // The value itself.  A point is considered invalid when one of the recognized
+  // value fields is not present inside this oneof.
+  oneof value {
+    double as_double = 4;
+    sfixed64 as_int = 6;
+  }
+
+  // (Optional) List of exemplars collected from
+  // measurements that were used to form the data point
+  repeated Exemplar exemplars = 5;
+
+  // Flags that apply to this specific data point.  See DataPointFlags
+  // for the available flags and their meaning.
+  uint32 flags = 8;
+}
+
+// HistogramDataPoint is a single data point in a timeseries that describes the
+// time-varying values of a Histogram. A Histogram contains summary statistics
+// for a population of values, it may optionally contain the distribution of
+// those values across a set of buckets.
+//
+// If the histogram contains the distribution of values, then both
+// "explicit_bounds" and "bucket counts" fields must be defined.
+// If the histogram does not contain the distribution of values, then both
+// "explicit_bounds" and "bucket_counts" must be omitted and only "count" and
+// "sum" are known.
+message HistogramDataPoint {
+  reserved 1;
+
+  // The set of key/value pairs that uniquely identify the timeseries from
+  // where this point belongs. The list may be empty (may contain 0 elements).
+  // Attribute keys MUST be unique (it is not allowed to have more than one
+  // attribute with the same key).
+  repeated com.automq.opentelemetry.telemetry.proto.common.v1.KeyValue attributes = 9;
+
+  // StartTimeUnixNano is optional but strongly encouraged, see the
+  // the detailed comments above Metric.
+  //
+  // Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January
+  // 1970.
+  fixed64 start_time_unix_nano = 2;
+
+  // TimeUnixNano is required, see the detailed comments above Metric.
+  //
+  // Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January
+  // 1970.
+  fixed64 time_unix_nano = 3;
+
+  // count is the number of values in the population. Must be non-negative. This
+  // value must be equal to the sum of the "count" fields in buckets if a
+  // histogram is provided.
+  fixed64 count = 4;
+
+  // sum of the values in the population. If count is zero then this field
+  // must be zero.
+  //
+  // Note: Sum should only be filled out when measuring non-negative discrete
+  // events, and is assumed to be monotonic over the values of these events.
+  // Negative events *can* be recorded, but sum should not be filled out when
+  // doing so.  This is specifically to enforce compatibility w/ OpenMetrics,
+  // see: https://github.com/OpenObservability/OpenMetrics/blob/main/specification/OpenMetrics.md#histogram
+  optional double sum = 5;
+
+  // bucket_counts is an optional field contains the count values of histogram
+  // for each bucket.
+  //
+  // The sum of the bucket_counts must equal the value in the count field.
+  //
+  // The number of elements in bucket_counts array must be by one greater than
+  // the number of elements in explicit_bounds array.
+  repeated fixed64 bucket_counts = 6;
+
+  // explicit_bounds specifies buckets with explicitly defined bounds for values.
+  //
+  // The boundaries for bucket at index i are:
+  //
+  // (-infinity, explicit_bounds[i]] for i == 0
+  // (explicit_bounds[i-1], explicit_bounds[i]] for 0 < i < size(explicit_bounds)
+  // (explicit_bounds[i-1], +infinity) for i == size(explicit_bounds)
+  //
+  // The values in the explicit_bounds array must be strictly increasing.
+  //
+  // Histogram buckets are inclusive of their upper boundary, except the last
+  // bucket where the boundary is at infinity. This format is intentionally
+  // compatible with the OpenMetrics histogram definition.
+  repeated double explicit_bounds = 7;
+
+  // (Optional) List of exemplars collected from
+  // measurements that were used to form the data point
+  repeated Exemplar exemplars = 8;
+
+  // Flags that apply to this specific data point.  See DataPointFlags
+  // for the available flags and their meaning.
+  uint32 flags = 10;
+
+  // min is the minimum value over (start_time, end_time].
+  optional double min = 11;
+
+  // max is the maximum value over (start_time, end_time].
+  optional double max = 12;
+}
+
+// ExponentialHistogramDataPoint is a single data point in a timeseries that describes the
+// time-varying values of a ExponentialHistogram of double values. A ExponentialHistogram contains
+// summary statistics for a population of values, it may optionally contain the
+// distribution of those values across a set of buckets.
+//
+message ExponentialHistogramDataPoint {
+  // The set of key/value pairs that uniquely identify the timeseries from
+  // where this point belongs. The list may be empty (may contain 0 elements).
+  // Attribute keys MUST be unique (it is not allowed to have more than one
+  // attribute with the same key).
+  repeated com.automq.opentelemetry.telemetry.proto.common.v1.KeyValue attributes = 1;
+
+  // StartTimeUnixNano is optional but strongly encouraged, see the
+  // the detailed comments above Metric.
+  //
+  // Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January
+  // 1970.
+  fixed64 start_time_unix_nano = 2;
+
+  // TimeUnixNano is required, see the detailed comments above Metric.
+  //
+  // Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January
+  // 1970.
+  fixed64 time_unix_nano = 3;
+
+  // count is the number of values in the population. Must be
+  // non-negative. This value must be equal to the sum of the "bucket_counts"
+  // values in the positive and negative Buckets plus the "zero_count" field.
+  fixed64 count = 4;
+
+  // sum of the values in the population. If count is zero then this field
+  // must be zero.
+  //
+  // Note: Sum should only be filled out when measuring non-negative discrete
+  // events, and is assumed to be monotonic over the values of these events.
+  // Negative events *can* be recorded, but sum should not be filled out when
+  // doing so.  This is specifically to enforce compatibility w/ OpenMetrics,
+  // see: https://github.com/OpenObservability/OpenMetrics/blob/main/specification/OpenMetrics.md#histogram
+  optional double sum = 5;
+  
+  // scale describes the resolution of the histogram.  Boundaries are
+  // located at powers of the base, where:
+  //
+  //   base = (2^(2^-scale))
+  //
+  // The histogram bucket identified by `index`, a signed integer,
+  // contains values that are greater than (base^index) and
+  // less than or equal to (base^(index+1)).
+  //
+  // The positive and negative ranges of the histogram are expressed
+  // separately.  Negative values are mapped by their absolute value
+  // into the negative range using the same scale as the positive range.
+  //
+  // scale is not restricted by the protocol, as the permissible
+  // values depend on the range of the data.
+  sint32 scale = 6;
+
+  // zero_count is the count of values that are either exactly zero or
+  // within the region considered zero by the instrumentation at the
+  // tolerated degree of precision.  This bucket stores values that
+  // cannot be expressed using the standard exponential formula as
+  // well as values that have been rounded to zero.
+  //
+  // Implementations MAY consider the zero bucket to have probability
+  // mass equal to (zero_count / count).
+  fixed64 zero_count = 7;
+
+  // positive carries the positive range of exponential bucket counts.
+  Buckets positive = 8;
+
+  // negative carries the negative range of exponential bucket counts.
+  Buckets negative = 9;
+
+  // Buckets are a set of bucket counts, encoded in a contiguous array
+  // of counts.
+  message Buckets {
+    // Offset is the bucket index of the first entry in the bucket_counts array.
+    // 
+    // Note: This uses a varint encoding as a simple form of compression.
+    sint32 offset = 1;
+
+    // bucket_counts is an array of count values, where bucket_counts[i] carries
+    // the count of the bucket at index (offset+i). bucket_counts[i] is the count
+    // of values greater than base^(offset+i) and less than or equal to
+    // base^(offset+i+1).
+    //
+    // Note: By contrast, the explicit HistogramDataPoint uses
+    // fixed64.  This field is expected to have many buckets,
+    // especially zeros, so uint64 has been selected to ensure
+    // varint encoding.
+    repeated uint64 bucket_counts = 2;
+  } 
+
+  // Flags that apply to this specific data point.  See DataPointFlags
+  // for the available flags and their meaning.
+  uint32 flags = 10;
+
+  // (Optional) List of exemplars collected from
+  // measurements that were used to form the data point
+  repeated Exemplar exemplars = 11;
+
+  // min is the minimum value over (start_time, end_time].
+  optional double min = 12;
+
+  // max is the maximum value over (start_time, end_time].
+  optional double max = 13;
+
+  // ZeroThreshold may be optionally set to convey the width of the zero
+  // region. Where the zero region is defined as the closed interval
+  // [-ZeroThreshold, ZeroThreshold].
+  // When ZeroThreshold is 0, zero count bucket stores values that cannot be
+  // expressed using the standard exponential formula as well as values that
+  // have been rounded to zero.
+  double zero_threshold = 14;
+}
+
+// SummaryDataPoint is a single data point in a timeseries that describes the
+// time-varying values of a Summary metric. The count and sum fields represent
+// cumulative values.
+message SummaryDataPoint {
+  reserved 1;
+
+  // The set of key/value pairs that uniquely identify the timeseries from
+  // where this point belongs. The list may be empty (may contain 0 elements).
+  // Attribute keys MUST be unique (it is not allowed to have more than one
+  // attribute with the same key).
+  repeated com.automq.opentelemetry.telemetry.proto.common.v1.KeyValue attributes = 7;
+
+  // StartTimeUnixNano is optional but strongly encouraged, see the
+  // the detailed comments above Metric.
+  //
+  // Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January
+  // 1970.
+  fixed64 start_time_unix_nano = 2;
+
+  // TimeUnixNano is required, see the detailed comments above Metric.
+  //
+  // Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January
+  // 1970.
+  fixed64 time_unix_nano = 3;
+
+  // count is the number of values in the population. Must be non-negative.
+  fixed64 count = 4;
+
+  // sum of the values in the population. If count is zero then this field
+  // must be zero.
+  //
+  // Note: Sum should only be filled out when measuring non-negative discrete
+  // events, and is assumed to be monotonic over the values of these events.
+  // Negative events *can* be recorded, but sum should not be filled out when
+  // doing so.  This is specifically to enforce compatibility w/ OpenMetrics,
+  // see: https://github.com/OpenObservability/OpenMetrics/blob/main/specification/OpenMetrics.md#summary
+  double sum = 5;
+
+  // Represents the value at a given quantile of a distribution.
+  //
+  // To record Min and Max values following conventions are used:
+  // - The 1.0 quantile is equivalent to the maximum value observed.
+  // - The 0.0 quantile is equivalent to the minimum value observed.
+  //
+  // See the following issue for more context:
+  // https://github.com/open-telemetry/opentelemetry-proto/issues/125
+  message ValueAtQuantile {
+    // The quantile of a distribution. Must be in the interval
+    // [0.0, 1.0].
+    double quantile = 1;
+
+    // The value at the given quantile of a distribution.
+    //
+    // Quantile values must NOT be negative.
+    double value = 2;
+  }
+
+  // (Optional) list of values at different quantiles of the distribution calculated
+  // from the current snapshot. The quantiles must be strictly increasing.
+  repeated ValueAtQuantile quantile_values = 6;
+
+  // Flags that apply to this specific data point.  See DataPointFlags
+  // for the available flags and their meaning.
+  uint32 flags = 8;
+}
+
+// A representation of an exemplar, which is a sample input measurement.
+// Exemplars also hold information about the environment when the measurement
+// was recorded, for example the span and trace ID of the active span when the
+// exemplar was recorded.
+message Exemplar {
+  reserved 1;
+
+  // The set of key/value pairs that were filtered out by the aggregator, but
+  // recorded alongside the original measurement. Only key/value pairs that were
+  // filtered out by the aggregator should be included
+  repeated com.automq.opentelemetry.telemetry.proto.common.v1.KeyValue filtered_attributes = 7;
+
+  // time_unix_nano is the exact time when this exemplar was recorded
+  //
+  // Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January
+  // 1970.
+  fixed64 time_unix_nano = 2;
+
+  // The value of the measurement that was recorded. An exemplar is
+  // considered invalid when one of the recognized value fields is not present
+  // inside this oneof.
+  oneof value {
+    double as_double = 3;
+    sfixed64 as_int = 6;
+  }
+
+  // (Optional) Span ID of the exemplar trace.
+  // span_id may be missing if the measurement is not recorded inside a trace
+  // or if the trace is not sampled.
+  bytes span_id = 4;
+
+  // (Optional) Trace ID of the exemplar trace.
+  // trace_id may be missing if the measurement is not recorded inside a trace
+  // or if the trace is not sampled.
+  bytes trace_id = 5;
+}
diff --git a/opentelemetry/src/main/proto/remote_write.proto b/opentelemetry/src/main/proto/remote_write.proto
new file mode 100644
index 0000000000..b7e92fc4d2
--- /dev/null
+++ b/opentelemetry/src/main/proto/remote_write.proto
@@ -0,0 +1,36 @@
+// Copyright 2016 Prometheus Team
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+syntax = "proto3";
+
+option java_package = "com.automq.opentelemetry.telemetry";
+
+message WriteRequest {
+  repeated TimeSeries timeseries = 1;
+}
+
+// TimeSeries represents samples and labels for a single time series.
+message TimeSeries {
+  repeated Label labels   = 1;
+  repeated Sample samples = 2;
+}
+
+message Label {
+  string name  = 1;
+  string value = 2;
+}
+
+message Sample {
+  double value    = 1;
+  int64 timestamp = 2;
+}
\ No newline at end of file
diff --git a/opentelemetry/src/main/proto/resource/v1/resource.proto b/opentelemetry/src/main/proto/resource/v1/resource.proto
new file mode 100644
index 0000000000..e56d453ac3
--- /dev/null
+++ b/opentelemetry/src/main/proto/resource/v1/resource.proto
@@ -0,0 +1,37 @@
+// Copyright 2019, OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+syntax = "proto3";
+
+package com.automq.opentelemetry.telemetry.proto.resource.v1;
+
+import "common/v1/common.proto";
+
+option csharp_namespace = "OpenTelemetry.Proto.Resource.V1";
+option java_multiple_files = true;
+option java_package = "com.automq.opentelemetry.telemetry.resource.v1";
+option java_outer_classname = "ResourceProto";
+option go_package = "go.opentelemetry.io/proto/otlp/resource/v1";
+
+// Resource information.
+message Resource {
+  // Set of attributes that describe the resource.
+  // Attribute keys MUST be unique (it is not allowed to have more than one
+  // attribute with the same key).
+  repeated com.automq.opentelemetry.telemetry.proto.common.v1.KeyValue attributes = 1;
+
+  // dropped_attributes_count is the number of dropped attributes. If the value is 0, then
+  // no attributes were dropped.
+  uint32 dropped_attributes_count = 2;
+}
diff --git a/opentelemetry/src/main/resources/META-INF/services/com.automq.opentelemetry.exporter.s3.UploaderNodeSelectorProvider b/opentelemetry/src/main/resources/META-INF/services/com.automq.opentelemetry.exporter.s3.UploaderNodeSelectorProvider
new file mode 100644
index 0000000000..6d28daa029
--- /dev/null
+++ b/opentelemetry/src/main/resources/META-INF/services/com.automq.opentelemetry.exporter.s3.UploaderNodeSelectorProvider
@@ -0,0 +1 @@
+com.automq.opentelemetry.exporter.s3.kafka.KafkaLeaderSelectorProvider
diff --git a/opentelemetry/src/test/java/com/automq/opentelemetry/TelemetryConfigTest.java b/opentelemetry/src/test/java/com/automq/opentelemetry/TelemetryConfigTest.java
new file mode 100644
index 0000000000..e928f6290b
--- /dev/null
+++ b/opentelemetry/src/test/java/com/automq/opentelemetry/TelemetryConfigTest.java
@@ -0,0 +1,29 @@
+package com.automq.opentelemetry;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.Map;
+import java.util.Properties;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+
+class TelemetryConfigTest {
+
+    @Test
+    void getPropertiesWithPrefixStripsPrefixAndIgnoresOthers() {
+        Properties properties = new Properties();
+        properties.setProperty("automq.telemetry.s3.selector.type", "kafka");
+        properties.setProperty("automq.telemetry.s3.selector.kafka.bootstrap.servers", "localhost:9092");
+        properties.setProperty("automq.telemetry.s3.selector.kafka.security.protocol", "SASL_PLAINTEXT");
+        properties.setProperty("unrelated.key", "value");
+
+        TelemetryConfig config = new TelemetryConfig(properties);
+        Map<String, String> result = config.getPropertiesWithPrefix("automq.telemetry.s3.selector.");
+
+        assertEquals("kafka", result.get("type"));
+        assertEquals("localhost:9092", result.get("kafka.bootstrap.servers"));
+        assertEquals("SASL_PLAINTEXT", result.get("kafka.security.protocol"));
+        assertFalse(result.containsKey("unrelated.key"));
+    }
+}
diff --git a/settings.gradle b/settings.gradle
index 3e1b9ba992..998ad87039 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -104,7 +104,9 @@ include 'clients',
     'transaction-coordinator',
     'trogdor',
     's3stream',
-    'automq-shell'
+    'automq-shell',
+    'automq-log-uploader',
+    'opentelemetry'
 
 project(":storage:api").name = "storage-api"
 rootProject.name = 'kafka'
diff --git a/tests/kafkatest/tests/connect/connect_distributed_test.py b/tests/kafkatest/tests/connect/connect_distributed_test.py
index cd36ce1976..d5deda32f8 100644
--- a/tests/kafkatest/tests/connect/connect_distributed_test.py
+++ b/tests/kafkatest/tests/connect/connect_distributed_test.py
@@ -32,6 +32,7 @@
 import json
 import operator
 import time
+import subprocess
 
 class ConnectDistributedTest(Test):
     """
@@ -114,7 +115,7 @@ def _start_connector(self, config_file, extra_config={}):
         connector_config = dict([line.strip().split('=', 1) for line in connector_props.split('\n') if line.strip() and not line.strip().startswith('#')])
         connector_config.update(extra_config)
         self.cc.create_connector(connector_config)
-            
+
     def _connector_status(self, connector, node=None):
         try:
             return self.cc.get_connector_status(connector, node)
@@ -179,139 +180,6 @@ def task_is_running(self, connector, task_id, node=None):
     #     metadata_quorum=[quorum.zk],
     #     use_new_coordinator=[False]
     # )
-    @matrix(
-        exactly_once_source=[True, False],
-        connect_protocol=['sessioned', 'compatible', 'eager'],
-        metadata_quorum=[quorum.isolated_kraft],
-        use_new_coordinator=[True],
-        group_protocol=consumer_group.all_group_protocols
-    )
-    def test_restart_failed_connector(self, exactly_once_source, connect_protocol, metadata_quorum, use_new_coordinator=False, group_protocol=None):
-        self.EXACTLY_ONCE_SOURCE_SUPPORT = 'enabled' if exactly_once_source else 'disabled'
-        self.CONNECT_PROTOCOL = connect_protocol
-        self.setup_services()
-        self.cc.set_configs(lambda node: self.render("connect-distributed.properties", node=node))
-        self.cc.start()
-
-        if exactly_once_source:
-            self.connector = MockSource(self.cc, mode='connector-failure', delay_sec=5)
-        else:
-            self.connector = MockSink(self.cc, self.topics.keys(), mode='connector-failure', delay_sec=5, consumer_group_protocol=group_protocol)
-        self.connector.start()
-
-        wait_until(lambda: self.connector_is_failed(self.connector), timeout_sec=15,
-                   err_msg="Failed to see connector transition to the FAILED state")
-
-        self.cc.restart_connector(self.connector.name)
-        
-        wait_until(lambda: self.connector_is_running(self.connector), timeout_sec=10,
-                   err_msg="Failed to see connector transition to the RUNNING state")
-
-    @cluster(num_nodes=5)
-    @matrix(
-        connector_type=['source', 'exactly-once source', 'sink'],
-        connect_protocol=['sessioned', 'compatible', 'eager'],
-        metadata_quorum=[quorum.isolated_kraft],
-        use_new_coordinator=[False]
-    )
-    @matrix(
-        connector_type=['source', 'exactly-once source', 'sink'],
-        connect_protocol=['sessioned', 'compatible', 'eager'],
-        metadata_quorum=[quorum.isolated_kraft],
-        use_new_coordinator=[True],
-        group_protocol=consumer_group.all_group_protocols
-    )
-    def test_restart_failed_task(self, connector_type, connect_protocol, metadata_quorum, use_new_coordinator=False, group_protocol=None):
-        self.EXACTLY_ONCE_SOURCE_SUPPORT = 'enabled' if connector_type == 'exactly-once source' else 'disabled'
-        self.CONNECT_PROTOCOL = connect_protocol
-        self.setup_services()
-        self.cc.set_configs(lambda node: self.render("connect-distributed.properties", node=node))
-        self.cc.start()
-
-        connector = None
-        if connector_type == "sink":
-            connector = MockSink(self.cc, self.topics.keys(), mode='task-failure', delay_sec=5, consumer_group_protocol=group_protocol)
-        else:
-            connector = MockSource(self.cc, mode='task-failure', delay_sec=5)
-            
-        connector.start()
-
-        task_id = 0
-        wait_until(lambda: self.task_is_failed(connector, task_id), timeout_sec=20,
-                   err_msg="Failed to see task transition to the FAILED state")
-
-        self.cc.restart_task(connector.name, task_id)
-        
-        wait_until(lambda: self.task_is_running(connector, task_id), timeout_sec=10,
-                   err_msg="Failed to see task transition to the RUNNING state")
-
-    @cluster(num_nodes=5)
-    @matrix(
-        connect_protocol=['sessioned', 'compatible', 'eager'],
-        metadata_quorum=[quorum.isolated_kraft],
-        use_new_coordinator=[False]
-    )
-    @matrix(
-        connect_protocol=['sessioned', 'compatible', 'eager'],
-        metadata_quorum=[quorum.isolated_kraft],
-        use_new_coordinator=[True],
-        group_protocol=consumer_group.all_group_protocols
-    )
-    def test_restart_connector_and_tasks_failed_connector(self, connect_protocol, metadata_quorum, use_new_coordinator=False, group_protocol=None):
-        self.CONNECT_PROTOCOL = connect_protocol
-        self.setup_services()
-        self.cc.set_configs(lambda node: self.render("connect-distributed.properties", node=node))
-        self.cc.start()
-
-        self.sink = MockSink(self.cc, self.topics.keys(), mode='connector-failure', delay_sec=5, consumer_group_protocol=group_protocol)
-        self.sink.start()
-
-        wait_until(lambda: self.connector_is_failed(self.sink), timeout_sec=15,
-                   err_msg="Failed to see connector transition to the FAILED state")
-
-        self.cc.restart_connector_and_tasks(self.sink.name, only_failed = "true", include_tasks = "false")
-
-        wait_until(lambda: self.connector_is_running(self.sink), timeout_sec=10,
-                   err_msg="Failed to see connector transition to the RUNNING state")
-
-    @cluster(num_nodes=5)
-    @matrix(
-        connector_type=['source', 'sink'],
-        connect_protocol=['sessioned', 'compatible', 'eager'],
-        metadata_quorum=[quorum.isolated_kraft],
-        use_new_coordinator=[False]
-    )
-    @matrix(
-        connector_type=['source', 'sink'],
-        connect_protocol=['sessioned', 'compatible', 'eager'],
-        metadata_quorum=[quorum.isolated_kraft],
-        use_new_coordinator=[True],
-        group_protocol=consumer_group.all_group_protocols
-    )
-    def test_restart_connector_and_tasks_failed_task(self, connector_type, connect_protocol, metadata_quorum, use_new_coordinator=False, group_protocol=None):
-        self.CONNECT_PROTOCOL = connect_protocol
-        self.setup_services()
-        self.cc.set_configs(lambda node: self.render("connect-distributed.properties", node=node))
-        self.cc.start()
-
-        connector = None
-        if connector_type == "sink":
-            connector = MockSink(self.cc, self.topics.keys(), mode='task-failure', delay_sec=5, consumer_group_protocol=group_protocol)
-        else:
-            connector = MockSource(self.cc, mode='task-failure', delay_sec=5)
-
-        connector.start()
-
-        task_id = 0
-        wait_until(lambda: self.task_is_failed(connector, task_id), timeout_sec=20,
-                   err_msg="Failed to see task transition to the FAILED state")
-
-        self.cc.restart_connector_and_tasks(connector.name, only_failed = "false", include_tasks = "true")
-
-        wait_until(lambda: self.task_is_running(connector, task_id), timeout_sec=10,
-                   err_msg="Failed to see task transition to the RUNNING state")
-
-    @cluster(num_nodes=5)
     # @matrix(
     #     exactly_once_source=[True, False],
     #     connect_protocol=['sessioned', 'compatible', 'eager'],
@@ -341,7 +209,7 @@ def test_pause_and_resume_source(self, exactly_once_source, connect_protocol, me
 
         wait_until(lambda: self.is_running(self.source), timeout_sec=30,
                    err_msg="Failed to see connector transition to the RUNNING state")
-        
+
         self.cc.pause_connector(self.source.name)
 
         # wait until all nodes report the paused transition
@@ -394,7 +262,7 @@ def test_pause_and_resume_sink(self, connect_protocol, metadata_quorum, use_new_
 
         wait_until(lambda: self.is_running(self.sink), timeout_sec=30,
                    err_msg="Failed to see connector transition to the RUNNING state")
-        
+
         self.cc.pause_connector(self.sink.name)
 
         # wait until all nodes report the paused transition
@@ -421,8 +289,8 @@ def test_pause_and_resume_sink(self, connect_protocol, metadata_quorum, use_new_
     # @matrix(
     #     exactly_once_source=[True, False],
     #     connect_protocol=['sessioned', 'compatible', 'eager'],
-    #     metadata_quorum=[quorum.zk],
-    #     use_new_coordinator=[False]
+    #     metadata_quorum=[quorum.isolated_kraft],
+    #     use_new_coordinator=[True, False]
     # )
     @matrix(
         exactly_once_source=[True, False],
@@ -446,7 +314,7 @@ def test_pause_state_persistent(self, exactly_once_source, connect_protocol, met
 
         wait_until(lambda: self.is_running(self.source), timeout_sec=30,
                    err_msg="Failed to see connector transition to the RUNNING state")
-        
+
         self.cc.pause_connector(self.source.name)
 
         self.cc.restart()
@@ -669,7 +537,7 @@ def test_file_source_and_sink(self, security_protocol, exactly_once_source, conn
             self._start_connector("connect-file-sink.properties", {"consumer.override.group.protocol" : group_protocol})
         else:
             self._start_connector("connect-file-sink.properties")
-        
+
         # Generating data on the source node should generate new records and create new output on the sink node. Timeouts
         # here need to be more generous than they are for standalone mode because a) it takes longer to write configs,
         # do rebalancing of the group, etc, and b) without explicit leave group support, rebalancing takes awhile
@@ -726,8 +594,8 @@ def test_bounce(self, clean, connect_protocol, metadata_quorum, use_new_coordina
                 # Give additional time for the consumer groups to recover. Even if it is not a hard bounce, there are
                 # some cases where a restart can cause a rebalance to take the full length of the session timeout
                 # (e.g. if the client shuts down before it has received the memberId from its initial JoinGroup).
-                # If we don't give enough time for the group to stabilize, the next bounce may cause consumers to 
-                # be shut down before they have any time to process data and we can end up with zero data making it 
+                # If we don't give enough time for the group to stabilize, the next bounce may cause consumers to
+                # be shut down before they have any time to process data and we can end up with zero data making it
                 # through the test.
                 time.sleep(15)
 
@@ -1034,8 +902,8 @@ def test_transformations(self, connect_protocol, metadata_quorum, use_new_coordi
     # @parametrize(broker_version=str(LATEST_0_10_0), auto_create_topics=True, exactly_once_source=False, connect_protocol='eager')
     def test_broker_compatibility(self, broker_version, auto_create_topics, exactly_once_source, connect_protocol):
         """
-        Verify that Connect will start up with various broker versions with various configurations. 
-        When Connect distributed starts up, it either creates internal topics (v0.10.1.0 and after) 
+        Verify that Connect will start up with various broker versions with various configurations.
+        When Connect distributed starts up, it either creates internal topics (v0.10.1.0 and after)
         or relies upon the broker to auto-create the topics (v0.10.0.x and before).
         """
         self.EXACTLY_ONCE_SOURCE_SUPPORT = 'enabled' if exactly_once_source else 'disabled'
@@ -1088,3 +956,712 @@ def _restart_worker(self, node, clean=True):
             monitor.wait_until("Starting connectors and tasks using config offset", timeout_sec=90,
                                err_msg="Kafka Connect worker didn't successfully join group and start work")
         self.logger.info("Bounced Kafka Connect on %s and rejoined in %f seconds", node.account, time.time() - started)
+
+    def _wait_for_metrics_available(self, timeout_sec=60):
+        """Wait for metrics endpoint to become available"""
+        self.logger.info("Waiting for metrics endpoint to become available...")
+        
+        def metrics_available():
+            for node in self.cc.nodes:
+                try:
+                    cmd = "curl -s http://localhost:9464/metrics"
+                    result = node.account.ssh_capture(cmd, allow_fail=True)
+                    metrics_output = "".join([line for line in result])
+                    
+                    # Check for any metrics output (not just kafka_connect)
+                    if len(metrics_output.strip()) > 0 and ("#" in metrics_output or "_" in metrics_output):
+                        self.logger.info(f"Metrics available on node {node.account.hostname}, content length: {len(metrics_output)}")
+                        return True
+                    else:
+                        self.logger.debug(f"Node {node.account.hostname} metrics not ready yet, output length: {len(metrics_output)}")
+                except Exception as e:
+                    self.logger.debug(f"Error checking metrics on node {node.account.hostname}: {e}")
+                    continue
+            return False
+
+        wait_until(
+            metrics_available,
+            timeout_sec=timeout_sec,
+            err_msg="Metrics endpoint did not become available within the specified time"
+        )
+        
+        self.logger.info("Metrics endpoint is now available!")
+
+    def _verify_opentelemetry_metrics(self):
+        """Verify OpenTelemetry metrics content"""
+        for node in self.cc.nodes:
+            cmd = "curl -s http://localhost:9464/metrics"
+            result = node.account.ssh_capture(cmd)
+            metrics_output = "".join([line for line in result])
+
+            # Basic check - verify any metrics output exists
+            assert len(metrics_output.strip()) > 0, "Metrics endpoint returned no content"
+            
+            # Print ALL metrics for debugging
+            self.logger.info(f"=== ALL METRICS from Node {node.account.hostname} ===")
+            self.logger.info(metrics_output)
+            self.logger.info(f"=== END OF METRICS from Node {node.account.hostname} ===")
+
+            # Find all metric lines (not comments)
+            metric_lines = [line for line in metrics_output.split('\n') 
+                           if line.strip() and not line.startswith('#') and ('_' in line or '{' in line)]
+            
+            # Should have at least some metrics
+            assert len(metric_lines) > 0, "No valid metric lines found"
+            
+            self.logger.info(f"Found {len(metric_lines)} metric lines")
+            
+            # Log kafka_connect metrics specifically
+            kafka_connect_lines = [line for line in metric_lines if 'kafka_connect' in line]
+            self.logger.info(f"Found {len(kafka_connect_lines)} kafka_connect metric lines:")
+            for i, line in enumerate(kafka_connect_lines):
+                self.logger.info(f"kafka_connect metric {i+1}: {line}")
+
+            # Check for Prometheus format characteristics
+            has_help = "# HELP" in metrics_output
+            has_type = "# TYPE" in metrics_output
+            
+            if has_help and has_type:
+                self.logger.info("Metrics conform to Prometheus format")
+            else:
+                self.logger.warning("Metrics may not be in standard Prometheus format")
+
+            # Use lenient metric validation to analyze values
+            self._validate_metric_values(metrics_output)
+
+            self.logger.info(f"Node {node.account.hostname} basic metrics validation passed")
+
+    def _verify_comprehensive_metrics(self):
+        """Comprehensive metrics validation"""
+        for node in self.cc.nodes:
+            cmd = "curl -s http://localhost:9464/metrics"
+            result = node.account.ssh_capture(cmd)
+            metrics_output = "".join([line for line in result])
+
+            # Basic check - verify any metrics output exists
+            assert len(metrics_output.strip()) > 0, "Metrics endpoint returned no content"
+
+            # Print ALL metrics for comprehensive debugging
+            self.logger.info(f"=== COMPREHENSIVE METRICS from Node {node.account.hostname} ===")
+            self.logger.info(metrics_output)
+            self.logger.info(f"=== END OF COMPREHENSIVE METRICS from Node {node.account.hostname} ===")
+
+            # Find all metric lines (start with letter, not comments)
+            metric_lines = [line for line in metrics_output.split('\n')
+                           if line.strip() and not line.startswith('#') and ('_' in line or '{' in line)]
+            self.logger.info(f"Found metric line count: {len(metric_lines)}")
+
+            # Find kafka_connect related metrics
+            kafka_connect_lines = [line for line in metric_lines if 'kafka_connect' in line]
+            self.logger.info(f"Found kafka_connect metric line count: {len(kafka_connect_lines)}")
+
+            # Print all kafka_connect metrics
+            self.logger.info("=== ALL kafka_connect metrics ===")
+            for i, line in enumerate(kafka_connect_lines):
+                self.logger.info(f"kafka_connect metric {i+1}: {line}")
+
+            # If no kafka_connect metrics found, show other metrics
+            if len(kafka_connect_lines) == 0:
+                self.logger.warning("No kafka_connect metrics found, showing other metrics:")
+                for i, line in enumerate(metric_lines[:10]):  # Show first 10 instead of 5
+                    self.logger.info(f"Other metric line {i+1}: {line}")
+
+                # Should have at least some metric output
+                assert len(metric_lines) > 0, "No valid metric lines found"
+            else:
+                # Found kafka_connect metrics
+                self.logger.info(f"Successfully found {len(kafka_connect_lines)} kafka_connect metrics")
+
+            # Check for HELP and TYPE comments (Prometheus format characteristics)
+            has_help = "# HELP" in metrics_output
+            has_type = "# TYPE" in metrics_output
+
+            if has_help:
+                self.logger.info("Found HELP comments - conforms to Prometheus format")
+            if has_type:
+                self.logger.info("Found TYPE comments - conforms to Prometheus format")
+
+            self.logger.info(f"Node {node.account.hostname} metrics validation passed, total {len(metric_lines)} metrics found")
+
+    def _validate_metric_values(self, metrics_output):
+        """Validate metric value reasonableness - more lenient version"""
+        lines = metrics_output.split('\n')
+        negative_metrics = []
+        
+        self.logger.info("=== ANALYZING METRIC VALUES ===")
+        
+        for line in lines:
+            if line.startswith('kafka_connect_') and not line.startswith('#'):
+                # Parse metric line: metric_name{labels} value timestamp
+                parts = line.split()
+                if len(parts) >= 2:
+                    try:
+                        value = float(parts[1])
+                        metric_name = parts[0].split('{')[0] if '{' in parts[0] else parts[0]
+                        
+                        # Log all metric values for analysis
+                        self.logger.info(f"Metric: {metric_name} = {value}")
+                        
+                        # Some metrics can legitimately be negative (e.g., ratios, differences, etc.)
+                        # Only flag as problematic if it's a count or gauge that shouldn't be negative
+                        if value < 0:
+                            negative_metrics.append(f"{parts[0]} = {value}")
+                            
+                            # Allow certain metrics to be negative
+                            allowed_negative_patterns = [
+                                'ratio',
+                                'seconds_ago',
+                                'difference',
+                                'offset',
+                                'lag'
+                            ]
+                            
+                            is_allowed_negative = any(pattern in parts[0].lower() for pattern in allowed_negative_patterns)
+                            
+                            if is_allowed_negative:
+                                self.logger.info(f"Negative value allowed for metric: {parts[0]} = {value}")
+                            else:
+                                self.logger.warning(f"Potentially problematic negative value: {parts[0]} = {value}")
+                                # Don't assert here, just log for now
+                                
+                    except ValueError:
+                        # Skip unparseable lines
+                        continue
+        
+        if negative_metrics:
+            self.logger.info(f"Found {len(negative_metrics)} metrics with negative values:")
+            for metric in negative_metrics:
+                self.logger.info(f"  - {metric}")
+        
+        self.logger.info("=== END METRIC VALUE ANALYSIS ===")
+
+    def _verify_metrics_updates(self):
+        """Verify metrics update over time"""
+        # Get initial metrics
+        initial_metrics = {}
+        for node in self.cc.nodes:
+            cmd = "curl -s http://localhost:9464/metrics"
+            result = node.account.ssh_capture(cmd)
+            initial_metrics[node] = "".join([line for line in result])
+
+        # Wait for some time
+        time.sleep(5)
+
+        # Get metrics again and compare
+        for node in self.cc.nodes:
+            cmd = "curl -s http://localhost:9464/metrics"
+            result = node.account.ssh_capture(cmd)
+            current_metrics = "".join([line for line in result])
+
+            # Metrics should have changed (at least timestamps will update)
+            # More detailed verification can be done here
+            self.logger.info(f"Node {node.account.hostname} metrics have been updated")
+
+    def _safe_cleanup(self):
+        """Safe resource cleanup"""
+        try:
+            # Delete connectors
+            connectors = self.cc.list_connectors()
+            for connector in connectors:
+                try:
+                    self.cc.delete_connector(connector)
+                    self.logger.info(f"Deleted connector: {connector}")
+                except Exception as e:
+                    self.logger.warning(f"Failed to delete connector {connector}: {e}")
+
+            # Stop services
+            self.cc.stop()
+
+        except Exception as e:
+            self.logger.error(f"Error occurred during cleanup: {e}")
+
+
+    @cluster(num_nodes=5)
+    def test_opentelemetry_metrics_basic(self):
+        """Basic OpenTelemetry metrics reporting test"""
+        # Use standard setup, template already contains OpenTelemetry configuration
+        self.setup_services()
+        self.cc.set_configs(lambda node: self.render("connect-distributed.properties", node=node))
+        
+        self.logger.info("Starting Connect cluster...")
+        self.cc.start()
+
+        try:
+            self.logger.info("Creating VerifiableSource connector...")
+            # Use VerifiableSource instead of file connector
+            self.source = VerifiableSource(self.cc, topic=self.TOPIC, throughput=10)
+            self.source.start()
+
+            # Wait for connector to be running
+            self.logger.info("Waiting for connector to be running...")
+            wait_until(lambda: self.is_running(self.source), timeout_sec=30,
+                       err_msg="VerifiableSource connector failed to start")
+
+            self.logger.info("Connector is running, checking metrics...")
+            
+            # Wait for and verify metrics
+            self._wait_for_metrics_available()
+            self._verify_opentelemetry_metrics()
+
+            # Verify metrics update over time
+            self._verify_metrics_updates()
+            
+            self.logger.info("All metrics validations passed!")
+
+        finally:
+            if hasattr(self, 'source'):
+                self.logger.info("Stopping source connector...")
+                self.source.stop()
+            self.logger.info("Stopping Connect cluster...")
+            self.cc.stop()
+
+
+    @cluster(num_nodes=5)
+    def test_opentelemetry_metrics_comprehensive(self):
+        """Comprehensive Connect OpenTelemetry metrics test - using VerifiableSource"""
+        # Use standard setup, template already contains OpenTelemetry configuration
+        self.setup_services(num_workers=3)
+        self.cc.set_configs(lambda node: self.render("connect-distributed.properties", node=node))
+        self.cc.start()
+
+        try:
+            # Create connector using VerifiableSource
+            self.source = VerifiableSource(self.cc, topic='metrics-test-topic', throughput=50)
+            self.source.start()
+
+            # Wait for connector startup
+            wait_until(
+                lambda: self.is_running(self.source),
+                timeout_sec=30,
+                err_msg="VerifiableSource connector failed to start within expected time"
+            )
+
+            # Verify metrics export
+            self._wait_for_metrics_available()
+            self._verify_comprehensive_metrics()
+
+            # Verify connector is producing data
+            wait_until(
+                lambda: len(self.source.sent_messages()) > 0,
+                timeout_sec=30,
+                err_msg="VerifiableSource failed to produce messages"
+            )
+
+        finally:
+            if hasattr(self, 'source'):
+                self.source.stop()
+            self.cc.stop()
+
+    @cluster(num_nodes=5)
+    def test_metrics_under_load(self):
+        """Test metrics functionality under load"""
+        # Use standard setup, template already contains OpenTelemetry configuration
+        self.setup_services(num_workers=3)
+        self.cc.set_configs(lambda node: self.render("connect-distributed.properties", node=node))
+        self.cc.start()
+
+        try:
+            # Create multiple connectors
+            connectors = []
+            for i in range(3):
+                connector_name = f'load-test-connector-{i}'
+                connector_config = {
+                    'name': connector_name,
+                    'connector.class': 'org.apache.kafka.connect.tools.VerifiableSourceConnector',
+                    'tasks.max': '2',
+                    'topic': f'load-test-topic-{i}',
+                    'throughput': '100'
+                }
+                self.cc.create_connector(connector_config)
+                connectors.append(connector_name)
+
+            # Wait for all connectors to start
+            for connector_name in connectors:
+                wait_until(
+                    lambda cn=connector_name: self.connector_is_running(
+                        type('MockConnector', (), {'name': cn})()
+                    ),
+                    timeout_sec=30,
+                    err_msg=f"Connector {connector_name} failed to start"
+                )
+
+            # Verify metrics accuracy under load
+            self._verify_metrics_under_load(len(connectors))
+
+        finally:
+            # Clean up all connectors
+            for connector_name in connectors:
+                try:
+                    self.cc.delete_connector(connector_name)
+                except:
+                    pass
+            self.cc.stop()
+
+    def _verify_metrics_under_load(self, expected_connector_count):
+        """Verify metrics accuracy under load"""
+        self._wait_for_metrics_available()
+
+        for node in self.cc.nodes:
+            cmd = "curl -s http://localhost:9464/metrics"
+            result = node.account.ssh_capture(cmd)
+            metrics_output = "".join([line for line in result])
+
+            # Verify connector count metrics
+            connector_count_found = False
+            for line in metrics_output.split('\n'):
+                if 'kafka_connect_worker_connector_count' in line and not line.startswith('#'):
+                    parts = line.split()
+                    if len(parts) >= 2:
+                        count = float(parts[1])
+                        assert count >= expected_connector_count, f"Connector count metric incorrect: {count} < {expected_connector_count}"
+                        connector_count_found = True
+                        break
+
+            assert connector_count_found, "Connector count metric not found"
+            self.logger.info(f"Node {node.account.hostname} load test metrics validation passed")
+
+    @cluster(num_nodes=5)
+    def test_opentelemetry_remote_write_exporter(self):
+        """Test OpenTelemetry Remote Write exporter functionality"""
+        # Setup mock remote write server
+        self.setup_services(num_workers=2)
+
+        # Override the template to use remote write exporter
+        def remote_write_config(node):
+            config = self.render("connect-distributed.properties", node=node)
+            # Replace prometheus exporter with remote write using correct URI format
+            self.logger.info(f"connect config: {config}")
+            config = config.replace(
+                "automq.telemetry.exporter.uri=prometheus://0.0.0.0:9464",
+                "automq.telemetry.exporter.uri=rw://?endpoint=http://localhost:9090/api/v1/write&auth=no_auth&maxBatchSize=1000000"
+            )
+            # Add remote write specific configurations
+            config += "\nautomq.telemetry.exporter.interval.ms=30000\n"
+
+            self.logger.info(f"connect new config: {config}")
+            return config
+
+        self.cc.set_configs(remote_write_config)
+
+        # Setup mock remote write endpoint using python HTTP server
+        mock_server_node = self.cc.nodes[0]
+        self.logger.info("Setting up mock remote write server...")
+
+        # Start mock server in background that accepts HTTP POST requests
+        mock_server_cmd = "nohup python3 -c \"\
+import http.server\n\
+import socketserver\n\
+from urllib.parse import urlparse\n\
+import gzip\n\
+import sys\n\
+import time\n\
+\n\
+class MockRemoteWriteHandler(http.server.BaseHTTPRequestHandler):\n\
+    def do_POST(self):\n\
+        if self.path == '/api/v1/write':\n\
+            content_length = int(self.headers.get('Content-Length', 0))\n\
+            post_data = self.rfile.read(content_length)\n\
+            # Handle gzip compression if present\n\
+            encoding = self.headers.get('Content-Encoding', '')\n\
+            if encoding == 'gzip':\n\
+                try:\n\
+                    post_data = gzip.decompress(post_data)\n\
+                except:\n\
+                    pass\n\
+            # Force flush to ensure log is written immediately\n\
+            log_msg = '{} - Received remote write request: {} bytes, encoding: {}'.format(time.strftime('%Y-%m-%d-%H:%M:%S'), len(post_data), encoding)\n\
+            print(log_msg, flush=True)\n\
+            sys.stdout.flush()\n\
+            self.send_response(200)\n\
+            self.end_headers()\n\
+            self.wfile.write(b'OK')\n\
+        else:\n\
+            print('{} - Received non-write request: {}'.format(time.strftime('%Y-%m-%d-%H:%M:%S'), self.path), flush=True)\n\
+            sys.stdout.flush()\n\
+            self.send_response(404)\n\
+            self.end_headers()\n\
+    \n\
+    def log_message(self, format, *args):\n\
+        # Re-enable basic HTTP server logging\n\
+        log_msg = '{} - HTTP: {}'.format(time.strftime('%Y-%m-%d-%H:%M:%S'), format % args)\n\
+        print(log_msg, flush=True)\n\
+        sys.stdout.flush()\n\
+\n\
+print('Mock remote write server starting...', flush=True)\n\
+sys.stdout.flush()\n\
+with socketserver.TCPServer(('', 9090), MockRemoteWriteHandler) as httpd:\n\
+    print('Mock remote write server listening on port 9090', flush=True)\n\
+    sys.stdout.flush()\n\
+    httpd.serve_forever()\n\
+\" > /tmp/mock_remote_write.log 2>&1 & echo $!"
+
+        try:
+            # Start mock server
+            mock_pid_result = list(mock_server_node.account.ssh_capture(mock_server_cmd))
+            mock_pid = mock_pid_result[0].strip() if mock_pid_result else None
+            if not mock_pid:
+                raise RuntimeError("Failed to start mock remote write server")
+            self.logger.info(f"Mock remote write server started with PID: {mock_pid}")
+
+            # Wait a bit for server to start
+            time.sleep(5)
+
+            # Verify mock server is listening
+            wait_until(
+                lambda: self._check_port_listening(mock_server_node, 9090),
+                timeout_sec=30,
+                err_msg="Mock remote write server failed to start"
+            )
+
+            self.logger.info("Starting Connect cluster with Remote Write exporter...")
+            self.cc.start()
+
+            # Create connector to generate metrics
+            self.source = VerifiableSource(self.cc, topic=self.TOPIC, throughput=20)
+            self.source.start()
+
+            # Wait for connector to be running
+            wait_until(lambda: self.is_running(self.source), timeout_sec=30,
+                       err_msg="VerifiableSource connector failed to start")
+
+            # Wait for metrics to be sent to remote write endpoint
+            self.logger.info("Waiting for remote write requests...")
+            time.sleep(120)  # Wait for at least 2 export intervals
+
+            # Verify remote write requests were received
+            self._verify_remote_write_requests(mock_server_node)
+
+            self.logger.info("Remote Write exporter test passed!")
+
+        finally:
+            # Cleanup
+            try:
+                if 'mock_pid' in locals() and mock_pid:
+                    mock_server_node.account.ssh(f"kill {mock_pid}", allow_fail=True)
+                if hasattr(self, 'source'):
+                    self.source.stop()
+                self.cc.stop()
+            except Exception as e:
+                self.logger.warning(f"Cleanup error: {e}")
+
+    @cluster(num_nodes=5)
+    def test_opentelemetry_s3_metrics_exporter(self):
+        """Test OpenTelemetry S3 Metrics exporter functionality"""
+        # Setup mock S3 server using localstack
+        self.setup_services(num_workers=2)
+
+        # Create a temporary directory to simulate S3 bucket
+        s3_mock_dir = "/tmp/mock-s3-bucket"
+        bucket_name = "test-metrics-bucket"
+
+        def s3_config(node):
+            config = self.render("connect-distributed.properties", node=node)
+            # Replace prometheus exporter with S3 exporter
+            config = config.replace(
+                "automq.telemetry.exporter.uri=prometheus://0.0.0.0:9464",
+                "automq.telemetry.exporter.uri=s3://my-bucket-name"
+            )
+            # Add S3 specific configurations
+            config += "\nautomq.telemetry.exporter.interval.ms=30000\n"
+            config += "automq.telemetry.exporter.s3.cluster.id=test-cluster\n"
+            config += f"automq.telemetry.exporter.s3.node.id={self.cc.nodes.index(node) + 1}\n"
+
+            # Set primary node for the first worker only
+            is_primary = self.cc.nodes.index(node) == 0
+            config += f"automq.telemetry.exporter.s3.primary.node={str(is_primary).lower()}\n"
+            config += "automq.telemetry.exporter.s3.selector.type=static\n"
+
+            # Configure S3 bucket properly for localstack
+            # Use localstack endpoint (10.5.0.2:4566 from docker-compose.yaml)
+            config += f"automq.telemetry.s3.bucket=0@s3://{bucket_name}?endpoint=http://10.5.0.2:4566&region=us-east-1\n"
+
+            # Add AWS credentials for localstack (localstack accepts any credentials)
+            return config
+
+        self.cc.set_configs(s3_config)
+
+        try:
+            # Setup mock S3 directory on all nodes (as fallback)
+            for node in self.cc.nodes:
+                node.account.ssh(f"mkdir -p {s3_mock_dir}", allow_fail=False)
+                node.account.ssh(f"chmod 777 {s3_mock_dir}", allow_fail=False)
+
+            self.logger.info("Starting Connect cluster with S3 exporter...")
+            self.cc.start()
+
+            # Create the S3 bucket in localstack first
+            primary_node = self.cc.nodes[0]
+
+            create_bucket_cmd = f"aws s3api create-bucket --bucket {bucket_name} --endpoint=http://10.5.0.2:4566"
+
+            ret, val = subprocess.getstatusoutput(create_bucket_cmd)
+            self.logger.info(
+                f'\n--------------objects[bucket:{bucket_name}]--------------------\n:{val}\n--------------objects--------------------\n')
+            if ret != 0:
+                raise Exception("Failed to get bucket objects size, output: %s" % val)
+
+            # Create connector to generate metrics
+            self.source = VerifiableSource(self.cc, topic=self.TOPIC, throughput=15)
+            self.source.start()
+
+            # Wait for connector to be running
+            wait_until(lambda: self.is_running(self.source), timeout_sec=30,
+                       err_msg="VerifiableSource connector failed to start")
+
+            # Wait for metrics to be exported to S3
+            self.logger.info("Waiting for S3 metrics export...")
+            time.sleep(60)  # Wait for at least 2 export intervals
+
+            # Verify S3 exports were created in localstack
+            self._verify_s3_metrics_export_localstack(bucket_name, primary_node)
+
+            self.logger.info("S3 Metrics exporter test passed!")
+
+        finally:
+            # Cleanup
+            try:
+                if hasattr(self, 'source'):
+                    self.source.stop()
+                self.cc.stop()
+                # Clean up mock S3 directory
+                for node in self.cc.nodes:
+                    self.logger.info("Cleaning up S3 mock directory...")
+                    # node.account.ssh(f"rm -rf {s3_mock_dir}", allow_fail=True)
+            except Exception as e:
+                self.logger.warning(f"Cleanup error: {e}")
+
+    def _check_port_listening(self, node, port):
+        """Check if a port is listening on the given node"""
+        try:
+            result = list(node.account.ssh_capture(f"netstat -ln | grep :{port}", allow_fail=True))
+            return len(result) > 0
+        except:
+            return False
+
+    def _verify_remote_write_requests(self, node, log_file="/tmp/mock_remote_write.log"):
+        """Verify that remote write requests were received"""
+        try:
+            # Check the mock server log for received requests
+            result = list(node.account.ssh_capture(f"cat {log_file}", allow_fail=True))
+            log_content = "".join(result)
+
+            self.logger.info(f"Remote write log content: {log_content}")
+
+            # Look for evidence of received data
+            if "Received" in log_content or "received" in log_content:
+                self.logger.info("Remote write requests were successfully received")
+                return True
+
+            # Also check if the process is running and listening
+            if self._check_port_listening(node, 9090) or self._check_port_listening(node, 9091):
+                self.logger.info("Remote write server is listening, requests may have been processed")
+                return True
+
+            self.logger.warning("No clear evidence of remote write requests in log")
+            return False
+
+        except Exception as e:
+            self.logger.warning(f"Error verifying remote write requests: {e}")
+            # Don't fail the test if we can't verify the log, as the server might be working
+            return True
+
+    def _verify_s3_metrics_export_localstack(self, bucket_name, node):
+        """Verify that metrics were exported to S3 via localstack"""
+        try:
+            # 递归列出 S3 bucket 中的所有对象文件（而不是目录）
+            list_cmd = f"aws s3 ls s3://{bucket_name}/ --recursive --endpoint=http://10.5.0.2:4566"
+
+            ret, val = subprocess.getstatusoutput(list_cmd)
+            self.logger.info(
+                f'\n--------------recursive objects[bucket:{bucket_name}]--------------------\n{val}\n--------------recursive objects end--------------------\n')
+            if ret != 0:
+                self.logger.warning(f"Failed to list bucket objects recursively, return code: {ret}, output: {val}")
+                # 尝试非递归列出目录结构
+                list_dir_cmd = f"aws s3 ls s3://{bucket_name}/ --endpoint=http://10.5.0.2:4566"
+                ret2, val2 = subprocess.getstatusoutput(list_dir_cmd)
+                self.logger.info(f"Directory listing: {val2}")
+
+                # 如果非递归也失败，说明bucket可能不存在或没有权限
+                if ret2 != 0:
+                    raise Exception(f"Failed to list bucket contents, output: {val}")
+                else:
+                    # 看到了目录但没有文件，说明可能还没有上传完成
+                    self.logger.info("Found directories but no files yet, checking subdirectories...")
+
+                    # 尝试列出 automq/metrics/ 下的内容
+                    automq_cmd = f"aws s3 ls s3://{bucket_name}/automq/metrics/ --recursive --endpoint=http://10.5.0.2:4566"
+                    ret3, val3 = subprocess.getstatusoutput(automq_cmd)
+                    self.logger.info(f"AutoMQ metrics directory contents: {val3}")
+
+                    if ret3 == 0 and val3.strip():
+                        s3_objects = [line.strip() for line in val3.strip().split('\n') if line.strip()]
+                    else:
+                        return False
+            else:
+                s3_objects = [line.strip() for line in val.strip().split('\n') if line.strip()]
+
+            self.logger.info(f"S3 bucket {bucket_name} file contents (total {len(s3_objects)} files): {s3_objects}")
+
+            if s3_objects:
+                # 过滤掉目录行，只保留文件行（文件行通常有size信息）
+                file_objects = []
+                for obj_line in s3_objects:
+                    parts = obj_line.split()
+                    # 文件行格式: 2025-01-01 12:00:00 size_in_bytes filename
+                    # 目录行格式: PRE directory_name/ 或者只有目录名
+                    if len(parts) >= 4 and not obj_line.strip().startswith('PRE') and 'automq/metrics/' in obj_line:
+                        file_objects.append(obj_line)
+
+                self.logger.info(f"Found {len(file_objects)} actual metric files in S3:")
+                for file_obj in file_objects:
+                    self.logger.info(f"  - {file_obj}")
+
+                if file_objects:
+                    self.logger.info(f"S3 metrics export verified via localstack: found {len(file_objects)} metric files")
+
+                    # 尝试下载并检查第一个文件的内容
+                    try:
+                        first_file_parts = file_objects[0].split()
+                        if len(first_file_parts) >= 4:
+                            object_name = ' '.join(first_file_parts[3:])  # 文件名可能包含空格
+
+                            # 下载并检查内容
+                            download_cmd = f"aws s3 cp s3://{bucket_name}/{object_name} /tmp/sample_metrics.json --endpoint=http://10.5.0.2:4566"
+                            ret, download_output = subprocess.getstatusoutput(download_cmd)
+                            if ret == 0:
+                                self.logger.info(f"Successfully downloaded sample metrics file: {download_output}")
+
+                                # 检查文件内容
+                                cat_cmd = "head -n 3 /tmp/sample_metrics.json"
+                                ret2, content = subprocess.getstatusoutput(cat_cmd)
+                                if ret2 == 0:
+                                    self.logger.info(f"Sample metrics content: {content}")
+                                    # 验证内容格式是正确（应该包含JSON格式的指标数据）
+                                    if any(keyword in content for keyword in ['timestamp', 'name', 'kind', 'tags']):
+                                        self.logger.info("Metrics content format verification passed")
+                                    else:
+                                        self.logger.warning(f"Metrics content format may be incorrect: {content}")
+                            else:
+                                self.logger.warning(f"Failed to download sample file: {download_output}")
+                    except Exception as e:
+                        self.logger.warning(f"Error validating sample metrics file: {e}")
+
+                    return True
+                else:
+                    self.logger.warning("Found S3 objects but none appear to be metric files")
+                    return False
+            else:
+                # 检查bucket是否存在但为空
+                bucket_check_cmd = f"aws s3api head-bucket --bucket {bucket_name} --endpoint-url http://10.5.0.2:4566"
+                ret, bucket_output = subprocess.getstatusoutput(bucket_check_cmd)
+                if ret == 0:
+                    self.logger.info(f"Bucket {bucket_name} exists but is empty - metrics may not have been exported yet")
+                    return False
+                else:
+                    self.logger.warning(f"Bucket {bucket_name} may not exist: {bucket_output}")
+                    return False
+
+        except Exception as e:
+            self.logger.warning(f"Error verifying S3 metrics export via localstack: {e}")
+            return False
+
diff --git a/tests/kafkatest/tests/connect/templates/connect-distributed.properties b/tests/kafkatest/tests/connect/templates/connect-distributed.properties
index fa2172edd7..051a1e23ca 100644
--- a/tests/kafkatest/tests/connect/templates/connect-distributed.properties
+++ b/tests/kafkatest/tests/connect/templates/connect-distributed.properties
@@ -69,4 +69,16 @@ config.providers.file.class=org.apache.kafka.common.config.provider.FileConfigPr
 {% if PLUGIN_PATH is defined %}
 plugin.path={{ PLUGIN_PATH }}
 {% endif %}
-plugin.discovery={{ PLUGIN_DISCOVERY|default("service_load") }}
\ No newline at end of file
+plugin.discovery={{ PLUGIN_DISCOVERY|default("service_load") }}
+
+# ??OpenTelemetry?????
+metric.reporters=org.apache.kafka.connect.automq.OpenTelemetryMetricsReporter
+
+# OpenTelemetry????
+opentelemetry.metrics.enabled=true
+opentelemetry.metrics.prefix=kafka.connect
+
+# AutoMQ???? - ??Prometheus???
+automq.telemetry.exporter.uri=prometheus://0.0.0.0:9464
+service.name=kafka-connect-test
+service.instance.id=worker-1
\ No newline at end of file