Merge branch 'master' into update-doc9083

update
Signed-off-by: tomsun28 <tomsun28@outlook.com>
2026-09-17 18:19:02 +00:00 · 2025-10-25 13:17:14 +08:00 · 2025-10-25 13:16:02 +08:00 · 2025-10-25 13:12:27 +08:00 · 2025-10-25 13:09:22 +08:00 · 2025-10-25 12:57:33 +08:00
417 changed files with 6705 additions and 10431 deletions
@@ -16,15 +16,11 @@
 #

 github:
-  description: An AI-powered next-generation open source real-time observability system.
+  description: Real-time observability system with agentless, performance cluster, prometheus-compatible, custom monitoring and status page building capabilities.
  homepage: https://hertzbeat.apache.org/
  labels:
-    - ai
-    - agent
-    - llm
-    - logs
-    - monitor
    - monitoring
+    - monitor
    - notifications
    - alerting
    - self-hosted
@@ -34,11 +30,15 @@ github:
    - metrics
    - observability
    - uptime
+    - uptime-monitoring
    - status
    - status-page
+    - devops
    - server
    - linux
    - database
+    - mysql
+    - cloud
  enabled_merge_buttons:
    squash: true
    merge: false
@@ -90,24 +90,24 @@ e2e:
 backend:
  - changed-files:
      - any-glob-to-any-file:
-          - "hertzbeat-alerter/**/*"
-          - "hertzbeat-collector/**/*"
-          - "hertzbeat-common/**/*"
-          - "hertzbeat-grafana/**/*"
-          - "hertzbeat-manager/**/*"
-          - "hertzbeat-push/**/*"
-          - "hertzbeat-remoting/**/*"
-          - "hertzbeat-warehouse/**/*"
+          - "alerter/**/*"
+          - "collector/**/*"
+          - "common/**/*"
+          - "grafana/**/*"
+          - "manager/**/*"
+          - "push/**/*"
+          - "remoting/**/*"
+          - "warehouse/**/*"

 collector:
  - changed-files:
      - any-glob-to-any-file:
-          - "hertzbeat-collector/**/*"
+          - "collector/**/*"
            
 monitoring-template:
  - changed-files:
      - any-glob-to-any-file:
-          - "hertzbeat-manager/src/main/resources/define/**/*"
+          - "manager/src/main/resources/define/**/*"

 HIP:
  - changed-files:
@@ -39,7 +39,7 @@ jobs:
          python-version: '3.8'

      - name: Check Markdown
-        uses: DavidAnson/markdownlint-cli2-action@992badcdf24e3b8eb7e87ff9287fe931bcb00c6e
+        uses: DavidAnson/markdownlint-cli2-action@v16
        with:
          globs: './home/**/*.md'

@@ -4,7 +4,7 @@ image:
 tasks:

    - name: Run backend
-      before: cd hertzbeat-startup
+      before: cd hertzbeat-manager
      command: |
          gp sync-await setup-backend
          mvn spring-boot:run
@@ -13,7 +13,7 @@ tasks:
      before: cd web-app
      command: |
          gp sync-await setup-frontend
-          pnpm start --public-host "`gp url 4200`"
+          yarn start --public-host "`gp url 4200`"
      openMode: split-right

    - name: Setup backend
@@ -25,7 +25,7 @@ tasks:

    - name: Setup frontend
      init: |
-          cd web-app && pnpm install
+          cd web-app && yarn install
      command: |
          gp sync-done setup-frontend
          exit 0
@@ -20,27 +20,27 @@

 - 💬**Suggestion**: You can also make some suggestions to the project or community to promote the healthy development of the community;

-More see [Contribution Types](https://allcontributors.org/emoji-key)    
+More see [Contribution Types](https://allcontributors.org/docs/en/emoji-key)    

 Even small corrections to typos are very welcome :)   

 ### Getting HertzBeat up and running   

 > To get HertzBeat code running on your development tools, and able to debug with breakpoints.
-> This is a front-end and back-end separation project. To start the local code, the back-end [startup](hertzbeat-startup) and the front-end [web-app](web-app) must be started separately.  
+> This is a front-end and back-end separation project. To start the local code, the back-end [manager](manager) and the front-end [web-app](web-app) must be started separately.  


 #### Backend start

 1. Requires `maven3+`, `java17` and `lombok` environments

-2. (Optional) Modify the configuration file: `hertzbeat-startup/src/main/resources/application.yml`
+2. (Optional) Modify the configuration file: `manager/src/main/resources/application.yml`

 3. Execute under the project root directory: `mvn clean install -DskipTests`

 4. Add VM Options: `--add-opens=java.base/java.nio=org.apache.arrow.memory.core,ALL-UNNAMED`

-5. Start `springboot startup` service: `hertzbeat-startup/src/main/java/org/apache/hertzbeat/startup/HertzBeatApplication.java`
+5. Start `springboot manager` service: `manager/src/main/java/org/apache/hertzbeat/hertzbeat-manager/Manager.java`

 #### Frontend start

@@ -131,6 +131,17 @@ Add WeChat account `ahertzbeat` to pull you into the WeChat group.

 ## 🥐 Architecture

+- **[manager](https://github.com/apache/hertzbeat/tree/master/hertzbeat-manager)** Provide monitoring management, system management basic services.
+> Provides monitoring management, monitoring configuration management, system user management, etc.
+- **[collector](https://github.com/apache/hertzbeat/tree/master/collector)** Provide metrics data collection services.
+> Use common protocols to remotely collect and obtain peer-to-peer metrics data.
+- **[warehouse](https://github.com/apache/hertzbeat/tree/master/warehouse)** Provide monitoring data warehousing services.
+> Metrics data management, data query, calculation and statistics.
+- **[alerter](https://github.com/apache/hertzbeat/tree/master/hertzbeat-alerter)** Provide alert service.
+> Alarm calculation trigger, monitoring status linkage, alarm configuration, and alarm notification.
+- **[web-app](https://github.com/apache/hertzbeat/tree/master/web-app)** Provide web ui.
+> Angular Web UI.
+
 ![hertzBeat](home/static/img/docs/hertzbeat-arch.png)

 <br>  
@@ -161,26 +172,26 @@ Add WeChat account `ahertzbeat` to pull you into the WeChat group.

 - 💬**建议**：也可以对项目或者社区提出一些建议，促进社区的良性发展；  

-更多贡献方式参见 [Contribution Types](https://allcontributors.org/emoji-key)
+更多贡献方式参见 [Contribution Types](https://allcontributors.org/docs/en/emoji-key)

 即便是小到错别字的修正我们也都非常欢迎 :)   

 ### 让 HertzBeat 运行起来   

 > 让 HertzBeat 的代码在您的开发工具上运行起来，并且能够断点调试。   
-> 此为前后端分离项目，本地代码启动需将后端[hertzbeat-startup](hertzbeat-startup)和前端[web-app](web-app)分别启动生效。
+> 此为前后端分离项目，本地代码启动需将后端[manager](manager)和前端[web-app](web-app)分别启动生效。

 #### 后端启动

 1. 需要 `maven3+`, `java17` 和 `lombok` 环境

-2. (可选)修改配置文件配置信息-`hertzbeat-startup/src/main/resources/application.yml`
+2. (可选)修改配置文件配置信息-`manager/src/main/resources/application.yml`

 3. 在项目根目录运行编译: `mvn clean install -DskipTests`

 4. 在 `jvm` 加入参数 `--add-opens=java.base/java.nio=org.apache.arrow.memory.core,ALL-UNNAMED`

-5. 启动`springboot startup`服务 `hertzbeat-startup/src/main/java/org/apache/hertzbeat/startup/HertzBeatApplication.java`
+5. 启动`springboot manager`服务 `manager/src/main/java/org/apache/hertzbeat/hertzbeat-manager/Manager.java`


 #### 前端启动
@@ -271,4 +282,15 @@ Add WeChat account `ahertzbeat` to pull you into the WeChat group.

 ### 模块

+- **[manager](https://github.com/apache/hertzbeat/tree/master/hertzbeat-manager)** 提供监控管理,系统管理基础服务
+> 提供对监控的管理，监控应用配置的管理，系统用户租户后台管理等。
+- **[collector](https://github.com/apache/hertzbeat/tree/master/collector)** 提供监控数据采集服务
+> 使用通用协议远程采集获取对端指标数据。
+- **[warehouse](https://github.com/apache/hertzbeat/tree/master/warehouse)** 提供监控数据仓储服务
+> 采集指标结果数据管理，数据落盘，查询，计算统计。
+- **[alerter](https://github.com/apache/hertzbeat/tree/master/hertzbeat-alerter)** 提供告警服务
+> 告警计算触发，任务状态联动，告警配置，告警通知。
+- **[web-app](https://github.com/apache/hertzbeat/tree/master/web-app)** 提供可视化控制台页面
+> 监控告警系统可视化控制台前端
+
 ![hertzBeat](home/static/img/docs/hertzbeat-arch.png)     
@@ -9,6 +9,8 @@
 <b><a href="README.md">English</a></b> | <a href="README_CN.md">中文</a> | <a href="README_JP.md">日本語</a>
 </p>

+> A real-time observability system with agentless, performance cluster, prometheus-compatible, custom monitoring and status page building capabilities.
+
 [![Discord](https://img.shields.io/badge/Chat-Discord-7289DA?logo=discord)](https://discord.gg/Fb6M73htGr)
 [![Reddit](https://img.shields.io/badge/Reddit-Community-7289DA?logo=reddit)](https://www.reddit.com/r/hertzbeat/)
 [![Twitter](https://img.shields.io/twitter/follow/hertzbeat1024?logo=twitter)](https://x.com/hertzbeat1024)
@@ -19,7 +21,6 @@
 [![YouTube Channel Subscribers](https://img.shields.io/youtube/channel/subscribers/UCri75zfWX0GHqJFPENEbLow?logo=youtube&label=YouTube%20Channel)](https://www.youtube.com/channel/UCri75zfWX0GHqJFPENEbLow)
 [![Contribute with Gitpod](https://img.shields.io/badge/Contribute%20with-Gitpod-908a85?logo=gitpod&color=green)](https://gitpod.io/#https://github.com/apache/hertzbeat)
 [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/apache/hertzbeat)
-[![zread](https://img.shields.io/badge/Ask_Zread-_.svg?style=flat&color=00b0aa&labelColor=000000&logo=data%3Aimage%2Fsvg%2Bxml%3Bbase64%2CPHN2ZyB3aWR0aD0iMTYiIGhlaWdodD0iMTYiIHZpZXdCb3g9IjAgMCAxNiAxNiIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHBhdGggZD0iTTQuOTYxNTYgMS42MDAxSDIuMjQxNTZDMS44ODgxIDEuNjAwMSAxLjYwMTU2IDEuODg2NjQgMS42MDE1NiAyLjI0MDFWNC45NjAxQzEuNjAxNTYgNS4zMTM1NiAxLjg4ODEgNS42MDAxIDIuMjQxNTYgNS42MDAxSDQuOTYxNTZDNS4zMTUwMiA1LjYwMDEgNS42MDE1NiA1LjMxMzU2IDUuNjAxNTYgNC45NjAxVjIuMjQwMUM1LjYwMTU2IDEuODg2NjQgNS4zMTUwMiAxLjYwMDEgNC45NjE1NiAxLjYwMDFaIiBmaWxsPSIjZmZmIi8%2BCjxwYXRoIGQ9Ik00Ljk2MTU2IDEwLjM5OTlIMi4yNDE1NkMxLjg4ODEgMTAuMzk5OSAxLjYwMTU2IDEwLjY4NjQgMS42MDE1NiAxMS4wMzk5VjEzLjc1OTlDMS42MDE1NiAxNC4xMTM0IDEuODg4MSAxNC4zOTk5IDIuMjQxNTYgMTQuMzk5OUg0Ljk2MTU2QzUuMzE1MDIgMTQuMzk5OSA1LjYwMTU2IDE0LjExMzQgNS42MDE1NiAxMy43NTk5VjExLjAzOTlDNS42MDE1NiAxMC42ODY0IDUuMzE1MDIgMTAuMzk5OSA0Ljk2MTU2IDEwLjM5OTlaIiBmaWxsPSIjZmZmIi8%2BCjxwYXRoIGQ9Ik0xMy43NTg0IDEuNjAwMUgxMS4wMzg0QzEwLjY4NSAxLjYwMDEgMTAuMzk4NCAxLjg4NjY0IDEwLjM5ODQgMi4yNDAxVjQuOTYwMUMxMC4zOTg0IDUuMzEzNTYgMTAuNjg1IDUuNjAwMSAxMS4wMzg0IDUuNjAwMUgxMy43NTg0QzE0LjExMTkgNS42MDAxIDE0LjM5ODQgNS4zMTM1NiAxNC4zOTg0IDQuOTYwMVYyLjI0MDFDMTQuMzk4NCAxLjg4NjY0IDE0LjExMTkgMS42MDAxIDEzLjc1ODQgMS42MDAxWiIgZmlsbD0iI2ZmZiIvPgo8cGF0aCBkPSJNNCAxMkwxMiA0TDQgMTJaIiBmaWxsPSIjZmZmIi8%2BCjxwYXRoIGQ9Ik00IDEyTDEyIDQiIHN0cm9rZT0iI2ZmZiIgc3Ryb2tlLXdpZHRoPSIxLjUiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIvPgo8L3N2Zz4K&logoColor=ffffff)](https://zread.ai/apache/hertzbeat)

 **Home: [hertzbeat.apache.org](https://hertzbeat.apache.org)**   
 **Email: <a href="mailto:dev-subscribe@hertzbeat.apache.org">Mail to `dev-subscribe@hertzbeat.apache.org`</a> to subscribe mailing lists**
@@ -27,23 +28,28 @@

 ## 🎡 <font color="green">Introduction</font>

-[Apache HertzBeat™](https://github.com/apache/hertzbeat) is an AI-powered next-generation open source real-time observability system. Unified metrics and logs collection, centralized alerting distribution, intelligent management and analysis. No Agent required, high performance cluster, provides powerful custom monitoring and status page building capabilities.     
+[Apache HertzBeat™](https://github.com/apache/hertzbeat) is an easy-to-use, open source, real-time observability system with agentless, high performance cluster, prometheus-compatible, offers powerful custom monitoring and status page building capabilities.   

 ### Features

- Integrates **collection + analysis + alerting + notification** into one platform, with new AI-powered interactions and features under HertzBeat AI, and built-in MCP Server capabilities.
- Unified metrics platform, agentless, Prometheus-compatible, supports application services, programs, databases, caches, operating systems, big data, middleware, web servers, cloud-native, networks, custom monitoring and more.
- Unified logging platform, seamlessly integrates multiple log sources through OTLP protocol for reporting.
- Unified alerting platform, integrates internal alerts with various external alert sources, unified alert processing and analysis, flexible real-time and periodic threshold rules, grouping convergence, silence, suppression, etc.
- Unified message distribution, alerts processed by the alerting platform are distributed via `Email` `Discord` `Slack` `Telegram` `DingTalk` `WeChat` `FeiShu` `SMS` `Webhook` `ServerChan` and other methods.
- Makes protocols such as `Http, Jmx, Ssh, Snmp, Jdbc, Prometheus` configurable, allowing you to collect any metrics by simply configuring the template `YML` file online. Imagine being able to quickly adapt to a new monitoring type like K8s or Docker simply by configuring online with HertzBeat.
- High performance, supports horizontal expansion of multi-collector clusters, multi-isolated network monitoring and cloud-edge collaboration.
- Provides powerful status page building capabilities, easily communicate the real-time status of your service to users.
+* Combines **monitoring, alarm, and notification** features into one platform, and supports monitoring for web service, program, database, cache, os, webserver, middleware, bigdata, cloud-native, network, custom and more.
+* Easy to use and agentless, web-based and with one-click monitoring and alerting, zero learning curve.
+* Makes protocols such as `Http, Jmx, Ssh, Snmp, Jdbc, Prometheus` configurable, allowing you to collect any metrics by simply configuring the template `YML` file online. Imagine being able to quickly adapt to a new monitoring type like K8s or Docker simply by configuring online with HertzBeat.
+* Compatible with the `Prometheus` ecosystem and more, can monitoring what `Prometheus` can monitoring with few clicks on webui.
+* High performance, supports horizontal expansion of multi-collector clusters, multi-isolated network monitoring and cloud-edge collaboration.
+* Provides flexible alarm threshold rules and timely notifications delivered via  `Discord` `Slack` `Telegram` `Email` `Dingtalk` `WeChat` `FeiShu` `Webhook` `SMS` `ServerChan`.
+* Provides powerful status page building capabilities, easily communicate the real-time status of your service to users.

-> HertzBeat's unified platform, AI intelligence, powerful customization, multi-type support, high performance, and easy expansion, aims to help users quickly and conveniently achieve observability requirements.      
+> HertzBeat's powerful customization, multi-type support, high performance, easy expansion, and low coupling, aims to help users quickly build their own monitoring system.      

 ----

+![hertzbeat](home/static/img/home/1.png)
+
+![hertzbeat](home/static/img/home/status.png)
+
+![hertzbeat](home/static/img/home/9.png)
+
 ----

 ## 🥐 Architecture   
@@ -52,8 +58,8 @@

 ## ⛄ Supported   

-> We define all metrics collection types such as `mysql`, `jvm`, and `k8s` as `YML` templates, allowing users to import them to support corresponding types of monitoring.
-> Welcome everyone to contribute your customized general metrics type YML template during use.
+> We define all monitoring collection types such as `mysql`, `jvm`, and `k8s` as `YML` monitoring templates, allowing users to import them to support corresponding types of monitoring.
+> Welcome everyone to contribute your customized general monitoring type YML template during use.


 - [Website](https://raw.githubusercontent.com/apache/hertzbeat/master/hertzbeat-manager/src/main/resources/define/app-website.yml), [Port Telnet](https://raw.githubusercontent.com/apache/hertzbeat/master/hertzbeat-manager/src/main/resources/define/app-port.yml),
@@ -155,8 +161,8 @@ Detailed config refer to [Install HertzBeat via Package](https://hertzbeat.apach

 ##### 3：Start via source code        

-1. Local source code debugging needs to start the back-end project `hertzbeat-startup` and the front-end project `web-app`.  
-2. Backend：need `maven3+`, `java17`, `lombok`, add VM options in IDE: ` --add-opens=java.base/java.nio=org.apache.arrow.memory.core,ALL-UNNAMED `, then start the `hertzbeat-startup` service. 
+1. Local source code debugging needs to start the back-end project `manager` and the front-end project `web-app`.  
+2. Backend：need `maven3+`, `java17`, `lombok`, add VM options in IDE: ` --add-opens=java.base/java.nio=org.apache.arrow.memory.core,ALL-UNNAMED `, then start the `manager` service. 
 3. Web：need `nodejs npm angular-cli` environment, Run `ng serve --open` in `web-app` directory after backend startup.  
 4. Access `http://localhost:4200` to start, default account: `admin/hertzbeat`  

@@ -9,6 +9,8 @@
 <a href="README.md">English</a> | <b><a href="README_CN.md">中文</a></b> | <a href="README_JP.md">日本語</a>
 </p>

+> 实时观测系统，无需 Agent，性能集群，兼容 Prometheus，自定义监控和状态页构建能力。
+
 [![Discord](https://img.shields.io/badge/Chat-Discord-7289DA?logo=discord)](https://discord.gg/Fb6M73htGr)
 [![Reddit](https://img.shields.io/badge/Reddit-Community-7289DA?logo=reddit)](https://www.reddit.com/r/hertzbeat/)
 [![Twitter](https://img.shields.io/twitter/follow/hertzbeat1024?logo=twitter)](https://x.com/hertzbeat1024)
@@ -26,24 +28,29 @@

 ## 🎡 <font color="green">介绍</font>

-[Apache HertzBeat™](https://github.com/apache/hertzbeat) 是 AI 驱动的下一代开源实时观测系统。指标日志统一收集，告警一站分发，智能管控分析。无需 Agent，高性能集群，提供强大的自定义监控和状态页构建能力。     
+[Apache HertzBeat™](https://github.com/apache/hertzbeat) 是一个易用友好的开源实时监控告警系统，无需 Agent，高性能集群，兼容 Prometheus，提供强大的自定义监控和状态页构建能力。     

 ### 特点

- 集```采集+分析+告警+通知```为一体，HertzBeat AI 驱动下的新交互与功能，也内置 MCP Server 对外能力。
- 统一的指标平台，无需 Agent，兼容 Prometheus，支持应用服务，程序，数据库，缓存，操作系统，大数据，中间件，Web 服务器，云原生，网络，自定义等。
- 统一的日志平台，通过 OTLP 协议多日志源无缝对接上报。
- 统一的告警平台，内部告警与外部多种告警源集成接入，统一告警处理分析，灵活的实时与周期阈值规则，分组收敛，静默，抑制等。
- 统一的消息分发，告警平台处理后通过 `邮件` `Discord` `Slack` `Telegram` `钉钉` `微信` `飞书` `短信` `Webhook` `Server酱` 等方式分发通知。
- 将 `Http, Jmx, Ssh, Snmp, Jdbc, Prometheus` 等协议规范可配置化，只需配置模板 `YML` 就能自定义采集指标。您相信只需简单配置即可快速适配一款 `K8s` 或 `Docker` 等新的监控类型吗？
+- 集 **监控+告警+通知** 为一体，支持对应用服务，应用程序，数据库，缓存，操作系统，大数据，中间件，Web 服务器，云原生，网络，自定义等监控阈值告警通知一步到位。
+- 易用友好，无需 `Agent`，全 `WEB` 页面操作，鼠标点一点就能监控告警，无需学习成本。    
+- 将 `Http, Jmx, Ssh, Snmp, Jdbc, Prometheus` 等协议规范可配置化，只需在浏览器配置监控模板 `YML` 就能使用这些协议去自定义采集想要的指标。您相信只需简单配置即可快速适配一款 `K8s` 或 `Docker` 等新的监控类型吗？  
+- 兼容 `Prometheus` 的系统生态并且更多，只需页面操作就可以监控 `Prometheus` 所能监控的。
 - 高性能，支持多采集器集群横向扩展，支持多隔离网络监控，云边协同。
+- 灵活的告警阈值规则，`邮件` `Discord` `Slack` `Telegram` `钉钉` `微信` `飞书` `短信` `Webhook` `Server酱` 等方式消息及时送达。
 - 提供强大的状态页构建能力，轻松向用户传达您产品服务的实时状态。


-> `HertzBeat`的统一平台，AI智能，强大自定义，多类型支持，高性能，易扩展，希望能帮助用户快速方便实现观测需求。    
+> `HertzBeat`的强大自定义，多类型支持，高性能，易扩展，低耦合，希望能帮助用户快速搭建自有监控系统。    

 ----

+![hertzbeat](home/static/img/home/1.png)
+
+![hertzbeat](home/static/img/home/status.png)
+
+![hertzbeat](home/static/img/home/9.png)
+
 ----

 ## 🥐 模块  
@@ -52,8 +59,8 @@

 ## ⛄ 已支持    

-> 我们将监控采集类型（mysql,jvm,k8s）都定义为 `yml` 模板，用户可以导入这些模板来支持对应类型的监控!    
-> 欢迎大家一起贡献你使用过程中自定义的通用指标模板。
+> 我们将监控采集类型（mysql,jvm,k8s）都定义为 `yml` 监控模板，用户可以导入这些模板来支持对应类型的监控!    
+> 欢迎大家一起贡献你使用过程中自定义的通用监控类型监控模板。

 - [Website](https://raw.githubusercontent.com/apache/hertzbeat/master/hertzbeat-manager/src/main/resources/define/app-website.yml), [Port Telnet](https://raw.githubusercontent.com/apache/hertzbeat/master/hertzbeat-manager/src/main/resources/define/app-port.yml),
  [Http Api](https://raw.githubusercontent.com/apache/hertzbeat/master/hertzbeat-manager/src/main/resources/define/app-api.yml), [Ping Connect](https://raw.githubusercontent.com/apache/hertzbeat/master/hertzbeat-manager/src/main/resources/define/app-ping.yml),
@@ -91,7 +98,7 @@
 - [CiscoSwitch](https://raw.githubusercontent.com/apache/hertzbeat/master/hertzbeat-manager/src/main/resources/define/app-cisco_switch.yml), [HpeSwitch](https://raw.githubusercontent.com/apache/hertzbeat/master/hertzbeat-manager/src/main/resources/define/app-hpe_switch.yml),
  [HuaweiSwitch](https://raw.githubusercontent.com/apache/hertzbeat/master/hertzbeat-manager/src/main/resources/define/app-huawei_switch.yml), [TpLinkSwitch](https://raw.githubusercontent.com/apache/hertzbeat/master/hertzbeat-manager/src/main/resources/define/app-tplink_switch.yml),
  [H3cSwitch](https://raw.githubusercontent.com/apache/hertzbeat/master/hertzbeat-manager/src/main/resources/define/app-h3c_switch.yml)
- 和更多自定义指标模板。
+- 和更多自定义监控模板。
 - 通知支持 `Discord` `Slack` `Telegram` `邮件` `钉钉` `微信` `飞书` `短信` `Webhook` `Server酱`。

 ## 🐕 快速开始  
@@ -152,8 +159,8 @@

 ##### 方式三：本地代码启动

-1. 此为前后端分离项目，本地代码调试需要分别启动后端工程 `hertzbeat-startup` 和前端工程 `web-app`
-2. 后端：需要 `maven3+`, `java17` 和 `lombok` 环境，修改 `YML` 配置信息，添加JVM参数`--add-opens=java.base/java.nio=org.apache.arrow.memory.core,ALL-UNNAMED`后启动 `hertzbeat-startup` 服务即可。
+1. 此为前后端分离项目，本地代码调试需要分别启动后端工程 `manager` 和前端工程 `web-app`
+2. 后端：需要 `maven3+`, `java17` 和 `lombok` 环境，修改 `YML` 配置信息，添加JVM参数`--add-opens=java.base/java.nio=org.apache.arrow.memory.core,ALL-UNNAMED`后启动 `manager` 服务即可。
 3. 前端：需要 `nodejs npm angular-cli`环境，待本地后端启动后，在 `web-app` 目录下启动 `ng serve --open`
 4. 浏览器访问 `http://localhost:4200` 即可开始，默认账号密码 `admin/hertzbeat`

@@ -9,6 +9,8 @@
 <a href="README.md">English</a> | <a href="README_CN.md">中文</a> | <b><a href="README_JP.md">日本語</a></b>
 </p>  

+> オープンソースのリアルタイム監視システム、エージェントレス、クラスタ対応、Prometheus互換、カスタムおよびステータスページ付き。
+
 [![Discord](https://img.shields.io/badge/Chat-Discord-7289DA?logo=discord)](https://discord.gg/Fb6M73htGr)
 [![Reddit](https://img.shields.io/badge/Reddit-Community-7289DA?logo=reddit)](https://www.reddit.com/r/hertzbeat/)
 [![Twitter](https://img.shields.io/twitter/follow/hertzbeat1024?logo=twitter)](https://x.com/hertzbeat1024)
@@ -26,23 +28,29 @@

 ## 🎡 <font color="green">紹介</font>

-[Apache HertzBeat™](https://github.com/apache/hertzbeat) は AI 駆動の次世代オープンソースリアルタイム観測システムです。メトリクスとログの統一収集、アラートの一元配信、インテリジェント管理分析。エージェント不要、高性能クラスタ、強力なカスタム監視とステータスページ構築機能を提供します。     
+[Apache HertzBeat](https://github.com/apache/hertzbeat) （incubating）はオープンソースのリアルタイム監視システム、エージェントレス、クラスタ対応、Prometheus互換、カスタムおよびステータスページ付き。     

 ### 特性

- **収集+分析+アラート+通知**を一つのプラットフォームに統合し、HertzBeat AI 駆動の新しいインタラクションと機能、内蔵 MCP Server 機能を提供。
- 統一メトリクスプラットフォーム、エージェントレス、Prometheus互換、アプリケーションサービス、プログラム、データベース、キャッシュ、オペレーティングシステム、ビッグデータ、ミドルウェア、Webサーバー、クラウドネイティブ、ネットワーク、カスタム監視などをサポート。
- 統一ログプラットフォーム、OTLP プロトコルを通じて複数のログソースをシームレスに統合してレポート。
- 統一アラートプラットフォーム、内部アラートと様々な外部アラートソースを統合接続、統一アラート処理分析、柔軟なリアルタイムと周期的閾値ルール、グループ収束、サイレンス、抑制など。
- 統一メッセージ配信、アラートプラットフォームで処理後、`メール` `Discord` `Slack` `Telegram` `DingTalk` `WeChat` `FeiShu` `SMS` `Webhook` `ServerChan` などの方法で配信通知。
- `Http、Jmx、Ssh、Snmp、Jdbc、Prometheus`などのプロトコルを設定可能にし、テンプレート`YML`ファイルをオンラインで設定するだけで、あらゆるメトリクスを収集できるようにします。HertzBeatでオンライン設定するだけで、`K8s`や`Docker`のような新しい監視タイプに素早く対応できることを想像してみてください。
- 高性能で、コレクタークラスタの水平拡張、マルチ分離ネットワーク監視、クラウドエッジ協調をサポート。
- 強力なステータスページ構築機能を提供し、サービスのリアルタイムステータスをユーザーに簡単に伝達。
+- **モニター・アラーム・通知** を一体化し、Web、データベース、キャッシュ、OS、ミドルウェア、クラウドネイティブ、ネットワークなどをサポート。
+- 使いやすさを重視し、マウスのクリックだけで完全なWebベースの操作が可能。
+- `Http、Jmx、Ssh、Snmp、jdbc、Prometheus`などのプロトコルを設定可能にし、テンプレート`YML`ファイルをオンラインで設定するだけで、あらゆるメトリクスを収集できるようにします。HertzBeatでオンライン設定するだけで、`K8S`や`Docker`のような新しい監視タイプに素早く対応できることを想像してみてください。
+- `Prometheus`のエコシステム互換、Prometheusが監視できるものを、全てオンライン設定によって監視することができます。
+- 高性能で、コレクタークラスタ、マルチアイソレートネットワーク、クラウドエッジをサポート。
+- 柔軟なアラーム閾値ルールで、メール、discord、slack、telegramなどを通じてタイムリーに通知。
+- 強力なステータスページを簡単に構築し、リアルタイムのステータスをユーザーと共有。

-> `HertzBeat`の統一プラットフォーム、AI インテリジェンス、強力なカスタマイズ、多種類サポート、高性能、容易な拡張性は、ユーザーが迅速かつ便利に観測要件を実現することを支援することを目的としています。    
+
+> `HertzBeat`の強力なカスタマイズ、多種類のサポート、高性能および容易な拡張性は、ユーザーが迅速に独自の監視システムを構築するのを支援することを目的としています。    

 ----

+![hertzbeat](home/static/img/home/1.png)
+
+![hertzbeat](home/static/img/home/status.png)
+
+![hertzbeat](home/static/img/home/9.png)
+
 ----

 ## 🥐 モジュール  
@@ -155,8 +163,8 @@

 ##### 方式３：ローカルの実行

-1. ローカルの実行には、バックエンドのプロジェクト`hertzbeat-startup`とフロントエンドのプロジェクト`web-app`を起動する必要があります。
-2. バックエンド：`maven3+`、`java17`と`lombok`の環境は必要です。`YML` 設定を修正し、Java仮想マシンパラメータに`--add-opens=java.base/java.nio=org.apache.arrow.memory.core,ALL-UNNAMED` を追加し、`hertzbeat-startup` を起動します。
+1. ローカルの実行には、バックエンドのプロジェクト`manager`とフロントエンドのプロジェクト`web-app`を起動する必要があります。
+2. バックエンド：`maven3+`、`java17`と`lombok`の環境は必要です。`YML` 設定を修正し、Java仮想マシンパラメータに`--add-opens=java.base/java.nio=org.apache.arrow.memory.core,ALL-UNNAMED` を追加し、`manager` を起動します。
 3. フロントエンド：`nodejs npm angular-cli`の環境は必要です。ローカルのバックエンドが立ち上がったら、`web-app` ディレクトリで `ng serve --open` というコマンドを実行します。
 4. スタート：`http://localhost:4200`にアクセスします。デフォルトのアカウントとパスワード：`admin/hertzbeat`。

@@ -5,7 +5,7 @@
      "intervals": 60,
      "tags": [],
      "app": "ftp",
-      "instance": "127.0.0.1",
+      "host": "127.0.0.1",
      "name": "{{.param.monitorFTP}}"
    },
    "params": [
@@ -5,7 +5,7 @@
    "intervals": 60,
    "tags": [],
    "app": "api",
-    "instance": "127.0.0.1",
+    "host": "127.0.0.1",
      "name": "{{.param.monitorHTTP}}"
  },
  "params": [
@@ -5,7 +5,7 @@
      "intervals": 60,
      "tags": [],
      "app": "ping",
-      "instance": "127.0.0.1",
+      "host": "127.0.0.1",
      "name": "{{.param.monitorPing}}"
    },
    "params": [
@@ -5,7 +5,7 @@
      "intervals": 60,
      "tags": [],
      "app": "port",
-      "instance": "127.0.0.1",
+      "host": "127.0.0.1",
      "name": "{{.param.monitorPort}}"
    },
    "params": [
@@ -5,7 +5,7 @@
      "intervals": 60,
      "tags": [],
      "app": "fullsite",
-      "instance": "127.0.0.1",
+      "host": "127.0.0.1",
      "name": "{{.param.monitorSiteMap}}"
    },
    "params": [
@@ -5,7 +5,7 @@
      "intervals": 60,
      "tags": [],
      "app": "ssl_cert",
-      "instance": "127.0.0.1",
+      "host": "127.0.0.1",
      "name": "{{.param.monitorSSL}}"
    },
    "params": [
@@ -5,7 +5,7 @@
      "intervals": 60,
      "tags": [],
      "app": "udp_port",
-      "instance": "127.0.0.1",
+      "host": "127.0.0.1",
      "name": "{{.param.monitorUDP}}"
    },
    "params": [
@@ -5,7 +5,7 @@
      "intervals": 60,
      "tags": [],
      "app": "website",
-      "instance": "127.0.0.1",
+      "host": "127.0.0.1",
      "name": "{{.param.monitorWebsite}}"
    },
    "params": [
@@ -4,7 +4,7 @@
    "intervals": 10,
    "tags": [],
    "app": "kubernetes",
-    "instance": "172.29.0.11",
+    "host": "172.29.0.11",
    "name": "Brave_Stingray_55yR"
  },
  "collector": "",
@@ -23,7 +23,7 @@
 		<artifactId>hertzbeat</artifactId>
 		<version>2.0-SNAPSHOT</version>
 	</parent>
-	<artifactId>hertzbeat-ai</artifactId>
+	<artifactId>hertzbeat-ai-agent</artifactId>
 	<version>${hertzbeat.version}</version>
 	<properties>
 		<spring-ai.version>1.0.3</spring-ai.version>
@@ -65,15 +65,12 @@
        <dependency>
            <groupId>org.apache.hertzbeat</groupId>
            <artifactId>hertzbeat-base</artifactId>
+            <scope>provided</scope>
        </dependency>
 		<dependency>
 			<groupId>org.apache.hertzbeat</groupId>
 			<artifactId>hertzbeat-alerter</artifactId>
 		</dependency>
-        <dependency>
-            <groupId>org.apache.hertzbeat</groupId>
-            <artifactId>hertzbeat-manager</artifactId>
-        </dependency>
 		<dependency>
 			<groupId>com.usthe.sureness</groupId>
 			<artifactId>spring-boot3-starter-sureness</artifactId>
@@ -0,0 +1,81 @@
+/*
+ * 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.hertzbeat.ai.agent.adapters;
+
+import org.apache.hertzbeat.ai.agent.pojo.dto.Hierarchy;
+import org.apache.hertzbeat.common.entity.alerter.AlertDefine;
+import org.springframework.data.domain.Page;
+
+import java.util.List;
+
+/**
+ * Interface that provides access to alert definition information by retrieving data
+ * through the underlying alert define service.
+ */
+public interface AlertDefineServiceAdapter {
+
+    /**
+     * Add a new alert rule definition
+     * @param alertDefine Alert definition to add
+     * @return Created alert definition with ID
+     */
+    AlertDefine addAlertDefine(AlertDefine alertDefine);
+
+    /**
+     * Get alert definitions with filtering and pagination
+     * @param search Search term
+     * @param app Monitor type filter
+     * @param enabled Enabled status filter
+     * @param sort Sort field
+     * @param order Sort order
+     * @param pageIndex Page index
+     * @param pageSize Page size
+     * @return Page of alert definitions
+     */
+    Page<AlertDefine> getAlertDefines(String search, String app, Boolean enabled, String sort, String order, int pageIndex, int pageSize);
+
+    /**
+     * Get alert definition by ID
+     * @param id Alert definition ID
+     * @return Alert definition if found
+     */
+    AlertDefine getAlertDefine(Long id);
+
+    /**
+     * Enable or disable alert definition
+     * @param id Alert definition ID
+     * @param enabled Whether to enable
+     */
+    void toggleAlertDefineStatus(Long id, boolean enabled);
+
+    /**
+     * Modify/update an existing alert definition
+     * @param alertDefine Alert definition to update
+     * @return Updated alert definition
+     */
+    AlertDefine modifyAlertDefine(AlertDefine alertDefine);
+
+    /**
+     * Get specific app hierarchy structure
+     * @param app App type
+     * @param lang Language for localization
+     * @return List of hierarchy objects for specific app
+     */
+
+    List<Hierarchy> getAppHierarchy(String app, String lang);
+}
@@ -0,0 +1,60 @@
+/*
+ * 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.hertzbeat.ai.agent.adapters;
+
+import org.apache.hertzbeat.alert.dto.AlertSummary;
+import org.apache.hertzbeat.common.entity.alerter.GroupAlert;
+import org.apache.hertzbeat.common.entity.alerter.SingleAlert;
+import org.springframework.data.domain.Page;
+
+/**
+ * Interface that provides access to alert information by retrieving alert data
+ * through the underlying alert service.
+ */
+public interface AlertServiceAdapter {
+
+    /**
+     * Get single alerts with filtering and pagination
+     * @param status Alert status
+     * @param search Search term
+     * @param sort Sort field
+     * @param order Sort order
+     * @param pageIndex Page index
+     * @param pageSize Page size
+     * @return Page of single alerts
+     */
+    Page<SingleAlert> getSingleAlerts(String status, String search, String sort, String order, int pageIndex, int pageSize);
+
+    /**
+     * Get group alerts with filtering and pagination
+     * @param status Alert status
+     * @param search Search term
+     * @param sort Sort field
+     * @param order Sort order
+     * @param pageIndex Page index
+     * @param pageSize Page size
+     * @return Page of group alerts
+     */
+    Page<GroupAlert> getGroupAlerts(String status, String search, String sort, String order, int pageIndex, int pageSize);
+
+    /**
+     * Get alerts summary statistics
+     * @return Alert summary information
+     */
+    AlertSummary getAlertsSummary();
+}
@@ -0,0 +1,55 @@
+/*
+ * 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.hertzbeat.ai.agent.adapters;
+
+import org.apache.hertzbeat.common.entity.dto.MetricsData;
+import org.apache.hertzbeat.common.entity.dto.MetricsHistoryData;
+
+/**
+ * Interface that provides access to metrics information by retrieving metrics data
+ * through the underlying metrics service.
+ */
+public interface MetricsServiceAdapter {
+
+    /**
+     * Check warehouse storage server status
+     * @return true if warehouse is available, false otherwise
+     */
+    Boolean getWarehouseStorageServerStatus();
+
+    /**
+     * Query real-time metrics data
+     * @param monitorId Monitor ID
+     * @param metrics Metrics name
+     * @return Real-time metrics data
+     */
+    MetricsData getMetricsData(Long monitorId, String metrics);
+
+    /**
+     * Query historical metrics data
+     * @param monitorId Monitor ID
+     * @param app Monitor type
+     * @param metrics Metrics name
+     * @param metric Metric field name
+     * @param label Label filter
+     * @param history Query historical time period
+     * @param interval Whether to aggregate data
+     * @return Historical metrics data
+     */
+    MetricsHistoryData getMetricHistoryData(Long monitorId, String app, String metrics, String metric, String label, String history, Boolean interval);
+}
@@ -0,0 +1,71 @@
+/*
+ * 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.hertzbeat.ai.agent.adapters;
+
+import org.springframework.data.domain.Page;
+import org.apache.hertzbeat.common.entity.manager.Monitor;
+import org.apache.hertzbeat.common.entity.manager.Param;
+import org.apache.hertzbeat.common.entity.manager.ParamDefine;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Interface that provides access to monitor information by retrieving monitor data
+ * through the underlying monitor service.
+ */
+public interface MonitorServiceAdapter {
+    Page<Monitor> getMonitors(
+            List<Long> ids,
+            String app,
+            String search,
+            Byte status,
+            String sort,
+            String order,
+            Integer pageIndex,
+            Integer pageSize,
+            String labels
+    );
+
+    /**
+     * Add a new monitor
+     *
+     * @param monitor The monitor entity to create
+     * @param params List of parameters for the monitor
+     * @param collector Optional collector assignment
+     * @return The created monitor ID
+     */
+    Long addMonitor(Monitor monitor, List<Param> params, String collector);
+
+    /**
+     * Get all available monitor types with their display names
+     *
+     * @param language Language code (e.g., "en-US", "zh-CN")
+     * @return Map of monitor type key to display name
+     */
+    Map<String, String> getAvailableMonitorTypes(String language);
+
+    /**
+     * Get parameter definitions for a specific monitor type
+     *
+     * @param app Monitor type/application name (e.g., "linux", "mysql", "redis")
+     * @return List of parameter definitions for the monitor type
+     */
+    List<ParamDefine> getMonitorParamDefines(String app);
+}
+
@@ -0,0 +1,257 @@
+/*
+ * 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.hertzbeat.ai.agent.adapters.impl;
+
+import com.usthe.sureness.subject.SubjectSum;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.hertzbeat.ai.agent.adapters.AlertDefineServiceAdapter;
+import org.apache.hertzbeat.ai.agent.config.McpContextHolder;
+import org.apache.hertzbeat.ai.agent.pojo.dto.Hierarchy;
+import org.apache.hertzbeat.ai.agent.utils.UtilityClass;
+import org.apache.hertzbeat.common.entity.alerter.AlertDefine;
+import org.apache.hertzbeat.common.support.SpringContextHolder;
+import org.springframework.data.domain.Page;
+import org.springframework.stereotype.Component;
+
+import java.lang.reflect.Method;
+import java.util.List;
+
+/**
+ * Implementation of the AlertDefineServiceAdapter interface that provides access to alert definition information
+ * through reflection by invoking the underlying alert define service implementation.
+ */
+@Slf4j
+@Component
+public class AlertDefineServiceAdapterImpl implements AlertDefineServiceAdapter {
+
+    @Override
+    public AlertDefine addAlertDefine(AlertDefine alertDefine) {
+        try {
+            Object alertDefineService = null;
+            SubjectSum subjectSum = McpContextHolder.getSubject();
+            log.debug("Current security subject for addAlertDefine: {}", subjectSum);
+
+            try {
+                alertDefineService = SpringContextHolder.getBean("alertDefineServiceImpl");
+            } catch (Exception e) {
+                log.debug("Could not find bean by name 'alertDefineServiceImpl'");
+            }
+
+            assert alertDefineService != null;
+            log.debug("AlertDefineService bean found: {}", alertDefineService.getClass().getSimpleName());
+            
+            Method method = alertDefineService.getClass().getMethod("addAlertDefine", AlertDefine.class);
+
+            method.invoke(alertDefineService, alertDefine);
+            
+            log.debug("Successfully added alert define with ID: {}", alertDefine.getId());
+            return alertDefine;
+
+        } catch (NoSuchMethodException e) {
+            throw new RuntimeException("Method not found: addAlertDefine", e);
+        } catch (Exception e) {
+            log.error("Failed to invoke addAlertDefine via adapter", e);
+            throw new RuntimeException("Failed to invoke addAlertDefine via adapter: " + e.getMessage(), e);
+        }
+    }
+
+    @Override
+    public Page<AlertDefine> getAlertDefines(String search, String app, Boolean enabled, String sort, String order, int pageIndex, int pageSize) {
+        try {
+            Object alertDefineService = null;
+            SubjectSum subjectSum = McpContextHolder.getSubject();
+            log.debug("Current security subject for getAlertDefines: {}", subjectSum);
+
+            try {
+                alertDefineService = SpringContextHolder.getBean("alertDefineServiceImpl");
+            } catch (Exception e) {
+                log.debug("Could not find bean by name 'alertDefineServiceImpl'");
+            }
+
+            assert alertDefineService != null;
+            log.debug("AlertDefineService bean found: {}", alertDefineService.getClass().getSimpleName());
+            
+            Method method = alertDefineService.getClass().getMethod(
+                    "getAlertDefines",
+                    List.class, String.class, String.class, String.class, int.class, int.class);
+
+            @SuppressWarnings("unchecked")
+            Page<AlertDefine> result = (Page<AlertDefine>) method.invoke(
+                    alertDefineService, null, search, sort, order, pageIndex, pageSize);
+            
+            log.debug("Successfully retrieved {} alert defines", result.getContent().size());
+            return result;
+
+        } catch (NoSuchMethodException e) {
+            throw new RuntimeException("Method not found: getAlertDefines", e);
+        } catch (Exception e) {
+            log.error("Failed to invoke getAlertDefines via adapter", e);
+            throw new RuntimeException("Failed to invoke getAlertDefines via adapter: " + e.getMessage(), e);
+        }
+    }
+
+    @Override
+    public AlertDefine getAlertDefine(Long id) {
+        try {
+            Object alertDefineService = null;
+            SubjectSum subjectSum = McpContextHolder.getSubject();
+            log.debug("Current security subject for getAlertDefine: {}", subjectSum);
+
+            try {
+                alertDefineService = SpringContextHolder.getBean("alertDefineServiceImpl");
+            } catch (Exception e) {
+                log.debug("Could not find bean by name 'alertDefineServiceImpl'");
+            }
+
+            assert alertDefineService != null;
+            log.debug("AlertDefineService bean found: {}", alertDefineService.getClass().getSimpleName());
+            
+            Method method = alertDefineService.getClass().getMethod("getAlertDefine", long.class);
+
+            AlertDefine result = (AlertDefine) method.invoke(alertDefineService, id);
+            
+            log.debug("Successfully retrieved alert define with ID: {}", id);
+            return result;
+
+        } catch (NoSuchMethodException e) {
+            throw new RuntimeException("Method not found: getAlertDefine", e);
+        } catch (Exception e) {
+            log.error("Failed to invoke getAlertDefine via adapter for ID: {}", id, e);
+            throw new RuntimeException("Failed to invoke getAlertDefine via adapter: " + e.getMessage(), e);
+        }
+    }
+
+
+    @Override
+    public void toggleAlertDefineStatus(Long id, boolean enabled) {
+        try {
+            Object alertDefineService = null;
+            SubjectSum subjectSum = McpContextHolder.getSubject();
+            log.debug("Current security subject for toggleAlertDefineStatus: {}", subjectSum);
+
+            try {
+                alertDefineService = SpringContextHolder.getBean("alertDefineServiceImpl");
+            } catch (Exception e) {
+                log.debug("Could not find bean by name 'alertDefineServiceImpl'");
+            }
+
+            assert alertDefineService != null;
+            log.debug("AlertDefineService bean found: {}", alertDefineService.getClass().getSimpleName());
+            
+            // First get the existing AlertDefine
+            Method getMethod = alertDefineService.getClass().getMethod("getAlertDefine", long.class);
+            AlertDefine alertDefine = (AlertDefine) getMethod.invoke(alertDefineService, id);
+            
+            if (alertDefine == null) {
+                throw new RuntimeException("AlertDefine with ID " + id + " not found");
+            }
+            
+            // Update the enable status
+            alertDefine.setEnable(enabled);
+            
+            // Use modifyAlertDefine to save the changes
+            Method modifyMethod = alertDefineService.getClass().getMethod("modifyAlertDefine", AlertDefine.class);
+            modifyMethod.invoke(alertDefineService, alertDefine);
+            
+            log.debug("Successfully toggled alert define status for ID: {} to enabled: {}", id, enabled);
+
+        } catch (Exception e) {
+            log.error("Failed to invoke toggleAlertDefineStatus via adapter for ID: {}", id, e);
+            throw new RuntimeException("Failed to invoke toggleAlertDefineStatus via adapter: " + e.getMessage(), e);
+        }
+    }
+
+    @Override
+    public AlertDefine modifyAlertDefine(AlertDefine alertDefine) {
+        try {
+            Object alertDefineService = null;
+            SubjectSum subjectSum = McpContextHolder.getSubject();
+            log.debug("Current security subject for modifyAlertDefine: {}", subjectSum);
+
+            try {
+                alertDefineService = SpringContextHolder.getBean("alertDefineServiceImpl");
+            } catch (Exception e) {
+                log.debug("Could not find bean by name 'alertDefineServiceImpl'");
+            }
+
+            assert alertDefineService != null;
+            log.debug("AlertDefineService bean found: {}", alertDefineService.getClass().getSimpleName());
+            
+            Method method = alertDefineService.getClass().getMethod("modifyAlertDefine", AlertDefine.class);
+
+            method.invoke(alertDefineService, alertDefine);
+            
+            log.debug("Successfully modified alert define with ID: {}", alertDefine.getId());
+            return alertDefine;
+
+        } catch (NoSuchMethodException e) {
+            throw new RuntimeException("Method not found: modifyAlertDefine", e);
+        } catch (Exception e) {
+            log.error("Failed to invoke modifyAlertDefine via adapter", e);
+            throw new RuntimeException("Failed to invoke modifyAlertDefine via adapter: " + e.getMessage(), e);
+        }
+    }
+
+    /**
+     * Retrieves the application hierarchy for a given app and language.
+     * Uses reflection to call the underlying app service method.
+     *
+     * @param app  The application name
+     * @param lang The language code (optional, defaults to "en-US")
+     * @return List of Hierarchy objects representing the app hierarchy
+     */
+
+    @Override
+    public List<Hierarchy> getAppHierarchy(String app, String lang) {
+        try {
+            Object appService = null;
+            SubjectSum subjectSum = McpContextHolder.getSubject();
+            log.debug("Current security subject for getAppHierarchy: {}", subjectSum);
+
+            try {
+                appService = SpringContextHolder.getBean("appServiceImpl");
+            } catch (Exception e) {
+                log.debug("Could not find bean by name 'appServiceImpl', trying by class name");
+            }
+
+            assert appService != null;
+            log.debug("AppService bean found for getAppHierarchy: {}", appService.getClass().getSimpleName());
+
+            // Provide default language if not specified
+            if (lang == null || lang.trim().isEmpty()) {
+                lang = "en-US";
+            }
+
+            // Call getAppHierarchy method: getAppHierarchy(String app, String lang)
+            Method method = appService.getClass().getMethod("getAppHierarchy", String.class, String.class);
+
+            List<?> managerHierarchies = (List<?>) method.invoke(appService, app, lang);
+
+            // Convert manager DTOs to ai-agent DTOs
+            List<Hierarchy> result = UtilityClass.convertToAgentHierarchies(managerHierarchies);
+
+            log.debug("Successfully retrieved and converted {} hierarchies for app '{}'", result.size(), app);
+            return result;
+
+        } catch (Exception e) {
+            log.error("Failed to get app hierarchy for app '{}': {}", app, e.getMessage(), e);
+            throw new RuntimeException("Failed to get app hierarchy for " + app, e);
+        }
+    }
+
+}
@@ -0,0 +1,141 @@
+/*
+ * 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.hertzbeat.ai.agent.adapters.impl;
+
+import com.usthe.sureness.subject.SubjectSum;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.hertzbeat.ai.agent.adapters.AlertServiceAdapter;
+import org.apache.hertzbeat.ai.agent.config.McpContextHolder;
+import org.apache.hertzbeat.alert.dto.AlertSummary;
+import org.apache.hertzbeat.common.entity.alerter.GroupAlert;
+import org.apache.hertzbeat.common.entity.alerter.SingleAlert;
+import org.apache.hertzbeat.common.support.SpringContextHolder;
+import org.springframework.data.domain.Page;
+import org.springframework.stereotype.Component;
+
+import java.lang.reflect.Method;
+
+/**
+ * Implementation of the AlertServiceAdapter interface that provides access to alert information
+ * through reflection by invoking the underlying alert service implementation.
+ */
+@Slf4j
+@Component
+public class AlertServiceAdapterImpl implements AlertServiceAdapter {
+
+    @Override
+    public Page<SingleAlert> getSingleAlerts(String status, String search, String sort, String order, int pageIndex, int pageSize) {
+        try {
+            Object alertService = null;
+            SubjectSum subjectSum = McpContextHolder.getSubject();
+            log.debug("Current security subject for getSingleAlerts: {}", subjectSum);
+
+            try {
+                alertService = SpringContextHolder.getBean("alertServiceImpl");
+            } catch (Exception e) {
+                log.debug("Could not find bean by name 'alertServiceImpl'");
+            }
+
+            assert alertService != null;
+            log.debug("AlertService bean found: {}", alertService.getClass().getSimpleName());
+            
+            Method method = alertService.getClass().getMethod(
+                    "getSingleAlerts",
+                    String.class, String.class, String.class, String.class, int.class, int.class);
+
+            @SuppressWarnings("unchecked")
+            Page<SingleAlert> result = (Page<SingleAlert>) method.invoke(
+                    alertService, status, search, sort, order, pageIndex, pageSize);
+            
+            log.debug("Successfully retrieved {} single alerts", result.getContent().size());
+            return result;
+
+        } catch (NoSuchMethodException e) {
+            throw new RuntimeException("Method not found: getSingleAlerts", e);
+        } catch (Exception e) {
+            log.error("Failed to invoke getSingleAlerts via adapter", e);
+            throw new RuntimeException("Failed to invoke getSingleAlerts via adapter: " + e.getMessage(), e);
+        }
+    }
+
+    @Override
+    public Page<GroupAlert> getGroupAlerts(String status, String search, String sort, String order, int pageIndex, int pageSize) {
+        try {
+            Object alertService = null;
+            SubjectSum subjectSum = McpContextHolder.getSubject();
+            log.debug("Current security subject for getGroupAlerts: {}", subjectSum);
+
+            try {
+                alertService = SpringContextHolder.getBean("alertServiceImpl");
+            } catch (Exception e) {
+                log.debug("Could not find bean by name 'alertServiceImpl'");
+            }
+
+            assert alertService != null;
+            log.debug("AlertService bean found: {}", alertService.getClass().getSimpleName());
+            
+            Method method = alertService.getClass().getMethod(
+                    "getGroupAlerts",
+                    String.class, String.class, String.class, String.class, int.class, int.class);
+
+            @SuppressWarnings("unchecked")
+            Page<GroupAlert> result = (Page<GroupAlert>) method.invoke(
+                    alertService, status, search, sort, order, pageIndex, pageSize);
+            
+            log.debug("Successfully retrieved {} group alerts", result.getContent().size());
+            return result;
+
+        } catch (NoSuchMethodException e) {
+            throw new RuntimeException("Method not found: getGroupAlerts", e);
+        } catch (Exception e) {
+            log.error("Failed to invoke getGroupAlerts via adapter", e);
+            throw new RuntimeException("Failed to invoke getGroupAlerts via adapter: " + e.getMessage(), e);
+        }
+    }
+
+    @Override
+    public AlertSummary getAlertsSummary() {
+        try {
+            Object alertService = null;
+            SubjectSum subjectSum = McpContextHolder.getSubject();
+            log.debug("Current security subject for getAlertsSummary: {}", subjectSum);
+
+            try {
+                alertService = SpringContextHolder.getBean("alertServiceImpl");
+            } catch (Exception e) {
+                log.debug("Could not find bean by name 'alertServiceImpl'");
+            }
+
+            assert alertService != null;
+            log.debug("AlertService bean found: {}", alertService.getClass().getSimpleName());
+            
+            Method method = alertService.getClass().getMethod("getAlertsSummary");
+
+            AlertSummary result = (AlertSummary) method.invoke(alertService);
+            
+            log.debug("Successfully retrieved alerts summary");
+            return result;
+
+        } catch (NoSuchMethodException e) {
+            throw new RuntimeException("Method not found: getAlertsSummary", e);
+        } catch (Exception e) {
+            log.error("Failed to invoke getAlertsSummary via adapter", e);
+            throw new RuntimeException("Failed to invoke getAlertsSummary via adapter: " + e.getMessage(), e);
+        }
+    }
+}
@@ -0,0 +1,136 @@
+/*
+ * 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.hertzbeat.ai.agent.adapters.impl;
+
+import com.usthe.sureness.subject.SubjectSum;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.hertzbeat.ai.agent.adapters.MetricsServiceAdapter;
+import org.apache.hertzbeat.ai.agent.config.McpContextHolder;
+import org.apache.hertzbeat.common.entity.dto.MetricsData;
+import org.apache.hertzbeat.common.entity.dto.MetricsHistoryData;
+import org.apache.hertzbeat.common.support.SpringContextHolder;
+import org.springframework.stereotype.Component;
+
+import java.lang.reflect.Method;
+
+/**
+ * Implementation of the MetricsServiceAdapter interface that provides access to metrics information
+ * through reflection by invoking the underlying metrics service implementation.
+ */
+@Slf4j
+@Component
+public class MetricsServiceAdapterImpl implements MetricsServiceAdapter {
+
+    @Override
+    public Boolean getWarehouseStorageServerStatus() {
+        try {
+            Object metricsDataService = null;
+            SubjectSum subjectSum = McpContextHolder.getSubject();
+            log.debug("Current security subject for getWarehouseStorageServerStatus: {}", subjectSum);
+
+            try {
+                metricsDataService = SpringContextHolder.getBean("metricsDataServiceImpl");
+            } catch (Exception e) {
+                log.debug("Could not find bean by name 'metricsDataServiceImpl'");
+            }
+
+            assert metricsDataService != null;
+            log.debug("MetricsDataService bean found: {}", metricsDataService.getClass().getSimpleName());
+            
+            Method method = metricsDataService.getClass().getMethod("getWarehouseStorageServerStatus");
+
+            Boolean result = (Boolean) method.invoke(metricsDataService);
+            
+            log.debug("Successfully retrieved warehouse storage server status: {}", result);
+            return result;
+
+        } catch (NoSuchMethodException e) {
+            throw new RuntimeException("Method not found: getWarehouseStorageServerStatus", e);
+        } catch (Exception e) {
+            log.error("Failed to invoke getWarehouseStorageServerStatus via adapter", e);
+            throw new RuntimeException("Failed to invoke getWarehouseStorageServerStatus via adapter: " + e.getMessage(), e);
+        }
+    }
+
+    @Override
+    public MetricsData getMetricsData(Long monitorId, String metrics) {
+        try {
+            Object metricsDataService = null;
+            SubjectSum subjectSum = McpContextHolder.getSubject();
+            log.debug("Current security subject for getMetricsData: {}", subjectSum);
+
+            try {
+                metricsDataService = SpringContextHolder.getBean("metricsDataServiceImpl");
+            } catch (Exception e) {
+                log.debug("Could not find bean by name 'metricsDataServiceImpl'");
+            }
+
+            assert metricsDataService != null;
+            log.debug("MetricsDataService bean found: {}", metricsDataService.getClass().getSimpleName());
+            
+            Method method = metricsDataService.getClass().getMethod(
+                    "getMetricsData",
+                    Long.class, String.class);
+
+            MetricsData result = (MetricsData) method.invoke(metricsDataService, monitorId, metrics);
+            
+            log.debug("Successfully retrieved metrics data for monitor {} and metrics {}", monitorId, metrics);
+            return result;
+
+        } catch (NoSuchMethodException e) {
+            throw new RuntimeException("Method not found: getMetricsData", e);
+        } catch (Exception e) {
+            log.error("Failed to invoke getMetricsData via adapter for monitor {} and metrics {}", monitorId, metrics, e);
+            throw new RuntimeException("Failed to invoke getMetricsData via adapter: " + e.getMessage(), e);
+        }
+    }
+
+    @Override
+    public MetricsHistoryData getMetricHistoryData(Long monitorId, String app, String metrics, String metric, String label, String history, Boolean interval) {
+        try {
+            Object metricsDataService = null;
+            SubjectSum subjectSum = McpContextHolder.getSubject();
+            log.debug("Current security subject for getMetricHistoryData: {}", subjectSum);
+
+            try {
+                metricsDataService = SpringContextHolder.getBean("metricsDataServiceImpl");
+            } catch (Exception e) {
+                log.debug("Could not find bean by name 'metricsDataServiceImpl'");
+            }
+
+            assert metricsDataService != null;
+            log.debug("MetricsDataService bean found: {}", metricsDataService.getClass().getSimpleName());
+            
+            Method method = metricsDataService.getClass().getMethod(
+                    "getMetricHistoryData",
+                    Long.class, String.class, String.class, String.class, String.class, String.class, Boolean.class);
+
+            MetricsHistoryData result = (MetricsHistoryData) method.invoke(
+                    metricsDataService, monitorId, app, metrics, metric, label, history, interval);
+            
+            log.debug("Successfully retrieved historical metrics data for monitor {} and metrics {}", monitorId, metrics);
+            return result;
+
+        } catch (NoSuchMethodException e) {
+            throw new RuntimeException("Method not found: getMetricHistoryData", e);
+        } catch (Exception e) {
+            log.error("Failed to invoke getMetricHistoryData via adapter for monitor {} and metrics {}", monitorId, metrics, e);
+            throw new RuntimeException("Failed to invoke getMetricHistoryData via adapter: " + e.getMessage(), e);
+        }
+    }
+}
@@ -0,0 +1,214 @@
+/*
+ * 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.hertzbeat.ai.agent.adapters.impl;
+
+import com.usthe.sureness.subject.SubjectSum;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.hertzbeat.ai.agent.adapters.MonitorServiceAdapter;
+import org.apache.hertzbeat.ai.agent.config.McpContextHolder;
+import org.springframework.data.domain.Page;
+import org.apache.hertzbeat.common.entity.manager.Monitor;
+import org.apache.hertzbeat.common.entity.manager.Param;
+import org.apache.hertzbeat.common.entity.manager.ParamDefine;
+import org.apache.hertzbeat.common.support.SpringContextHolder;
+import org.springframework.stereotype.Component;
+
+import java.lang.reflect.Method;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Implementation of the MonitorServiceAdapter interface that provides access to monitor information
+ * through reflection by invoking the underlying monitor service implementation.
+ */
+@Slf4j
+@Component
+public class MonitorServiceAdapterImpl implements MonitorServiceAdapter {
+
+    @Override
+    public Page<Monitor> getMonitors(
+            List<Long> ids,
+            String app,
+            String search,
+            Byte status,
+            String sort,
+            String order,
+            Integer pageIndex,
+            Integer pageSize,
+            String labels) {
+        try {
+            // Provide default values for all nullable parameters
+            if (sort == null || sort.trim().isEmpty()) {
+                sort = "gmtCreate";
+            }
+            if (order == null || order.trim().isEmpty()) {
+                order = "desc";
+            }
+            if (pageIndex == null) {
+                pageIndex = 0;
+            }
+            if (pageSize == null) {
+                pageSize = 8;
+            }
+
+            Object monitorService = null;
+            SubjectSum subjectSum = McpContextHolder.getSubject();
+            log.debug("Current security subject: {}", subjectSum);
+
+            try {
+                monitorService = SpringContextHolder.getBean("monitorServiceImpl");
+            } catch (Exception e) {
+                log.debug("Could not find bean by name 'monitorServiceImpl', trying by class name");
+            }
+
+            assert monitorService != null;
+            log.debug("MonitorService bean found: {}", monitorService.getClass().getSimpleName());
+            Method method = monitorService.getClass().getMethod(
+                    "getMonitors",
+                    List.class, String.class, String.class, Byte.class,
+                    String.class, String.class, int.class, int.class, String.class);
+
+
+            @SuppressWarnings("unchecked")
+            Page<Monitor> result = (Page<Monitor>) method.invoke(
+                    monitorService,
+                    ids, app, search, status, sort, order, pageIndex, pageSize, labels);
+            log.debug("MonitorServiceAdapter.getMonitors result: {}", result.getContent());
+            return result;
+
+        } catch (NoSuchMethodException e) {
+            throw new RuntimeException("Method not found: getMonitors", e);
+        } catch (Exception e) {
+            log.debug("Failed to invoke getMonitors via adapter", e);
+            throw new RuntimeException("Failed to invoke getMonitors via adapter", e);
+        }
+    }
+
+    @Override
+    public Long addMonitor(Monitor monitor, List<Param> params, String collector) {
+        try {
+            Object monitorService = null;
+            SubjectSum subjectSum = McpContextHolder.getSubject();
+            log.debug("Current security subject for addMonitor: {}", subjectSum);
+
+            try {
+                monitorService = SpringContextHolder.getBean("monitorServiceImpl");
+            } catch (Exception e) {
+                log.debug("Could not find bean by name 'monitorServiceImpl', trying by class name");
+            }
+
+            assert monitorService != null;
+            log.debug("MonitorService bean found for addMonitor: {}", monitorService.getClass().getSimpleName());
+
+            // Call addMonitor method: addMonitor(Monitor monitor, List<Param> params, String collector, GrafanaDashboard dashboard)
+            Method method = monitorService.getClass().getMethod(
+                    "addMonitor",
+                    Monitor.class, List.class, String.class,
+                    Class.forName("org.apache.hertzbeat.common.entity.grafana.GrafanaDashboard"));
+
+            // Call the method with null dashboard
+            method.invoke(monitorService, monitor, params, collector, null);
+
+            log.debug("Successfully added monitor: {} with ID: {}", monitor.getName(), monitor.getId());
+            return monitor.getId();
+
+        } catch (NoSuchMethodException e) {
+            throw new RuntimeException("Method not found: addMonitor", e);
+        } catch (Exception e) {
+            log.error("Failed to invoke addMonitor via adapter", e);
+            throw new RuntimeException("Failed to invoke addMonitor via adapter: " + e.getMessage(), e);
+        }
+    }
+
+    @Override
+    public Map<String, String> getAvailableMonitorTypes(String language) {
+        try {
+            Object appService = null;
+            SubjectSum subjectSum = McpContextHolder.getSubject();
+            log.debug("Current security subject for getAvailableMonitorTypes: {}", subjectSum);
+
+            try {
+                appService = SpringContextHolder.getBean("appServiceImpl");
+            } catch (Exception e) {
+                log.debug("Could not find bean by name 'appServiceImpl', trying by class name");
+            }
+
+            assert appService != null;
+            log.debug("AppService bean found for getAvailableMonitorTypes: {}", appService.getClass().getSimpleName());
+
+            // Provide default language if not specified
+            if (language == null || language.trim().isEmpty()) {
+                language = "en-US";
+            }
+
+            // Call getI18nApps method: getI18nApps(String lang)
+            Method method = appService.getClass().getMethod("getI18nApps", String.class);
+
+            @SuppressWarnings("unchecked")
+            Map<String, String> result = (Map<String, String>) method.invoke(appService, language);
+
+            log.debug("Successfully retrieved {} monitor types", result.size());
+            return result;
+
+        } catch (NoSuchMethodException e) {
+            throw new RuntimeException("Method not found: getI18nApps", e);
+        } catch (Exception e) {
+            log.error("Failed to invoke getI18nApps via adapter", e);
+            throw new RuntimeException("Failed to invoke getI18nApps via adapter: " + e.getMessage(), e);
+        }
+    }
+
+    @Override
+    public List<ParamDefine> getMonitorParamDefines(String app) {
+        try {
+            Object appService = null;
+            SubjectSum subjectSum = McpContextHolder.getSubject();
+            log.debug("Current security subject for getMonitorParamDefines: {}", subjectSum);
+
+            try {
+                appService = SpringContextHolder.getBean("appServiceImpl");
+            } catch (Exception e) {
+                log.debug("Could not find bean by name 'appServiceImpl', trying by class name");
+            }
+
+            assert appService != null;
+            log.debug("AppService bean found for getMonitorParamDefines: {}", appService.getClass().getSimpleName());
+
+            // Validate app parameter
+            if (app == null || app.trim().isEmpty()) {
+                throw new IllegalArgumentException("Monitor type/app parameter is required");
+            }
+
+            // Call getAppParamDefines method: getAppParamDefines(String app)
+            Method method = appService.getClass().getMethod("getAppParamDefines", String.class);
+
+            @SuppressWarnings("unchecked")
+            List<ParamDefine> result = (List<ParamDefine>) method.invoke(appService, app.toLowerCase().trim());
+
+            log.debug("Successfully retrieved {} parameter definitions for monitor type: {}", result.size(), app);
+            return result;
+
+        } catch (NoSuchMethodException e) {
+            throw new RuntimeException("Method not found: getAppParamDefines", e);
+        } catch (Exception e) {
+            log.error("Failed to invoke getAppParamDefines via adapter for app: {}", app, e);
+            throw new RuntimeException("Failed to invoke getAppParamDefines via adapter: " + e.getMessage(), e);
+        }
+    }
+}
@@ -15,7 +15,7 @@
 * limitations under the License.
 */

-package org.apache.hertzbeat.ai.config;
+package org.apache.hertzbeat.ai.agent.config;


 import com.fasterxml.jackson.core.type.TypeReference;
@@ -0,0 +1,56 @@
+/*
+ * 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.hertzbeat.ai.agent.config;
+
+import lombok.extern.slf4j.Slf4j;
+import org.apache.hertzbeat.ai.agent.pojo.dto.ModelProviderConfig;
+import org.apache.hertzbeat.base.dao.GeneralConfigDao;
+import org.apache.hertzbeat.common.entity.manager.GeneralConfig;
+import org.apache.hertzbeat.common.util.JsonUtil;
+import org.jetbrains.annotations.NotNull;
+import org.springframework.ai.model.ApiKey;
+import org.springframework.stereotype.Component;
+
+/**
+ * Dynamic LLM Provider API Key implementation that retrieves the API key
+ */
+@Slf4j
+@Component
+public class DynamicOpenAiApiKey implements ApiKey {
+
+    private final GeneralConfigDao generalConfigDao;
+    
+    public DynamicOpenAiApiKey(GeneralConfigDao generalConfigDao) {
+        this.generalConfigDao = generalConfigDao;
+    }
+
+    @NotNull
+    @Override
+    public String getValue() {
+        GeneralConfig providerConfig = generalConfigDao.findByType("provider");
+        ModelProviderConfig modelProviderConfig = JsonUtil.fromJson(providerConfig.getContent(), ModelProviderConfig.class);
+
+        if (modelProviderConfig != null && modelProviderConfig.isEnable() && modelProviderConfig.isStatus()) {
+            log.debug("Retrieved {} API key from configuration service", modelProviderConfig.getCode());
+            return modelProviderConfig.getApiKey();
+        } else {
+            log.warn("No valid LLM Provider API key found in configuration");
+            return "";
+        }
+    }
+}
@@ -16,11 +16,11 @@
 */


-package org.apache.hertzbeat.ai.config;
+package org.apache.hertzbeat.ai.agent.config;

 import lombok.extern.slf4j.Slf4j;
 import org.apache.hertzbeat.common.support.event.AiProviderConfigChangeEvent;
-import org.apache.hertzbeat.common.entity.dto.ModelProviderConfig;
+import org.apache.hertzbeat.ai.agent.pojo.dto.ModelProviderConfig;
 import org.apache.hertzbeat.base.dao.GeneralConfigDao;
 import org.apache.hertzbeat.common.entity.manager.GeneralConfig;
 import org.apache.hertzbeat.common.util.JsonUtil;
@@ -72,7 +72,12 @@ public class LlmConfig {
        }
        ModelProviderConfig modelProviderConfig = JsonUtil.fromJson(providerConfig.getContent(), ModelProviderConfig.class);

-        if (modelProviderConfig == null || modelProviderConfig.getApiKey() == null) {
+        if (!modelProviderConfig.isEnable() || !modelProviderConfig.isStatus()) {
+            log.warn("LLM Provider is not enabled or status is not valid, ChatClient bean will not be created");
+            return null;
+        }
+
+        if (modelProviderConfig.getApiKey() == null) {
            log.warn("LLM Provider configuration is incomplete, ChatClient bean will not be created");
            return null;
        }
@@ -15,7 +15,7 @@
 * limitations under the License.
 */

-package org.apache.hertzbeat.ai.config;
+package org.apache.hertzbeat.ai.agent.config;

 import com.usthe.sureness.subject.SubjectSum;
 import org.springframework.core.NamedInheritableThreadLocal;
@@ -16,7 +16,7 @@
 */


-package org.apache.hertzbeat.ai.config;
+package org.apache.hertzbeat.ai.agent.config;

 import org.springframework.stereotype.Component;

@@ -179,4 +179,4 @@ public class PromptProvider {
            Keep responses focused on monitoring topics and HertzBeat's comprehensive capabilities.
            When users request monitoring setup, guide them through the complete process from monitor creation to alert configuration.
            """;
-}
+}
@@ -15,7 +15,7 @@
 * limitations under the License.
 */

-package org.apache.hertzbeat.ai.controller;
+package org.apache.hertzbeat.ai.agent.controller;

 import com.usthe.sureness.subject.SubjectSum;
 import com.usthe.sureness.util.SurenessContextHolder;
@@ -23,11 +23,11 @@ import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.Parameter;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import lombok.extern.slf4j.Slf4j;
-import org.apache.hertzbeat.ai.config.McpContextHolder;
-import org.apache.hertzbeat.ai.pojo.dto.ChatRequestContext;
-import org.apache.hertzbeat.ai.pojo.dto.ChatResponseChunk;
-import org.apache.hertzbeat.ai.service.ConversationService;
-import org.apache.hertzbeat.common.entity.ai.ChatConversation;
+import org.apache.hertzbeat.ai.agent.config.McpContextHolder;
+import org.apache.hertzbeat.ai.agent.pojo.dto.ChatRequestContext;
+import org.apache.hertzbeat.ai.agent.pojo.dto.ChatResponseDto;
+import org.apache.hertzbeat.ai.agent.pojo.dto.ConversationDto;
+import org.apache.hertzbeat.ai.agent.service.ConversationService;
 import org.apache.hertzbeat.common.entity.dto.Message;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.http.ResponseEntity;
@@ -63,6 +63,23 @@ public class ChatController {
        this.conversationService = conversationService;
    }

+    /**
+     * Create a new conversation
+     *
+     * @return Created conversation details
+     */
+    @PostMapping(path = "/conversations")
+    @Operation(summary = "Create a new conversation", description = "Create a new conversation")
+    public ResponseEntity<Message<ConversationDto>> createConversation() {
+        try {
+            ConversationDto conversation = conversationService.createConversation();
+            return ResponseEntity.ok(Message.success(conversation));
+        } catch (Exception e) {
+            log.error("Error creating conversation: ", e);
+            return ResponseEntity.ok(Message.fail((byte) -1, "Failed to create conversation"));
+        }
+    }
+
    /**
     * Send a message and get a streaming response with conversation tracking
     *
@@ -71,13 +88,14 @@ public class ChatController {
     */
    @PostMapping(value = "/stream", produces = TEXT_EVENT_STREAM_VALUE)
    @Operation(summary = "Send a chat message with streaming response", description = "Send a message to AI and get a streaming response with conversation tracking")
-    public Flux<ServerSentEvent<ChatResponseChunk>> streamChat(@Valid @RequestBody ChatRequestContext context) {
+    public Flux<ServerSentEvent<ChatResponseDto>> streamChat(@Valid @RequestBody ChatRequestContext context) {
        try {
            // Validate message is not empty
            SubjectSum subject = SurenessContextHolder.getBindSubject();
+            log.info(subject.toString());
            McpContextHolder.setSubject(subject);
            if (context.getMessage() == null || context.getMessage().trim().isEmpty()) {
-                ChatResponseChunk errorResponse = ChatResponseChunk.builder()
+                ChatResponseDto errorResponse = ChatResponseDto.builder()
                        .conversationId(context.getConversationId())
                        .response("Error: Message cannot be empty")
                        .build();
@@ -91,7 +109,7 @@ public class ChatController {

        } catch (Exception e) {
            log.error("Error in stream chat endpoint: ", e);
-            ChatResponseChunk errorResponse = ChatResponseChunk.builder()
+            ChatResponseDto errorResponse = ChatResponseDto.builder()
                    .conversationId(context.getConversationId())
                    .response("An error occurred: " + e.getMessage())
                    .build();
@@ -101,18 +119,6 @@ public class ChatController {
        }
    }

-    /**
-     * Create a new conversation
-     *
-     * @return Created conversation details
-     */
-    @PostMapping(path = "/conversations")
-    @Operation(summary = "Create a new conversation", description = "Create a new conversation")
-    public ResponseEntity<Message<ChatConversation>> createConversation() {
-        ChatConversation conversation = conversationService.createConversation();
-        return ResponseEntity.ok(Message.success(conversation));
-    }
-
    /**
     * Get all conversations
     *
@@ -120,9 +126,14 @@ public class ChatController {
     */
    @GetMapping(path = "/conversations")
    @Operation(summary = "List all conversations", description = "Get a list of all conversations")
-    public ResponseEntity<Message<List<ChatConversation>>> listConversations() {
-        List<ChatConversation> conversations = conversationService.getAllConversations();
-        return ResponseEntity.ok(Message.success(conversations));
+    public ResponseEntity<Message<List<ConversationDto>>> listConversations() {
+        try {
+            List<ConversationDto> conversations = conversationService.getAllConversations();
+            return ResponseEntity.ok(Message.success(conversations));
+        } catch (Exception e) {
+            log.error("Error listing conversations: ", e);
+            return ResponseEntity.ok(Message.fail((byte) -1, "Failed to retrieve conversations"));
+        }
    }

    /**
@@ -133,10 +144,26 @@ public class ChatController {
     */
    @GetMapping(path = "/conversations/{conversationId}")
    @Operation(summary = "Get conversation history", description = "Get detailed information and message history for a specific conversation")
-    public ResponseEntity<Message<ChatConversation>> getConversation(
-            @Parameter(description = "Conversation ID", example = "12345678") @PathVariable(value = "conversationId") Long conversationId) {
-        ChatConversation conversation = conversationService.getConversation(conversationId);
-        return ResponseEntity.ok(Message.success(conversation));
+    public ResponseEntity<Message<ConversationDto>> getConversation(
+            @Parameter(description = "Conversation ID", example = "conv-12345678") @PathVariable("conversationId") String conversationId) {
+        try {
+            // Validate conversation ID
+            if (conversationId == null || conversationId.trim().isEmpty()) {
+                return ResponseEntity.ok(Message.fail((byte) -1, "Conversation ID is required"));
+            }
+
+            ConversationDto conversation = conversationService.getConversation(conversationId);
+
+            if (conversation == null) {
+                return ResponseEntity.ok(Message.fail((byte) -1, "Conversation not found: " + conversationId));
+            }
+
+            return ResponseEntity.ok(Message.success(conversation));
+
+        } catch (Exception e) {
+            log.error("Error getting conversation: ", e);
+            return ResponseEntity.ok(Message.fail((byte) -1, "Failed to retrieve conversation"));
+        }
    }

    /**
@@ -148,8 +175,23 @@ public class ChatController {
    @DeleteMapping(path = "/conversations/{conversationId}")
    @Operation(summary = "Delete conversation", description = "Delete a specific conversation and all its messages")
    public ResponseEntity<Message<Void>> deleteConversation(
-            @Parameter(description = "Conversation ID", example = "2345678") @PathVariable("conversationId") Long conversationId) {
-        conversationService.deleteConversation(conversationId);
-        return ResponseEntity.ok(Message.success());
+            @Parameter(description = "Conversation ID", example = "conv-12345678") @PathVariable("conversationId") String conversationId) {
+        try {
+            // Validate conversation ID
+            if (conversationId == null || conversationId.trim().isEmpty()) {
+                return ResponseEntity.ok(Message.fail((byte) -1, "Conversation ID is required"));
+            }
+
+            boolean deleted = conversationService.deleteConversation(conversationId);
+            if (!deleted) {
+                return ResponseEntity.ok(Message.fail((byte) -1, "Conversation not found: " + conversationId));
+            }
+
+            return ResponseEntity.ok(Message.success("Conversation deleted successfully"));
+        } catch (Exception e) {
+            log.error("Error deleting conversation: ", e);
+            return ResponseEntity.ok(Message.fail((byte) -1, "Failed to delete conversation"));
+        }
+
    }
-}
+}
@@ -15,74 +15,66 @@
 * limitations under the License.
 */

-package org.apache.hertzbeat.common.entity.ai;
+package org.apache.hertzbeat.ai.agent.entity;

 import static io.swagger.v3.oas.annotations.media.Schema.AccessMode.READ_ONLY;
+import static io.swagger.v3.oas.annotations.media.Schema.AccessMode.READ_WRITE;
+
 import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.persistence.Column;
 import jakarta.persistence.Entity;
 import jakarta.persistence.EntityListeners;
-import jakarta.persistence.GeneratedValue;
-import jakarta.persistence.GenerationType;
 import jakarta.persistence.Id;
-import jakarta.persistence.Index;
-import jakarta.persistence.Lob;
-
 import jakarta.persistence.Table;
 import jakarta.validation.constraints.NotBlank;
-import java.time.LocalDateTime;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
 import org.springframework.data.annotation.CreatedBy;
 import org.springframework.data.annotation.CreatedDate;
 import org.springframework.data.annotation.LastModifiedBy;
 import org.springframework.data.annotation.LastModifiedDate;
 import org.springframework.data.jpa.domain.support.AuditingEntityListener;
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
+
+import java.time.LocalDateTime;

 /**
- * Entity for storing individual chat messages in conversations
+ * OpenAI Agent Config Entity
 */
+@Entity
+@Table(name = "hzb_ai_agent_config")
@Data
@Builder
-@Entity
-@EntityListeners(AuditingEntityListener.class)
-@Table(name = "hzb_ai_message", indexes = {
-    @Index(name = "idx_message_conversation_id", columnList = "conversation_id")
-})
@AllArgsConstructor
@NoArgsConstructor
-public class ChatMessage {
+@Schema(description = "OpenAI Agent config entity")
+@EntityListeners(AuditingEntityListener.class)
+public class OpenAiConfig {

    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    private Long id;
-    
-    @Schema(title = "conversation id")
-    private Long conversationId;
+    @Schema(title = "Config type: openai, primary key", description = "Config type: openai, primary key",
+            accessMode = READ_WRITE)
+    @NotBlank(message = "type can not null")
+    private String type;

-    @Schema(title = "message content")
-    @Lob
-    @NotBlank
+    @Schema(title = "Config content", description = "Config content，format json", accessMode = READ_WRITE)
+    @Column(length = 8192)
    private String content;

-    @Schema(title = "message role: user, system")
-    private String role;
-
    @Schema(title = "The creator of this record", example = "tom", accessMode = READ_ONLY)
    @CreatedBy
    private String creator;

-    @Schema(title = "The modifier of this record", example = "tom", accessMode = READ_ONLY)
+    @Schema(title = "This record was last modified by", example = "tom", accessMode = READ_ONLY)
    @LastModifiedBy
    private String modifier;

-    @Schema(title = "Record create time", example = "1612198922000", accessMode = READ_ONLY)
+    @Schema(title = "This record creation time (millisecond timestamp)", accessMode = READ_ONLY)
    @CreatedDate
    private LocalDateTime gmtCreate;

-    @Schema(title = "Record modify time", example = "1612198444000", accessMode = READ_ONLY)
+    @Schema(title = "Record the latest modification time (timestamp in milliseconds)", accessMode = READ_ONLY)
    @LastModifiedDate
    private LocalDateTime gmtUpdate;
-    
-}
+}
@@ -16,7 +16,7 @@
 */


-package org.apache.hertzbeat.ai.pojo.dto;
+package org.apache.hertzbeat.ai.agent.pojo.dto;

 import lombok.AllArgsConstructor;
 import lombok.Builder;
@@ -24,7 +24,6 @@ import lombok.Data;
 import lombok.NoArgsConstructor;

 import java.util.List;
-import org.apache.hertzbeat.common.entity.ai.ChatMessage;

 /**
 * Chat request context for AI chat endpoint.
@@ -41,10 +40,10 @@ public class ChatRequestContext {
    /**
     * Optional conversation ID for context
     */
-    private Long conversationId;
+    private String conversationId;

    /**
     * Conversation history messages for context
     */
-    private List<ChatMessage> conversationHistory;
-}
+    private List<MessageDto> conversationHistory;
+}
@@ -15,7 +15,7 @@
 * limitations under the License.
 */

-package org.apache.hertzbeat.ai.pojo.dto;
+package org.apache.hertzbeat.ai.agent.pojo.dto;

 import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.AllArgsConstructor;
@@ -31,18 +31,17 @@ import lombok.NoArgsConstructor;
@NoArgsConstructor
@AllArgsConstructor
@Schema(description = "Chat response")
-public class ChatResponseChunk {
+public class ChatResponseDto {

-    @Schema(description = "Conversation ID", example = "123")
-    private Long conversationId;
+    @Schema(description = "Conversation ID", example = "conv-123")
+    private String conversationId;

    @Schema(description = "AI response message", example = "Here are your monitors...")
    private String response;

-    @Schema(description = "User message ID", example = "123")
-    private Long userMessageId;
-    
-    @Schema(description = "Assistant message ID", example = "123")
-    private Long assistantMessageId;
+    @Schema(description = "User message ID", example = "msg-user-123")
+    private String userMessageId;

-}
+    @Schema(description = "Assistant message ID", example = "msg-assistant-123")
+    private String assistantMessageId;
+}
@@ -0,0 +1,53 @@
+/*
+ * 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.hertzbeat.ai.agent.pojo.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+/**
+ * Conversation DTO for AI chat conversations.
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+@Schema(description = "Conversation information")
+public class ConversationDto {
+
+    @Schema(description = "Conversation ID", example = "conv-123")
+    private String conversationId;
+
+    @Schema(description = "Creation time")
+    private LocalDateTime createdAt;
+
+    @Schema(description = "Last updated time")
+    private LocalDateTime updatedAt;
+
+    @Schema(description = "Messages in this conversation")
+    private List<MessageDto> messages;
+
+    @Schema(description = "Message count")
+    private Integer messageCount;
+}
@@ -0,0 +1,87 @@
+/*
+ * 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.hertzbeat.ai.agent.pojo.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.util.List;
+
+import static io.swagger.v3.oas.annotations.media.Schema.AccessMode.READ_WRITE;
+
+/**
+ * Hierarchical structure
+ * eg: Monitoring Type metrics Information Hierarchy Relationship
+ */
+@AllArgsConstructor
+@NoArgsConstructor
+@Data
+@Schema(description = "Monitor Hierarchy")
+public class Hierarchy {
+
+    /**
+     * Category value
+     */
+    @Schema(description = "Category Value", example = "os", accessMode = READ_WRITE)
+    String category;
+
+    /**
+     * Attribute value
+     */
+    @Schema(description = "Attribute value", example = "linux", accessMode = READ_WRITE)
+    String value;
+
+    /**
+     * Attribute internationalization tag
+     */
+    @Schema(description = "Attribute internationalization tag", example = "Linux system", accessMode = READ_WRITE)
+    String label;
+
+    /**
+     * Is it a leaf node
+     */
+    @Schema(description = "Is it a leaf node", example = "true", accessMode = READ_WRITE)
+    Boolean isLeaf = false;
+
+    /**
+     * Is hide this app type in main menus layout
+     */
+    @Schema(description = "Is hide this app in main menus layout, only for app type, default true.", example = "true")
+    Boolean hide = true;
+    
+    /**
+     * For leaf metric
+     * metric type 0-number: number 1-string: string
+     */
+    @Schema(description = "metric type 0-number: number 1-string: string")
+    private Byte type;
+    
+    /**
+     * metric unit
+     */
+    @Schema(description = "metric unit")
+    private String unit;
+
+    /**
+     * Next level of association
+     */
+    @Schema(description = "Next Hierarchy", accessMode = READ_WRITE)
+    private List<Hierarchy> children;
+}
@@ -0,0 +1,52 @@
+/*
+ * 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.hertzbeat.ai.agent.pojo.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.time.LocalDateTime;
+
+/**
+ * Message DTO for chat messages.
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+@Schema(description = "Chat message")
+public class MessageDto {
+
+    @Schema(description = "Message ID", example = "msg-123")
+    private String messageId;
+
+    @Schema(description = "Conversation ID", example = "conv-123")
+    private String conversationId;
+
+    @Schema(description = "Message content", example = "List all monitors")
+    private String content;
+
+    @Schema(description = "Message role", example = "user", allowableValues = {"user", "assistant"})
+    private String role;
+
+    @Schema(description = "Message timestamp")
+    private LocalDateTime timestamp;
+}
@@ -15,7 +15,7 @@
 * limitations under the License.
 */

-package org.apache.hertzbeat.common.entity.dto;
+package org.apache.hertzbeat.ai.agent.pojo.dto;

 import io.swagger.v3.oas.annotations.media.Schema;
 import jakarta.validation.constraints.NotBlank;
@@ -32,6 +32,15 @@ import lombok.NoArgsConstructor;
@Schema(description = "LLM Model Provider configuration")
 public class ModelProviderConfig {
    
+    @Schema(title = "Enable Provider", description = "Whether Provider is enabled", example = "true")
+    private boolean enable = false;
+    
+    @Schema(title = "Check the provider available status")
+    private boolean status = false;
+    
+    @Schema(title = "The error message when provider status check failed")
+    private String error;
+    
    @Schema(title = "Model type, text-generate, vision")
    private String type;
    
@@ -0,0 +1,60 @@
+/*
+ * 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.hertzbeat.ai.agent.service;
+
+/**
+ * Ai Configuration Service
+ */
+public interface AiConfigService {
+
+    /**
+     * Validate OpenAI API key by calling the OpenAI API
+     * @param apiKey the API key to validate
+     * @return validation result with success status and message
+     */
+    ValidationResult validateApiKey(String apiKey);
+
+    /**
+     * Validation result class
+     */
+    class ValidationResult {
+        private final boolean valid;
+        private final String message;
+
+        private ValidationResult(boolean valid, String message) {
+            this.valid = valid;
+            this.message = message;
+        }
+
+        public static ValidationResult success(String message) {
+            return new ValidationResult(true, message);
+        }
+
+        public static ValidationResult failure(String message) {
+            return new ValidationResult(false, message);
+        }
+
+        public boolean isValid() {
+            return valid;
+        }
+
+        public String getMessage() {
+            return message;
+        }
+    }
+}
@@ -16,9 +16,9 @@
 */


-package org.apache.hertzbeat.ai.service;
+package org.apache.hertzbeat.ai.agent.service;

-import org.apache.hertzbeat.ai.pojo.dto.ChatRequestContext;
+import org.apache.hertzbeat.ai.agent.pojo.dto.ChatRequestContext;
 import reactor.core.publisher.Flux;

 /**
@@ -16,10 +16,10 @@
 */


-package org.apache.hertzbeat.ai.service;
+package org.apache.hertzbeat.ai.agent.service;

-import org.apache.hertzbeat.ai.pojo.dto.ChatResponseChunk;
-import org.apache.hertzbeat.common.entity.ai.ChatConversation;
+import org.apache.hertzbeat.ai.agent.pojo.dto.ChatResponseDto;
+import org.apache.hertzbeat.ai.agent.pojo.dto.ConversationDto;
 import org.springframework.http.codec.ServerSentEvent;
 import reactor.core.publisher.Flux;

@@ -30,6 +30,13 @@ import java.util.List;
 */
 public interface ConversationService {

+    /**
+     * Create a new conversation
+     *
+     * @return Created conversation data
+     */
+    ConversationDto createConversation();
+
    /**
     * Send a message and receive a streaming response
     *
@@ -37,14 +44,8 @@ public interface ConversationService {
     * @param conversationId Optional conversation ID for continuing a chat
     * @return Flux of ServerSentEvent for streaming the response
     */
-    Flux<ServerSentEvent<ChatResponseChunk>> streamChat(String message, Long conversationId);
+    Flux<ServerSentEvent<ChatResponseDto>> streamChat(String message, String conversationId);

-    /**
-     * Create a new conversation
-     *
-     * @return Created conversation data
-     */
-    ChatConversation createConversation();

    /**
     * Get conversation history for a specific conversation
@@ -52,19 +53,28 @@ public interface ConversationService {
     * @param conversationId Conversation ID
     * @return Conversation data including messages
     */
-    ChatConversation getConversation(Long conversationId);
+    ConversationDto getConversation(String conversationId);

    /**
     * Get all conversations for the current user
     *
     * @return List of conversations
     */
-    List<ChatConversation> getAllConversations();
+    List<ConversationDto> getAllConversations();

    /**
     * Delete a conversation
     *
     * @param conversationId Conversation ID to delete
+     * @return true if deleted, false if conversation not found
     */
-    void deleteConversation(Long conversationId);
-}
+    boolean deleteConversation(String conversationId);
+
+    /**
+     * Check if a conversation exists
+     *
+     * @param conversationId Conversation ID to check
+     * @return true if conversation exists, false otherwise
+     */
+    boolean conversationExists(String conversationId);
+}
@@ -16,10 +16,10 @@
 */


-package org.apache.hertzbeat.ai.service;
+package org.apache.hertzbeat.ai.agent.service;

 import com.fasterxml.jackson.databind.ObjectMapper;
-import org.apache.hertzbeat.ai.config.CustomSseServerTransport;
+import org.apache.hertzbeat.ai.agent.config.CustomSseServerTransport;
 import org.springframework.ai.mcp.server.autoconfigure.McpServerProperties;
 import org.springframework.ai.tool.ToolCallbackProvider;
 import org.springframework.web.servlet.function.RouterFunction;
@@ -0,0 +1,100 @@
+/*
+ * 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.hertzbeat.ai.agent.service.impl;
+
+import lombok.extern.slf4j.Slf4j;
+import org.apache.hertzbeat.ai.agent.service.AiConfigService;
+import org.apache.hertzbeat.base.dao.GeneralConfigDao;
+import org.springframework.http.HttpEntity;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.stereotype.Service;
+import org.springframework.util.StringUtils;
+import org.springframework.web.client.RestTemplate;
+
+/**
+ * Ai Configuration Service Implementation
+ */
+@Slf4j
+@Service
+public class AiConfigServiceImpl implements AiConfigService {
+    
+    private static final String OPENAI_MODELS_ENDPOINT = "https://api.openai.com/v1/models";
+    private final RestTemplate restTemplate;
+
+    private final GeneralConfigDao generalConfigDao;
+
+    public AiConfigServiceImpl(GeneralConfigDao generalConfigDao, RestTemplate restTemplate) {
+        this.restTemplate = restTemplate;
+        this.generalConfigDao = generalConfigDao;
+    }
+
+    @Override
+    public ValidationResult validateApiKey(String apiKey) {
+        if (!StringUtils.hasText(apiKey)) {
+            return ValidationResult.failure("API key cannot be empty");
+        }
+
+        if (!apiKey.startsWith("sk-")) {
+            return ValidationResult.failure("Invalid API key format. OpenAI API keys should start with 'sk-'");
+        }
+
+        try {
+            HttpHeaders headers = new HttpHeaders();
+            headers.set("Authorization", "Bearer " + apiKey);
+            headers.set("Content-Type", "application/json");
+            
+            HttpEntity<String> entity = new HttpEntity<>(headers);
+            
+            log.debug("Validating OpenAI API key by calling models endpoint");
+            ResponseEntity<String> response = restTemplate.exchange(
+                OPENAI_MODELS_ENDPOINT,
+                HttpMethod.GET,
+                entity,
+                String.class
+            );
+
+            if (response.getStatusCode() == HttpStatus.OK) {
+                log.info("OpenAI API key validation successful");
+                return ValidationResult.success("API key is valid");
+            } else {
+                log.warn("OpenAI API key validation failed with status: {}", response.getStatusCode());
+                return ValidationResult.failure("API key validation failed: " + response.getStatusCode());
+            }
+
+        } catch (Exception e) {
+            log.error("Error validating OpenAI API key", e);
+            String errorMessage = e.getMessage();
+            
+            // Parse common error messages
+            if (errorMessage.contains("401")) {
+                return ValidationResult.failure("Invalid API key - authentication failed");
+            } else if (errorMessage.contains("403")) {
+                return ValidationResult.failure("API key does not have permission to access models");
+            } else if (errorMessage.contains("429")) {
+                return ValidationResult.failure("Rate limit exceeded - please try again later");
+            } else if (errorMessage.contains("timeout") || errorMessage.contains("connect")) {
+                return ValidationResult.failure("Network error - unable to connect to OpenAI API");
+            } else {
+                return ValidationResult.failure("API key validation failed: " + errorMessage);
+            }
+        }
+    }
+}
@@ -16,18 +16,18 @@
 */


-package org.apache.hertzbeat.ai.service.impl;
+package org.apache.hertzbeat.ai.agent.service.impl;

 import lombok.extern.slf4j.Slf4j;
-import org.apache.hertzbeat.ai.config.PromptProvider;
-import org.apache.hertzbeat.common.entity.ai.ChatMessage;
-import org.apache.hertzbeat.common.entity.dto.ModelProviderConfig;
-import org.apache.hertzbeat.ai.service.ChatClientProviderService;
+import org.apache.hertzbeat.ai.agent.config.PromptProvider;
+import org.apache.hertzbeat.ai.agent.pojo.dto.MessageDto;
+import org.apache.hertzbeat.ai.agent.pojo.dto.ModelProviderConfig;
+import org.apache.hertzbeat.ai.agent.service.ChatClientProviderService;
 import org.apache.hertzbeat.base.dao.GeneralConfigDao;
 import org.apache.hertzbeat.common.entity.manager.GeneralConfig;
 import org.apache.hertzbeat.common.util.JsonUtil;
 import org.springframework.stereotype.Service;
-import org.apache.hertzbeat.ai.pojo.dto.ChatRequestContext;
+import org.apache.hertzbeat.ai.agent.pojo.dto.ChatRequestContext;
 import org.springframework.ai.chat.client.ChatClient;
 import org.springframework.ai.chat.messages.AssistantMessage;
 import org.springframework.ai.chat.messages.Message;
@@ -66,6 +66,14 @@ public class ChatClientProviderServiceImpl implements ChatClientProviderService
        this.generalConfigDao = generalConfigDao;
    }

+    public String complete(String message) {
+        ChatClient chatClient = applicationContext.getBean("openAiChatClient", ChatClient.class);
+        return chatClient.prompt()
+                .user(message)
+                .call()
+                .content();
+    }
+
    @Override
    public Flux<String> streamChat(ChatRequestContext context) {
        try {
@@ -76,7 +84,7 @@ public class ChatClientProviderServiceImpl implements ChatClientProviderService

            // Add conversation history if available
            if (context.getConversationHistory() != null && !context.getConversationHistory().isEmpty()) {
-                for (ChatMessage historyMessage : context.getConversationHistory()) {
+                for (MessageDto historyMessage : context.getConversationHistory()) {
                    if ("user".equals(historyMessage.getRole())) {
                        messages.add(new UserMessage(historyMessage.getContent()));
                    } else if ("assistant".equals(historyMessage.getRole())) {
@@ -109,7 +117,7 @@ public class ChatClientProviderServiceImpl implements ChatClientProviderService
        if (!isConfigured) {
            GeneralConfig providerConfig = generalConfigDao.findByType("provider");
            ModelProviderConfig modelProviderConfig = JsonUtil.fromJson(providerConfig.getContent(), ModelProviderConfig.class);
-            isConfigured = modelProviderConfig != null && modelProviderConfig.getApiKey() != null;   
+            isConfigured = modelProviderConfig != null && modelProviderConfig.isStatus();   
        }
        return isConfigured;
    }
@@ -0,0 +1,272 @@
+/*
+ * 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.hertzbeat.ai.agent.service.impl;
+
+import lombok.extern.slf4j.Slf4j;
+import org.apache.hertzbeat.ai.agent.pojo.dto.ChatRequestContext;
+import org.apache.hertzbeat.ai.agent.pojo.dto.ChatResponseDto;
+import org.apache.hertzbeat.ai.agent.pojo.dto.ConversationDto;
+import org.apache.hertzbeat.ai.agent.pojo.dto.MessageDto;
+import org.apache.hertzbeat.ai.agent.service.ChatClientProviderService;
+import org.apache.hertzbeat.ai.agent.service.ConversationService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.codec.ServerSentEvent;
+import org.springframework.stereotype.Service;
+import reactor.core.publisher.Flux;
+
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.stream.Collectors;
+
+/**
+ * Implementation of the ConversationService interface for managing chat conversations.
+ */
+@Slf4j
+@Service
+public class ConversationServiceImpl implements ConversationService {
+
+    private final Map<String, Map<String, Object>> conversations = new ConcurrentHashMap<>();
+    private final Map<String, List<Map<String, Object>>> conversationMessages = new ConcurrentHashMap<>();
+
+    @Autowired
+    private ChatClientProviderService chatClientProviderService;
+    
+    @Override
+    public ConversationDto createConversation() {
+        String conversationId = createNewConversation();
+        return getConversation(conversationId);
+    }
+
+    @Override
+    public Flux<ServerSentEvent<ChatResponseDto>> streamChat(String message, String conversationId) {
+        // Validate conversation exists
+        if (!conversationExists(conversationId)) {
+            ChatResponseDto errorResponse = ChatResponseDto.builder()
+                    .conversationId(conversationId)
+                    .response("Error: Conversation not found: " + conversationId)
+                    .build();
+            return Flux.just(ServerSentEvent.builder(errorResponse)
+                    .event("error")
+                    .build());
+        }
+
+        // Check if OpenAI is properly configured
+        if (!chatClientProviderService.isConfigured()) {
+            ChatResponseDto errorResponse = ChatResponseDto.builder()
+                    .conversationId(conversationId)
+                    .response("Provider is not configured. Please configure your AI Provider.")
+                    .build();
+            return Flux.just(ServerSentEvent.builder(errorResponse)
+                    .event("error")
+                    .build());
+        }
+
+        log.info("Starting streaming conversation: {}", conversationId);
+
+        // Add user message to conversation
+        String userMessageId = addMessageToConversation(conversationId, message, "user");
+
+        // Get conversation history for context
+        List<Map<String, Object>> messagesList = conversationMessages.get(conversationId);
+        List<MessageDto> conversationHistory = new ArrayList<>();
+
+        if (messagesList != null && messagesList.size() > 1) {
+            // Get all messages except the last one (which is the current user message we just added)
+            for (int i = 0; i < messagesList.size() - 1; i++) {
+                Map<String, Object> msgMap = messagesList.get(i);
+                conversationHistory.add(mapToMessageDto(msgMap));
+            }
+        }
+
+        ChatRequestContext context = ChatRequestContext.builder()
+                .message(message)
+                .conversationId(conversationId)
+                .conversationHistory(conversationHistory)
+                .build();
+
+        // Stream response from AI service
+        StringBuilder fullResponse = new StringBuilder();
+        return chatClientProviderService.streamChat(context)
+                .map(chunk -> {
+                    fullResponse.append(chunk);
+                    ChatResponseDto responseDto = ChatResponseDto.builder()
+                            .conversationId(conversationId)
+                            .response(chunk)
+                            .userMessageId(userMessageId)
+                            .build();
+
+                    return ServerSentEvent.builder(responseDto)
+                            .event("message")
+                            .build();
+                })
+                .concatWith(Flux.defer(() -> {
+                    // Add the complete AI response to conversation
+                    String assistantMessageId = addMessageToConversation(conversationId, fullResponse.toString(), "assistant");
+
+                    ChatResponseDto finalResponse = ChatResponseDto.builder()
+                            .conversationId(conversationId)
+                            .response("")
+                            .userMessageId(userMessageId)
+                            .assistantMessageId(assistantMessageId)
+                            .build();
+
+                    return Flux.just(ServerSentEvent.builder(finalResponse)
+                            .event("complete")
+                            .build());
+                }))
+                .doOnComplete(() -> log.info("Streaming completed for conversation: {}", conversationId))
+                .doOnError(error -> log.error("Error in streaming chat for conversation {}: {}", conversationId, error.getMessage(), error))
+                .onErrorResume(error -> {
+                    ChatResponseDto errorResponse = ChatResponseDto.builder()
+                            .conversationId(conversationId)
+                            .response("An error occurred: " + error.getMessage())
+                            .userMessageId(userMessageId)
+                            .build();
+                    return Flux.just(ServerSentEvent.builder(errorResponse)
+                            .event("error")
+                            .build());
+                });
+    }
+
+    @Override
+    public ConversationDto getConversation(String conversationId) {
+        if (conversationId == null || conversationId.isEmpty()) {
+            return null;
+        }
+
+        Map<String, Object> conversation = conversations.get(conversationId);
+        if (conversation == null) {
+            return null;
+        }
+
+        List<Map<String, Object>> messagesList = conversationMessages.get(conversationId);
+        List<MessageDto> messages = messagesList != null
+                ? messagesList.stream().map(this::mapToMessageDto).collect(Collectors.toList()) :
+                new ArrayList<>();
+
+        return ConversationDto.builder()
+                .conversationId((String) conversation.get("conversationId"))
+                .createdAt((LocalDateTime) conversation.get("createdAt"))
+                .updatedAt((LocalDateTime) conversation.get("updatedAt"))
+                .messages(messages)
+                .build();
+    }
+
+    @Override
+    public List<ConversationDto> getAllConversations() {
+        List<ConversationDto> result = new ArrayList<>();
+
+        for (Map.Entry<String, Map<String, Object>> entry : conversations.entrySet()) {
+            Map<String, Object> conv = entry.getValue();
+            List<Map<String, Object>> messages = conversationMessages.get(entry.getKey());
+
+            ConversationDto dto = ConversationDto.builder()
+                    .conversationId((String) conv.get("conversationId"))
+                    .createdAt((LocalDateTime) conv.get("createdAt"))
+                    .updatedAt((LocalDateTime) conv.get("updatedAt"))
+                    .messages(new ArrayList<>()) // Don't include messages in list view for performance
+                    .build();
+            result.add(dto);
+        }
+
+        result.sort((a, b) -> b.getUpdatedAt().compareTo(a.getUpdatedAt()));
+
+        return result;
+    }
+
+    @Override
+    public boolean deleteConversation(String conversationId) {
+        if (conversationId == null || conversationId.isEmpty()) {
+            return false;
+        }
+
+        boolean existed = conversations.containsKey(conversationId);
+        if (existed) {
+            conversations.remove(conversationId);
+            conversationMessages.remove(conversationId);
+            log.info("Deleted conversation: {}", conversationId);
+        }
+        return existed;
+    }
+
+    @Override
+    public boolean conversationExists(String conversationId) {
+        return conversationId != null && !conversationId.isEmpty() && conversations.containsKey(conversationId);
+    }
+
+    private String createNewConversation() {
+        String conversationId = "conv-" + UUID.randomUUID().toString().substring(0, 8);
+        LocalDateTime now = LocalDateTime.now();
+
+        Map<String, Object> conversation = new HashMap<>();
+        conversation.put("conversationId", conversationId);
+        conversation.put("createdAt", now);
+        conversation.put("updatedAt", now);
+
+        conversations.put(conversationId, conversation);
+        conversationMessages.put(conversationId, new ArrayList<>());
+
+        log.info("Created new conversation: {}", conversationId);
+        return conversationId;
+    }
+
+    private MessageDto mapToMessageDto(Map<String, Object> messageMap) {
+        return MessageDto.builder()
+                .messageId((String) messageMap.get("messageId"))
+                .conversationId((String) messageMap.get("conversationId"))
+                .content((String) messageMap.get("content"))
+                .role((String) messageMap.get("role"))
+                .timestamp((LocalDateTime) messageMap.get("timestamp"))
+                .build();
+    }
+
+    private String addMessageToConversation(String conversationId, String content, String role) {
+        List<Map<String, Object>> messages = conversationMessages.computeIfAbsent(conversationId, k -> new ArrayList<>());
+
+        String messageId = "msg-" + UUID.randomUUID().toString().substring(0, 8);
+        Map<String, Object> message = new HashMap<>();
+        message.put("messageId", messageId);
+        message.put("conversationId", conversationId);
+        message.put("content", content);
+        message.put("role", role);
+        message.put("timestamp", LocalDateTime.now());
+
+        messages.add(message);
+
+        // Update conversation timestamp
+        Map<String, Object> conversation = conversations.get(conversationId);
+        if (conversation != null) {
+            conversation.put("updatedAt", LocalDateTime.now());
+            // Auto-generate title from first user message
+            if ("user".equals(role) && messages.stream().filter(m -> "user".equals(m.get("role"))).count() == 1) {
+                String title = content.length() > 30 ? content.substring(0, 27) + "..." : content;
+                conversation.put("title", title);
+            }
+        }
+
+        return messageId;
+    }
+
+
+
+}
@@ -16,14 +16,14 @@
 */


-package org.apache.hertzbeat.ai.service.impl;
+package org.apache.hertzbeat.ai.agent.service.impl;

-import org.apache.hertzbeat.ai.config.CustomSseServerTransport;
-import org.apache.hertzbeat.ai.service.McpServerService;
-import org.apache.hertzbeat.ai.tools.AlertDefineTools;
-import org.apache.hertzbeat.ai.tools.AlertTools;
-import org.apache.hertzbeat.ai.tools.MetricsTools;
-import org.apache.hertzbeat.ai.tools.MonitorTools;
+import org.apache.hertzbeat.ai.agent.config.CustomSseServerTransport;
+import org.apache.hertzbeat.ai.agent.service.McpServerService;
+import org.apache.hertzbeat.ai.agent.tools.AlertDefineTools;
+import org.apache.hertzbeat.ai.agent.tools.AlertTools;
+import org.apache.hertzbeat.ai.agent.tools.MetricsTools;
+import org.apache.hertzbeat.ai.agent.tools.MonitorTools;
 import org.springframework.ai.mcp.server.autoconfigure.McpServerProperties;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.annotation.Primary;
@@ -15,7 +15,7 @@
 * limitations under the License.
 */

-package org.apache.hertzbeat.ai.tools;
+package org.apache.hertzbeat.ai.agent.tools;

 /**
 * Tools for alert definition and threshold configuration operations
@@ -88,4 +88,4 @@ public interface AlertDefineTools {
     * @return Result message indicating success or failure
     */
    String bindMonitorsToAlertRule(Long ruleId, String monitorIds);
-}
+}
@@ -16,7 +16,7 @@
 */


-package org.apache.hertzbeat.ai.tools;
+package org.apache.hertzbeat.ai.agent.tools;

 /**
 * Tools for alert operations and alarm data queries
@@ -16,7 +16,7 @@
 */


-package org.apache.hertzbeat.ai.tools;
+package org.apache.hertzbeat.ai.agent.tools;

 /**
 * Tools for metrics data operations and queries
@@ -33,17 +33,16 @@ public interface MetricsTools {

    /**
     * Get historical metrics data for a monitor
-     *
-     * @param instance Instance identifier (e.g., "ip:port", "ip", or "domain")
-     * @param app      Monitor type (e.g., "linux", "mysql", "http")
-     * @param metrics  Metrics name (e.g., "system", "cpu", "memory")
-     * @param metric   Specific metric field (e.g., "usage", "used", "available")
-     * @param label    Label filter for specific instances
-     * @param history  Time range (e.g., "1h", "6h", "24h", "7d")
+     * @param monitorId Monitor ID
+     * @param app Monitor type (e.g., "linux", "mysql", "http")
+     * @param metrics Metrics name (e.g., "system", "cpu", "memory")
+     * @param metric Specific metric field (e.g., "usage", "used", "available")
+     * @param label Label filter for specific instances
+     * @param history Time range (e.g., "1h", "6h", "24h", "7d")
     * @param interval Whether to aggregate data with intervals
     * @return Historical metrics data formatted for display
     */
-    String getHistoricalMetrics(String instance, String app, String metrics, String metric, String label, String history, Boolean interval);
+    String getHistoricalMetrics(Long monitorId, String app, String metrics, String metric, String label, String history, Boolean interval);

    /**
     * Check warehouse storage server status
@@ -16,7 +16,7 @@
 */


-package org.apache.hertzbeat.ai.tools;
+package org.apache.hertzbeat.ai.agent.tools;

 import java.util.List;

@@ -94,4 +94,4 @@ public interface MonitorTools {
     * @return Formatted string with parameter definitions including field names, types, and requirements
     */
    String getMonitorAdditionalParams(String app);
-}
+}
@@ -15,20 +15,19 @@
 * limitations under the License.
 */

-package org.apache.hertzbeat.ai.tools.impl;
+package org.apache.hertzbeat.ai.agent.tools.impl;

 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.node.ArrayNode;
 import com.fasterxml.jackson.databind.node.ObjectNode;
 import com.usthe.sureness.subject.SubjectSum;
 import lombok.extern.slf4j.Slf4j;
-import org.apache.hertzbeat.ai.config.McpContextHolder;
-import org.apache.hertzbeat.alert.service.AlertDefineService;
-import org.apache.hertzbeat.manager.service.AppService;
-import org.apache.hertzbeat.ai.tools.AlertDefineTools;
-import org.apache.hertzbeat.ai.utils.UtilityClass;
+import org.apache.hertzbeat.ai.agent.adapters.AlertDefineServiceAdapter;
+import org.apache.hertzbeat.ai.agent.pojo.dto.Hierarchy;
+import org.apache.hertzbeat.ai.agent.config.McpContextHolder;
+import org.apache.hertzbeat.ai.agent.tools.AlertDefineTools;
+import org.apache.hertzbeat.ai.agent.utils.UtilityClass;
 import org.apache.hertzbeat.common.entity.alerter.AlertDefine;
-import org.apache.hertzbeat.manager.pojo.dto.Hierarchy;
 import org.springframework.ai.tool.annotation.Tool;
 import org.springframework.ai.tool.annotation.ToolParam;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -47,9 +46,7 @@ import java.util.Map;
@Service
 public class AlertDefineToolsImpl implements AlertDefineTools {
    @Autowired
-    private AlertDefineService alertDefineService;
-    @Autowired
-    private AppService appService;
+    private AlertDefineServiceAdapter alertDefineServiceAdapter;


    @Override
@@ -243,19 +240,17 @@ public class AlertDefineToolsImpl implements AlertDefineTools {
                    .datasource(datasource)
                    .enable(enable)
                    .build();
-            
-            log.debug("Current security subject for addAlertDefine: {}", subjectSum);

-            alertDefineService.addAlertDefine(alertDefine);
+            AlertDefine createdAlertDefine = alertDefineServiceAdapter.addAlertDefine(alertDefine);

            // Note: Monitor binding is handled separately via bind_monitors_to_alert_rule tool
            String bindingNote = String.format(" (Use bind_monitors_to_alert_rule tool to associate specific monitors)");

-            log.info("Successfully created alert rule '{}' with ID: {}", name, alertDefine.getId());
+            log.info("Successfully created alert rule '{}' with ID: {}", name, createdAlertDefine.getId());
            
            StringBuilder response = new StringBuilder();
            response.append(String.format("Successfully created %s alert rule '%s' with ID: %d\n", 
-                    type, name, alertDefine.getId()));
+                    type, name, createdAlertDefine.getId()));
            response.append(String.format("Expression: %s\n", expr));
            response.append(String.format("Priority: %d (%s)\n", priority, severityLabel));
            response.append(String.format("Trigger after: %d consecutive violations\n", times));
@@ -301,11 +296,8 @@ public class AlertDefineToolsImpl implements AlertDefineTools {
                pageSize = 10;
            }

-            SubjectSum subjectSum = McpContextHolder.getSubject();
-            log.debug("Current security subject for getAlertDefines: {}", subjectSum);
-
-            Page<AlertDefine> result = alertDefineService.getAlertDefines(null,
-                    search, "gmtCreate", "desc", pageIndex, pageSize);
+            Page<AlertDefine> result = alertDefineServiceAdapter.getAlertDefines(
+                    search, monitorType, enabled, "gmtCreate", "desc", pageIndex, pageSize);

            StringBuilder response = new StringBuilder();
            response.append("Found ").append(result.getContent().size())
@@ -353,21 +345,7 @@ public class AlertDefineToolsImpl implements AlertDefineTools {
        try {
            log.info("Toggling alert rule ID: {} to enabled: {}", ruleId, enabled);

-            SubjectSum subjectSum = McpContextHolder.getSubject();
-            log.debug("Current security subject for toggleAlertDefineStatus: {}", subjectSum);
-
-            // First get the existing AlertDefine
-            AlertDefine alertDefine = alertDefineService.getAlertDefine(ruleId);
-
-            if (alertDefine == null) {
-                throw new RuntimeException("AlertDefine with ID " + ruleId + " not found");
-            }
-
-            // Update the enable status
-            alertDefine.setEnable(enabled);
-
-            // Use modifyAlertDefine to save the changes
-            alertDefineService.modifyAlertDefine(alertDefine);
+            alertDefineServiceAdapter.toggleAlertDefineStatus(ruleId, enabled);

            log.info("Successfully toggled alert rule ID: {} to enabled: {}", ruleId, enabled);
            return String.format("Successfully %s alert rule ID: %d",
@@ -391,10 +369,7 @@ public class AlertDefineToolsImpl implements AlertDefineTools {
        try {
            log.info("Getting alert rule details for ID: {}", ruleId);

-            SubjectSum subjectSum = McpContextHolder.getSubject();
-            log.debug("Current security subject for getAlertDefine: {}", subjectSum);
-
-            AlertDefine alertDefine = alertDefineService.getAlertDefine(ruleId);
+            AlertDefine alertDefine = alertDefineServiceAdapter.getAlertDefine(ruleId);
            if (alertDefine == null) {
                return "Alert rule with ID " + ruleId + " not found";
            }
@@ -466,7 +441,7 @@ public class AlertDefineToolsImpl implements AlertDefineTools {
            log.debug("Current subject in get_apps_metrics_hierarchy tool: {}", subjectSum);

            List<Hierarchy> hierarchies;
-            hierarchies = appService.getAppHierarchy(app.trim().toLowerCase(), "en-US");
+            hierarchies = alertDefineServiceAdapter.getAppHierarchy(app.trim().toLowerCase(), "en-US");


            ObjectMapper mapper = new ObjectMapper();
@@ -484,7 +459,10 @@ public class AlertDefineToolsImpl implements AlertDefineTools {
                result.put("message", "No hierarchy data available");
            }

-            return mapper.writerWithDefaultPrettyPrinter().writeValueAsString(result);
+            String jsonResult = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(result);
+            log.info("Hierarchy JSON: {}", jsonResult);
+
+            return jsonResult;

        } catch (Exception e) {
            log.error("Failed to get apps metrics hierarchy: {}", e.getMessage(), e);
@@ -516,9 +494,7 @@ public class AlertDefineToolsImpl implements AlertDefineTools {
            }

            // Get the existing alert rule
-            log.debug("Current security subject for getAlertDefine: {}", subjectSum);
-
-            AlertDefine existingRule = alertDefineService.getAlertDefine(ruleId);
+            AlertDefine existingRule = alertDefineServiceAdapter.getAlertDefine(ruleId);
            if (existingRule == null) {
                return String.format("Error: Alert rule with ID %d not found", ruleId);
            }
@@ -595,9 +571,7 @@ public class AlertDefineToolsImpl implements AlertDefineTools {
                
                // Update the alert rule
                existingRule.setExpr(newExpr);
-                log.debug("Current security subject for modifyAlertDefine: {}", subjectSum);
-
-                alertDefineService.modifyAlertDefine(existingRule);
+                alertDefineServiceAdapter.modifyAlertDefine(existingRule);
                
                log.info("Successfully added monitors {} to existing bindings for alert rule ID: {}", validMonitorIds, ruleId);
                return String.format("Successfully added %d new monitor(s) to alert rule ID %d.\nTotal bound monitors: %s\nUpdated expression: %s", 
@@ -634,8 +608,7 @@ public class AlertDefineToolsImpl implements AlertDefineTools {

            // Update the alert rule
            existingRule.setExpr(newExpr);
-
-            alertDefineService.modifyAlertDefine(existingRule);
+            alertDefineServiceAdapter.modifyAlertDefine(existingRule);

            log.info("Successfully bound monitors {} to alert rule ID: {}", validMonitorIds, ruleId);
            return String.format("Successfully bound %d monitor(s) to alert rule ID %d.\nMonitor IDs: %s\nUpdated expression: %s", 
@@ -660,10 +633,7 @@ public class AlertDefineToolsImpl implements AlertDefineTools {
            log.debug("Validating hierarchy relationships: app={}, metrics={}, fieldConditions={}", app, metrics, fieldConditions);

            // Get hierarchy for the specified app
-            SubjectSum subjectSum = McpContextHolder.getSubject();
-            log.debug("Current security subject for getAppHierarchy: {}", subjectSum);
-
-            List<Hierarchy> hierarchies = appService.getAppHierarchy(app.toLowerCase(), "en-US");
+            List<Hierarchy> hierarchies = alertDefineServiceAdapter.getAppHierarchy(app.toLowerCase(), "en-US");

            if (hierarchies == null || hierarchies.isEmpty()) {
                return String.format("Error: App '%s' not found in hierarchy. Please use list_monitor_types to get valid app names.", app);
@@ -692,4 +662,4 @@ public class AlertDefineToolsImpl implements AlertDefineTools {
        }
    }

-}
+}
@@ -16,15 +16,15 @@
 */


-package org.apache.hertzbeat.ai.tools.impl;
+package org.apache.hertzbeat.ai.agent.tools.impl;

 import com.usthe.sureness.subject.SubjectSum;
 import lombok.extern.slf4j.Slf4j;
-import org.apache.hertzbeat.ai.config.McpContextHolder;
-import org.apache.hertzbeat.ai.tools.AlertTools;
-import org.apache.hertzbeat.ai.utils.UtilityClass;
+import org.apache.hertzbeat.ai.agent.adapters.AlertServiceAdapter;
+import org.apache.hertzbeat.ai.agent.config.McpContextHolder;
+import org.apache.hertzbeat.ai.agent.tools.AlertTools;
+import org.apache.hertzbeat.ai.agent.utils.UtilityClass;
 import org.apache.hertzbeat.alert.dto.AlertSummary;
-import org.apache.hertzbeat.alert.service.AlertService;
 import org.apache.hertzbeat.common.entity.alerter.GroupAlert;
 import org.apache.hertzbeat.common.entity.alerter.SingleAlert;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -41,7 +41,7 @@ import org.springframework.stereotype.Service;
@Service
 public class AlertToolsImpl implements AlertTools {
    @Autowired
-    private AlertService alertService;
+    private AlertServiceAdapter alertServiceAdapter;

    @Override
    @Tool(name = "query_alerts", description = """
@@ -116,7 +116,7 @@ public class AlertToolsImpl implements AlertTools {

            // Handle different alert types
            if ("single".equalsIgnoreCase(alertType) || "both".equalsIgnoreCase(alertType)) {
-                Page<SingleAlert> singleResult = alertService.getSingleAlerts(status, search, sort, order, pageIndex, pageSize);
+                Page<SingleAlert> singleResult = alertServiceAdapter.getSingleAlerts(status, search, sort, order, pageIndex, pageSize);
                
                response.append("SINGLE ALERTS:\n");
                response.append("Found ").append(singleResult.getContent().size()).append(" single alerts (Total: ").append(singleResult.getTotalElements()).append("):\n\n");
@@ -154,7 +154,7 @@ public class AlertToolsImpl implements AlertTools {
                    response.append("\n");
                }
                
-                Page<GroupAlert> groupResult = alertService.getGroupAlerts(status, search, sort, order, pageIndex, pageSize);
+                Page<GroupAlert> groupResult = alertServiceAdapter.getGroupAlerts(status, search, sort, order, pageIndex, pageSize);
                
                response.append("GROUP ALERTS:\n");
                response.append("Found ").append(groupResult.getContent().size()).append(" group alerts (Total: ").append(groupResult.getTotalElements()).append("):\n\n");
@@ -205,7 +205,7 @@ public class AlertToolsImpl implements AlertTools {
            SubjectSum subjectSum = McpContextHolder.getSubject();
            log.debug("Current subject in get_alerts_summary tool: {}", subjectSum);

-            AlertSummary summary = alertService.getAlertsSummary();
+            AlertSummary summary = alertServiceAdapter.getAlertsSummary();

            StringBuilder response = new StringBuilder();
            response.append("ALERTS SUMMARY\n");
@@ -16,13 +16,14 @@
 */


-package org.apache.hertzbeat.ai.tools.impl;
+package org.apache.hertzbeat.ai.agent.tools.impl;

 import com.usthe.sureness.subject.SubjectSum;
 import lombok.extern.slf4j.Slf4j;
-import org.apache.hertzbeat.ai.config.McpContextHolder;
-import org.apache.hertzbeat.warehouse.service.MetricsDataService;
-import org.apache.hertzbeat.ai.tools.MetricsTools;
+import org.apache.hertzbeat.ai.agent.adapters.MetricsServiceAdapter;
+import org.apache.hertzbeat.ai.agent.adapters.MonitorServiceAdapter;
+import org.apache.hertzbeat.ai.agent.config.McpContextHolder;
+import org.apache.hertzbeat.ai.agent.tools.MetricsTools;
 import org.apache.hertzbeat.common.entity.dto.Field;
 import org.apache.hertzbeat.common.entity.dto.MetricsData;
 import org.apache.hertzbeat.common.entity.dto.MetricsHistoryData;
@@ -43,7 +44,9 @@ import java.util.Map;
@Service
 public class MetricsToolsImpl implements MetricsTools {
    @Autowired
-    private MetricsDataService metricsDataService;
+    private MetricsServiceAdapter metricsServiceAdapter;
+    @Autowired
+    private MonitorServiceAdapter monitorServiceAdapter;

    @Override
    @Tool(name = "query_realtime_metrics", description = """
@@ -75,7 +78,7 @@ public class MetricsToolsImpl implements MetricsTools {
            SubjectSum subjectSum = McpContextHolder.getSubject();
            log.debug("Current subject in get_realtime_metrics tool: {}", subjectSum);

-            MetricsData metricsData = metricsDataService.getMetricsData(monitorId, metrics);
+            MetricsData metricsData = metricsServiceAdapter.getMetricsData(monitorId, metrics);

            if (metricsData == null) {
                return String.format("No real-time metrics data found for monitor ID %d and metrics '%s'", monitorId, metrics);
@@ -152,7 +155,7 @@ public class MetricsToolsImpl implements MetricsTools {
            Ask user to provide the filters for labels, history and interval aggregation
            """)
    public String getHistoricalMetrics(
-            @ToolParam(description = "Instance identifier (e.g., 'ip:port', 'ip', or 'domain')") String instance,
+            @ToolParam(description = "Monitor ID", required = true) Long monitorId,
            @ToolParam(description = "Monitor type (e.g., 'linux', 'mysql', 'http')", required = true) String app,
            @ToolParam(description = "Metrics name (e.g., 'target', 'cpu', 'memory')", required = true) String metrics,
            @ToolParam(description = "Field Parameter (e.g., 'usage', 'used', 'available')", required = false) String fieldParameter,
@@ -161,7 +164,7 @@ public class MetricsToolsImpl implements MetricsTools {
            @ToolParam(description = "Whether to aggregate data with intervals", required = false) Boolean interval) {

        try {
-            log.info("Getting historical metrics for monitor instance {} and metrics {}", instance, metrics);
+            log.info("Getting historical metrics for monitor {} and metrics {}", monitorId, metrics);

            if (history == null || history.trim().isEmpty()) {
                history = "24h";
@@ -170,15 +173,15 @@ public class MetricsToolsImpl implements MetricsTools {
                interval = true;
            }

-            MetricsHistoryData historyData = metricsDataService.getMetricHistoryData(instance,
-                    app, metrics, fieldParameter, history, interval);
+            MetricsHistoryData historyData = metricsServiceAdapter.getMetricHistoryData(
+                    monitorId, app, metrics, fieldParameter, label, history, interval);

            if (historyData == null) {
-                return String.format("No historical metrics data found for monitor %s and metrics '%s'", instance, metrics);
+                return String.format("No historical metrics data found for monitor ID %d and metrics '%s'", monitorId, metrics);
            }

            StringBuilder response = new StringBuilder();
-            response.append("HISTORICAL METRICS: ").append(metrics).append(" (Monitor ID: ").append(instance).append(")\n");
+            response.append("HISTORICAL METRICS: ").append(metrics).append(" (Monitor ID: ").append(monitorId).append(")\n");
            response.append("Time Range: ").append(history).append(" | Interval Aggregation: ").append(interval).append("\n");
            response.append("=".repeat(60)).append("\n\n");

@@ -232,10 +235,8 @@ public class MetricsToolsImpl implements MetricsTools {
    public String getWarehouseStatus() {
        try {
            log.info("Checking warehouse storage status");
-            SubjectSum subjectSum = McpContextHolder.getSubject();
-            log.debug("Current security subject for getWarehouseStorageServerStatus: {}", subjectSum);

-            Boolean status = metricsDataService.getWarehouseStorageServerStatus();
+            Boolean status = metricsServiceAdapter.getWarehouseStorageServerStatus();

            StringBuilder response = new StringBuilder();
            response.append("METRICS WAREHOUSE STATUS\n");
@@ -259,4 +260,4 @@ public class MetricsToolsImpl implements MetricsTools {
        }
    }

-}
+}
@@ -15,18 +15,17 @@
 * limitations under the License.
 */

-package org.apache.hertzbeat.ai.tools.impl;
+package org.apache.hertzbeat.ai.agent.tools.impl;

 import com.usthe.sureness.subject.SubjectSum;
 import lombok.extern.slf4j.Slf4j;
-import org.apache.hertzbeat.ai.config.McpContextHolder;
-import org.apache.hertzbeat.manager.service.MonitorService;
-import org.apache.hertzbeat.manager.service.AppService;
-import org.apache.hertzbeat.ai.utils.UtilityClass;
+import org.apache.hertzbeat.ai.agent.adapters.MonitorServiceAdapter;
+import org.apache.hertzbeat.ai.agent.config.McpContextHolder;
+import org.apache.hertzbeat.ai.agent.utils.UtilityClass;
 import org.springframework.ai.tool.annotation.Tool;
 import org.springframework.data.domain.Page;
 import org.springframework.stereotype.Service;
-import org.apache.hertzbeat.ai.tools.MonitorTools;
+import org.apache.hertzbeat.ai.agent.tools.MonitorTools;
 import org.springframework.ai.tool.annotation.ToolParam;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.apache.hertzbeat.common.entity.manager.Monitor;
@@ -36,7 +35,6 @@ import org.apache.hertzbeat.common.entity.manager.ParamDefine;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
-import java.util.Objects;

 /**
 * Implementation of Monitoring Tools functionality
@@ -45,9 +43,7 @@ import java.util.Objects;
@Service
 public class MonitorToolsImpl implements MonitorTools {
    @Autowired
-    private MonitorService monitorService;
-    @Autowired
-    private AppService appService;
+    private MonitorServiceAdapter monitorServiceAdapter;


    /**
@@ -127,12 +123,8 @@ public class MonitorToolsImpl implements MonitorTools {
                includeStats = false;
            }
            
-            SubjectSum subjectSum = McpContextHolder.getSubject();
-            log.debug("Current security subject: {}", subjectSum);
-
-            Page<Monitor> result = monitorService.getMonitors(
-                    ids, app, search, status, sort, order, pageIndex, pageSize, labels);
-            log.debug("MonitorService.getMonitors result: {}", result);
+            Page<Monitor> result = monitorServiceAdapter.getMonitors(ids, app, search, status, sort, order, pageIndex, pageSize, labels);
+            log.debug("MonitorServiceAdapter.getMonitors result: {}", result);
            
            StringBuilder response = new StringBuilder();
            response.append("MONITOR QUERY RESULTS\n");
@@ -141,10 +133,10 @@ public class MonitorToolsImpl implements MonitorTools {
            // Include statistics if requested
            if (includeStats) {
                // Get status distribution by calling with different status values
-                long onlineCount = monitorService.getMonitors(null, app, search, (byte) 1, null, null, 0, 1000, labels).getTotalElements();
-                long offlineCount = monitorService.getMonitors(null, app, search, (byte) 2, null, null, 0, 1000, labels).getTotalElements();
-                long unreachableCount = monitorService.getMonitors(null, app, search, (byte) 3, null, null, 0, 1000, labels).getTotalElements();
-                long pausedCount = monitorService.getMonitors(null, app, search, (byte) 0, null, null, 0, 1000, labels).getTotalElements();
+                long onlineCount = monitorServiceAdapter.getMonitors(null, app, search, (byte) 1, null, null, 0, 1000, labels).getTotalElements();
+                long offlineCount = monitorServiceAdapter.getMonitors(null, app, search, (byte) 2, null, null, 0, 1000, labels).getTotalElements();
+                long unreachableCount = monitorServiceAdapter.getMonitors(null, app, search, (byte) 3, null, null, 0, 1000, labels).getTotalElements();
+                long pausedCount = monitorServiceAdapter.getMonitors(null, app, search, (byte) 0, null, null, 0, 1000, labels).getTotalElements();
                
                response.append("STATUS OVERVIEW:\n");
                response.append("- Online: ").append(onlineCount).append("\n");
@@ -172,7 +164,7 @@ public class MonitorToolsImpl implements MonitorTools {
                response.append("ID: ").append(monitor.getId())
                       .append(" | Name: ").append(monitor.getName())
                       .append(" | Type: ").append(monitor.getApp())
-                       .append(" | Instance: ").append(monitor.getInstance())
+                       .append(" | Host: ").append(monitor.getHost())
                       .append(" | Status: ").append(UtilityClass.getStatusText(monitor.getStatus()));
                       
                // Add creation date for better context
@@ -258,14 +250,12 @@ public class MonitorToolsImpl implements MonitorTools {
            if (intervals == null || intervals < 10) {
                intervals = 600;
            }
-
-            String instance = Objects.nonNull(port) ? host.trim() + ":" + port : host.trim();
-
+            
            // Create Monitor entity
            Monitor monitor = Monitor.builder()
                    .name(name.trim())
                    .app(app.toLowerCase().trim())
-                    .instance(instance)
+                    .host(host.trim())
                    .intervals(intervals)
                    .status((byte) 1)
                    .type((byte) 0)
@@ -276,10 +266,7 @@ public class MonitorToolsImpl implements MonitorTools {
            
            // Validate that all required parameters for this monitor type are provided
            try {
-                SubjectSum subjectSum = McpContextHolder.getSubject();
-                log.debug("Current security subject for getMonitorParamDefines: {}", subjectSum);
-
-                List<ParamDefine> requiredParams = appService.getAppParamDefines(app.toLowerCase().trim());
+                List<ParamDefine> requiredParams = monitorServiceAdapter.getMonitorParamDefines(app);
                log.info("Checking required parameters for monitor type '{}': {}", app, requiredParams);
                List<String> missingParams = new ArrayList<>();
                
@@ -303,12 +290,8 @@ public class MonitorToolsImpl implements MonitorTools {
                log.warn("Could not validate required parameters for monitor type '{}': {}", app, e.getMessage());
            }
            
-            // Call monitor service - it handles all the complexity (validation, defaults, app-specific logic)
-            SubjectSum subjectSum = McpContextHolder.getSubject();
-            log.debug("Current security subject for addMonitor: {}", subjectSum);
-
-            monitorService.addMonitor(monitor, params, null, null);
-            Long monitorId = monitor.getId();
+            // Call adapter - it handles all the complexity (validation, defaults, app-specific logic)
+            Long monitorId = monitorServiceAdapter.addMonitor(monitor, params, null);
            
            log.info("Successfully added monitor '{}' with ID: {}", name, monitorId);
            return String.format("Successfully added %s monitor '%s' with ID: %d (Host: %s, Interval: %d seconds)", 
@@ -378,14 +361,14 @@ public class MonitorToolsImpl implements MonitorTools {
            log.info("Listing available monitor types for language: {}", language);
            SubjectSum subjectSum = McpContextHolder.getSubject();
            log.debug("Current subject in list_monitor_types tool: {}", subjectSum);
-
+            
            // Set default language if not provided
            if (language == null || language.trim().isEmpty()) {
                language = "en-US";
            }
-
-            // Get available monitor types from app service
-            Map<String, String> monitorTypes = appService.getI18nApps(language);
+            
+            // Get available monitor types from adapter
+            Map<String, String> monitorTypes = monitorServiceAdapter.getAvailableMonitorTypes(language);
            
            if (monitorTypes == null || monitorTypes.isEmpty()) {
                return "No monitor types are currently available.";
@@ -433,14 +416,14 @@ public class MonitorToolsImpl implements MonitorTools {
            log.info("Getting parameter definitions for monitor type: {}", app);
            SubjectSum subjectSum = McpContextHolder.getSubject();
            log.debug("Current subject in get_monitor_param_defines tool: {}", subjectSum);
-
+            
            // Validate required parameter
            if (app == null || app.trim().isEmpty()) {
                return "Error: Monitor type/application parameter is required";
            }
-
-            // Get parameter definitions from app service
-            List<ParamDefine> paramDefines = appService.getAppParamDefines(app.toLowerCase().trim());
+            
+            // Get parameter definitions from adapter
+            List<ParamDefine> paramDefines = monitorServiceAdapter.getMonitorParamDefines(app);
            
            if (paramDefines == null || paramDefines.isEmpty()) {
                return String.format("No parameter definitions found for monitor type '%s'. "
@@ -15,14 +15,16 @@
 * limitations under the License.
 */

-package org.apache.hertzbeat.ai.utils;
+package org.apache.hertzbeat.ai.agent.utils;


 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.node.ArrayNode;
 import com.fasterxml.jackson.databind.node.ObjectNode;
 import lombok.extern.slf4j.Slf4j;
+import org.apache.hertzbeat.ai.agent.pojo.dto.Hierarchy;

+import java.lang.reflect.Method;
 import java.time.Instant;
 import java.time.LocalDateTime;
 import java.time.ZoneId;
@@ -31,7 +33,6 @@ import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import org.apache.hertzbeat.manager.pojo.dto.Hierarchy;

 /**
 * Utility class providing helper methods for field expression validation, parsing,
@@ -226,6 +227,51 @@ public class UtilityClass {
        return "VALID";
    }

+    /**
+     * Helper method to validate operator
+     */
+    public boolean isValidOperator(String operator) {
+        return operator != null && (operator.equals(">") || operator.equals("<")
+                || operator.equals(">=") || operator.equals("<=")
+                || operator.equals("==") || operator.equals("!="));
+    }
+
+    /**
+     * Helper method to validate priority
+     */
+    public boolean isValidPriority(String priority) {
+        return priority != null && (priority.equalsIgnoreCase("critical")
+                || priority.equalsIgnoreCase("warning") || priority.equalsIgnoreCase("info"));
+    }
+
+    /**
+     * Helper method to build expression
+     */
+    public String buildExpression(String metric, String operator, String threshold) {
+        return String.format("%s %s %s", metric, operator, threshold);
+    }
+
+    /**
+     * Helper method to parse existing expression into components
+     */
+    public String[] parseExpression(String expression) {
+        if (expression == null || expression.trim().isEmpty()) {
+            return null;
+        }
+
+        // Simple parsing for basic expressions like "metric > value"
+        String[] operators = {">", "<", ">=", "<=", "==", "!="};
+        for (String op : operators) {
+            if (expression.contains(" " + op + " ")) {
+                String[] parts = expression.split(" " + op + " ");
+                if (parts.length == 2) {
+                    return new String[]{parts[0].trim(), op, parts[1].trim()};
+                }
+            }
+        }
+        return null;
+    }
+
    /**
     * Helper method to parse key-value pairs from a string
     * Format: "key1:value1, key2:value2, ..."
@@ -427,6 +473,19 @@ public class UtilityClass {
        return dateTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
    }

+    /**
+     * Parse time range string to milliseconds
+     */
+    public long parseTimeRangeToMillis(String timeRange) {
+        return switch (timeRange.toLowerCase()) {
+            case "1h" -> 60 * 60 * 1000L;
+            case "6h" -> 6 * 60 * 60 * 1000L;
+            case "24h" -> 24 * 60 * 60 * 1000L;
+            case "7d" -> 7 * 24 * 60 * 60 * 1000L;
+            default -> 24 * 60 * 60 * 1000L; // default to 24h
+        };
+    }
+
    /**
     * Helper method to convert monitor status byte to readable text
     * @param status The status byte from monitor
@@ -445,6 +504,143 @@ public class UtilityClass {
        };
    }

+    /**
+     * Helper method to get metrics name for a metric type
+     */
+    public String getMetricsNameForType(String metricType) {
+        return switch (metricType.toLowerCase()) {
+            case "cpu" -> "cpu";
+            case "memory" -> "memory";
+            case "disk" -> "disk";
+            case "network" -> "network";
+            default -> "system";
+        };
+    }
+
+    /**
+     * Helper method to check if a field represents usage for a metric type
+     */
+    public boolean isUsageField(String field, String metricType) {
+        if (field == null) return false;
+
+        String fieldLower = field.toLowerCase();
+        String typeLower = metricType.toLowerCase();
+
+        return fieldLower.contains("usage")
+                || fieldLower.contains("percent")
+                || fieldLower.contains("util")
+                || (typeLower.equals("cpu") && (fieldLower.contains("cpu") || fieldLower.contains("idle")))
+                || (typeLower.equals("memory") && fieldLower.contains("memory"))
+                || (typeLower.equals("disk") && fieldLower.contains("disk"));
+    }
+
+    /**
+     * Convert manager module Hierarchy objects to ai-agent module Hierarchy objects
+     * This handles the cross-module DTO conversion to avoid ClassCastException
+     */
+    public List<Hierarchy> convertToAgentHierarchies(List<?> managerHierarchies) {
+        List<Hierarchy> agentHierarchies = new ArrayList<>();
+
+        for (Object managerHierarchy : managerHierarchies) {
+            Hierarchy agentHierarchy = convertToAgentHierarchy(managerHierarchy);
+            agentHierarchies.add(agentHierarchy);
+        }
+
+        return agentHierarchies;
+    }
+
+    /**
+     * Convert a single manager Hierarchy object to ai-agent Hierarchy object using reflection
+     */
+    public Hierarchy convertToAgentHierarchy(Object managerHierarchy) {
+        try {
+            Hierarchy agentHierarchy = new Hierarchy();
+
+            // Use reflection to copy properties from manager DTO to agent DTO
+            Class<?> managerClass = managerHierarchy.getClass();
+
+            // Copy basic properties
+            agentHierarchy.setCategory(getStringField(managerHierarchy, managerClass, "category"));
+            agentHierarchy.setValue(getStringField(managerHierarchy, managerClass, "value"));
+            agentHierarchy.setLabel(getStringField(managerHierarchy, managerClass, "label"));
+            agentHierarchy.setIsLeaf(getBooleanField(managerHierarchy, managerClass, "isLeaf"));
+            agentHierarchy.setHide(getBooleanField(managerHierarchy, managerClass, "hide"));
+            agentHierarchy.setType(getByteField(managerHierarchy, managerClass, "type"));
+            agentHierarchy.setUnit(getStringField(managerHierarchy, managerClass, "unit"));
+
+            // Handle children recursively
+            List<?> managerChildren = getListField(managerHierarchy, managerClass, "children");
+            if (managerChildren != null && !managerChildren.isEmpty()) {
+                List<Hierarchy> agentChildren = convertToAgentHierarchies(managerChildren);
+                agentHierarchy.setChildren(agentChildren);
+            }
+
+            return agentHierarchy;
+
+        } catch (Exception e) {
+            log.error("Failed to convert manager hierarchy to agent hierarchy: {}", e.getMessage(), e);
+            throw new RuntimeException("Failed to convert hierarchy", e);
+        }
+    }
+
+    public String getStringField(Object obj, Class<?> clazz, String fieldName) {
+        try {
+            Method getter = clazz.getMethod("get" + capitalize(fieldName));
+            Object value = getter.invoke(obj);
+            return value != null ? value.toString() : null;
+        } catch (Exception e) {
+            log.debug("Could not get string field '{}': {}", fieldName, e.getMessage());
+            return null;
+        }
+    }
+
+    public Boolean getBooleanField(Object obj, Class<?> clazz, String fieldName) {
+        try {
+            Method getter = clazz.getMethod("get" + capitalize(fieldName));
+            Object value = getter.invoke(obj);
+            return value instanceof Boolean ? (Boolean) value : null;
+        } catch (Exception e) {
+            try {
+                // Try alternative getter pattern for boolean fields
+                Method isGetter = clazz.getMethod("is" + capitalize(fieldName));
+                Object value = isGetter.invoke(obj);
+                return value instanceof Boolean ? (Boolean) value : null;
+            } catch (Exception e2) {
+                log.debug("Could not get boolean field '{}': {}", fieldName, e.getMessage());
+                return null;
+            }
+        }
+    }
+
+    public Byte getByteField(Object obj, Class<?> clazz, String fieldName) {
+        try {
+            Method getter = clazz.getMethod("get" + capitalize(fieldName));
+            Object value = getter.invoke(obj);
+            return value instanceof Byte ? (Byte) value : null;
+        } catch (Exception e) {
+            log.debug("Could not get byte field '{}': {}", fieldName, e.getMessage());
+            return null;
+        }
+    }
+
+    public List<?> getListField(Object obj, Class<?> clazz, String fieldName) {
+        try {
+            Method getter = clazz.getMethod("get" + capitalize(fieldName));
+            Object value = getter.invoke(obj);
+            return value instanceof List ? (List<?>) value : null;
+        } catch (Exception e) {
+            log.debug("Could not get list field '{}': {}", fieldName, e.getMessage());
+            return null;
+        }
+    }
+
+    public String capitalize(String str) {
+        if (str == null || str.isEmpty()) {
+            return str;
+        }
+        return str.substring(0, 1).toUpperCase() + str.substring(1);
+    }
+

    /**
     * Extract existing monitor IDs from the alert expression
@@ -1,160 +0,0 @@
-/*
- * 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.hertzbeat.ai.service.impl;
-
-import lombok.extern.slf4j.Slf4j;
-import org.apache.hertzbeat.ai.dao.ChatConversationDao;
-import org.apache.hertzbeat.ai.dao.ChatMessageDao;
-import org.apache.hertzbeat.ai.pojo.dto.ChatRequestContext;
-import org.apache.hertzbeat.ai.pojo.dto.ChatResponseChunk;
-import org.apache.hertzbeat.ai.service.ChatClientProviderService;
-import org.apache.hertzbeat.ai.service.ConversationService;
-import org.apache.hertzbeat.common.entity.ai.ChatConversation;
-import org.apache.hertzbeat.common.entity.ai.ChatMessage;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.data.domain.Sort;
-import org.springframework.http.codec.ServerSentEvent;
-import org.springframework.stereotype.Service;
-import org.springframework.util.CollectionUtils;
-import reactor.core.publisher.Flux;
-
-import java.util.List;
-import java.util.UUID;
-
-/**
- * Implementation of the ConversationService interface for managing chat conversations.
- */
-@Slf4j
-@Service
-public class ConversationServiceImpl implements ConversationService {
-    
-    @Autowired
-    private ChatConversationDao conversationDao;
-    
-    @Autowired
-    private ChatMessageDao messageDao;
-    
-    @Autowired
-    private ChatClientProviderService chatClientProviderService;
-
-    @Override
-    public Flux<ServerSentEvent<ChatResponseChunk>> streamChat(String message, Long conversationId) {
-
-        // Check if provider is properly configured
-        if (!chatClientProviderService.isConfigured()) {
-            ChatResponseChunk errorResponse = ChatResponseChunk.builder()
-                    .conversationId(conversationId)
-                    .response("Provider is not configured. Please configure your AI Provider.")
-                    .build();
-            return Flux.just(ServerSentEvent.builder(errorResponse)
-                    .event("error")
-                    .build());
-        }
-
-        log.info("Starting streaming conversation: {}", conversationId);
-
-        // Add user message to conversation
-        ChatMessage chatMessage = ChatMessage.builder().conversationId(conversationId)
-                .content(message).role("user").build();
-        chatMessage = messageDao.save(chatMessage);
-        ChatConversation conversation = conversationDao.getReferenceById(conversationId);
-        if (conversation.getTitle().startsWith("conversation")) {
-            // Auto-generate title from first user message
-            String title = message.length() > 30 ? message.substring(0, 27) + "..." : message;
-            conversation.setTitle(title);
-            conversationDao.save(conversation);
-        }
-
-        ChatRequestContext context = ChatRequestContext.builder()
-                .message(message)
-                .conversationId(conversationId)
-                .conversationHistory(CollectionUtils.isEmpty(conversation.getMessages()) ? null 
-                        : conversation.getMessages().subList(0, conversation.getMessages().size() - 1))
-                .build();
-
-        // Stream response from AI service
-        StringBuilder fullResponse = new StringBuilder();
-        ChatMessage finalChatMessage = chatMessage;
-        return chatClientProviderService.streamChat(context)
-                .map(chunk -> {
-                    fullResponse.append(chunk);
-                    ChatResponseChunk responseChunk = ChatResponseChunk.builder()
-                            .conversationId(conversationId)
-                            .userMessageId(finalChatMessage.getId())
-                            .response(chunk)
-                            .build();
-
-                    return ServerSentEvent.builder(responseChunk)
-                            .event("message")
-                            .build();
-                })
-                .concatWith(Flux.defer(() -> {
-                    // Add the complete AI response to conversation
-                    ChatMessage assistantMessage = ChatMessage.builder().conversationId(conversationId)
-                            .content(fullResponse.toString()).role("assistant").build();
-                    assistantMessage = messageDao.save(assistantMessage);
-                    
-                    ChatResponseChunk finalResponse = ChatResponseChunk.builder()
-                            .conversationId(conversationId)
-                            .response("")
-                            .assistantMessageId(assistantMessage.getId())
-                            .build();
-
-                    return Flux.just(ServerSentEvent.builder(finalResponse)
-                            .event("complete")
-                            .build());
-                }))
-                .doOnComplete(() -> log.info("Streaming completed for conversation: {}", conversationId))
-                .doOnError(error -> log.error("Error in streaming chat for conversation {}: {}", conversationId, error.getMessage(), error))
-                .onErrorResume(error -> {
-                    ChatResponseChunk errorResponse = ChatResponseChunk.builder()
-                            .conversationId(conversationId)
-                            .response("An error occurred: " + error.getMessage())
-                            .userMessageId(finalChatMessage.getId())
-                            .build();
-                    return Flux.just(ServerSentEvent.builder(errorResponse)
-                            .event("error")
-                            .build());
-                });
-    }
-
-    @Override
-    public ChatConversation createConversation() {
-        ChatConversation conversation = new ChatConversation();
-        conversation.setTitle("conversation-" + UUID.randomUUID().toString().substring(0, 4));
-        return conversationDao.save(conversation);
-    }
-
-    @Override
-    public ChatConversation getConversation(Long conversationId) {
-        if (conversationId == null) {
-            return null;
-        }
-        return conversationDao.getReferenceById(conversationId);
-    }
-
-    @Override
-    public List<ChatConversation> getAllConversations() {
-        return conversationDao.findAll(Sort.by(Sort.Direction.DESC, "id"));
-    }
-
-    @Override
-    public void deleteConversation(Long conversationId) {
-        conversationDao.deleteById(conversationId);
-    }
-}
@@ -17,6 +17,15 @@

 package org.apache.hertzbeat.alert.calculate.realtime;

+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.hertzbeat.alert.AlerterWorkerPool;
@@ -32,24 +41,11 @@ import org.apache.hertzbeat.common.entity.alerter.AlertDefine;
 import org.apache.hertzbeat.common.entity.alerter.SingleAlert;
 import org.apache.hertzbeat.common.entity.message.CollectRep;
 import org.apache.hertzbeat.common.queue.CommonDataQueue;
-import org.apache.hertzbeat.common.support.exception.CommonDataQueueUnknownException;
-import org.apache.hertzbeat.common.util.BackoffUtils;
 import org.apache.hertzbeat.common.util.CommonUtil;
-import org.apache.hertzbeat.common.util.ExponentialBackoff;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 import org.springframework.util.CollectionUtils;

-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Set;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-import java.util.stream.Collectors;
-
 /**
 * Calculate alarms based on the alarm definition rules and collected data
 */
@@ -126,22 +122,13 @@ public class MetricsRealTimeAlertCalculator {
     */
    public void startCalculate() {
        Runnable runnable = () -> {
-            ExponentialBackoff backoff = new ExponentialBackoff(50L, 1000L);
            while (!Thread.currentThread().isInterrupted()) {
                try {
                    CollectRep.MetricsData metricsData = dataQueue.pollMetricsDataToAlerter();
-                    if (metricsData == null) {
-                        continue;
-                    }
-                    backoff.reset();
                    calculate(metricsData);
                    dataQueue.sendMetricsDataToStorage(metricsData);
                } catch (InterruptedException ignored) {
                    Thread.currentThread().interrupt();
-                } catch (CommonDataQueueUnknownException ue) {
-                    if (!BackoffUtils.shouldContinueAfterBackoff(backoff)) {
-                        break;
-                    }
                } catch (Exception e) {
                    log.error("calculate alarm error: {}.", e.getMessage(), e);
                }
@@ -156,7 +143,7 @@ public class MetricsRealTimeAlertCalculator {
        long currentTimeMilli = System.currentTimeMillis();
        String instance = String.valueOf(metricsData.getId());
        String instanceName = metricsData.getInstanceName();
-        String instanceHost = metricsData.getInstance();
+        String instanceHost = metricsData.getInstanceHost();
        String app = metricsData.getApp();
        String metrics = metricsData.getMetrics();
        if ((CommonConstants.PROMETHEUS_APP_PREFIX + instanceName).equals(metricsData.getApp())) {
@@ -205,11 +192,12 @@ public class MetricsRealTimeAlertCalculator {
            }
            Long defineId = define.getId();
            Map<String, String> commonFingerPrints = new HashMap<>(8);
+            commonFingerPrints.put(CommonConstants.LABEL_INSTANCE, instance);
            // here use the alert name as finger, not care the alert name may be changed
            commonFingerPrints.put(CommonConstants.LABEL_DEFINE_ID, String.valueOf(define.getId()));
            commonFingerPrints.put(CommonConstants.LABEL_ALERT_NAME, define.getName());
            commonFingerPrints.put(CommonConstants.LABEL_INSTANCE_NAME, instanceName);
-            commonFingerPrints.put(CommonConstants.LABEL_INSTANCE, instanceHost);
+            commonFingerPrints.put(CommonConstants.LABEL_INSTANCE_HOST, instanceHost);
            commonFingerPrints.putAll(define.getLabels());
            if (labels != null) {
                commonFingerPrints.putAll(labels);
@@ -17,17 +17,13 @@

 package org.apache.hertzbeat.alert.calculate.realtime;

-import com.google.common.util.concurrent.ThreadFactoryBuilder;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.hertzbeat.alert.calculate.realtime.window.LogWorker;
 import org.apache.hertzbeat.alert.calculate.realtime.window.TimeService;
 import org.apache.hertzbeat.common.entity.log.LogEntry;
 import org.apache.hertzbeat.common.queue.CommonDataQueue;
-import org.apache.hertzbeat.common.support.exception.CommonDataQueueUnknownException;
-import org.apache.hertzbeat.common.util.BackoffUtils;
-import org.apache.hertzbeat.common.util.ExponentialBackoff;
 import org.springframework.stereotype.Component;
-
+import com.google.common.util.concurrent.ThreadFactoryBuilder;
 import javax.annotation.PostConstruct;
 import javax.annotation.PreDestroy;
 import java.util.concurrent.LinkedBlockingQueue;
@@ -62,22 +58,16 @@ public class WindowedLogRealTimeAlertCalculator implements Runnable {

    @Override
    public void run() {
-        ExponentialBackoff backoff = new ExponentialBackoff(50L, 1000L);
        while (!Thread.currentThread().isInterrupted()) {
            try {
                LogEntry logEntry = dataQueue.pollLogEntry();
-                if (logEntry == null) {
-                    continue;
+                if (logEntry != null) {
+                    processLogEntry(logEntry);
+                    dataQueue.sendLogEntryToStorage(logEntry);
                }
-                backoff.reset();
-                processLogEntry(logEntry);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                break;
-            } catch (CommonDataQueueUnknownException ue) {
-                if (!BackoffUtils.shouldContinueAfterBackoff(backoff)) {
-                    break;
-                }
            } catch (Exception e) {
                log.error("Error in log dispatch loop: {}", e.getMessage(), e);
            }
@@ -15,7 +15,7 @@
 * limitations under the License.
 */

-package org.apache.hertzbeat.common.entity.dto.sms;
+package org.apache.hertzbeat.alert.config;

 import jakarta.validation.constraints.NotBlank;
 import lombok.AllArgsConstructor;
@@ -15,7 +15,7 @@
 * limitations under the License.
 */

-package org.apache.hertzbeat.common.entity.dto.sms;
+package org.apache.hertzbeat.alert.config;

 import jakarta.validation.constraints.NotBlank;
 import lombok.Data;
@@ -15,7 +15,7 @@
 * limitations under the License.
 */

-package org.apache.hertzbeat.common.entity.dto.sms;
+package org.apache.hertzbeat.alert.config;

 import jakarta.validation.constraints.NotBlank;
 import lombok.AllArgsConstructor;
@@ -74,4 +74,4 @@ public class SmsConfig {
     * Smslocal SMS configuration
     */
    private SmslocalSmsProperties smslocal;
-}
+}
@@ -15,7 +15,7 @@
 * limitations under the License.
 */

-package org.apache.hertzbeat.common.entity.dto.sms;
+package org.apache.hertzbeat.alert.config;


 import lombok.AllArgsConstructor;
@@ -15,7 +15,7 @@
 * limitations under the License.
 */

-package org.apache.hertzbeat.common.entity.dto.sms;
+package org.apache.hertzbeat.alert.config;

 import jakarta.validation.constraints.NotBlank;
 import lombok.AllArgsConstructor;
@@ -58,4 +58,4 @@ public class TencentSmsProperties {
     */
    @NotBlank(message = "templateId cannot be null")
    private String templateId;
-}
+}
@@ -15,7 +15,7 @@
 * limitations under the License.
 */

-package org.apache.hertzbeat.common.entity.dto.sms;
+package org.apache.hertzbeat.alert.config;

 import jakarta.validation.constraints.NotBlank;
 import lombok.AllArgsConstructor;
@@ -46,4 +46,4 @@ public class TwilioSmsProperties {
     */
    @NotBlank(message = "Twilio Phone Number cannot be empty")
    private String twilioPhoneNumber;
-}
+}
@@ -15,7 +15,7 @@
 * limitations under the License.
 */

-package org.apache.hertzbeat.common.entity.dto.sms;
+package org.apache.hertzbeat.alert.config;

 import jakarta.validation.constraints.NotBlank;
 import lombok.AllArgsConstructor;
@@ -57,4 +57,4 @@ public class UniSmsProperties {
     */
    @NotBlank(message = "authMode cannot be null")
    private String authMode = "simple";
-} 
+} 
@@ -15,7 +15,7 @@
 * limitations under the License.
 */

-package org.apache.hertzbeat.common.entity.dto;
+package org.apache.hertzbeat.alert.dto;

 import jakarta.validation.constraints.Email;
 import jakarta.validation.constraints.Max;
@@ -18,17 +18,12 @@
 package org.apache.hertzbeat.alert.notice.impl;

 import com.fasterxml.jackson.annotation.JsonProperty;
-
-import java.net.URLEncoder;
-import java.nio.charset.StandardCharsets;
 import java.util.List;
-
 import lombok.Data;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.hertzbeat.alert.notice.AlertNoticeException;
-import org.apache.hertzbeat.alert.util.CryptoUtils;
 import org.apache.hertzbeat.common.entity.alerter.GroupAlert;
 import org.apache.hertzbeat.common.entity.alerter.NoticeReceiver;
 import org.apache.hertzbeat.common.entity.alerter.NoticeTemplate;
@@ -59,13 +54,7 @@ final class DingTalkRobotAlertNotifyHandlerImpl extends AbstractAlertNotifyHandl
            HttpHeaders headers = new HttpHeaders();
            headers.setContentType(MediaType.APPLICATION_JSON);
            HttpEntity<DingTalkWebHookDto> httpEntity = new HttpEntity<>(dingTalkWebHookDto, headers);
-            StringBuilder webHookUrlBuilder = new StringBuilder()
-                    .append(alerterProperties.getDingTalkWebhookUrl())
-                    .append(receiver.getAccessToken());
-            if (StringUtils.isNotBlank(receiver.getAppSecret())) {
-                webHookUrlBuilder.append(signSecret(receiver.getAppSecret()));
-            }
-            String webHookUrl = webHookUrlBuilder.toString();
+            String webHookUrl = alerterProperties.getDingTalkWebhookUrl() + receiver.getAccessToken();
            ResponseEntity<CommonRobotNotifyResp> responseEntity = restTemplate.postForEntity(webHookUrl,
                    httpEntity, CommonRobotNotifyResp.class);
            if (responseEntity.getStatusCode() == HttpStatus.OK) {
@@ -113,13 +102,6 @@ final class DingTalkRobotAlertNotifyHandlerImpl extends AbstractAlertNotifyHandl
        return dingTalkWebHookDto;
    }

-    private String signSecret(String secret) throws Exception {
-        Long timestamp = System.currentTimeMillis();
-        String sign = URLEncoder.encode(CryptoUtils.hmacSha256Base64(secret, timestamp + "\n" + secret),
-                StandardCharsets.UTF_8);
-        return String.format("&timestamp=%s&sign=%s", timestamp, sign);
-    }
-
    @Override
    public byte type() {
        return 5;
@@ -127,7 +109,6 @@ final class DingTalkRobotAlertNotifyHandlerImpl extends AbstractAlertNotifyHandl

    /**
     * DingTalk robot request body
-     *
     * @version 1.0
     */
    @Data
@@ -206,4 +187,5 @@ final class DingTalkRobotAlertNotifyHandlerImpl extends AbstractAlertNotifyHandl
    }


+
 }
@@ -24,7 +24,7 @@ import java.util.Properties;
 import java.util.ResourceBundle;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
-import org.apache.hertzbeat.common.entity.dto.MailServerConfig;
+import org.apache.hertzbeat.alert.dto.MailServerConfig;
 import org.apache.hertzbeat.alert.notice.AlertNoticeException;
 import org.apache.hertzbeat.common.entity.alerter.GroupAlert;
 import org.apache.hertzbeat.common.entity.manager.GeneralConfig;
@@ -1,487 +0,0 @@
-/*
- * 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.hertzbeat.alert.notice.impl;
-
-import com.fasterxml.jackson.annotation.JsonProperty;
-import com.fasterxml.jackson.core.JsonProcessingException;
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.EqualsAndHashCode;
-import lombok.NoArgsConstructor;
-import lombok.RequiredArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.lang3.StringUtils;
-import org.apache.hertzbeat.alert.AlerterProperties;
-import org.apache.hertzbeat.alert.notice.AlertNoticeException;
-import org.apache.hertzbeat.common.entity.alerter.GroupAlert;
-import org.apache.hertzbeat.common.entity.alerter.NoticeReceiver;
-import org.apache.hertzbeat.common.entity.alerter.NoticeTemplate;
-import org.apache.hertzbeat.common.util.JsonUtil;
-import org.springframework.http.HttpEntity;
-import org.springframework.http.HttpHeaders;
-import org.springframework.http.HttpMethod;
-import org.springframework.http.MediaType;
-import org.springframework.http.ResponseEntity;
-import org.springframework.stereotype.Component;
-import org.springframework.web.client.RestTemplate;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Objects;
-import java.util.UUID;
-import java.util.stream.Collectors;
-
-/**
- * FeiShu app alert notify impl
- */
-@Component
-@RequiredArgsConstructor
-@Slf4j
-public class FeiShuAppAlertNotifyHandlerImpl extends AbstractAlertNotifyHandlerImpl {
-
-    /**
-     * get tenant access_token url
-     */
-    private static final String TENANT_ACCESS_TOKEN_URL = "https://open.feishu.cn/open-apis/auth/v3/tenant_access_token/internal";
-
-    /**
-     * get FeiShu app employee url
-     */
-    private static final String EMPLOYEE_URL = "https://open.feishu.cn/open-apis/ehr/v1/employees?status=2&status=4&user_id_type=user_id&page_size=100";
-
-    /**
-     * send FeiShu app message url
-     */
-    private static final String APP_MESSAGE_URL = "https://open.feishu.cn/open-apis/im/v1/messages";
-
-    /**
-     * send FeiShu app batch message url
-     */
-    private static final String APP_BATCH_MESSAGE_URL = "https://open.feishu.cn/open-apis/message/v4/batch_send/";
-
-    private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
-    private static final byte USER_RECEIVE_TYPE = 0;
-    private static final byte CHAT_RECEIVE_TYPE = 1;
-    private static final byte PART_RECEIVE_TYPE = 2;
-    private static final byte ALL_RECEIVE_TYPE = 3;
-
-    private final RestTemplate restTemplate;
-    private final AlerterProperties alerterProperties;
-
-    @Override
-    public void send(NoticeReceiver receiver, NoticeTemplate noticeTemplate, GroupAlert alert) throws AlertNoticeException {
-        var appId = receiver.getAppId();
-        var appSecret = receiver.getAppSecret();
-        var larkReceiveIdType = receiver.getLarkReceiveType();
-        try {
-            var accessToken = getAccessToken(appId, appSecret);
-            var notificationContent = JsonUtil.toJson(renderContent(noticeTemplate, alert));
-            JsonNode messageContent = createLarkMessage(receiver, notificationContent);
-            switch (larkReceiveIdType) {
-                case USER_RECEIVE_TYPE -> {
-                    String[] userIds = receiver.getUserId().split(",");
-                    if (userIds.length == 1) {
-                        sendLarkMessage(accessToken, "user_id", userIds[0], messageContent);
-                    } else {
-                        sendLarkUserBatchMessage(accessToken, userIds, messageContent);
-                    }
-                }
-                case CHAT_RECEIVE_TYPE -> sendLarkMessage(accessToken, "chat_id", receiver.getChatId(), messageContent);
-                case PART_RECEIVE_TYPE ->
-                        sendLarkDepartmentBatchMessage(accessToken, receiver.getPartyId().split(","), messageContent);
-                case ALL_RECEIVE_TYPE -> {
-                    List<String> userIds = new ArrayList<>();
-                    getLarkEmployeeUserIds(accessToken, null, userIds);
-                    sendLarkUserBatchMessage(accessToken, userIds.toArray(new String[0]), messageContent);
-                }
-                default -> throw new AlertNoticeException("Invalid larkReceiveIdType: " + larkReceiveIdType);
-            }
-        } catch (Exception e) {
-            throw new AlertNoticeException("[FeiShu App Notify Error] " + e.getMessage());
-        }
-    }
-
-    @Override
-    public byte type() {
-        return 14;
-    }
-
-    /**
-     * Send FeiShu app message to chat or designated personnel
-     *
-     * @param accessToken    Tenant access token
-     * @param receiverIdType FeiShu app send message receiver id type: user_id, chat_id
-     * @param receiverId     FeiShu app user id or chat id
-     * @param messageContent Message content
-     * @see <a href="https://open.feishu.cn/document/server-docs/im-v1/batch_message/send-messages-in-batches">send message</a>
-     */
-    private void sendLarkMessage(String accessToken, String receiverIdType, String receiverId, JsonNode messageContent) throws JsonProcessingException {
-        HttpHeaders headers = new HttpHeaders();
-        headers.setContentType(MediaType.APPLICATION_JSON);
-        headers.setBearerAuth(accessToken);
-        FeiShuAppMessageDto messageDto = FeiShuAppMessageDto.builder()
-                .receiveId(receiverId)
-                .content(escapedCompactJson(messageContent))
-                .build();
-        HttpEntity<FeiShuAppMessageDto> request = new HttpEntity<>(messageDto, headers);
-        call(APP_MESSAGE_URL + "?receive_id_type=" + receiverIdType, request, HttpMethod.POST, FeiShuAppResponse.class);
-    }
-
-    /**
-     * Send FeiShu app department batch message
-     *
-     * @param accessToken    Tenant access token
-     * @param partyIds       FeiShu app department ids
-     * @param messageContent Message content
-     * @see <a href="https://open.feishu.cn/document/server-docs/im-v1/batch_message/send-messages-in-batches">send batch message</a>
-     */
-    private void sendLarkDepartmentBatchMessage(String accessToken, String[] partyIds, JsonNode messageContent) {
-        HttpHeaders headers = new HttpHeaders();
-        headers.setContentType(MediaType.APPLICATION_JSON);
-        headers.setBearerAuth(accessToken);
-        FeiShuAppBatchMessageDto batchMessageDto = FeiShuAppBatchMessageDto.builder()
-                .departmentIds(partyIds)
-                .card(messageContent)
-                .build();
-        HttpEntity<FeiShuAppBatchMessageDto> request = new HttpEntity<>(batchMessageDto, headers);
-        call(APP_BATCH_MESSAGE_URL, request, HttpMethod.POST, FeiShuAppResponse.class);
-    }
-
-    /**
-     * Send FeiShu app batch message to user
-     *
-     * @param accessToken    Tenant access token
-     * @param userIds        FeiShu app user ids
-     * @param messageContent Message content
-     * @see <a href="https://open.feishu.cn/document/server-docs/im-v1/batch_message/send-messages-in-batches">send batch message</a>
-     */
-    private void sendLarkUserBatchMessage(String accessToken, String[] userIds, JsonNode messageContent) {
-        HttpHeaders headers = new HttpHeaders();
-        headers.setContentType(MediaType.APPLICATION_JSON);
-        headers.setBearerAuth(accessToken);
-        FeiShuAppBatchMessageDto batchMessageDto = FeiShuAppBatchMessageDto.builder()
-                .userIds(userIds)
-                .card(messageContent)
-                .build();
-        HttpEntity<FeiShuAppBatchMessageDto> request = new HttpEntity<>(batchMessageDto, headers);
-        FeiShuAppResponse call = call(APP_BATCH_MESSAGE_URL, request, HttpMethod.POST, FeiShuAppResponse.class);
-    }
-
-    /**
-     * Get FeiShu app tenant access token
-     *
-     * @param appId     Unique identifier for the application, obtained after creating the application
-     * @param appSecret Application key, obtained after creating the application
-     * @return Tenant access token
-     * @see <a href="https://open.feishu.cn/document/server-docs/authentication-management/access-token/tenant_access_token_internal">tenant_access_token</a>
-     */
-    private String getAccessToken(String appId, String appSecret) {
-        HttpHeaders headers = new HttpHeaders();
-        headers.setContentType(MediaType.APPLICATION_JSON);
-        FeiShuAppAccessTokenDto accessTokenRequest = FeiShuAppAccessTokenDto.builder()
-                .appId(appId)
-                .appSecret(appSecret)
-                .build();
-        HttpEntity<FeiShuAppAccessTokenDto> request = new HttpEntity<>(accessTokenRequest, headers);
-        FeiShuAppAccessTokenResponse data = call(TENANT_ACCESS_TOKEN_URL, request, HttpMethod.POST, FeiShuAppAccessTokenResponse.class);
-        return data.getTenantAccessToken();
-    }
-
-
-    /**
-     * Get FeiShu app employee user ids
-     *
-     * @param accessToken FeiShu app tenant access token
-     * @param pageToken   Paging marker, left blank for the first request, indicating traversal from scratch;
-     *                    When there are more items in the pagination query result, a new page_token will be returned at the same time.
-     *                    The next iteration can use this page_token to obtain the query result
-     * @param userIds     Collection for recursive padding
-     * @see <a href="https://open.feishu.cn/document/server-docs/ehr-v1/list?appId=cli_a999532b1f52900b">https://open.feishu.cn/open-apis/ehr/v1/employees</a>
-     */
-    private void getLarkEmployeeUserIds(String accessToken, String pageToken, List<String> userIds) {
-        HttpHeaders headers = new HttpHeaders();
-        headers.setContentType(MediaType.APPLICATION_JSON);
-        headers.setBearerAuth(accessToken);
-        HttpEntity<String> request = new HttpEntity<>(headers);
-        var url = StringUtils.isNotBlank(pageToken) ? EMPLOYEE_URL + "&page_token=" + pageToken : EMPLOYEE_URL;
-        FeiShuAppEmployeeResponse employeeResponse = call(url,
-                request,
-                HttpMethod.GET,
-                FeiShuAppEmployeeResponse.class);
-        if (Objects.equals(employeeResponse.getCode(), 0)) {
-            userIds.addAll(employeeResponse.getData().getItems().stream().map(FeiShuAppEmployeeResponse.Employee::getUserId).toList());
-            var hasMore = employeeResponse.getData().getHasMore();
-            if (Boolean.TRUE.equals(hasMore)) {
-                getLarkEmployeeUserIds(accessToken, employeeResponse.getData().getPageToken(), userIds);
-            }
-        }
-
-    }
-
-    private <R extends FeiShuAppResponse, E> R call(String url, HttpEntity<E> request, HttpMethod httpMethod, Class<R> responseType) {
-        ResponseEntity<R> response = restTemplate.exchange(url, httpMethod, request, responseType);
-        if (Objects.nonNull(response.getBody()) && !Objects.equals(response.getBody().getCode(), 0)) {
-            log.warn("Send FeiShu App Error: {}", response.getBody().getMsg());
-            throw new AlertNoticeException("Http StatusCode " + response.getStatusCode() + " Error: " + response.getBody().getMsg());
-        }
-        return response.getBody();
-    }
-
-    private JsonNode createLarkMessage(NoticeReceiver receiver, String notificationContent) throws JsonProcessingException {
-        String larkCardMessage = """
-                {
-                      "schema": "2.0",
-                      "config": {
-                          "update_multi": true,
-                          "locales": [
-                              "en_us",
-                              "zh_cn"
-                          ],
-                          "style": {
-                              "text_size": {
-                                  "normal_v2": {
-                                      "default": "normal",
-                                      "pc": "normal",
-                                      "mobile": "heading"
-                                  }
-                              }
-                          }
-                      },
-                      "body": {
-                          "direction": "vertical",
-                          "padding": "12px 12px 12px 12px",
-                          "elements": [
-                              {
-                                  "tag": "markdown",
-                                  "content": "%s",
-                                  "i18n_content": {
-                                      "en_us": ""
-                                  },
-                                  "text_align": "left",
-                                  "text_size": "normal_v2",
-                                  "margin": "0px 0px 0px 0px"
-                              },
-                              {
-                                  "tag": "hr",
-                                  "margin": "0px 0px 0px 0px"
-                              },
-                              {
-                                  "tag": "column_set",
-                                  "horizontal_align": "left",
-                                  "columns": [
-                                      {
-                                          "tag": "column",
-                                          "width": "weighted",
-                                          "elements": [
-                                              {
-                                                  "tag": "button",
-                                                  "text": {
-                                                      "tag": "plain_text",
-                                                      "content": "登入控制台",
-                                                      "i18n_content": {
-                                                          "en_us": "Login In"
-                                                      }
-                                                  },
-                                                  "type": "default",
-                                                  "width": "default",
-                                                  "size": "medium",
-                                                  "behaviors": [
-                                                      {
-                                                          "type": "open_url",
-                                                          "default_url": "%s",
-                                                          "pc_url": "",
-                                                          "ios_url": "",
-                                                          "android_url": ""
-                                                      }
-                                                  ]
-                                              }
-                                          ],
-                                          "direction": "horizontal",
-                                          "vertical_spacing": "8px",
-                                          "horizontal_align": "left",
-                                          "vertical_align": "top",
-                                          "weight": 1
-                                      }
-                                  ],
-                                  "margin": "0px 0px 0px 0px"
-                              }
-                          ]
-                      },
-                      "header": {
-                          "title": {
-                              "tag": "plain_text",
-                              "content": "HertzBeat 告警",
-                              "i18n_content": {
-                                  "en_us": "HertzBeat Alarm"
-                              }
-                          },
-                          "subtitle": {
-                              "tag": "plain_text",
-                              "content": ""
-                          },
-                          "template": "red",
-                          "padding": "12px 12px 12px 12px"
-                      }
-                  }
-                """;
-        Byte larkReceiveIdType = receiver.getLarkReceiveType();
-        String userId = receiver.getUserId();
-        String atUserElement = "";
-        if (Objects.equals(larkReceiveIdType, CHAT_RECEIVE_TYPE) && StringUtils.isNotBlank(userId)) {
-            atUserElement = "\\n" + Arrays.stream(userId.split(","))
-                    .map(id -> "<at id=" + id + "></at>")
-                    .collect(Collectors.joining(" "));
-        }
-
-        if (notificationContent.startsWith("\"") && notificationContent.endsWith("\"")) {
-            notificationContent = StringUtils.removeStart(notificationContent, "\"");
-            notificationContent = StringUtils.removeEnd(notificationContent, "\"");
-        }
-        String jsonStr = String.format(larkCardMessage,
-                notificationContent.replace("\"", "\\\"") + atUserElement,
-                alerterProperties.getConsoleUrl());
-        return OBJECT_MAPPER.readTree(jsonStr);
-    }
-
-
-    private String escapedCompactJson(JsonNode json) throws JsonProcessingException {
-        return OBJECT_MAPPER.writeValueAsString(json);
-    }
-
-    /**
-     * feiShu app response
-     */
-    @Data
-    protected static class FeiShuAppResponse {
-
-        private Integer code;
-
-        private String msg;
-
-    }
-
-    /**
-     * FeiShu app message get tenant access token request
-     */
-    @Data
-    @Builder
-    @AllArgsConstructor
-    @NoArgsConstructor
-    protected static class FeiShuAppAccessTokenDto {
-
-        @JsonProperty("app_id")
-        private String appId;
-
-        @JsonProperty("app_secret")
-        private String appSecret;
-    }
-
-
-    /**
-     * FeiShu app message get tenant access token response
-     */
-    @EqualsAndHashCode(callSuper = true)
-    @Data
-    protected static class FeiShuAppAccessTokenResponse extends FeiShuAppResponse {
-
-        @JsonProperty("tenant_access_token")
-        private String tenantAccessToken;
-    }
-
-    /**
-     * FeiShu app employee response
-     */
-    @EqualsAndHashCode(callSuper = true)
-    @Data
-    protected static class FeiShuAppEmployeeResponse extends FeiShuAppResponse {
-
-        private EmployeeResponseData data;
-
-        @Data
-        private static class EmployeeResponseData {
-            @JsonProperty("page_token")
-            private String pageToken;
-
-            @JsonProperty("has_more")
-            private Boolean hasMore;
-
-            private List<Employee> items;
-        }
-
-        @Data
-        private static class Employee {
-
-            @JsonProperty("user_id")
-            private String userId;
-        }
-    }
-
-
-    /**
-     * FeiShu app message request
-     */
-    @Data
-    @Builder
-    @AllArgsConstructor
-    @NoArgsConstructor
-    protected static class FeiShuAppMessageDto {
-
-        @JsonProperty("receive_id")
-        private String receiveId;
-
-        @Builder.Default
-        @JsonProperty("msg_type")
-        private String msgType = "interactive";
-
-        @JsonProperty("content")
-        private String content;
-
-        @Builder.Default
-        private final String uuid = UUID.randomUUID().toString();
-
-    }
-
-    /**
-     * FeiShu app batch message request
-     */
-    @Data
-    @Builder
-    @AllArgsConstructor
-    @NoArgsConstructor
-    protected static class FeiShuAppBatchMessageDto {
-
-        @Builder.Default
-        @JsonProperty("msg_type")
-        private final String msgType = "interactive";
-
-        private JsonNode card;
-
-        @JsonProperty("department_ids")
-        private String[] departmentIds;
-
-        @JsonProperty("user_ids")
-        private String[] userIds;
-
-    }
-
-
-}
@@ -48,11 +48,6 @@ final class WebHookAlertNotifyHandlerImpl extends AbstractAlertNotifyHandlerImpl
            }

            HttpHeaders headers = new HttpHeaders();
-            if ("Basic".equalsIgnoreCase(receiver.getHookAuthType())) {
-                headers.setBasicAuth(receiver.getHookAuthToken());
-            } else if ("Bearer".equalsIgnoreCase(receiver.getHookAuthType())) {
-                headers.setBearerAuth(receiver.getHookAuthToken());
-            }
            headers.setContentType(MediaType.APPLICATION_JSON);
            //  alert.setContent(escapeJsonStr(alert.getContent()));
            String webhookJson = renderContent(noticeTemplate, alert);
@@ -19,7 +19,7 @@ package org.apache.hertzbeat.alert.service;

 import com.fasterxml.jackson.databind.ObjectMapper;
 import lombok.extern.slf4j.Slf4j;
-import org.apache.hertzbeat.common.entity.dto.sms.SmsConfig;
+import org.apache.hertzbeat.alert.config.SmsConfig;
 import org.apache.hertzbeat.alert.service.impl.SmsLocalSmsClientImpl;
 import org.apache.hertzbeat.alert.service.impl.AwsSmsClientImpl;
 import org.apache.hertzbeat.alert.service.impl.TencentSmsClientImpl;
@@ -151,4 +151,4 @@ public class SmsClientFactory {
                break;
        }
    }
-}
+}
@@ -17,9 +17,7 @@

 package org.apache.hertzbeat.alert.service.impl;

-import com.fasterxml.jackson.core.type.TypeReference;
 import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.lang3.BooleanUtils;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.hertzbeat.alert.dto.AlibabaCloudSlsExternAlert;
 import org.apache.hertzbeat.alert.reduce.AlarmCommonReduce;
@@ -35,9 +33,7 @@ import java.time.Instant;
 import java.time.LocalDateTime;
 import java.time.ZoneId;
 import java.time.format.DateTimeFormatter;
-import java.util.ArrayList;
 import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
 import java.util.Optional;

@@ -50,32 +46,19 @@ public class AlibabaCloudSlsExternAlertService implements ExternAlertService {

    private final AlarmCommonReduce alarmCommonReduce;

-    private static final AlibabaCloudSlsConverter CONVERTER = new AlibabaCloudSlsConverter();
-
    public AlibabaCloudSlsExternAlertService(AlarmCommonReduce alarmCommonReduce) {
        this.alarmCommonReduce = alarmCommonReduce;
    }

    @Override
    public void addExternAlert(String content) {
-        List<AlibabaCloudSlsExternAlert> externAlerts = new ArrayList<>();
-        if (BooleanUtils.isTrue(JsonUtil.isArray(content))) {
-            TypeReference<List<AlibabaCloudSlsExternAlert>> typeReference = new TypeReference<>() {};
-            externAlerts = JsonUtil.fromJson(content, typeReference);
-        } else {
-            AlibabaCloudSlsExternAlert externAlert = JsonUtil.fromJson(content, AlibabaCloudSlsExternAlert.class);
-            if (null != externAlert) {
-                externAlerts.add(externAlert);
-            }
-        }
-        if (null == externAlerts || externAlerts.isEmpty()) {
+        AlibabaCloudSlsExternAlert externAlert = JsonUtil.fromJson(content, AlibabaCloudSlsExternAlert.class);
+        if (externAlert == null) {
            log.warn("Failure to parse external alert content. content: {}", content);
            return;
        }
-        for (AlibabaCloudSlsExternAlert externAlert : externAlerts) {
-            SingleAlert singleAlert = CONVERTER.convert(externAlert);
-            alarmCommonReduce.reduceAndSendAlarm(singleAlert);
-        }
+        SingleAlert singleAlert = new AlibabaCloudSlsConverter().convert(externAlert);
+        alarmCommonReduce.reduceAndSendAlarm(singleAlert);
    }

    @Override
@@ -19,7 +19,7 @@ package org.apache.hertzbeat.alert.service.impl;

 import com.fasterxml.jackson.databind.JsonNode;
 import lombok.extern.slf4j.Slf4j;
-import org.apache.hertzbeat.common.entity.dto.sms.AlibabaSmsProperties;
+import org.apache.hertzbeat.alert.config.AlibabaSmsProperties;
 import org.apache.hertzbeat.alert.service.SmsClient;
 import org.apache.hertzbeat.alert.util.CryptoUtils;
 import org.apache.hertzbeat.common.entity.alerter.GroupAlert;
@@ -236,4 +236,4 @@ public class AlibabaSmsClientImpl implements SmsClient {
    public boolean checkConfig() {
        return !(accessKeyId.isBlank() || accessKeySecret.isBlank() || signName.isBlank() || templateCode.isBlank());
    }
-} 
+} 
@@ -20,7 +20,7 @@ package org.apache.hertzbeat.alert.service.impl;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import lombok.extern.slf4j.Slf4j;
-import org.apache.hertzbeat.common.entity.dto.sms.AwsSmsProperties;
+import org.apache.hertzbeat.alert.config.AwsSmsProperties;
 import org.apache.hertzbeat.alert.service.SmsClient;
 import org.apache.hertzbeat.alert.util.CryptoUtils;
 import org.apache.hertzbeat.common.entity.alerter.GroupAlert;
@@ -18,7 +18,6 @@
 package org.apache.hertzbeat.alert.service.impl;

 import com.fasterxml.jackson.databind.JsonNode;
-import lombok.Getter;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.hertzbeat.alert.dto.HuaweiCloudExternAlert;
@@ -44,7 +43,6 @@ import java.security.cert.CertificateFactory;
 import java.security.cert.X509Certificate;
 import java.text.MessageFormat;
 import java.time.Instant;
-import java.util.Arrays;
 import java.util.Base64;
 import java.util.HashMap;
 import java.util.Map;
@@ -72,8 +70,6 @@ public class HuaweiCloudExternAlertService implements ExternAlertService {

    private static final String CHARSET_UTF8 = StandardCharsets.UTF_8.name();

-    private static final String SUBSCRIBE_URL_PREFIX = "https://console.huaweicloud.com/smn/subscription/confirm";
-
    private final AlarmCommonReduce alarmCommonReduce;

    public HuaweiCloudExternAlertService(AlarmCommonReduce alarmCommonReduce) {
@@ -201,9 +197,6 @@ public class HuaweiCloudExternAlertService implements ExternAlertService {
        if (StringUtils.isBlank(subscribeUrl)) {
            return;
        }
-        if (!subscribeUrl.startsWith(SUBSCRIBE_URL_PREFIX)) {
-            throw new SecurityException("Untrusted domain: " + subscribeUrl);
-        }
        try (CloseableHttpClient httpClient = HttpClients.createDefault()) {
            HttpGet httpGet = new HttpGet(subscribeUrl);
            try (CloseableHttpResponse response = httpClient.execute(httpGet)) {
@@ -310,13 +303,6 @@ public class HuaweiCloudExternAlertService implements ExternAlertService {
     */
    private X509Certificate getCertificate(String signCertUrl) throws Exception {
        URL url = new URL(signCertUrl);
-        if (!"https".equalsIgnoreCase(url.getProtocol())) {
-            throw new SecurityException("Only HTTPS is allowed");
-        }
-        boolean trusted = Arrays.stream(Region.values()).anyMatch(ep -> ep.getEndpoint().equals(url.getHost()));
-        if (!trusted) {
-            throw new SecurityException("Untrusted domain: " + url.getHost());
-        }
        try (InputStream in = url.openStream()) {
            CertificateFactory cf = CertificateFactory.getInstance(CERTIFICATE_TYPE);
            return (X509Certificate) cf.generateCertificate(in);
@@ -354,51 +340,4 @@ public class HuaweiCloudExternAlertService implements ExternAlertService {
        return "huaweicloud-ces";
    }

-
-    /**
-     * doc: <a href="https://console.huaweicloud.com/apiexplorer/#/endpoint/SMN">SMN API</a>
-     */
-    @Getter
-    private enum Region {
-
-        AE_AD_1("ae-ad-1", "smn.ae-ad-1.myhuaweicloud.com"),
-        AF_SOUTH_1("af-south-1", "smn.af-south-1.myhuaweicloud.com"),
-        AP_SOUTHEAST_1("ap-southeast-1", "smn.ap-southeast-1.myhuaweicloud.com"),
-        AP_SOUTHEAST_2("ap-southeast-2", "smn.ap-southeast-2.myhuaweicloud.com"),
-        AP_SOUTHEAST_3("ap-southeast-3", "smn.ap-southeast-3.myhuaweicloud.com"),
-        AP_SOUTHEAST_4("ap-southeast-4", "smn.ap-southeast-4.myhuaweicloud.com"),
-        CN_EAST_2("cn-east-2", "smn.cn-east-2.myhuaweicloud.com"),
-        CN_EAST_3("cn-east-3", "smn.cn-east-3.myhuaweicloud.com"),
-        CN_EAST_4("cn-east-4", "smn.cn-east-4.myhuaweicloud.com"),
-        CN_EAST_5("cn-east-5", "smn.cn-east-5.myhuaweicloud.com"),
-        CN_NORTH_1("cn-north-1", "smn.cn-north-1.myhuaweicloud.com"),
-        CN_NORTH_11("cn-north-11", "smn.cn-north-11.myhuaweicloud.com"),
-        CN_NORTH_12("cn-north-12", "smn.cn-north-12.myhuaweicloud.com"),
-        CN_NORTH_2("cn-north-2", "smn.cn-north-2.myhuaweicloud.cn"),
-        CN_NORTH_4("cn-north-4", "smn.cn-north-4.myhuaweicloud.com"),
-        CN_NORTH_9("cn-north-9", "smn.cn-north-9.myhuaweicloud.com"),
-        CN_SOUTH_1("cn-south-1", "smn.cn-south-1.myhuaweicloud.com"),
-        CN_SOUTH_2("cn-south-2", "smn.cn-south-2.myhuaweicloud.com"),
-        CN_SOUTH_4("cn-south-4", "smn.cn-south-4.myhuaweicloud.com"),
-        CN_SOUTHWEST_2("cn-southwest-2", "smn.cn-southwest-2.myhuaweicloud.com"),
-        CN_SOUTHWEST_3("cn-southwest-3", "smn.cn-southwest-3.myhuaweicloud.com"),
-        EU_WEST_0("eu-west-0", "smn.eu-west-0.myhuaweicloud.com"),
-        LA_NORTH_2("la-north-2", "smn.la-north-2.myhuaweicloud.com"),
-        LA_SOUTH_2("la-south-2", "smn.la-south-2.myhuaweicloud.com"),
-        MY_KUALALUMPUR_1("my-kualalumpur-1", "smn.my-kualalumpur-1.myhuaweicloud.com"),
-        NA_MEXICO_1("na-mexico-1", "smn.na-mexico-1.myhuaweicloud.com"),
-        RU_MOSCOW_1("ru-moscow-1", "smn.ru-moscow-1.myhuaweicloud.com"),
-        SA_BRAZIL_1("sa-brazil-1", "smn.sa-brazil-1.myhuaweicloud.com"),
-        TR_WEST_1("tr-west-1", "smn.tr-west-1.myhuaweicloud.com"),
-        EU_WEST_101("eu-west-101", "smn.eu-west-101.myhuaweicloud.eu");
-
-        private final String id;
-
-        private final String endpoint;
-
-        Region(String id, String endpoint) {
-            this.id = id;
-            this.endpoint = endpoint;
-        }
-    }
 }
@@ -303,8 +303,9 @@ public class NoticeConfigServiceImpl implements NoticeConfigService, CommandLine
    @Override
    public boolean sendTestMsg(NoticeReceiver noticeReceiver) {
        Map<String, String> labels = new HashMap<>(8);
-        labels.put(CommonConstants.LABEL_INSTANCE, "127.0.0.1");
+        labels.put(CommonConstants.LABEL_INSTANCE, "1000000");
        labels.put(CommonConstants.LABEL_ALERT_NAME, "CPU Usage Alert");
+        labels.put(CommonConstants.LABEL_INSTANCE_HOST, "127.0.0.1");
        Map<String, String> annotations = new HashMap<>(8);
        annotations.put("suggest", "Please check the CPU usage of the server");
        SingleAlert singleAlert1 = SingleAlert.builder()
@@ -21,7 +21,7 @@ import com.fasterxml.jackson.databind.JsonNode;
 import lombok.Getter;
 import lombok.Setter;
 import lombok.extern.slf4j.Slf4j;
-import org.apache.hertzbeat.common.entity.dto.sms.SmslocalSmsProperties;
+import org.apache.hertzbeat.alert.config.SmslocalSmsProperties;
 import org.apache.hertzbeat.alert.service.SmsClient;
 import org.apache.hertzbeat.common.constants.SmsConstants;
 import org.apache.hertzbeat.common.entity.alerter.GroupAlert;
@@ -19,7 +19,7 @@ package org.apache.hertzbeat.alert.service.impl;

 import jakarta.xml.bind.DatatypeConverter;
 import lombok.extern.slf4j.Slf4j;
-import org.apache.hertzbeat.common.entity.dto.sms.TencentSmsProperties;
+import org.apache.hertzbeat.alert.config.TencentSmsProperties;
 import org.apache.hertzbeat.alert.service.SmsClient;
 import org.apache.hertzbeat.alert.util.CryptoUtils;
 import org.apache.hertzbeat.common.entity.alerter.GroupAlert;
@@ -19,7 +19,7 @@ package org.apache.hertzbeat.alert.service.impl;

 import com.fasterxml.jackson.databind.JsonNode;
 import lombok.extern.slf4j.Slf4j;
-import org.apache.hertzbeat.common.entity.dto.sms.TwilioSmsProperties;
+import org.apache.hertzbeat.alert.config.TwilioSmsProperties;
 import org.apache.hertzbeat.alert.service.SmsClient;
 import org.apache.hertzbeat.common.entity.alerter.GroupAlert;
 import org.apache.hertzbeat.common.entity.alerter.NoticeReceiver;
@@ -168,4 +168,4 @@ public class TwilioSmsClientImpl implements SmsClient {
    public boolean checkConfig() {
        return !(accountSid.isBlank() || authToken.isBlank() || twilioPhoneNumber.isBlank());
    }
-}
+}
@@ -18,7 +18,7 @@
 package org.apache.hertzbeat.alert.service.impl;

 import lombok.extern.slf4j.Slf4j;
-import org.apache.hertzbeat.common.entity.dto.sms.UniSmsProperties;
+import org.apache.hertzbeat.alert.config.UniSmsProperties;
 import org.apache.hertzbeat.alert.service.SmsClient;
 import org.apache.hertzbeat.common.entity.alerter.GroupAlert;
 import org.apache.hertzbeat.common.entity.alerter.NoticeReceiver;
@@ -190,4 +190,4 @@ public class UniSmsClientImpl implements SmsClient {

        return true;
    }
-} 
+} 
@@ -88,7 +88,7 @@ public class CryptoUtils {
     * @return lowercase hexadecimal string
     */
    public static String hmacSha256Hex(String key, String data) {
-        return hmacSha256Hex(key.getBytes(UTF8), data);
+        return hmacSha256Hex(hmac256(key.getBytes(UTF8), data), data);
    }

    /**
@@ -125,7 +125,7 @@ public class MetricsRealTimeAlertCalculatorMatchTest {

        Map<String, String> meta = new HashMap<>();
        meta.put(MetricDataConstants.INSTANCE_NAME, "Cool_Stingray_34Nj_copy");
-        meta.put(MetricDataConstants.INSTANCE, "127.0.0.1");
+        meta.put(MetricDataConstants.INSTANCE_HOST, "127.0.0.1");

        builder.addMetadataAll(meta);
        builder.addAllFields(Lists.newArrayList(destination, mode, metricValue));
@@ -175,7 +175,7 @@ public class MetricsRealTimeAlertCalculatorMatchTest {

        Map<String, String> meta = new HashMap<>();
        meta.put(MetricDataConstants.INSTANCE_NAME, "Cool_Stingray_34Nj");
-        meta.put(MetricDataConstants.INSTANCE, "127.0.0.1");
+        meta.put(MetricDataConstants.INSTANCE_HOST, "127.0.0.1");

        builder.addMetadataAll(meta);
        builder.addAllFields(Lists.newArrayList(destination, mode, metricValue));
@@ -225,7 +225,7 @@ public class MetricsRealTimeAlertCalculatorMatchTest {

        Map<String, String> meta = new HashMap<>();
        meta.put(MetricDataConstants.INSTANCE_NAME, "Vibrant_Gazelle_83vJ");
-        meta.put(MetricDataConstants.INSTANCE, "127.0.0.1");
+        meta.put(MetricDataConstants.INSTANCE_HOST, "127.0.0.1");

        builder.addMetadataAll(meta);
        builder.addAllFields(Lists.newArrayList(responseTime));
@@ -108,6 +108,7 @@ class WindowedLogRealTimeAlertCalculatorTest {
        verify(timeService).isLateData(anyLong());
        verify(timeService).updateMaxTimestamp(anyLong());
        verify(logWorker).reduceAndSendLogTask(validLogEntry);
+        verify(dataQueue).sendLogEntryToStorage(validLogEntry);
    }

    @Test
@@ -133,6 +134,7 @@ class WindowedLogRealTimeAlertCalculatorTest {
        verify(timeService, never()).isLateData(anyLong());
        verify(timeService, never()).updateMaxTimestamp(anyLong());
        verify(logWorker, never()).reduceAndSendLogTask(any());
+        verify(dataQueue).sendLogEntryToStorage(invalidTimestampLogEntry);
    }

    @Test
@@ -160,6 +162,7 @@ class WindowedLogRealTimeAlertCalculatorTest {
        verify(timeService).isLateData(anyLong());
        verify(timeService, never()).updateMaxTimestamp(anyLong());
        verify(logWorker, never()).reduceAndSendLogTask(any());
+        verify(dataQueue).sendLogEntryToStorage(lateDataLogEntry);
    }

    @Test
@@ -88,7 +88,7 @@ class AlertDefineControllerTest {
                                Monitor.builder()
                                        .id(1L)
                                        .app("app")
-                                        .instance("localhost")
+                                        .host("localhost")
                                        .name("monitor")
                                        .build()
                        )
@@ -27,7 +27,7 @@ import static org.mockito.Mockito.when;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import java.util.Properties;
-import org.apache.hertzbeat.common.entity.dto.MailServerConfig;
+import org.apache.hertzbeat.alert.dto.MailServerConfig;
 import org.apache.hertzbeat.base.dao.GeneralConfigDao;
 import org.apache.hertzbeat.common.entity.alerter.GroupAlert;
 import org.apache.hertzbeat.common.entity.alerter.NoticeReceiver;
@@ -1,333 +0,0 @@
-/*
- * 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.hertzbeat.alert.notice.impl;
-
-import org.apache.hertzbeat.alert.AlerterProperties;
-import org.apache.hertzbeat.alert.notice.AlertNoticeException;
-import org.apache.hertzbeat.common.entity.alerter.GroupAlert;
-import org.apache.hertzbeat.common.entity.alerter.NoticeReceiver;
-import org.apache.hertzbeat.common.entity.alerter.NoticeTemplate;
-import org.apache.hertzbeat.common.entity.alerter.SingleAlert;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.jupiter.MockitoExtension;
-import org.springframework.http.HttpStatus;
-import org.springframework.http.ResponseEntity;
-import org.springframework.web.client.RestTemplate;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.ResourceBundle;
-
-import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.lenient;
-import static org.mockito.Mockito.when;
-
-/**
- * Test case for FeiShu App Alert Notify
- */
-@ExtendWith(MockitoExtension.class)
-class FeiShuAppAlertNotifyHandlerImplTest {
-
-    @Mock
-    private RestTemplate restTemplate;
-
-    @Mock
-    private ResourceBundle bundle;
-
-    @Mock
-    private AlerterProperties alerterProperties;
-
-    @InjectMocks
-    private FeiShuAppAlertNotifyHandlerImpl feiShuAppAlertNotifyHandler;
-
-    private NoticeReceiver receiver;
-    private GroupAlert groupAlert;
-    private NoticeTemplate template;
-
-    @BeforeEach
-    public void setUp() {
-        receiver = new NoticeReceiver();
-        receiver.setId(1L);
-        receiver.setName("test-receiver");
-        receiver.setType((byte) 14);
-        receiver.setAppId("cli-test-app-id");
-        receiver.setAppSecret("test-app-secret");
-
-        groupAlert = new GroupAlert();
-        SingleAlert singleAlert = new SingleAlert();
-        singleAlert.setLabels(new HashMap<>());
-        singleAlert.getLabels().put("severity", "critical");
-        singleAlert.getLabels().put("alertname", "Test Alert");
-
-        List<SingleAlert> alerts = new ArrayList<>();
-        alerts.add(singleAlert);
-        groupAlert.setAlerts(alerts);
-
-        template = new NoticeTemplate();
-        template.setId(1L);
-        template.setName("test-template");
-        template.setContent("test content");
-
-        lenient().when(bundle.getString("alerter.notify.title")).thenReturn("Alert Notification");
-        lenient().when(alerterProperties.getConsoleUrl()).thenReturn("https://console.hertzbeat.com");
-    }
-
-    /**
-     * Test successful notification to single user
-     */
-    @Test
-    public void testNotifyAlertSuccessSingleUser() {
-        // Setup receiver for single user
-        receiver.setLarkReceiveType((byte) 0);
-        receiver.setUserId("user-001");
-
-        // Mock access token response
-        FeiShuAppAlertNotifyHandlerImpl.FeiShuAppAccessTokenResponse accessTokenResp =
-                new FeiShuAppAlertNotifyHandlerImpl.FeiShuAppAccessTokenResponse();
-        accessTokenResp.setCode(0);
-        accessTokenResp.setMsg("success");
-        accessTokenResp.setTenantAccessToken("test-access-token");
-
-        // Mock message send response
-        FeiShuAppAlertNotifyHandlerImpl.FeiShuAppResponse messageResp =
-                new FeiShuAppAlertNotifyHandlerImpl.FeiShuAppResponse();
-        messageResp.setCode(0);
-        messageResp.setMsg("success");
-
-        // Mock restTemplate calls
-        when(restTemplate.exchange(
-                anyString(),
-                eq(org.springframework.http.HttpMethod.POST),
-                any(),
-                eq(FeiShuAppAlertNotifyHandlerImpl.FeiShuAppAccessTokenResponse.class)))
-                .thenReturn(new ResponseEntity<>(accessTokenResp, HttpStatus.OK));
-
-        when(restTemplate.exchange(
-                anyString(),
-                eq(org.springframework.http.HttpMethod.POST),
-                any(),
-                eq(FeiShuAppAlertNotifyHandlerImpl.FeiShuAppResponse.class)))
-                .thenReturn(new ResponseEntity<>(messageResp, HttpStatus.OK));
-        feiShuAppAlertNotifyHandler.send(receiver, template, groupAlert);
-    }
-
-    /**
-     * Test successful notification to multiple users
-     */
-    @Test
-    public void testNotifyAlertSuccessMultipleUsers() {
-        receiver.setLarkReceiveType((byte) 0);
-        receiver.setUserId("user-001,user-002,user-003");
-
-        FeiShuAppAlertNotifyHandlerImpl.FeiShuAppAccessTokenResponse accessTokenResp =
-                new FeiShuAppAlertNotifyHandlerImpl.FeiShuAppAccessTokenResponse();
-        accessTokenResp.setCode(0);
-        accessTokenResp.setMsg("success");
-        accessTokenResp.setTenantAccessToken("test-access-token");
-
-        FeiShuAppAlertNotifyHandlerImpl.FeiShuAppResponse messageResp =
-                new FeiShuAppAlertNotifyHandlerImpl.FeiShuAppResponse();
-        messageResp.setCode(0);
-        messageResp.setMsg("success");
-
-        when(restTemplate.exchange(
-                anyString(),
-                eq(org.springframework.http.HttpMethod.POST),
-                any(),
-                eq(FeiShuAppAlertNotifyHandlerImpl.FeiShuAppAccessTokenResponse.class)))
-                .thenReturn(new ResponseEntity<>(accessTokenResp, HttpStatus.OK));
-
-        when(restTemplate.exchange(
-                anyString(),
-                eq(org.springframework.http.HttpMethod.POST),
-                any(),
-                eq(FeiShuAppAlertNotifyHandlerImpl.FeiShuAppResponse.class)))
-                .thenReturn(new ResponseEntity<>(messageResp, HttpStatus.OK));
-
-        feiShuAppAlertNotifyHandler.send(receiver, template, groupAlert);
-    }
-
-    /**
-     * Test successful notification to chat
-     */
-    @Test
-    public void testNotifyAlertSuccessChat() {
-        receiver.setLarkReceiveType((byte) 1);
-        receiver.setChatId("chat-001");
-
-        FeiShuAppAlertNotifyHandlerImpl.FeiShuAppAccessTokenResponse accessTokenResp =
-                new FeiShuAppAlertNotifyHandlerImpl.FeiShuAppAccessTokenResponse();
-        accessTokenResp.setCode(0);
-        accessTokenResp.setMsg("success");
-        accessTokenResp.setTenantAccessToken("test-access-token");
-
-        FeiShuAppAlertNotifyHandlerImpl.FeiShuAppResponse messageResp =
-                new FeiShuAppAlertNotifyHandlerImpl.FeiShuAppResponse();
-        messageResp.setCode(0);
-        messageResp.setMsg("success");
-
-        when(restTemplate.exchange(
-                anyString(),
-                eq(org.springframework.http.HttpMethod.POST),
-                any(),
-                eq(FeiShuAppAlertNotifyHandlerImpl.FeiShuAppAccessTokenResponse.class)))
-                .thenReturn(new ResponseEntity<>(accessTokenResp, HttpStatus.OK));
-
-        when(restTemplate.exchange(
-                anyString(),
-                eq(org.springframework.http.HttpMethod.POST),
-                any(),
-                eq(FeiShuAppAlertNotifyHandlerImpl.FeiShuAppResponse.class)))
-                .thenReturn(new ResponseEntity<>(messageResp, HttpStatus.OK));
-
-        feiShuAppAlertNotifyHandler.send(receiver, template, groupAlert);
-    }
-
-    /**
-     * Test successful notification to departments
-     */
-    @Test
-    public void testNotifyAlertSuccessDepartments() {
-        receiver.setLarkReceiveType((byte) 2);
-        receiver.setPartyId("dept-001,dept-002");
-
-        FeiShuAppAlertNotifyHandlerImpl.FeiShuAppAccessTokenResponse accessTokenResp =
-                new FeiShuAppAlertNotifyHandlerImpl.FeiShuAppAccessTokenResponse();
-        accessTokenResp.setCode(0);
-        accessTokenResp.setMsg("success");
-        accessTokenResp.setTenantAccessToken("test-access-token");
-
-        FeiShuAppAlertNotifyHandlerImpl.FeiShuAppResponse messageResp =
-                new FeiShuAppAlertNotifyHandlerImpl.FeiShuAppResponse();
-        messageResp.setCode(0);
-        messageResp.setMsg("success");
-
-        when(restTemplate.exchange(
-                anyString(),
-                eq(org.springframework.http.HttpMethod.POST),
-                any(),
-                eq(FeiShuAppAlertNotifyHandlerImpl.FeiShuAppAccessTokenResponse.class)))
-                .thenReturn(new ResponseEntity<>(accessTokenResp, HttpStatus.OK));
-
-        when(restTemplate.exchange(
-                anyString(),
-                eq(org.springframework.http.HttpMethod.POST),
-                any(),
-                eq(FeiShuAppAlertNotifyHandlerImpl.FeiShuAppResponse.class)))
-                .thenReturn(new ResponseEntity<>(messageResp, HttpStatus.OK));
-
-        feiShuAppAlertNotifyHandler.send(receiver, template, groupAlert);
-    }
-
-    /**
-     * Test notification failure due to access token error
-     */
-    @Test
-    public void testNotifyAlertFailureAccessToken() {
-        receiver.setLarkReceiveType((byte) 0);
-        receiver.setUserId("user-001");
-
-        FeiShuAppAlertNotifyHandlerImpl.FeiShuAppAccessTokenResponse accessTokenResp =
-                new FeiShuAppAlertNotifyHandlerImpl.FeiShuAppAccessTokenResponse();
-        accessTokenResp.setCode(999);
-        accessTokenResp.setMsg("Invalid app credentials");
-
-        when(restTemplate.exchange(
-                anyString(),
-                eq(org.springframework.http.HttpMethod.POST),
-                any(),
-                eq(FeiShuAppAlertNotifyHandlerImpl.FeiShuAppAccessTokenResponse.class)))
-                .thenReturn(new ResponseEntity<>(accessTokenResp, HttpStatus.OK));
-
-        assertThrows(AlertNoticeException.class, () -> {
-            feiShuAppAlertNotifyHandler.send(receiver, template, groupAlert);
-        });
-    }
-
-    /**
-     * Test notification failure due to message send error
-     */
-    @Test
-    public void testNotifyAlertFailureMessageSend() {
-        receiver.setLarkReceiveType((byte) 0);
-        receiver.setUserId("user-001");
-
-        FeiShuAppAlertNotifyHandlerImpl.FeiShuAppAccessTokenResponse accessTokenResp =
-                new FeiShuAppAlertNotifyHandlerImpl.FeiShuAppAccessTokenResponse();
-        accessTokenResp.setCode(0);
-        accessTokenResp.setMsg("success");
-        accessTokenResp.setTenantAccessToken("test-access-token");
-
-        FeiShuAppAlertNotifyHandlerImpl.FeiShuAppResponse messageResp =
-                new FeiShuAppAlertNotifyHandlerImpl.FeiShuAppResponse();
-        messageResp.setCode(999);
-        messageResp.setMsg("User not found");
-
-        when(restTemplate.exchange(
-                anyString(),
-                eq(org.springframework.http.HttpMethod.POST),
-                any(),
-                eq(FeiShuAppAlertNotifyHandlerImpl.FeiShuAppAccessTokenResponse.class)))
-                .thenReturn(new ResponseEntity<>(accessTokenResp, HttpStatus.OK));
-
-        when(restTemplate.exchange(
-                anyString(),
-                eq(org.springframework.http.HttpMethod.POST),
-                any(),
-                eq(FeiShuAppAlertNotifyHandlerImpl.FeiShuAppResponse.class)))
-                .thenReturn(new ResponseEntity<>(messageResp, HttpStatus.OK));
-
-        assertThrows(AlertNoticeException.class, () -> {
-            feiShuAppAlertNotifyHandler.send(receiver, template, groupAlert);
-        });
-    }
-
-    /**
-     * Test invalid larkReceiveType
-     */
-    @Test
-    public void testInvalidLarkReceiveType() {
-        receiver.setLarkReceiveType((byte) 99);
-        receiver.setUserId("user-001");
-
-        FeiShuAppAlertNotifyHandlerImpl.FeiShuAppAccessTokenResponse accessTokenResp =
-                new FeiShuAppAlertNotifyHandlerImpl.FeiShuAppAccessTokenResponse();
-        accessTokenResp.setCode(0);
-        accessTokenResp.setMsg("success");
-        accessTokenResp.setTenantAccessToken("test-access-token");
-
-        when(restTemplate.exchange(
-                anyString(),
-                eq(org.springframework.http.HttpMethod.POST),
-                any(),
-                eq(FeiShuAppAlertNotifyHandlerImpl.FeiShuAppAccessTokenResponse.class)))
-                .thenReturn(new ResponseEntity<>(accessTokenResp, HttpStatus.OK));
-
-        assertThrows(AlertNoticeException.class, () -> {
-            feiShuAppAlertNotifyHandler.send(receiver, template, groupAlert);
-        });
-    }
-}
@@ -105,19 +105,19 @@ class AlertDefineServiceTest {

    @Test
    void addAlertDefine() {
-        assertDoesNotThrow(() -> this.alertDefineService.addAlertDefine(alertDefine));
+        assertDoesNotThrow(() -> alertDefineService.addAlertDefine(alertDefine));
        when(alertDefineDao.saveAndFlush(alertDefine)).thenThrow(new RuntimeException());
-        assertThrows(RuntimeException.class, () -> this.alertDefineService.addAlertDefine(alertDefine));
+        assertThrows(RuntimeException.class, () -> alertDefineService.addAlertDefine(alertDefine));
    }

    @Test
    void modifyAlertDefine() {
        AlertDefine alertDefine = AlertDefine.builder().id(1L).build();
        when(alertDefineDao.saveAndFlush(alertDefine)).thenReturn(alertDefine);
-        assertDoesNotThrow(() -> this.alertDefineService.modifyAlertDefine(alertDefine));
+        assertDoesNotThrow(() -> alertDefineService.modifyAlertDefine(alertDefine));
        reset();
        when(alertDefineDao.saveAndFlush(alertDefine)).thenThrow(new RuntimeException());
-        assertThrows(RuntimeException.class, () -> this.alertDefineService.modifyAlertDefine(alertDefine));
+        assertThrows(RuntimeException.class, () -> alertDefineService.modifyAlertDefine(alertDefine));
    }

    @Test
@@ -28,12 +28,9 @@ import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
-import org.springframework.beans.BeanUtils;

 import java.time.Instant;
-import java.util.ArrayList;
 import java.util.HashMap;
-import java.util.List;
 import java.util.Map;

 import static org.junit.jupiter.api.Assertions.assertEquals;
@@ -150,36 +147,4 @@ public class AlibabaCloudSlsExternAlertServiceTest {
        verify(alarmCommonReduce, times(1)).reduceAndSendAlarm(any(SingleAlert.class));
    }

-    @Test
-    void testAddMergeExternAlert() {
-        String source = externAlertService.supportSource();
-        assertEquals("alibabacloud-sls", source);
-
-        AlibabaCloudSlsExternAlert externAlert = new AlibabaCloudSlsExternAlert();
-        externAlert.setAlertName("Test SLS alert");
-        externAlert.setFireTime((int) Instant.now().getEpochSecond());
-        externAlert.setAlertTime((int) Instant.now().getEpochSecond());
-        externAlert.setRegion("cn-hangzhou");
-        externAlert.setProject("project");
-        externAlert.setStatus("firing");
-        externAlert.setSeverity(AlibabaCloudSlsExternAlert.Severity.HIGH.getStatus());
-
-        Map<String, String> labels = new HashMap<>();
-        labels.put("labels-k", "labels-v");
-        externAlert.setLabels(labels);
-
-        Map<String, String> annotations = new HashMap<>();
-        annotations.put("annotations-k", "annotations-v");
-        externAlert.setAnnotations(annotations);
-
-        AlibabaCloudSlsExternAlert externAlert1 = new AlibabaCloudSlsExternAlert();
-        BeanUtils.copyProperties(externAlert, externAlert1);
-
-        List<AlibabaCloudSlsExternAlert> externAlerts = new ArrayList<>();
-        externAlerts.add(externAlert);
-        externAlerts.add(externAlert1);
-        externAlertService.addExternAlert(JsonUtil.toJson(externAlerts));
-        verify(alarmCommonReduce, times(2)).reduceAndSendAlarm(any(SingleAlert.class));
-    }
-
 }
@@ -17,7 +17,7 @@

 package org.apache.hertzbeat.alert.service;

-import org.apache.hertzbeat.common.entity.dto.sms.AwsSmsProperties;
+import org.apache.hertzbeat.alert.config.AwsSmsProperties;
 import org.apache.hertzbeat.alert.service.impl.AwsSmsClientImpl;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
@@ -146,42 +146,7 @@ public class HuaweiCloudExternAlertServiceTest {
        verify(alarmCommonReduce, never()).reduceAndSendAlarm(any(SingleAlert.class));
    }

-    @Test
-    void testSubscriptionUrlFail() {
-        HuaweiCloudExternAlert externAlert = new HuaweiCloudExternAlert();
-        externAlert.setSubscribeUrl("https://console.huaweicloud.com/smn/subscription/confirm?token=477a784601d744e4ab9ab83986502d31c4b938"
-                + "0ec0b64392b134e517c3aa17eb7b3a12dc9f3b4ab495e61c4dee654b435d7223ea934345bf8ae8901cef912b1d&topic_urn=urn:smn:cn-north-4"
-                + ":477a784601d744e4ab9ab83986502d31:CES_notification_group_bngJ2aMpX&region=cn-north-4");
-        externAlert.setSignature("ottf37C/2RdDgqimRQMIBU6i7XjUfPPMU760jJn71wwP3825YPoIT22uw2A9399rkm9Jrt1qUEFrDLuA5yHFLd5n/XoM4FghIgyFn7VIfgpuVM31a+co78s"
-                + "YBiZ1egOCE/AwFm2oygRhfIceUj9Kw9vmc06el9TXY6RtE5tAEF6qEmICtTh45KwtCO/WRs3DY72dQi5hm0w7/tktS4WFZ1iP4LHt5eCwFvnH0u29Y96cJNI0fLUQxI5MkhgjK"
-                + "77JkFK7UT6ZYJZhzgSp/B7OQGStOQx+3Duvx4T4CzccZQM3sca81Z0B0GFGWeVXuEHyCPLsayY/Iz+5Tco51elT8w==");
-        externAlert.setTopicUrn("urn:smn:cn-north-4:477a784601d744e4ab9ab83986502d31:CES_notification_group_bngJ2aMpX");
-        externAlert.setMessageId("242fac183d3a4936b5ead6c725a32ed0");
-        externAlert.setType("SubscriptionConfirmation");
-        externAlert.setMessage("You are invited to subscribe to topic: urn:smn:cn-north-4:477a784601d744e4ab9ab83986502d31:"
-                + "CES_notification_group_bngJ2aMpX. To confirm this subscription, please visit the subscribe_url included in this message. The subscribe_url is valid only within 48 hours.");
-        externAlert.setSigningCertUrl("https://xxxx.myhuaweicloud.com/smn/SMN_cn-north-4_b98100ca131b4116ab8ee7ccedbaae99.pem");
-        externAlert.setTimestamp("2025-06-07T15:07:14Z");
-        externAlertService.addExternAlert(JsonUtil.toJson(externAlert));
-        verify(alarmCommonReduce, never()).reduceAndSendAlarm(any(SingleAlert.class));
-    }

-    @Test
-    void testCertUrlFailed() {
-        HuaweiCloudExternAlert externAlert = new HuaweiCloudExternAlert();
-        externAlert.setSignature("TImrLoeb0tV1JZJSPyA0rpC9mNqH3MmhwQ4tgpuHHa+JztfGVZFvkU//OthKKhzpDAoYiXOYG9DbzXCLb"
-                + "vaGePIRITakoynYyYr9zZIpdx9jXhQNlgF8np1+t0JxNeoIq0DYWgH52tsodwqOm+OnmkcHwCRo/1rFv85KrKAaX2gy3sNwX"
-                + "w1hKnAwAw0mJlxHHSf/N3+7j6GoxCNV7fN9K4CpJiLMGNvUa7zVmG0U9mPvt/7Lac155kPPQ9lYyeL7vVI0e4sfRbuQruz3E"
-                + "0ZP40TKx0afoeR0/Bx/IoZzRP1La7pKlbEISvkcM7TqW/IOGQTkhVsQ32RFRxZWO2snw==");
-        externAlert.setSubject("DCS Redis “dcs-h4tv” ");
-        externAlert.setTopicUrn("urn:smn:cn-north-4:477a784601d744e4ab9ab83986502d31:CES_notification_group_bngJ2aMpX");
-        externAlert.setMessageId("d3672d737bb742cf8c2aa3f0fd72d4d1");
-        externAlert.setType("Notification");
-        externAlert.setMessage("{}");
-        externAlert.setSigningCertUrl("https://xxx.myhuaweicloud.com/failedUrl");
-        externAlert.setTimestamp("2025-06-07T15:12:09Z");
-        externAlertService.addExternAlert(JsonUtil.toJson(externAlert));
-        verify(alarmCommonReduce, never()).reduceAndSendAlarm(any(SingleAlert.class));
-    }
+

 }
@@ -19,8 +19,8 @@ package org.apache.hertzbeat.alert.service;

 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
-import org.apache.hertzbeat.common.entity.dto.sms.SmsConfig;
-import org.apache.hertzbeat.common.entity.dto.sms.SmslocalSmsProperties;
+import org.apache.hertzbeat.alert.config.SmsConfig;
+import org.apache.hertzbeat.alert.config.SmslocalSmsProperties;
 import org.apache.hertzbeat.base.dao.GeneralConfigDao;
 import org.apache.hertzbeat.common.constants.GeneralConfigTypeEnum;
 import org.apache.hertzbeat.common.entity.manager.GeneralConfig;
@@ -89,4 +89,4 @@ public class SmsClientFactoryTest {
        assertNull(smsClientFactory.getSmsClient());
    }

-}
+}
@@ -17,7 +17,7 @@

 package org.apache.hertzbeat.alert.service;

-import org.apache.hertzbeat.common.entity.dto.sms.TwilioSmsProperties;
+import org.apache.hertzbeat.alert.config.TwilioSmsProperties;
 import org.apache.hertzbeat.alert.service.impl.TwilioSmsClientImpl;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
@@ -61,4 +61,4 @@ class TwilioSmsClientImplTest {

        assertEquals(expected, twilioSmsClient.checkConfig());
    }
-}
+}
@@ -18,7 +18,7 @@
 package org.apache.hertzbeat.alert.service.impl;

 import com.google.common.collect.Lists;
-import org.apache.hertzbeat.common.entity.dto.sms.SmslocalSmsProperties;
+import org.apache.hertzbeat.alert.config.SmslocalSmsProperties;
 import org.apache.hertzbeat.common.entity.alerter.GroupAlert;
 import org.apache.hertzbeat.common.entity.alerter.NoticeReceiver;
 import org.apache.hertzbeat.common.entity.alerter.SingleAlert;
@@ -70,4 +70,4 @@ public class SmsLocalSmsClientImplTest {
                () -> smsLocalSmsClient.sendMessage(noticeReceiver, null, groupAlert));
    }

-}
+}
@@ -17,7 +17,7 @@

 package org.apache.hertzbeat.alert.service.impl;

-import org.apache.hertzbeat.common.entity.dto.sms.UniSmsProperties;
+import org.apache.hertzbeat.alert.config.UniSmsProperties;
 import org.apache.hertzbeat.common.entity.alerter.GroupAlert;
 import org.apache.hertzbeat.common.entity.alerter.NoticeReceiver;
 import org.apache.hertzbeat.common.support.exception.SendMessageException;
@@ -82,4 +82,4 @@ public class UniSmsClientImplTest {
    }


-}
+}
@@ -42,7 +42,7 @@ public class CryptoUtilsTest {
    @Test
    void testHmacSha256Hex() {
        String signature = CryptoUtils.hmacSha256Hex("your-real-key", "your-real-data");;
-        assertEquals("f09adf5f4bf94eddecf0f7c8f39a3a8dc7f95ccdc2faf2e5330bc5a78e4bba95", signature);
+        assertEquals("41878ccd7ecd795a2dd7ec39be7f33fed4be3ec75f5307689e39dd6f41fdbaac", signature);
    }

 }
@@ -109,12 +109,6 @@
            <artifactId>orai18n</artifactId>
            <scope>provided</scope>
        </dependency>
-        <!-- db2 -->
-        <dependency>
-            <groupId>com.ibm.db2</groupId>
-            <artifactId>jcc</artifactId>
-            <scope>provided</scope>
-        </dependency>
        <!--redis-->
        <dependency>
            <groupId>io.lettuce</groupId>
@@ -158,6 +152,7 @@
        </dependency>


+
        <!--plc-->
        <dependency>
            <groupId>org.apache.plc4x</groupId>
@@ -172,14 +172,6 @@ public class JdbcCommonCollect extends AbstractCollect {
                ".*en\\s*([/\\\\]|\\\\n|/n|\\n)\\s*crypt.*",
                ".*ci\\s*([/\\\\]|\\\\n|/n|\\n)\\s*pher.*"
        });
-
-        // DB2 bypass mode
-        PLATFORM_BYPASS_PATTERNS.put("db2", new String[]{
-                ".*security\\s*([/\\\\]|\\\\n|/n|\\n)\\s*mechanism.*",
-                ".*client\\s*([/\\\\]|\\\\n|/n|\\n)\\s*accounting.*",
-                ".*ssl\\s*([/\\\\]|\\\\n|/n|\\n)\\s*connection.*",
-                ".*use\\s*([/\\\\]|\\\\n|/n|\\n)\\s*client\\s*([/\\\\]|\\\\n|/n|\\n)\\s*information.*"
-        });
    }

    private final GlobalConnectionCache connectionCommonCache = GlobalConnectionCache.getInstance();
@@ -539,8 +531,6 @@ public class JdbcCommonCollect extends AbstractCollect {
            case "oracle" -> "jdbc:oracle:thin:@" + host + ":" + port
                    + "/" + (jdbcProtocol.getDatabase() == null ? "" : jdbcProtocol.getDatabase());
            case "dm" -> "jdbc:dm://" + host + ":" + port;
-            case "db2" -> "jdbc:db2://" + host + ":" + port
-                    + "/" + (jdbcProtocol.getDatabase() == null ? "" : jdbcProtocol.getDatabase());
            case "testcontainers" -> "jdbc:tc:" + host + ":" + port
                    + ":///" + (jdbcProtocol.getDatabase() == null ? "" : jdbcProtocol.getDatabase()) + "?user=root&password=root";
            default -> throw new IllegalArgumentException("Not support database platform: " + jdbcProtocol.getPlatform());
@@ -67,8 +67,6 @@ public class RedisCommonCollectImpl extends AbstractCollect {

    private static final String CLUSTER = "3";

-    private static final String SINGLE = "1";
-
    private static final String CLUSTER_INFO = "cluster";

    private static final String UNIQUE_IDENTITY = "identity";
@@ -142,7 +140,7 @@ public class RedisCommonCollectImpl extends AbstractCollect {
     * @return data
     */
    private List<Map<String, String>> getClusterRedisInfo(Metrics metrics) throws GeneralSecurityException, IOException {
-        Map<String, StatefulRedisConnection<String, String>> connectionMap = getConnectionList(metrics.getRedis());
+        Map<String, StatefulRedisClusterConnection<String, String>> connectionMap = getConnectionList(metrics.getRedis());
        List<Map<String, String>> list = new ArrayList<>(connectionMap.size());
        connectionMap.forEach((identity, connection) ->{
            String info = connection.sync().info(metrics.getName());
@@ -216,23 +214,16 @@ public class RedisCommonCollectImpl extends AbstractCollect {
     * @param redisProtocol protocol
     * @return connection map
     */
-    private Map<String, StatefulRedisConnection<String, String>> getConnectionList(RedisProtocol redisProtocol) throws GeneralSecurityException, IOException {
+    private Map<String, StatefulRedisClusterConnection<String, String>> getConnectionList(RedisProtocol redisProtocol) throws GeneralSecurityException, IOException {
        // first connection
        StatefulRedisClusterConnection<String, String> connection = getClusterConnection(redisProtocol);
        Partitions partitions = connection.getPartitions();
-        Map<String, StatefulRedisConnection<String, String>> clusterConnectionMap = new HashMap<>(partitions.size());
+        Map<String, StatefulRedisClusterConnection<String, String>> clusterConnectionMap = new HashMap<>(partitions.size());
        for (RedisClusterNode partition : partitions) {
            RedisURI uri = partition.getUri();
-            RedisProtocol singleRedisProtocol = RedisProtocol.builder()
-                    .host(uri.getHost())
-                    .port(String.valueOf(uri.getPort()))
-                    .username(redisProtocol.getUsername())
-                    .password(redisProtocol.getPassword())
-                    .pattern(SINGLE)
-                    .timeout(redisProtocol.getTimeout())
-                    .sshTunnel(redisProtocol.getSshTunnel())
-                    .build();
-            StatefulRedisConnection<String, String> clusterConnection = getSingleConnection(singleRedisProtocol);
+            redisProtocol.setHost(uri.getHost());
+            redisProtocol.setPort(String.valueOf(uri.getPort()));
+            StatefulRedisClusterConnection<String, String> clusterConnection = getClusterConnection(redisProtocol);
            clusterConnectionMap.put(doUri(uri.getHost(), uri.getPort()), clusterConnection);
        }
        return clusterConnectionMap;
@@ -19,13 +19,10 @@ package org.apache.hertzbeat.collector.collect.redis;

 import static org.apache.hertzbeat.common.constants.CommonConstants.TYPE_STRING;
 import static org.junit.jupiter.api.Assertions.assertEquals;
-
-import io.lettuce.core.RedisClient;
 import io.lettuce.core.RedisURI;
-import io.lettuce.core.api.StatefulRedisConnection;
-import io.lettuce.core.api.sync.RedisCommands;
 import io.lettuce.core.cluster.RedisClusterClient;
 import io.lettuce.core.cluster.api.StatefulRedisClusterConnection;
+import io.lettuce.core.cluster.api.sync.RedisAdvancedClusterCommands;
 import io.lettuce.core.cluster.models.partitions.Partitions;
 import io.lettuce.core.cluster.models.partitions.RedisClusterNode;
 import io.lettuce.core.resource.ClientResources;
@@ -40,7 +37,6 @@ import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
-import org.mockito.MockedStatic;
 import org.mockito.Mockito;
 import org.mockito.junit.jupiter.MockitoExtension;

@@ -55,19 +51,13 @@ public class RedisClusterCollectImplTest {


    @Mock
-    private StatefulRedisClusterConnection<String, String> clusterConnection;
+    private StatefulRedisClusterConnection<String, String> connection;

    @Mock
-    private StatefulRedisConnection<String, String> singleConnection;
+    private RedisAdvancedClusterCommands<String, String> cmd;

    @Mock
-    private RedisCommands<String, String> cmd;
-
-    @Mock
-    private RedisClusterClient clusterClient;
-
-    @Mock
-    private RedisClient singleClient;
+    private RedisClusterClient client;

    @BeforeEach
    void setUp() {
@@ -75,10 +65,8 @@ public class RedisClusterCollectImplTest {

    @AfterEach
    void setDown() {
-        clusterConnection.close();
-        singleConnection.close();
-        clusterClient.shutdown();
-        singleClient.shutdown();
+        connection.close();
+        client.shutdown();
    }

    @Test
@@ -122,14 +110,10 @@ public class RedisClusterCollectImplTest {
        metrics.setAliasFields(aliasField);
        metrics.setFields(fields);

-        MockedStatic<RedisClusterClient> redisClusterClientMockedStatic = Mockito.mockStatic(RedisClusterClient.class);
-        redisClusterClientMockedStatic.when(() -> RedisClusterClient.create(Mockito.any(ClientResources.class),
-                Mockito.any(RedisURI.class))).thenReturn(clusterClient);
-        Mockito.when(clusterClient.connect()).thenReturn(clusterConnection);
-        MockedStatic<RedisClient> redisClientMockedStatic = Mockito.mockStatic(RedisClient.class);
-        redisClientMockedStatic.when(() -> RedisClient.create(Mockito.any(ClientResources.class),
-                Mockito.any(RedisURI.class))).thenReturn(singleClient);
-        Mockito.when(singleClient.connect()).thenReturn(singleConnection);
+
+        Mockito.mockStatic(RedisClusterClient.class).when(() -> RedisClusterClient.create(Mockito.any(ClientResources.class),
+                Mockito.any(RedisURI.class))).thenReturn(client);
+        Mockito.when(client.connect()).thenReturn(connection);

        Partitions partitions = new Partitions();
        RedisClusterNode node = new RedisClusterNode();
@@ -141,9 +125,9 @@ public class RedisClusterCollectImplTest {
        node2.setUri(RedisURI.create("redis://" + uri2));
        partitions.add(node2);

-        Mockito.when(clusterConnection.getPartitions()).thenReturn(partitions);
+        Mockito.when(connection.getPartitions()).thenReturn(partitions);

-        Mockito.when(singleConnection.sync()).thenReturn(cmd);
+        Mockito.when(connection.sync()).thenReturn(cmd);
        Mockito.when(cmd.info(metrics.getName())).thenReturn(info);
        Mockito.when(cmd.clusterInfo()).thenReturn(clusterInfo);

@@ -163,8 +147,6 @@ public class RedisClusterCollectImplTest {
                assertEquals(row.getColumns(2), uri2);
            }
        }
-        redisClusterClientMockedStatic.close();
-        redisClientMockedStatic.close();

    }
 }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Tomsun28	74cbfe0c74	Merge branch 'master' into update-doc9083	2025-10-25 13:17:14 +08:00
tomsun28	ae5d30790c	update Signed-off-by: tomsun28 <tomsun28@outlook.com>	2025-10-25 13:16:02 +08:00
tomsun28	a6be462eba	[doc] update	2025-10-25 13:12:27 +08:00
tomsun28	afa41621f7	[doc] update	2025-10-25 13:09:22 +08:00
tomsun28	92fce7edac	update Signed-off-by: tomsun28 <tomsun28@outlook.com>	2025-10-25 12:57:33 +08:00
tomsun28	9e791ff6b8	Update @pentium100 as a contributor	2025-10-25 12:23:03 +08:00
tomsun28	6ce68ab94c	Add @dedyks as a contributor	2025-10-25 12:22:47 +08:00
tomsun28	38843e8e86	Update @pentium100 as a contributor	2025-10-25 12:22:31 +08:00
tomsun28	591ad4a101	Add @pentium100 as a contributor	2025-10-25 12:22:16 +08:00
tomsun28	f57972e389	Add @Jetiaime as a contributor	2025-10-25 12:21:59 +08:00
tomsun28	4327e888da	Add @warrobe as a contributor	2025-10-25 12:21:14 +08:00
tomsun28	e2290bec92	Add @mengnankkkk as a contributor	2025-10-25 12:20:09 +08:00
tomsun28	0c1a810701	Add @AlbertYang0801 as a contributor	2025-10-25 12:19:54 +08:00
tomsun28	98275f3a61	Add @jl15988 as a contributor	2025-10-25 12:19:39 +08:00
tomsun28	f17844e3e8	Update @tuzuy as a contributor	2025-10-25 12:19:17 +08:00
tomsun28	0317b67975	Add @cxhello as a contributor	2025-10-25 12:18:54 +08:00
tomsun28	262c6b31c7	Update @lynx009 as a contributor	2025-10-25 12:18:01 +08:00
tomsun28	d8dba67066	Update @sarthakeash as a contributor	2025-10-25 12:17:36 +08:00
tomsun28	dd13b74a6f	Update @sarthakeash as a contributor	2025-10-25 12:17:23 +08:00