refactor basic auth configurations: merge HTTP.Pushgw and HTTP.Heartbeat to HTTP.APIForAgent; merge HTTP.Alert and HTTP.Service to HTTP.APIForService

2026-03-03 06:29:16 +00:00 · 2023-06-01 16:12:50 +08:00
648 changed files with 16756 additions and 116328 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -30,11 +30,7 @@ _test
 /dist
 /etc/*.local.yml
 /etc/*.local.conf
-/etc/rsa/*
 /etc/plugins/*.local.yml
-/etc/script/rules.yaml
-/etc/script/alert-rules.json
-/etc/script/record-rules.json
 /data*
 /tarball
 /run
@@ -44,12 +40,9 @@ _test
 /n9e
 /docker/pub
 /docker/n9e
-/docker/compose-bridge/mysqldata
-/docker/compose-host-network/mysqldata
-/docker/compose-postgres/pgdata
+/docker/mysqldata
+/docker/experience_pg_vm/pgdata
 /etc.local*
-/front/statik/statik.go
-/docker/compose-bridge/etc-nightingale/rsa/

 .alerts
 .idea
--- a/.goreleaser.yaml
+++ b/.goreleaser.yaml
@@ -15,8 +15,7 @@ builds:
  - id: build
    hooks:
      pre:
-      - cmd: sh -x ./fe.sh
-        output: true
+       - ./fe.sh
    main: ./cmd/center/
    binary: n9e
    env:
@@ -42,9 +41,22 @@ builds:
    ldflags:
      - -s -w
      - -X github.com/ccfos/nightingale/v6/pkg/version.Version={{ .Tag }}-{{.Commit}}
-  - id: build-edge
-    main: ./cmd/edge/
-    binary: n9e-edge
+  - id: build-alert
+    main: ./cmd/alert/
+    binary: n9e-alert
+    env:
+      - CGO_ENABLED=0
+    goos:
+      - linux
+    goarch:
+      - amd64
+      - arm64
+    ldflags:
+      - -s -w
+      - -X github.com/ccfos/nightingale/v6/pkg/version.Version={{ .Tag }}-{{.Commit}}
+  - id: build-pushgw
+    main: ./cmd/pushgw/
+    binary: n9e-pushgw
    env:
      - CGO_ENABLED=0
    goos:
@@ -61,7 +73,8 @@ archives:
    builds:
      - build
      - build-cli
-      - build-edge
+      - build-alert
+      - build-pushgw
    format: tar.gz
    format_overrides:
      - goos: windows
@@ -71,6 +84,7 @@ archives:
    files:
      - docker/*
      - etc/*
+      - pub/*
      - integrations/*
      - cli/*
      - n9e.sql
@@ -90,6 +104,7 @@ dockers:
      - build
    dockerfile: docker/Dockerfile.goreleaser
    extra_files:
+      - pub
      - etc
      - integrations
    use: buildx
@@ -103,6 +118,7 @@ dockers:
      - build
    dockerfile: docker/Dockerfile.goreleaser.arm64
    extra_files:
+      - pub
      - etc
      - integrations
    use: buildx
--- a/13
+++ b/13
@@ -1,4 +1,4 @@
-.PHONY: prebuild build
+.PHONY: prebuild start build

 ROOT:=$(shell pwd -P)
 GIT_COMMIT:=$(shell git --work-tree ${ROOT}  rev-parse 'HEAD^{commit}')
@@ -6,19 +6,16 @@ _GIT_VERSION:=$(shell git --work-tree ${ROOT} describe --tags --abbrev=14 "${GIT
 TAG=$(shell echo "${_GIT_VERSION}" |  awk -F"-" '{print $$1}')
 RELEASE_VERSION:="$(TAG)-$(GIT_COMMIT)"

-all: prebuild build
-
 prebuild:
 	echo "begin download and embed the front-end file..."
 	sh fe.sh
 	echo "front-end file download and embedding completed."

+all: build
+
 build:
 	go build -ldflags "-w -s -X github.com/ccfos/nightingale/v6/pkg/version.Version=$(RELEASE_VERSION)" -o n9e ./cmd/center/main.go

-build-edge:
-	go build -ldflags "-w -s -X github.com/ccfos/nightingale/v6/pkg/version.Version=$(RELEASE_VERSION)" -o n9e-edge ./cmd/edge/
-
 build-alert:
 	go build -ldflags "-w -s -X github.com/ccfos/nightingale/v6/pkg/version.Version=$(RELEASE_VERSION)" -o n9e-alert ./cmd/alert/main.go

@@ -31,10 +28,10 @@ build-cli:
 run:
 	nohup ./n9e > n9e.log 2>&1 &

-run-alert:
+run_alert:
 	nohup ./n9e-alert > n9e-alert.log 2>&1 &

-run-pushgw:
+run_pushgw:
 	nohup ./n9e-pushgw > n9e-pushgw.log 2>&1 &

 release:
--- a/README.md
+++ b/README.md
@@ -20,77 +20,36 @@
 <img alt="License" src="https://img.shields.io/badge/license-Apache--2.0-blue"/>
 </p>
 <p align="center">
-  An open-source cloud-native monitoring system that is <b>all-in-one</b> <br/>
-  <b>Out-of-the-box</b>, it integrates data collection, visualization, and monitoring alert <br/>
-  We recommend upgrading your <b>Prometheus + AlertManager + Grafana</b> combination to Nightingale!
+  告警管理专家，一体化开源观测平台！
 </p>

-[English](./README.md) | [中文](./README_zh.md)
+[English](./README_en.md) | [中文](./README.md)

+## 资料

-## Highlighted Features
+- 文档：[https://flashcat.cloud/docs/](https://flashcat.cloud/docs/)
+- 论坛提问：[https://answer.flashcat.cloud/](https://answer.flashcat.cloud/)
+- 报Bug：[https://github.com/ccfos/nightingale/issues](https://github.com/ccfos/nightingale/issues/new?assignees=&labels=kind%2Fbug&projects=&template=bug_report.yml)
+- 商业版本：[企业版](https://mp.weixin.qq.com/s/FOwnnGPkRao2ZDV574EHrw) | [专业版](https://mp.weixin.qq.com/s/uM2a8QUDJEYwdBpjkbQDxA) 感兴趣请 [联系我们交流试用](https://flashcat.cloud/contact/)

- **Out-of-the-box**
-  - Supports multiple deployment methods such as **Docker, Helm Chart, and cloud services**, integrates data collection, monitoring, and alerting into one system, and comes with various monitoring dashboards, quick views, and alert rule templates. **It greatly reduces the construction cost, learning cost, and usage cost of cloud-native monitoring systems**.
- **Professional Alerting**
-  - Provides visual alert configuration and management, supports various alert rules, offers the ability to configure silence and subscription rules, supports multiple alert delivery channels, and has features such as alert self-healing and event management.
- **Cloud-Native**
-  - Quickly builds an enterprise-level cloud-native monitoring system through a turnkey approach, supports multiple collectors such as [Categraf](https://github.com/flashcatcloud/categraf), Telegraf, and Grafana-agent, supports multiple data sources such as Prometheus, VictoriaMetrics, M3DB, ElasticSearch, and Jaeger, and is compatible with importing Grafana dashboards. **It seamlessly integrates with the cloud-native ecosystem**.
- **High Performance and High Availability**
-  - Due to the multi-data-source management engine of Nightingale and its excellent architecture design, and utilizing a high-performance time-series database, it can handle data collection, storage, and alert analysis scenarios with billions of time-series data, saving a lot of costs.
-  - Nightingale components can be horizontally scaled with no single point of failure. It has been deployed in thousands of enterprises and tested in harsh production practices. Many leading Internet companies have used Nightingale for cluster machines with hundreds of nodes, processing billions of time-series data.
- **Flexible Extension and Centralized Management**
-  - Nightingale can be deployed on a 1-core 1G cloud host, deployed in a cluster of hundreds of machines, or run in Kubernetes. Time-series databases, alert engines, and other components can also be decentralized to various data centers and regions, balancing edge deployment with centralized management. **It solves the problem of data fragmentation and lack of unified views**.
+## 功能和特点

+- **统一接入各种时序库**：支持对接 Prometheus、VictoriaMetrics、Thanos、Mimir、M3DB 等多种时序库，实现统一告警管理
+- **专业告警能力**：内置支持多种告警规则，可以扩展支持所有通知媒介，支持告警屏蔽、告警抑制、告警自愈、告警事件管理
+- **无缝搭配 [FlashDuty](https://flashcat.cloud/product/flashcat-duty/)**：实现告警聚合收敛、认领、升级、排班、IM集成，确保告警处理不遗漏，减少打扰，更好协同
+- **支持所有常见采集器**：支持 categraf、telegraf、grafana-agent、datadog-agent、给类 exporter 作为采集器，没有什么数据是不能监控的
+- **统一的观测平台**：从 v6 版本开始，支持接入 ElasticSearch、Jaeger 数据源，逐步实现日志、链路、指标的一体化观测

-#### If you are using Prometheus and have one or more of the following requirement scenarios, it is recommended that you upgrade to Nightingale:
-
- Multiple systems such as Prometheus, Alertmanager, Grafana, etc. are fragmented and lack a unified view and cannot be used out of the box;
- The way to manage Prometheus and Alertmanager by modifying configuration files has a big learning curve and is difficult to collaborate;
- Too much data to scale-up your Prometheus cluster;
- Multiple Prometheus clusters running in production environments, which faced high management and usage costs;
-
-#### If you are using Zabbix and have the following scenarios, it is recommended that you upgrade to Nightingale:
-
- Monitoring too much data and wanting a better scalable solution;
- A high learning curve and a desire for better efficiency of collaborative use in a multi-person, multi-team model;
- Microservice and cloud-native architectures with variable monitoring data lifecycles and high monitoring data dimension bases, which are not easily adaptable to the Zabbix data model;
-
-
-#### If you are using [open-falcon](https://github.com/open-falcon/falcon-plus), we recommend you to upgrade to Nightingale：
- For more information about open-falcon and Nightingale, please refer to read [Ten features and trends of cloud-native monitoring](https://mp.weixin.qq.com/s?__biz=MzkzNjI5OTM5Nw==&mid=2247483738&idx=1&sn=e8bdbb974a2cd003c1abcc2b5405dd18&chksm=c2a19fb0f5d616a63185cd79277a79a6b80118ef2185890d0683d2bb20451bd9303c78d083c5#rd)。
-
-## Getting Started
-
-[https://n9e.github.io/](https://n9e.github.io/)
-
-## Screenshots
+## 产品示意图

 https://user-images.githubusercontent.com/792850/216888712-2565fcea-9df5-47bd-a49e-d60af9bd76e8.mp4

-## Architecture

-<img src="doc/img/arch-product.png" width="600">
+## 加入交流群

-Nightingale monitoring can receive monitoring data reported by various collectors (such as [Categraf](https://github.com/flashcatcloud/categraf) , telegraf, grafana-agent, Prometheus, etc.) and write them to various popular time-series databases (such as Prometheus, M3DB, VictoriaMetrics, Thanos, TDEngine, etc.). It provides configuration capabilities for alert rules, silence rules, and subscription rules, as well as the ability to view monitoring data. It also provides automatic alarm self-healing mechanisms (such as automatically calling back to a webhook address or executing a script after an alarm is triggered), and the ability to store and manage historical alarm events and view them in groups.
+欢迎加入 QQ 交流群，群号：479290895，也可以扫下方二维码加入微信交流群：

-If the performance of a standalone time-series database (such as Prometheus) has bottlenecks or poor disaster recovery, we recommend using [VictoriaMetrics](https://github.com/VictoriaMetrics/VictoriaMetrics). The VictoriaMetrics architecture is relatively simple, has excellent performance, and is easy to deploy and maintain. The architecture diagram is as shown above. For more detailed documentation on VictoriaMetrics, please refer to its [official website](https://victoriametrics.com/).
-
-**We welcome you to participate in the Nightingale open-source project and community in various ways, including but not limited to**：
- Adding and improving documentation => [n9e.github.io](https://n9e.github.io/)
- Sharing your best practices and experience in using Nightingale monitoring => [Article sharing]((https://n9e.github.io/docs/prologue/share/))
- Submitting product suggestions => [github issue](https://github.com/ccfos/nightingale/issues/new?assignees=&labels=kind%2Ffeature&template=enhancement.md)
- Submitting code to make Nightingale monitoring faster, more stable, and easier to use => [github pull request](https://github.com/didi/nightingale/pulls)
-
-
-**Respecting, recognizing, and recording the work of every contributor** is the first guiding principle of the Nightingale open-source community. We advocate effective questioning, which not only respects the developer's time but also contributes to the accumulation of knowledge in the entire community
- Before asking a question, please first refer to the [FAQ](https://www.gitlink.org.cn/ccfos/nightingale/wiki/faq) 
- We use [GitHub Discussions](https://github.com/ccfos/nightingale/discussions) as the communication forum. You can search and ask questions here.
- We also recommend that you join ours [Slack channel](https://n9e-talk.slack.com/) to exchange experiences with other Nightingale users.
-
-
-## Who is using Nightingale
-You can register your usage and share your experience by posting on **[Who is Using Nightingale](https://github.com/ccfos/nightingale/issues/897)**.
+<img src="doc/img/wecom.png" width="240">

 ## Stargazers over time
 [![Stargazers over time](https://starchart.cc/ccfos/nightingale.svg)](https://starchart.cc/ccfos/nightingale)
@@ -101,4 +60,9 @@ You can register your usage and share your experience by posting on **[Who is Us
 </a>

 ## License
-[Apache License V2.0](https://github.com/didi/nightingale/blob/main/LICENSE)
+[Apache License V2.0](https://github.com/didi/nightingale/blob/main/LICENSE)
+
+## 社区管理
+
+[夜莺开源项目和社区治理架构（草案）](./doc/community-governance.md)
+
--- a/README_en.md
+++ b/README_en.md
@@ -0,0 +1,104 @@
+<p align="center">
+  <a href="https://github.com/ccfos/nightingale">
+    <img src="doc/img/nightingale_logo_h.png" alt="nightingale - cloud native monitoring" width="240" /></a>
+</p>
+
+<p align="center">
+<img alt="GitHub latest release" src="https://img.shields.io/github/v/release/ccfos/nightingale"/>
+<a href="https://n9e.github.io">
+  <img alt="Docs" src="https://img.shields.io/badge/docs-get%20started-brightgreen"/></a>
+<a href="https://hub.docker.com/u/flashcatcloud">
+  <img alt="Docker pulls" src="https://img.shields.io/docker/pulls/flashcatcloud/nightingale"/></a>
+<img alt="GitHub Repo stars" src="https://img.shields.io/github/stars/ccfos/nightingale">
+<img alt="GitHub Repo issues" src="https://img.shields.io/github/issues/ccfos/nightingale">
+<img alt="GitHub Repo issues closed" src="https://img.shields.io/github/issues-closed/ccfos/nightingale">
+<img alt="GitHub forks" src="https://img.shields.io/github/forks/ccfos/nightingale">
+<a href="https://github.com/ccfos/nightingale/graphs/contributors">
+  <img alt="GitHub contributors" src="https://img.shields.io/github/contributors-anon/ccfos/nightingale"/></a>
+<a href="https://n9e-talk.slack.com/">
+  <img alt="GitHub contributors" src="https://img.shields.io/badge/join%20slack-%23n9e-brightgreen.svg"/></a>
+<img alt="License" src="https://img.shields.io/badge/license-Apache--2.0-blue"/>
+</p>
+<p align="center">
+  An open-source cloud-native monitoring system that is <b>all-in-one</b> <br/>
+  <b>Out-of-the-box</b>, it integrates data collection, visualization, and monitoring alert <br/>
+  We recommend upgrading your <b>Prometheus + AlertManager + Grafana</b> combination to Nightingale!
+</p>
+
+[English](./README.md) | [中文](./README_ZH.md)
+
+
+## Highlighted Features
+
+- **Out-of-the-box**
+  - Supports multiple deployment methods such as **Docker, Helm Chart, and cloud services**, integrates data collection, monitoring, and alerting into one system, and comes with various monitoring dashboards, quick views, and alert rule templates. **It greatly reduces the construction cost, learning cost, and usage cost of cloud-native monitoring systems**.
+- **Professional Alerting**
+  - Provides visual alert configuration and management, supports various alert rules, offers the ability to configure silence and subscription rules, supports multiple alert delivery channels, and has features such as alert self-healing and event management.
+- **Cloud-Native**
+  - Quickly builds an enterprise-level cloud-native monitoring system through a turnkey approach, supports multiple collectors such as [Categraf](https://github.com/flashcatcloud/categraf), Telegraf, and Grafana-agent, supports multiple data sources such as Prometheus, VictoriaMetrics, M3DB, ElasticSearch, and Jaeger, and is compatible with importing Grafana dashboards. **It seamlessly integrates with the cloud-native ecosystem**.
+- **High Performance and High Availability**
+  - Due to the multi-data-source management engine of Nightingale and its excellent architecture design, and utilizing a high-performance time-series database, it can handle data collection, storage, and alert analysis scenarios with billions of time-series data, saving a lot of costs.
+  - Nightingale components can be horizontally scaled with no single point of failure. It has been deployed in thousands of enterprises and tested in harsh production practices. Many leading Internet companies have used Nightingale for cluster machines with hundreds of nodes, processing billions of time-series data.
+- **Flexible Extension and Centralized Management**
+  - Nightingale can be deployed on a 1-core 1G cloud host, deployed in a cluster of hundreds of machines, or run in Kubernetes. Time-series databases, alert engines, and other components can also be decentralized to various data centers and regions, balancing edge deployment with centralized management. **It solves the problem of data fragmentation and lack of unified views**.
+
+
+#### If you are using Prometheus and have one or more of the following requirement scenarios, it is recommended that you upgrade to Nightingale:
+
+- Multiple systems such as Prometheus, Alertmanager, Grafana, etc. are fragmented and lack a unified view and cannot be used out of the box;
+- The way to manage Prometheus and Alertmanager by modifying configuration files has a big learning curve and is difficult to collaborate;
+- Too much data to scale-up your Prometheus cluster;
+- Multiple Prometheus clusters running in production environments, which faced high management and usage costs;
+
+#### If you are using Zabbix and have the following scenarios, it is recommended that you upgrade to Nightingale:
+
+- Monitoring too much data and wanting a better scalable solution;
+- A high learning curve and a desire for better efficiency of collaborative use in a multi-person, multi-team model;
+- Microservice and cloud-native architectures with variable monitoring data lifecycles and high monitoring data dimension bases, which are not easily adaptable to the Zabbix data model;
+
+
+#### If you are using [open-falcon](https://github.com/open-falcon/falcon-plus), we recommend you to upgrade to Nightingale：
+- For more information about open-falcon and Nightingale, please refer to read [Ten features and trends of cloud-native monitoring](https://mp.weixin.qq.com/s?__biz=MzkzNjI5OTM5Nw==&mid=2247483738&idx=1&sn=e8bdbb974a2cd003c1abcc2b5405dd18&chksm=c2a19fb0f5d616a63185cd79277a79a6b80118ef2185890d0683d2bb20451bd9303c78d083c5#rd)。
+
+## Getting Started
+
+[English Doc](https://n9e.github.io/) |  [中文文档](http://n9e.flashcat.cloud/)
+
+## Screenshots
+
+https://user-images.githubusercontent.com/792850/216888712-2565fcea-9df5-47bd-a49e-d60af9bd76e8.mp4
+
+## Architecture
+
+<img src="doc/img/arch-product.png" width="600">
+
+Nightingale monitoring can receive monitoring data reported by various collectors (such as [Categraf](https://github.com/flashcatcloud/categraf) , telegraf, grafana-agent, Prometheus, etc.) and write them to various popular time-series databases (such as Prometheus, M3DB, VictoriaMetrics, Thanos, TDEngine, etc.). It provides configuration capabilities for alert rules, silence rules, and subscription rules, as well as the ability to view monitoring data. It also provides automatic alarm self-healing mechanisms (such as automatically calling back to a webhook address or executing a script after an alarm is triggered), and the ability to store and manage historical alarm events and view them in groups.
+
+If the performance of a standalone time-series database (such as Prometheus) has bottlenecks or poor disaster recovery, we recommend using [VictoriaMetrics](https://github.com/VictoriaMetrics/VictoriaMetrics). The VictoriaMetrics architecture is relatively simple, has excellent performance, and is easy to deploy and maintain. The architecture diagram is as shown above. For more detailed documentation on VictoriaMetrics, please refer to its [official website](https://victoriametrics.com/).
+
+**We welcome you to participate in the Nightingale open-source project and community in various ways, including but not limited to**：
+- Adding and improving documentation => [n9e.github.io](https://n9e.github.io/)
+- Sharing your best practices and experience in using Nightingale monitoring => [Article sharing]((https://n9e.github.io/docs/prologue/share/))
+- Submitting product suggestions => [github issue](https://github.com/ccfos/nightingale/issues/new?assignees=&labels=kind%2Ffeature&template=enhancement.md)
+- Submitting code to make Nightingale monitoring faster, more stable, and easier to use => [github pull request](https://github.com/didi/nightingale/pulls)
+
+
+**Respecting, recognizing, and recording the work of every contributor** is the first guiding principle of the Nightingale open-source community. We advocate effective questioning, which not only respects the developer's time but also contributes to the accumulation of knowledge in the entire community
+- Before asking a question, please first refer to the [FAQ](https://www.gitlink.org.cn/ccfos/nightingale/wiki/faq) 
+- We use [GitHub Discussions](https://github.com/ccfos/nightingale/discussions) as the communication forum. You can search and ask questions here.
+- We also recommend that you join ours [Slack channel](https://n9e-talk.slack.com/) to exchange experiences with other Nightingale users.
+
+
+## Who is using Nightingale
+You can register your usage and share your experience by posting on **[Who is Using Nightingale](https://github.com/ccfos/nightingale/issues/897)**.
+
+## Stargazers over time
+[![Stargazers over time](https://starchart.cc/ccfos/nightingale.svg)](https://starchart.cc/ccfos/nightingale)
+
+## Contributors
+<a href="https://github.com/ccfos/nightingale/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=ccfos/nightingale" />
+</a>
+
+## License
+[Apache License V2.0](https://github.com/didi/nightingale/blob/main/LICENSE)
--- a/README_zh.md
+++ b/README_zh.md
@@ -1,74 +0,0 @@
-<p align="center">
-  <a href="https://github.com/ccfos/nightingale">
-    <img src="doc/img/nightingale_logo_h.png" alt="nightingale - cloud native monitoring" width="240" /></a>
-</p>
-
-<p align="center">
-<a href="https://flashcat.cloud/docs/">
-  <img alt="Docs" src="https://img.shields.io/badge/docs-get%20started-brightgreen"/></a>
-<a href="https://hub.docker.com/u/flashcatcloud">
-  <img alt="Docker pulls" src="https://img.shields.io/docker/pulls/flashcatcloud/nightingale"/></a>
-<a href="https://github.com/ccfos/nightingale/graphs/contributors">
-  <img alt="GitHub contributors" src="https://img.shields.io/github/contributors-anon/ccfos/nightingale"/></a>
-<img alt="GitHub Repo stars" src="https://img.shields.io/github/stars/ccfos/nightingale">
-<br/><img alt="GitHub Repo issues" src="https://img.shields.io/github/issues/ccfos/nightingale">
-<img alt="GitHub Repo issues closed" src="https://img.shields.io/github/issues-closed/ccfos/nightingale">
-<img alt="GitHub forks" src="https://img.shields.io/github/forks/ccfos/nightingale">
-<img alt="GitHub latest release" src="https://img.shields.io/github/v/release/ccfos/nightingale"/>
-<img alt="License" src="https://img.shields.io/badge/license-Apache--2.0-blue"/>
-<a href="https://n9e-talk.slack.com/">
-  <img alt="GitHub contributors" src="https://img.shields.io/badge/join%20slack-%23n9e-brightgreen.svg"/></a>
-</p>
-
-<p align="center">
-  告警管理专家，一体化的开源可观测平台
-</p>
-
-[English](./README.md) | [中文](./README_zh.md)
-
-夜莺Nightingale是中国计算机学会托管的开源云原生可观测工具，最早由滴滴于 2020 年孵化并开源，并于 2022 年正式捐赠予中国计算机学会。夜莺采用 All-in-One 的设计理念，集数据采集、可视化、监控告警、数据分析于一体，与云原生生态紧密集成，融入了顶级互联网公司可观测性最佳实践，沉淀了众多社区专家经验，开箱即用。
-
-## 资料
-
- 文档：[flashcat.cloud/docs](https://flashcat.cloud/docs/)
- 提问：[answer.flashcat.cloud](https://answer.flashcat.cloud/)
- 报Bug：[github.com/ccfos/nightingale/issues](https://github.com/ccfos/nightingale/issues/new?assignees=&labels=kind%2Fbug&projects=&template=bug_report.yml)
-
-
-## 功能和特点
-
- 统一接入各种时序库：支持对接 Prometheus、VictoriaMetrics、Thanos、Mimir、M3DB 等多种时序库，实现统一告警管理
- 专业告警能力：内置支持多种告警规则，可以扩展支持所有通知媒介，支持告警屏蔽、告警抑制、告警自愈、告警事件管理
- 高性能可视化引擎：支持多种图表样式，内置众多Dashboard模版，也可导入Grafana模版，开箱即用，开源协议商业友好
- 无缝搭配 [Flashduty](https://flashcat.cloud/product/flashcat-duty/)：实现告警聚合收敛、认领、升级、排班、IM集成，确保告警处理不遗漏，减少打扰，更好协同
- 支持所有常见采集器：支持 [Categraf](https://flashcat.cloud/product/categraf)、telegraf、grafana-agent、datadog-agent、各种 exporter 作为采集器，没有什么数据是不能监控的
- 一体化观测平台：从 v6 版本开始，支持接入 ElasticSearch、Jaeger 数据源，实现日志、链路、指标多维度的统一可观测
-
-
-## 产品演示
-
-![演示](doc/img/n9e-screenshot-gif-v6.gif)
-
-## 部署架构
-
-![架构](doc/img/n9e-arch-latest.png)
-
-## 加入交流群
-
-欢迎加入 QQ 交流群，群号：479290895，QQ 群适合群友互助，夜莺研发人员通常不在群里。如果要报 bug 请到[这里](https://github.com/ccfos/nightingale/issues/new?assignees=&labels=kind%2Fbug&projects=&template=bug_report.yml)，提问到[这里](https://answer.flashcat.cloud/)。
-
-## Stargazers over time
-
-[![Stargazers over time](https://api.star-history.com/svg?repos=ccfos/nightingale&type=Date)](https://star-history.com/#ccfos/nightingale&Date)
-
-
-## Contributors
-<a href="https://github.com/ccfos/nightingale/graphs/contributors">
-  <img src="https://contrib.rocks/image?repo=ccfos/nightingale" />
-</a>
-
-## 社区治理
-[夜莺开源项目和社区治理架构（草案）](./doc/community-governance.md)
-
-## License
-[Apache License V2.0](https://github.com/didi/nightingale/blob/main/LICENSE)
--- a/alert/aconf/conf.go
+++ b/alert/aconf/conf.go
@@ -2,10 +2,11 @@ package aconf

 import (
 	"path"
+
+	"github.com/toolkits/pkg/runner"
 )

 type Alert struct {
-	Disable     bool
 	EngineDelay int64
 	Heartbeat   HeartbeatConfig
 	Alerting    Alerting
@@ -53,9 +54,9 @@ type Ibex struct {
 	Timeout       int64
 }

-func (a *Alert) PreCheck(configDir string) {
+func (a *Alert) PreCheck() {
 	if a.Alerting.TemplatesDir == "" {
-		a.Alerting.TemplatesDir = path.Join(configDir, "template")
+		a.Alerting.TemplatesDir = path.Join(runner.Cwd, "etc", "template")
 	}

 	if a.Alerting.NotifyConcurrency == 0 {
@@ -69,8 +70,4 @@ func (a *Alert) PreCheck(configDir string) {
 	if a.Heartbeat.EngineName == "" {
 		a.Heartbeat.EngineName = "default"
 	}
-
-	if a.EngineDelay == 0 {
-		a.EngineDelay = 30
-	}
 }
--- a/alert/alert.go
+++ b/alert/alert.go
@@ -15,7 +15,6 @@ import (
 	"github.com/ccfos/nightingale/v6/alert/router"
 	"github.com/ccfos/nightingale/v6/alert/sender"
 	"github.com/ccfos/nightingale/v6/conf"
-	"github.com/ccfos/nightingale/v6/dumper"
 	"github.com/ccfos/nightingale/v6/memsto"
 	"github.com/ccfos/nightingale/v6/models"
 	"github.com/ccfos/nightingale/v6/pkg/ctx"
@@ -24,7 +23,6 @@ import (
 	"github.com/ccfos/nightingale/v6/prom"
 	"github.com/ccfos/nightingale/v6/pushgw/pconf"
 	"github.com/ccfos/nightingale/v6/pushgw/writer"
-	"github.com/ccfos/nightingale/v6/tdengine"
 )

 func Initialize(configDir string, cryptoKey string) (func(), error) {
@@ -43,27 +41,22 @@ func Initialize(configDir string, cryptoKey string) (func(), error) {
 	syncStats := memsto.NewSyncStats()
 	alertStats := astats.NewSyncStats()

-	configCache := memsto.NewConfigCache(ctx, syncStats, nil, "")
 	targetCache := memsto.NewTargetCache(ctx, syncStats, nil)
 	busiGroupCache := memsto.NewBusiGroupCache(ctx, syncStats)
 	alertMuteCache := memsto.NewAlertMuteCache(ctx, syncStats)
 	alertRuleCache := memsto.NewAlertRuleCache(ctx, syncStats)
-	notifyConfigCache := memsto.NewNotifyConfigCache(ctx, configCache)
+	notifyConfigCache := memsto.NewNotifyConfigCache(ctx)
 	dsCache := memsto.NewDatasourceCache(ctx, syncStats)
-	userCache := memsto.NewUserCache(ctx, syncStats)
-	userGroupCache := memsto.NewUserGroupCache(ctx, syncStats)

 	promClients := prom.NewPromClient(ctx, config.Alert.Heartbeat)
-	tdengineClients := tdengine.NewTdengineClient(ctx, config.Alert.Heartbeat)

 	externalProcessors := process.NewExternalProcessors()

-	Start(config.Alert, config.Pushgw, syncStats, alertStats, externalProcessors, targetCache, busiGroupCache, alertMuteCache, alertRuleCache, notifyConfigCache, dsCache, ctx, promClients, tdengineClients, userCache, userGroupCache)
+	Start(config.Alert, config.Pushgw, syncStats, alertStats, externalProcessors, targetCache, busiGroupCache, alertMuteCache, alertRuleCache, notifyConfigCache, dsCache, ctx, promClients)

 	r := httpx.GinEngine(config.Global.RunMode, config.HTTP)
 	rt := router.New(config.HTTP, config.Alert, alertMuteCache, targetCache, busiGroupCache, alertStats, ctx, externalProcessors)
 	rt.Config(r)
-	dumper.ConfigRouter(r)

 	httpClean := httpx.Init(config.HTTP, r)

@@ -74,8 +67,9 @@ func Initialize(configDir string, cryptoKey string) (func(), error) {
 }

 func Start(alertc aconf.Alert, pushgwc pconf.Pushgw, syncStats *memsto.Stats, alertStats *astats.Stats, externalProcessors *process.ExternalProcessorsType, targetCache *memsto.TargetCacheType, busiGroupCache *memsto.BusiGroupCacheType,
-	alertMuteCache *memsto.AlertMuteCacheType, alertRuleCache *memsto.AlertRuleCacheType, notifyConfigCache *memsto.NotifyConfigCacheType, datasourceCache *memsto.DatasourceCacheType, ctx *ctx.Context,
-	promClients *prom.PromClientMap, tdendgineClients *tdengine.TdengineClientMap, userCache *memsto.UserCacheType, userGroupCache *memsto.UserGroupCacheType) {
+	alertMuteCache *memsto.AlertMuteCacheType, alertRuleCache *memsto.AlertRuleCacheType, notifyConfigCache *memsto.NotifyConfigCacheType, datasourceCache *memsto.DatasourceCacheType, ctx *ctx.Context, promClients *prom.PromClientMap) {
+	userCache := memsto.NewUserCache(ctx, syncStats)
+	userGroupCache := memsto.NewUserGroupCache(ctx, syncStats)
 	alertSubscribeCache := memsto.NewAlertSubscribeCache(ctx, syncStats)
 	recordingRuleCache := memsto.NewRecordingRuleCache(ctx, syncStats)

@@ -86,14 +80,14 @@ func Start(alertc aconf.Alert, pushgwc pconf.Pushgw, syncStats *memsto.Stats, al
 	writers := writer.NewWriters(pushgwc)
 	record.NewScheduler(alertc, recordingRuleCache, promClients, writers, alertStats)

-	eval.NewScheduler(alertc, externalProcessors, alertRuleCache, targetCache, busiGroupCache, alertMuteCache, datasourceCache, promClients, tdendgineClients, naming, ctx, alertStats)
+	eval.NewScheduler(alertc, externalProcessors, alertRuleCache, targetCache, busiGroupCache, alertMuteCache, datasourceCache, promClients, naming, ctx, alertStats)

-	dp := dispatch.NewDispatch(alertRuleCache, userCache, userGroupCache, alertSubscribeCache, targetCache, notifyConfigCache, alertc.Alerting, ctx, alertStats)
+	dp := dispatch.NewDispatch(alertRuleCache, userCache, userGroupCache, alertSubscribeCache, targetCache, notifyConfigCache, alertc.Alerting, ctx)
 	consumer := dispatch.NewConsumer(alertc.Alerting, ctx, dp)

 	go dp.ReloadTpls()
 	go consumer.LoopConsume()

 	go queue.ReportQueueSize(alertStats)
-	go sender.InitEmailSender(notifyConfigCache.GetSMTP())
+	go sender.StartEmailSender(notifyConfigCache.GetSMTP()) // todo
 }
--- a/alert/astats/stats.go
+++ b/alert/astats/stats.go
@@ -10,52 +10,22 @@ const (
 )

 type Stats struct {
-	AlertNotifyTotal            *prometheus.CounterVec
-	AlertNotifyErrorTotal       *prometheus.CounterVec
-	CounterAlertsTotal          *prometheus.CounterVec
-	GaugeAlertQueueSize         prometheus.Gauge
-	CounterRuleEval             *prometheus.CounterVec
-	CounterQueryDataErrorTotal  *prometheus.CounterVec
-	CounterRecordEval           *prometheus.CounterVec
-	CounterRecordEvalErrorTotal *prometheus.CounterVec
-	CounterMuteTotal            *prometheus.CounterVec
+	CounterSampleTotal   *prometheus.CounterVec
+	CounterAlertsTotal   *prometheus.CounterVec
+	GaugeAlertQueueSize  prometheus.Gauge
+	GaugeSampleQueueSize *prometheus.GaugeVec
+	RequestDuration      *prometheus.HistogramVec
+	ForwardDuration      *prometheus.HistogramVec
 }

 func NewSyncStats() *Stats {
-	CounterRuleEval := prometheus.NewCounterVec(prometheus.CounterOpts{
+	// 从各个接收接口接收到的监控数据总量
+	CounterSampleTotal := prometheus.NewCounterVec(prometheus.CounterOpts{
 		Namespace: namespace,
 		Subsystem: subsystem,
-		Name:      "rule_eval_total",
-		Help:      "Number of rule eval.",
-	}, []string{})
-
-	CounterRecordEval := prometheus.NewCounterVec(prometheus.CounterOpts{
-		Namespace: namespace,
-		Subsystem: subsystem,
-		Name:      "record_eval_total",
-		Help:      "Number of record eval.",
-	}, []string{})
-
-	CounterRecordEvalErrorTotal := prometheus.NewCounterVec(prometheus.CounterOpts{
-		Namespace: namespace,
-		Subsystem: subsystem,
-		Name:      "record_eval_error_total",
-		Help:      "Number of record eval error.",
-	}, []string{})
-
-	AlertNotifyTotal := prometheus.NewCounterVec(prometheus.CounterOpts{
-		Namespace: namespace,
-		Subsystem: subsystem,
-		Name:      "alert_notify_total",
-		Help:      "Number of send msg.",
-	}, []string{"channel"})
-
-	AlertNotifyErrorTotal := prometheus.NewCounterVec(prometheus.CounterOpts{
-		Namespace: namespace,
-		Subsystem: subsystem,
-		Name:      "alert_notify_error_total",
-		Help:      "Number of send msg.",
-	}, []string{"channel"})
+		Name:      "samples_received_total",
+		Help:      "Total number samples received.",
+	}, []string{"cluster", "channel"})

 	// 产生的告警总量
 	CounterAlertsTotal := prometheus.NewCounterVec(prometheus.CounterOpts{
@@ -63,7 +33,7 @@ func NewSyncStats() *Stats {
 		Subsystem: subsystem,
 		Name:      "alerts_total",
 		Help:      "Total number alert events.",
-	}, []string{"cluster", "type", "busi_group"})
+	}, []string{"cluster"})

 	// 内存中的告警事件队列的长度
 	GaugeAlertQueueSize := prometheus.NewGauge(prometheus.GaugeOpts{
@@ -73,41 +43,51 @@ func NewSyncStats() *Stats {
 		Help:      "The size of alert queue.",
 	})

-	CounterQueryDataErrorTotal := prometheus.NewCounterVec(prometheus.CounterOpts{
+	// 数据转发队列，各个队列的长度
+	GaugeSampleQueueSize := prometheus.NewGaugeVec(prometheus.GaugeOpts{
 		Namespace: namespace,
 		Subsystem: subsystem,
-		Name:      "query_data_error_total",
-		Help:      "Number of query data error.",
-	}, []string{"datasource"})
+		Name:      "sample_queue_size",
+		Help:      "The size of sample queue.",
+	}, []string{"cluster", "channel_number"})

-	CounterMuteTotal := prometheus.NewCounterVec(prometheus.CounterOpts{
-		Namespace: namespace,
-		Subsystem: subsystem,
-		Name:      "mute_total",
-		Help:      "Number of mute.",
-	}, []string{"group"})
+	// 一些重要的请求，比如接收数据的请求，应该统计一下延迟情况
+	RequestDuration := prometheus.NewHistogramVec(
+		prometheus.HistogramOpts{
+			Namespace: namespace,
+			Subsystem: subsystem,
+			Buckets:   []float64{.01, .1, 1},
+			Name:      "http_request_duration_seconds",
+			Help:      "HTTP request latencies in seconds.",
+		}, []string{"code", "path", "method"},
+	)
+
+	// 发往后端TSDB，延迟如何
+	ForwardDuration := prometheus.NewHistogramVec(
+		prometheus.HistogramOpts{
+			Namespace: namespace,
+			Subsystem: subsystem,
+			Buckets:   []float64{.1, 1, 10},
+			Name:      "forward_duration_seconds",
+			Help:      "Forward samples to TSDB. latencies in seconds.",
+		}, []string{"cluster", "channel_number"},
+	)

 	prometheus.MustRegister(
+		CounterSampleTotal,
 		CounterAlertsTotal,
 		GaugeAlertQueueSize,
-		AlertNotifyTotal,
-		AlertNotifyErrorTotal,
-		CounterRuleEval,
-		CounterQueryDataErrorTotal,
-		CounterRecordEval,
-		CounterRecordEvalErrorTotal,
-		CounterMuteTotal,
+		GaugeSampleQueueSize,
+		RequestDuration,
+		ForwardDuration,
 	)

 	return &Stats{
-		CounterAlertsTotal:          CounterAlertsTotal,
-		GaugeAlertQueueSize:         GaugeAlertQueueSize,
-		AlertNotifyTotal:            AlertNotifyTotal,
-		AlertNotifyErrorTotal:       AlertNotifyErrorTotal,
-		CounterRuleEval:             CounterRuleEval,
-		CounterQueryDataErrorTotal:  CounterQueryDataErrorTotal,
-		CounterRecordEval:           CounterRecordEval,
-		CounterRecordEvalErrorTotal: CounterRecordEvalErrorTotal,
-		CounterMuteTotal:            CounterMuteTotal,
+		CounterSampleTotal:   CounterSampleTotal,
+		CounterAlertsTotal:   CounterAlertsTotal,
+		GaugeAlertQueueSize:  GaugeAlertQueueSize,
+		GaugeSampleQueueSize: GaugeSampleQueueSize,
+		RequestDuration:      RequestDuration,
+		ForwardDuration:      ForwardDuration,
 	}
 }
--- a/alert/common/conv.go
+++ b/alert/common/conv.go
@@ -15,7 +15,6 @@ type AnomalyPoint struct {
 	Value     float64      `json:"value"`
 	Severity  int          `json:"severity"`
 	Triggered bool         `json:"triggered"`
-	Query     string       `json:"query"`
 }

 func NewAnomalyPoint(key string, labels map[string]string, ts int64, value float64, severity int) AnomalyPoint {
--- a/alert/common/key.go
+++ b/alert/common/key.go
@@ -22,14 +22,6 @@ func MatchTags(eventTagsMap map[string]string, itags []models.TagFilter) bool {
 	}
 	return true
 }
-func MatchGroupsName(groupName string, groupFilter []models.TagFilter) bool {
-	for _, filter := range groupFilter {
-		if !matchTag(groupName, filter) {
-			return false
-		}
-	}
-	return true
-}

 func matchTag(value string, filter models.TagFilter) bool {
 	switch filter.Func {
--- a/alert/dispatch/consume.go
+++ b/alert/dispatch/consume.go
@@ -61,13 +61,6 @@ func (e *Consumer) consume(events []interface{}, sema *semaphore.Semaphore) {
 func (e *Consumer) consumeOne(event *models.AlertCurEvent) {
 	LogEvent(event, "consume")

-	eventType := "alert"
-	if event.IsRecovered {
-		eventType = "recovery"
-	}
-
-	e.dispatch.astats.CounterAlertsTotal.WithLabelValues(event.Cluster, eventType, event.GroupName).Inc()
-
 	if err := event.ParseRule("rule_name"); err != nil {
 		event.RuleName = fmt.Sprintf("failed to parse rule name: %v", err)
 	}
@@ -90,16 +83,11 @@ func (e *Consumer) consumeOne(event *models.AlertCurEvent) {
 }

 func (e *Consumer) persist(event *models.AlertCurEvent) {
-	if event.Status != 0 {
-		return
-	}
-
 	if !e.ctx.IsCenter {
 		event.DB2FE()
-		var err error
-		event.Id, err = poster.PostByUrlsWithResp[int64](e.ctx, "/v1/n9e/event-persist", event)
+		err := poster.PostByUrls(e.ctx, "/v1/n9e/event-persist", event)
 		if err != nil {
-			logger.Errorf("event:%+v persist err:%v", event, err)
+			logger.Errorf("event%+v persist err:%v", event, err)
 		}
 		return
 	}
--- a/alert/dispatch/dispatch.go
+++ b/alert/dispatch/dispatch.go
@@ -9,7 +9,6 @@ import (
 	"time"

 	"github.com/ccfos/nightingale/v6/alert/aconf"
-	"github.com/ccfos/nightingale/v6/alert/astats"
 	"github.com/ccfos/nightingale/v6/alert/common"
 	"github.com/ccfos/nightingale/v6/alert/sender"
 	"github.com/ccfos/nightingale/v6/memsto"
@@ -29,13 +28,11 @@ type Dispatch struct {

 	alerting aconf.Alerting

-	Senders          map[string]sender.Sender
-	tpls             map[string]*template.Template
-	ExtraSenders     map[string]sender.Sender
-	BeforeSenderHook func(*models.AlertCurEvent) bool
+	senders      map[string]sender.Sender
+	tpls         map[string]*template.Template
+	ExtraSenders map[string]sender.Sender

-	ctx    *ctx.Context
-	astats *astats.Stats
+	ctx *ctx.Context

 	RwLock sync.RWMutex
 }
@@ -43,7 +40,7 @@ type Dispatch struct {
 // 创建一个 Notify 实例
 func NewDispatch(alertRuleCache *memsto.AlertRuleCacheType, userCache *memsto.UserCacheType, userGroupCache *memsto.UserGroupCacheType,
 	alertSubscribeCache *memsto.AlertSubscribeCacheType, targetCache *memsto.TargetCacheType, notifyConfigCache *memsto.NotifyConfigCacheType,
-	alerting aconf.Alerting, ctx *ctx.Context, astats *astats.Stats) *Dispatch {
+	alerting aconf.Alerting, ctx *ctx.Context) *Dispatch {
 	notify := &Dispatch{
 		alertRuleCache:      alertRuleCache,
 		userCache:           userCache,
@@ -54,13 +51,11 @@ func NewDispatch(alertRuleCache *memsto.AlertRuleCacheType, userCache *memsto.Us

 		alerting: alerting,

-		Senders:          make(map[string]sender.Sender),
-		tpls:             make(map[string]*template.Template),
-		ExtraSenders:     make(map[string]sender.Sender),
-		BeforeSenderHook: func(*models.AlertCurEvent) bool { return true },
+		senders:      make(map[string]sender.Sender),
+		tpls:         make(map[string]*template.Template),
+		ExtraSenders: make(map[string]sender.Sender),

-		ctx:    ctx,
-		astats: astats,
+		ctx: ctx,
 	}
 	return notify
 }
@@ -68,7 +63,7 @@ func NewDispatch(alertRuleCache *memsto.AlertRuleCacheType, userCache *memsto.Us
 func (e *Dispatch) ReloadTpls() error {
 	err := e.relaodTpls()
 	if err != nil {
-		logger.Errorf("failed to reload tpls: %v", err)
+		logger.Error("failed to reload tpls: %v", err)
 	}

 	duration := time.Duration(9000) * time.Millisecond
@@ -88,24 +83,23 @@ func (e *Dispatch) relaodTpls() error {
 	smtp := e.notifyConfigCache.GetSMTP()

 	senders := map[string]sender.Sender{
-		models.Email:      sender.NewSender(models.Email, tmpTpls, smtp),
-		models.Dingtalk:   sender.NewSender(models.Dingtalk, tmpTpls),
-		models.Wecom:      sender.NewSender(models.Wecom, tmpTpls),
-		models.Feishu:     sender.NewSender(models.Feishu, tmpTpls),
-		models.Mm:         sender.NewSender(models.Mm, tmpTpls),
-		models.Telegram:   sender.NewSender(models.Telegram, tmpTpls),
-		models.FeishuCard: sender.NewSender(models.FeishuCard, tmpTpls),
+		models.Email:    sender.NewSender(models.Email, tmpTpls, smtp),
+		models.Dingtalk: sender.NewSender(models.Dingtalk, tmpTpls, smtp),
+		models.Wecom:    sender.NewSender(models.Wecom, tmpTpls, smtp),
+		models.Feishu:   sender.NewSender(models.Feishu, tmpTpls, smtp),
+		models.Mm:       sender.NewSender(models.Mm, tmpTpls, smtp),
+		models.Telegram: sender.NewSender(models.Telegram, tmpTpls, smtp),
 	}

 	e.RwLock.RLock()
-	for channelName, extraSender := range e.ExtraSenders {
-		senders[channelName] = extraSender
+	for channel, sender := range e.ExtraSenders {
+		senders[channel] = sender
 	}
 	e.RwLock.RUnlock()

 	e.RwLock.Lock()
 	e.tpls = tmpTpls
-	e.Senders = senders
+	e.senders = senders
 	e.RwLock.Unlock()
 	return nil
 }
@@ -146,7 +140,7 @@ func (e *Dispatch) HandleEventNotify(event *models.AlertCurEvent, isSubscribe bo
 	}

 	// 处理事件发送,这里用一个goroutine处理一个event的所有发送事件
-	go e.Send(rule, event, notifyTarget)
+	go e.Send(rule, event, notifyTarget, isSubscribe)

 	// 如果是不是订阅规则出现的event, 则需要处理订阅规则的event
 	if !isSubscribe {
@@ -173,73 +167,45 @@ func (e *Dispatch) handleSubs(event *models.AlertCurEvent) {

 // handleSub 处理订阅规则的event,注意这里event要使用值传递,因为后面会修改event的状态
 func (e *Dispatch) handleSub(sub *models.AlertSubscribe, event models.AlertCurEvent) {
-	if sub.IsDisabled() {
+	if sub.IsDisabled() || !sub.MatchCluster(event.DatasourceId) {
 		return
 	}
-
-	if !sub.MatchCluster(event.DatasourceId) {
-		return
-	}
-
-	if !sub.MatchProd(event.RuleProd) {
-		return
-	}
-
 	if !common.MatchTags(event.TagsMap, sub.ITags) {
 		return
 	}
-	// event BusiGroups filter
-	if !common.MatchGroupsName(event.GroupName, sub.IBusiGroups) {
-		return
-	}
 	if sub.ForDuration > (event.TriggerTime - event.FirstTriggerTime) {
 		return
 	}
-
-	if len(sub.SeveritiesJson) != 0 {
-		match := false
-		for _, s := range sub.SeveritiesJson {
-			if s == event.Severity || s == 0 {
-				match = true
-				break
-			}
-		}
-		if !match {
-			return
-		}
-	}
-
 	sub.ModifyEvent(&event)
 	LogEvent(&event, "subscribe")
-
-	event.SubRuleId = sub.Id
 	e.HandleEventNotify(&event, true)
 }

-func (e *Dispatch) Send(rule *models.AlertRule, event *models.AlertCurEvent, notifyTarget *NotifyTarget) {
-	needSend := e.BeforeSenderHook(event)
-	if needSend {
-		for channel, uids := range notifyTarget.ToChannelUserMap() {
-			msgCtx := sender.BuildMessageContext(rule, []*models.AlertCurEvent{event}, uids, e.userCache, e.astats)
-			e.RwLock.RLock()
-			s := e.Senders[channel]
-			e.RwLock.RUnlock()
-			if s == nil {
-				logger.Debugf("no sender for channel: %s", channel)
-				continue
-			}
-			s.Send(msgCtx)
+func (e *Dispatch) Send(rule *models.AlertRule, event *models.AlertCurEvent, notifyTarget *NotifyTarget, isSubscribe bool) {
+	for channel, uids := range notifyTarget.ToChannelUserMap() {
+		ctx := sender.BuildMessageContext(rule, event, uids, e.userCache)
+		e.RwLock.RLock()
+		s := e.senders[channel]
+		e.RwLock.RUnlock()
+		if s == nil {
+			logger.Debugf("no sender for channel: %s", channel)
+			continue
 		}
+		logger.Debugf("send event: %s, channel: %s", event.Hash, channel)
+		for i := 0; i < len(ctx.Users); i++ {
+			logger.Debug("send event to user: ", ctx.Users[i])
+		}
+		s.Send(ctx)
 	}

 	// handle event callbacks
-	sender.SendCallbacks(e.ctx, notifyTarget.ToCallbackList(), event, e.targetCache, e.userCache, e.notifyConfigCache.GetIbex(), e.astats)
+	sender.SendCallbacks(e.ctx, notifyTarget.ToCallbackList(), event, e.targetCache, e.userCache, e.notifyConfigCache.GetIbex())

 	// handle global webhooks
-	sender.SendWebhooks(notifyTarget.ToWebhookList(), event, e.astats)
+	sender.SendWebhooks(notifyTarget.ToWebhookList(), event)

 	// handle plugin call
-	go sender.MayPluginNotify(e.genNoticeBytes(event), e.notifyConfigCache.GetNotifyScript(), e.astats)
+	go sender.MayPluginNotify(e.genNoticeBytes(event), e.notifyConfigCache.GetNotifyScript())
 }

 type Notice struct {
--- a/alert/eval/alert_rule.go
+++ b/alert/eval/alert_rule.go
@@ -12,8 +12,6 @@ import (
 	"github.com/ccfos/nightingale/v6/memsto"
 	"github.com/ccfos/nightingale/v6/pkg/ctx"
 	"github.com/ccfos/nightingale/v6/prom"
-	"github.com/ccfos/nightingale/v6/tdengine"
-
 	"github.com/toolkits/pkg/logger"
 )

@@ -31,8 +29,7 @@ type Scheduler struct {
 	alertMuteCache  *memsto.AlertMuteCacheType
 	datasourceCache *memsto.DatasourceCacheType

-	promClients     *prom.PromClientMap
-	tdengineClients *tdengine.TdengineClientMap
+	promClients *prom.PromClientMap

 	naming *naming.Naming

@@ -41,8 +38,8 @@ type Scheduler struct {
 }

 func NewScheduler(aconf aconf.Alert, externalProcessors *process.ExternalProcessorsType, arc *memsto.AlertRuleCacheType, targetCache *memsto.TargetCacheType,
-	busiGroupCache *memsto.BusiGroupCacheType, alertMuteCache *memsto.AlertMuteCacheType, datasourceCache *memsto.DatasourceCacheType,
-	promClients *prom.PromClientMap, tdengineClients *tdengine.TdengineClientMap, naming *naming.Naming, ctx *ctx.Context, stats *astats.Stats) *Scheduler {
+	busiGroupCache *memsto.BusiGroupCacheType, alertMuteCache *memsto.AlertMuteCacheType, datasourceCache *memsto.DatasourceCacheType, promClients *prom.PromClientMap, naming *naming.Naming,
+	ctx *ctx.Context, stats *astats.Stats) *Scheduler {
 	scheduler := &Scheduler{
 		aconf:      aconf,
 		alertRules: make(map[string]*AlertRuleWorker),
@@ -55,9 +52,8 @@ func NewScheduler(aconf aconf.Alert, externalProcessors *process.ExternalProcess
 		alertMuteCache:  alertMuteCache,
 		datasourceCache: datasourceCache,

-		promClients:     promClients,
-		tdengineClients: tdengineClients,
-		naming:          naming,
+		promClients: promClients,
+		naming:      naming,

 		ctx:   ctx,
 		stats: stats,
@@ -89,11 +85,8 @@ func (s *Scheduler) syncAlertRules() {
 		if rule == nil {
 			continue
 		}
-
-		ruleType := rule.GetRuleType()
-		if rule.IsPrometheusRule() || rule.IsLokiRule() || rule.IsTdengineRule() {
+		if rule.IsPrometheusRule() {
 			datasourceIds := s.promClients.Hit(rule.DatasourceIdsJson)
-			datasourceIds = append(datasourceIds, s.tdengineClients.Hit(rule.DatasourceIdsJson)...)
 			for _, dsId := range datasourceIds {
 				if !naming.DatasourceHashRing.IsHit(dsId, fmt.Sprintf("%d", rule.Id), s.aconf.Heartbeat.Endpoint) {
 					continue
@@ -104,18 +97,13 @@ func (s *Scheduler) syncAlertRules() {
 					continue
 				}

-				if ds.PluginType != ruleType {
-					logger.Debugf("datasource %d category is %s not %s", dsId, ds.PluginType, ruleType)
-					continue
-				}
-
 				if ds.Status != "enabled" {
 					logger.Debugf("datasource %d status is %s", dsId, ds.Status)
 					continue
 				}
-				processor := process.NewProcessor(rule, dsId, s.alertRuleCache, s.targetCache, s.busiGroupCache, s.alertMuteCache, s.datasourceCache, s.ctx, s.stats)
+				processor := process.NewProcessor(rule, dsId, s.alertRuleCache, s.targetCache, s.busiGroupCache, s.alertMuteCache, s.datasourceCache, s.promClients, s.ctx, s.stats)

-				alertRule := NewAlertRuleWorker(rule, dsId, processor, s.promClients, s.tdengineClients, s.ctx)
+				alertRule := NewAlertRuleWorker(rule, dsId, processor, s.promClients, s.ctx)
 				alertRuleWorkers[alertRule.Hash()] = alertRule
 			}
 		} else if rule.IsHostRule() && s.ctx.IsCenter {
@@ -123,8 +111,8 @@ func (s *Scheduler) syncAlertRules() {
 			if !naming.DatasourceHashRing.IsHit(naming.HostDatasource, fmt.Sprintf("%d", rule.Id), s.aconf.Heartbeat.Endpoint) {
 				continue
 			}
-			processor := process.NewProcessor(rule, 0, s.alertRuleCache, s.targetCache, s.busiGroupCache, s.alertMuteCache, s.datasourceCache, s.ctx, s.stats)
-			alertRule := NewAlertRuleWorker(rule, 0, processor, s.promClients, s.tdengineClients, s.ctx)
+			processor := process.NewProcessor(rule, 0, s.alertRuleCache, s.targetCache, s.busiGroupCache, s.alertMuteCache, s.datasourceCache, s.promClients, s.ctx, s.stats)
+			alertRule := NewAlertRuleWorker(rule, 0, processor, s.promClients, s.ctx)
 			alertRuleWorkers[alertRule.Hash()] = alertRule
 		} else {
 			// 如果 rule 不是通过 prometheus engine 来告警的，则创建为 externalRule
@@ -140,7 +128,7 @@ func (s *Scheduler) syncAlertRules() {
 					logger.Debugf("datasource %d status is %s", dsId, ds.Status)
 					continue
 				}
-				processor := process.NewProcessor(rule, dsId, s.alertRuleCache, s.targetCache, s.busiGroupCache, s.alertMuteCache, s.datasourceCache, s.ctx, s.stats)
+				processor := process.NewProcessor(rule, dsId, s.alertRuleCache, s.targetCache, s.busiGroupCache, s.alertMuteCache, s.datasourceCache, s.promClients, s.ctx, s.stats)
 				externalRuleWorkers[processor.Key()] = processor
 			}
 		}
--- a/alert/eval/eval.go
+++ b/alert/eval/eval.go
@@ -11,11 +11,8 @@ import (
 	"github.com/ccfos/nightingale/v6/alert/process"
 	"github.com/ccfos/nightingale/v6/models"
 	"github.com/ccfos/nightingale/v6/pkg/ctx"
-	"github.com/ccfos/nightingale/v6/pkg/hash"
-	"github.com/ccfos/nightingale/v6/pkg/parser"
 	promsdk "github.com/ccfos/nightingale/v6/pkg/prom"
 	"github.com/ccfos/nightingale/v6/prom"
-	"github.com/ccfos/nightingale/v6/tdengine"

 	"github.com/toolkits/pkg/logger"
 	"github.com/toolkits/pkg/str"
@@ -31,21 +28,19 @@ type AlertRuleWorker struct {

 	processor *process.Processor

-	promClients     *prom.PromClientMap
-	tdengineClients *tdengine.TdengineClientMap
-	ctx             *ctx.Context
+	promClients *prom.PromClientMap
+	ctx         *ctx.Context
 }

-func NewAlertRuleWorker(rule *models.AlertRule, datasourceId int64, processor *process.Processor, promClients *prom.PromClientMap, tdengineClients *tdengine.TdengineClientMap, ctx *ctx.Context) *AlertRuleWorker {
+func NewAlertRuleWorker(rule *models.AlertRule, datasourceId int64, processor *process.Processor, promClients *prom.PromClientMap, ctx *ctx.Context) *AlertRuleWorker {
 	arw := &AlertRuleWorker{
 		datasourceId: datasourceId,
 		quit:         make(chan struct{}),
 		rule:         rule,
 		processor:    processor,

-		promClients:     promClients,
-		tdengineClients: tdengineClients,
-		ctx:             ctx,
+		promClients: promClients,
+		ctx:         ctx,
 	}

 	return arw
@@ -74,16 +69,14 @@ func (arw *AlertRuleWorker) Start() {
 	if interval <= 0 {
 		interval = 10
 	}
-
-	ticker := time.NewTicker(time.Duration(interval) * time.Second)
 	go func() {
-		defer ticker.Stop()
 		for {
 			select {
 			case <-arw.quit:
 				return
-			case <-ticker.C:
+			default:
 				arw.Eval()
+				time.Sleep(time.Duration(interval) * time.Second)
 			}
 		}
 	}()
@@ -92,23 +85,17 @@ func (arw *AlertRuleWorker) Start() {
 func (arw *AlertRuleWorker) Eval() {
 	cachedRule := arw.rule
 	if cachedRule == nil {
-		// logger.Errorf("rule_eval:%s rule not found", arw.Key())
+		//logger.Errorf("rule_eval:%s rule not found", arw.Key())
 		return
 	}
-	arw.processor.Stats.CounterRuleEval.WithLabelValues().Inc()

 	typ := cachedRule.GetRuleType()
-	var anomalyPoints []common.AnomalyPoint
-	var recoverPoints []common.AnomalyPoint
+	var lst []common.AnomalyPoint
 	switch typ {
 	case models.PROMETHEUS:
-		anomalyPoints = arw.GetPromAnomalyPoint(cachedRule.RuleConfig)
+		lst = arw.GetPromAnomalyPoint(cachedRule.RuleConfig)
 	case models.HOST:
-		anomalyPoints = arw.GetHostAnomalyPoint(cachedRule.RuleConfig)
-	case models.TDENGINE:
-		anomalyPoints, recoverPoints = arw.GetTdengineAnomalyPoint(cachedRule, arw.processor.DatasourceId())
-	case models.LOKI:
-		anomalyPoints = arw.GetPromAnomalyPoint(cachedRule.RuleConfig)
+		lst = arw.GetHostAnomalyPoint(cachedRule.RuleConfig)
 	default:
 		return
 	}
@@ -118,11 +105,7 @@ func (arw *AlertRuleWorker) Eval() {
 		return
 	}

-	arw.processor.Handle(anomalyPoints, "inner", arw.inhibit)
-	for _, point := range recoverPoints {
-		str := fmt.Sprintf("%v", point.Value)
-		arw.processor.RecoverSingle(process.Hash(cachedRule.Id, arw.processor.DatasourceId(), point), point.Timestamp, &str)
-	}
+	arw.processor.Handle(lst, "inner", arw.inhibit)
 }

 func (arw *AlertRuleWorker) Stop() {
@@ -168,13 +151,11 @@ func (arw *AlertRuleWorker) GetPromAnomalyPoint(ruleConfig string) []common.Anom
 		value, warnings, err := readerClient.Query(context.Background(), promql, time.Now())
 		if err != nil {
 			logger.Errorf("rule_eval:%s promql:%s, error:%v", arw.Key(), promql, err)
-			arw.processor.Stats.CounterQueryDataErrorTotal.WithLabelValues(fmt.Sprintf("%d", arw.datasourceId)).Inc()
 			continue
 		}

 		if len(warnings) > 0 {
 			logger.Errorf("rule_eval:%s promql:%s, warnings:%v", arw.Key(), promql, warnings)
-			arw.processor.Stats.CounterQueryDataErrorTotal.WithLabelValues(fmt.Sprintf("%d", arw.datasourceId)).Inc()
 			continue
 		}

@@ -182,118 +163,12 @@ func (arw *AlertRuleWorker) GetPromAnomalyPoint(ruleConfig string) []common.Anom
 		points := common.ConvertAnomalyPoints(value)
 		for i := 0; i < len(points); i++ {
 			points[i].Severity = query.Severity
-			points[i].Query = promql
 		}
 		lst = append(lst, points...)
 	}
 	return lst
 }

-func (arw *AlertRuleWorker) GetTdengineAnomalyPoint(rule *models.AlertRule, dsId int64) ([]common.AnomalyPoint, []common.AnomalyPoint) {
-	// 获取查询和规则判断条件
-	points := []common.AnomalyPoint{}
-	recoverPoints := []common.AnomalyPoint{}
-	ruleConfig := strings.TrimSpace(rule.RuleConfig)
-	if ruleConfig == "" {
-		logger.Warningf("rule_eval:%d promql is blank", rule.Id)
-		return points, recoverPoints
-	}
-
-	var ruleQuery models.RuleQuery
-	err := json.Unmarshal([]byte(ruleConfig), &ruleQuery)
-	if err != nil {
-		logger.Warningf("rule_eval:%d promql parse error:%s", rule.Id, err.Error())
-		return points, recoverPoints
-	}
-
-	arw.inhibit = ruleQuery.Inhibit
-	if len(ruleQuery.Queries) > 0 {
-		seriesStore := make(map[uint64]*models.DataResp)
-		seriesTagIndex := make(map[uint64][]uint64)
-
-		for _, query := range ruleQuery.Queries {
-			cli := arw.tdengineClients.GetCli(dsId)
-			if cli == nil {
-				logger.Warningf("rule_eval:%d tdengine client is nil", rule.Id)
-				continue
-			}
-
-			series, err := cli.Query(query)
-			if err != nil {
-				logger.Warningf("rule_eval rid:%d query data error: %v", rule.Id, err)
-				continue
-			}
-
-			//  此条日志很重要，是告警判断的现场值
-			logger.Debugf("rule_eval rid:%d req:%+v resp:%+v", rule.Id, query, series)
-			for i := 0; i < len(series); i++ {
-				serieHash := hash.GetHash(series[i].Metric, series[i].Ref)
-				tagHash := hash.GetTagHash(series[i].Metric)
-				seriesStore[serieHash] = series[i]
-
-				// 将曲线按照相同的 tag 分组
-				if _, exists := seriesTagIndex[tagHash]; !exists {
-					seriesTagIndex[tagHash] = make([]uint64, 0)
-				}
-				seriesTagIndex[tagHash] = append(seriesTagIndex[tagHash], serieHash)
-			}
-		}
-
-		// 判断
-		for _, trigger := range ruleQuery.Triggers {
-			for _, seriesHash := range seriesTagIndex {
-				m := make(map[string]float64)
-				var ts int64
-				var sample *models.DataResp
-				var value float64
-				for _, serieHash := range seriesHash {
-					series, exists := seriesStore[serieHash]
-					if !exists {
-						logger.Warningf("rule_eval rid:%d series:%+v not found", rule.Id, series)
-						continue
-					}
-					t, v, exists := series.Last()
-					if !exists {
-						logger.Warningf("rule_eval rid:%d series:%+v value not found", rule.Id, series)
-						continue
-					}
-
-					if !strings.Contains(trigger.Exp, "$"+series.Ref) {
-						// 表达式中不包含该变量
-						continue
-					}
-
-					m["$"+series.Ref] = v
-					m["$"+series.Ref+"."+series.MetricName()] = v
-					ts = int64(t)
-					sample = series
-					value = v
-				}
-				isTriggered := parser.Calc(trigger.Exp, m)
-				//  此条日志很重要，是告警判断的现场值
-				logger.Debugf("rule_eval rid:%d trigger:%+v exp:%s res:%v m:%v", rule.Id, trigger, trigger.Exp, isTriggered, m)
-
-				point := common.AnomalyPoint{
-					Key:       sample.MetricName(),
-					Labels:    sample.Metric,
-					Timestamp: int64(ts),
-					Value:     value,
-					Severity:  trigger.Severity,
-					Triggered: isTriggered,
-				}
-
-				if isTriggered {
-					points = append(points, point)
-				} else {
-					recoverPoints = append(recoverPoints, point)
-				}
-			}
-		}
-	}
-
-	return points, recoverPoints
-}
-
 func (arw *AlertRuleWorker) GetHostAnomalyPoint(ruleConfig string) []common.AnomalyPoint {
 	var lst []common.AnomalyPoint
 	var severity int
@@ -323,7 +198,6 @@ func (arw *AlertRuleWorker) GetHostAnomalyPoint(ruleConfig string) []common.Anom
 			targets, err := models.MissTargetGetsByFilter(arw.ctx, query, t)
 			if err != nil {
 				logger.Errorf("rule_eval:%s query:%v, error:%v", arw.Key(), query, err)
-				arw.processor.Stats.CounterQueryDataErrorTotal.WithLabelValues(fmt.Sprintf("%d", arw.datasourceId)).Inc()
 				continue
 			}
 			for _, target := range targets {
@@ -345,7 +219,6 @@ func (arw *AlertRuleWorker) GetHostAnomalyPoint(ruleConfig string) []common.Anom
 			targets, err := models.TargetGetsByFilter(arw.ctx, query, 0, 0)
 			if err != nil {
 				logger.Errorf("rule_eval:%s query:%v, error:%v", arw.Key(), query, err)
-				arw.processor.Stats.CounterQueryDataErrorTotal.WithLabelValues(fmt.Sprintf("%d", arw.datasourceId)).Inc()
 				continue
 			}
 			var targetMap = make(map[string]*models.Target)
@@ -377,14 +250,12 @@ func (arw *AlertRuleWorker) GetHostAnomalyPoint(ruleConfig string) []common.Anom
 			count, err := models.MissTargetCountByFilter(arw.ctx, query, t)
 			if err != nil {
 				logger.Errorf("rule_eval:%s query:%v, error:%v", arw.Key(), query, err)
-				arw.processor.Stats.CounterQueryDataErrorTotal.WithLabelValues(fmt.Sprintf("%d", arw.datasourceId)).Inc()
 				continue
 			}

 			total, err := models.TargetCountByFilter(arw.ctx, query)
 			if err != nil {
 				logger.Errorf("rule_eval:%s query:%v, error:%v", arw.Key(), query, err)
-				arw.processor.Stats.CounterQueryDataErrorTotal.WithLabelValues(fmt.Sprintf("%d", arw.datasourceId)).Inc()
 				continue
 			}
 			pct := float64(count) / float64(total) * 100
--- a/alert/mute/mute.go
+++ b/alert/mute/mute.go
@@ -13,11 +13,7 @@ import (
 )

 func IsMuted(rule *models.AlertRule, event *models.AlertCurEvent, targetCache *memsto.TargetCacheType, alertMuteCache *memsto.AlertMuteCacheType) bool {
-	if rule.Disabled == 1 {
-		return true
-	}
-
-	if TimeSpanMuteStrategy(rule, event) {
+	if TimeNonEffectiveMuteStrategy(rule, event) {
 		return true
 	}

@@ -36,9 +32,12 @@ func IsMuted(rule *models.AlertRule, event *models.AlertCurEvent, targetCache *m
 	return false
 }

-// TimeSpanMuteStrategy 根据规则配置的告警生效时间段过滤,如果产生的告警不在规则配置的告警生效时间段内,则不告警,即被mute
-// 时间范围，左闭右开，默认范围：00:00-24:00
-func TimeSpanMuteStrategy(rule *models.AlertRule, event *models.AlertCurEvent) bool {
+// TimeNonEffectiveMuteStrategy 根据规则配置的告警时间过滤,如果产生的告警不在规则配置的告警时间内,则不告警
+func TimeNonEffectiveMuteStrategy(rule *models.AlertRule, event *models.AlertCurEvent) bool {
+	if rule.Disabled == 1 {
+		return true
+	}
+
 	tm := time.Unix(event.TriggerTime, 0)
 	triggerTime := tm.Format("15:04")
 	triggerWeek := strconv.Itoa(int(tm.Weekday()))
@@ -53,33 +52,18 @@ func TimeSpanMuteStrategy(rule *models.AlertRule, event *models.AlertCurEvent) b
 		if !strings.Contains(enableDaysOfWeek[i], triggerWeek) {
 			continue
 		}
-
-		if enableStime[i] < enableEtime[i] {
-			if enableEtime[i] == "23:59" {
-				// 02:00-23:59，这种情况做个特殊处理，相当于左闭右闭区间了
-				if triggerTime < enableStime[i] {
-					// mute, 即没生效
-					continue
-				}
-			} else {
-				// 02:00-04:00 或者 02:00-24:00
-				if triggerTime < enableStime[i] || triggerTime >= enableEtime[i] {
-					// mute, 即没生效
-					continue
-				}
+		if enableStime[i] <= enableEtime[i] {
+			if triggerTime < enableStime[i] || triggerTime > enableEtime[i] {
+				continue
 			}
-		} else if enableStime[i] > enableEtime[i] {
-			// 21:00-09:00
-			if triggerTime < enableStime[i] && triggerTime >= enableEtime[i] {
-				// mute, 即没生效
+		} else {
+			if triggerTime < enableStime[i] && triggerTime > enableEtime[i] {
 				continue
 			}
 		}
-
-		// 到这里说明当前时刻在告警规则的某组生效时间范围内，即没有 mute，直接返回 false
+		// 到这里说明当前时刻在告警规则的某组生效时间范围内，直接返回 false
 		return false
 	}
-
 	return true
 }

@@ -172,16 +156,13 @@ func matchMute(event *models.AlertCurEvent, mute *models.AlertMute, clock ...int

 		for i := 0; i < len(mute.PeriodicMutesJson); i++ {
 			if strings.Contains(mute.PeriodicMutesJson[i].EnableDaysOfWeek, triggerWeek) {
-				if mute.PeriodicMutesJson[i].EnableStime == mute.PeriodicMutesJson[i].EnableEtime {
-					matchTime = true
-					break
-				} else if mute.PeriodicMutesJson[i].EnableStime < mute.PeriodicMutesJson[i].EnableEtime {
+				if mute.PeriodicMutesJson[i].EnableStime <= mute.PeriodicMutesJson[i].EnableEtime {
 					if triggerTime >= mute.PeriodicMutesJson[i].EnableStime && triggerTime < mute.PeriodicMutesJson[i].EnableEtime {
 						matchTime = true
 						break
 					}
 				} else {
-					if triggerTime >= mute.PeriodicMutesJson[i].EnableStime || triggerTime < mute.PeriodicMutesJson[i].EnableEtime {
+					if triggerTime < mute.PeriodicMutesJson[i].EnableStime || triggerTime >= mute.PeriodicMutesJson[i].EnableEtime {
 						matchTime = true
 						break
 					}
@@ -193,21 +174,5 @@ func matchMute(event *models.AlertCurEvent, mute *models.AlertMute, clock ...int
 		return false
 	}

-	var matchSeverity bool
-	if len(mute.SeveritiesJson) > 0 {
-		for _, s := range mute.SeveritiesJson {
-			if event.Severity == s || s == 0 {
-				matchSeverity = true
-				break
-			}
-		}
-	} else {
-		matchSeverity = true
-	}
-
-	if !matchSeverity {
-		return false
-	}
-
 	return common.MatchTags(event.TagsMap, mute.ITags)
 }
--- a/alert/naming/hashring.go
+++ b/alert/naming/hashring.go
@@ -16,7 +16,7 @@ type DatasourceHashRingType struct {
 }

 // for alert_rule sharding
-var HostDatasource int64 = 99999999
+var HostDatasource int64 = 100000
 var DatasourceHashRing = DatasourceHashRingType{Rings: make(map[int64]*consistent.Consistent)}

 func NewConsistentHashRing(replicas int32, nodes []string) *consistent.Consistent {
@@ -53,8 +53,10 @@ func (chr *DatasourceHashRingType) GetNode(datasourceId int64, pk string) (strin
 func (chr *DatasourceHashRingType) IsHit(datasourceId int64, pk string, currentNode string) bool {
 	node, err := chr.GetNode(datasourceId, pk)
 	if err != nil {
-		if !errors.Is(err, consistent.ErrEmptyCircle) {
-			logger.Errorf("rule id:%s is not work, datasource id:%d failed to get node from hashring:%v", pk, datasourceId, err)
+		if errors.Is(err, consistent.ErrEmptyCircle) {
+			logger.Debugf("rule id:%s is not work, datasource id:%d is not assigned to active alert engine", pk, datasourceId)
+		} else {
+			logger.Debugf("rule id:%s is not work, datasource id:%d failed to get node from hashring:%v", pk, datasourceId, err)
 		}
 		return false
 	}
@@ -66,14 +68,3 @@ func (chr *DatasourceHashRingType) Set(datasourceId int64, r *consistent.Consist
 	defer chr.Unlock()
 	chr.Rings[datasourceId] = r
 }
-
-func (chr *DatasourceHashRingType) Clear() {
-	chr.Lock()
-	defer chr.Unlock()
-	for id := range chr.Rings {
-		if id == HostDatasource {
-			continue
-		}
-		delete(chr.Rings, id)
-	}
-}
--- a/alert/naming/heartbeat.go
+++ b/alert/naming/heartbeat.go
@@ -96,16 +96,6 @@ func (n *Naming) heartbeat() error {
 		}
 	}

-	if len(datasourceIds) == 0 {
-		DatasourceHashRing.Clear()
-		for dsId := range localss {
-			if dsId == HostDatasource {
-				continue
-			}
-			delete(localss, dsId)
-		}
-	}
-
 	for i := 0; i < len(datasourceIds); i++ {
 		servers, err := n.ActiveServers(datasourceIds[i])
 		if err != nil {
@@ -167,13 +157,3 @@ func (n *Naming) ActiveServers(datasourceId int64) ([]string, error) {
 	// 30秒内有心跳，就认为是活的
 	return models.AlertingEngineGetsInstances(n.ctx, "datasource_id = ? and clock > ?", datasourceId, time.Now().Unix()-30)
 }
-
-func (n *Naming) ActiveServersByEngineName() ([]string, error) {
-	if !n.ctx.IsCenter {
-		lst, err := poster.GetByUrls[[]string](n.ctx, "/v1/n9e/servers-active?engine_name="+n.heartbeatConfig.EngineName)
-		return lst, err
-	}
-
-	// 30秒内有心跳，就认为是活的
-	return models.AlertingEngineGetsInstances(n.ctx, "engine_cluster = ? and clock > ?", n.heartbeatConfig.EngineName, time.Now().Unix()-30)
-}
--- a/alert/process/process.go
+++ b/alert/process/process.go
@@ -23,8 +23,6 @@ import (
 	"github.com/toolkits/pkg/str"
 )

-type EventMuteHookFunc func(event *models.AlertCurEvent) bool
-
 type ExternalProcessorsType struct {
 	ExternalLock sync.RWMutex
 	Processors   map[string]*Processor
@@ -45,8 +43,6 @@ func (e *ExternalProcessorsType) GetExternalAlertRule(datasourceId, id int64) (*
 	return processor, has
 }

-type HandleEventFunc func(event *models.AlertCurEvent)
-
 type Processor struct {
 	datasourceId int64

@@ -69,11 +65,7 @@ type Processor struct {

 	promClients *prom.PromClientMap
 	ctx         *ctx.Context
-	Stats       *astats.Stats
-
-	HandleFireEventHook    HandleEventFunc
-	HandleRecoverEventHook HandleEventFunc
-	EventMuteHook          EventMuteHookFunc
+	stats       *astats.Stats
 }

 func (p *Processor) Key() string {
@@ -94,7 +86,7 @@ func (p *Processor) Hash() string {
 }

 func NewProcessor(rule *models.AlertRule, datasourceId int64, atertRuleCache *memsto.AlertRuleCacheType, targetCache *memsto.TargetCacheType,
-	busiGroupCache *memsto.BusiGroupCacheType, alertMuteCache *memsto.AlertMuteCacheType, datasourceCache *memsto.DatasourceCacheType, ctx *ctx.Context,
+	busiGroupCache *memsto.BusiGroupCacheType, alertMuteCache *memsto.AlertMuteCacheType, datasourceCache *memsto.DatasourceCacheType, promClients *prom.PromClientMap, ctx *ctx.Context,
 	stats *astats.Stats) *Processor {

 	p := &Processor{
@@ -107,12 +99,9 @@ func NewProcessor(rule *models.AlertRule, datasourceId int64, atertRuleCache *me
 		atertRuleCache:  atertRuleCache,
 		datasourceCache: datasourceCache,

-		ctx:   ctx,
-		Stats: stats,
-
-		HandleFireEventHook:    func(event *models.AlertCurEvent) {},
-		HandleRecoverEventHook: func(event *models.AlertCurEvent) {},
-		EventMuteHook:          func(event *models.AlertCurEvent) bool { return false },
+		promClients: promClients,
+		ctx:         ctx,
+		stats:       stats,
 	}

 	p.mayHandleGroup()
@@ -141,15 +130,9 @@ func (p *Processor) Handle(anomalyPoints []common.AnomalyPoint, from string, inh
 		hash := event.Hash
 		alertingKeys[hash] = struct{}{}
 		if mute.IsMuted(cachedRule, event, p.TargetCache, p.alertMuteCache) {
-			p.Stats.CounterMuteTotal.WithLabelValues(event.GroupName).Inc()
 			logger.Debugf("rule_eval:%s event:%v is muted", p.Key(), event)
 			continue
 		}
-
-		if p.EventMuteHook(event) {
-			continue
-		}
-
 		tagHash := TagHash(anomalyPoint)
 		eventsMap[tagHash] = append(eventsMap[tagHash], event)
 	}
@@ -191,8 +174,6 @@ func (p *Processor) BuildEvent(anomalyPoint common.AnomalyPoint, from string, no
 	event.RuleConfig = p.rule.RuleConfig
 	event.RuleConfigJson = p.rule.RuleConfigJson
 	event.Severity = anomalyPoint.Severity
-	event.ExtraConfig = p.rule.ExtraConfigJSON
-	event.PromQl = anomalyPoint.Query

 	if from == "inner" {
 		event.LastEvalTime = now
@@ -246,8 +227,6 @@ func (p *Processor) RecoverSingle(hash string, now int64, value *string) {
 	cachedRule.UpdateEvent(event)
 	event.IsRecovered = true
 	event.LastEvalTime = now
-
-	p.HandleRecoverEventHook(event)
 	p.pushEventToQueue(event)
 }

@@ -305,12 +284,9 @@ func (p *Processor) fireEvent(event *models.AlertCurEvent) {
 	if cachedRule == nil {
 		return
 	}
-
 	logger.Debugf("rule_eval:%s event:%+v fire", p.Key(), event)
 	if fired, has := p.fires.Get(event.Hash); has {
 		p.fires.UpdateLastEvalTime(event.Hash, event.LastEvalTime)
-		event.FirstTriggerTime = fired.FirstTriggerTime
-		p.HandleFireEventHook(event)

 		if cachedRule.NotifyRepeatStep == 0 {
 			logger.Debugf("rule_eval:%s event:%+v repeat is zero nothing to do", p.Key(), event)
@@ -320,10 +296,11 @@ func (p *Processor) fireEvent(event *models.AlertCurEvent) {
 		}

 		// 之前发送过告警了，这次是否要继续发送，要看是否过了通道静默时间
-		if event.LastEvalTime >= fired.LastSentTime+int64(cachedRule.NotifyRepeatStep)*60 {
+		if event.LastEvalTime > fired.LastSentTime+int64(cachedRule.NotifyRepeatStep)*60 {
 			if cachedRule.NotifyMaxNumber == 0 {
 				// 最大可以发送次数如果是0，表示不想限制最大发送次数，一直发即可
 				event.NotifyCurNumber = fired.NotifyCurNumber + 1
+				event.FirstTriggerTime = fired.FirstTriggerTime
 				p.pushEventToQueue(event)
 			} else {
 				// 有最大发送次数的限制，就要看已经发了几次了，是否达到了最大发送次数
@@ -332,6 +309,7 @@ func (p *Processor) fireEvent(event *models.AlertCurEvent) {
 					return
 				} else {
 					event.NotifyCurNumber = fired.NotifyCurNumber + 1
+					event.FirstTriggerTime = fired.FirstTriggerTime
 					p.pushEventToQueue(event)
 				}
 			}
@@ -339,7 +317,6 @@ func (p *Processor) fireEvent(event *models.AlertCurEvent) {
 	} else {
 		event.NotifyCurNumber = 1
 		event.FirstTriggerTime = event.TriggerTime
-		p.HandleFireEventHook(event)
 		p.pushEventToQueue(event)
 	}
 }
@@ -350,6 +327,7 @@ func (p *Processor) pushEventToQueue(e *models.AlertCurEvent) {
 		p.fires.Set(e.Hash, e)
 	}

+	p.stats.CounterAlertsTotal.WithLabelValues(fmt.Sprintf("%d", e.DatasourceId)).Inc()
 	dispatch.LogEvent(e, "push_queue")
 	if !queue.EventQueue.PushFront(e) {
 		logger.Warningf("event_push_queue: queue is full, event:%+v", e)
@@ -427,13 +405,7 @@ func (p *Processor) mayHandleIdent() {
 		if target, exists := p.TargetCache.Get(ident); exists {
 			p.target = target.Ident
 			p.targetNote = target.Note
-		} else {
-			p.target = ident
-			p.targetNote = ""
 		}
-	} else {
-		p.target = ""
-		p.targetNote = ""
 	}
 }

@@ -460,7 +432,7 @@ func labelMapToArr(m map[string]string) []string {
 }

 func Hash(ruleId, datasourceId int64, vector common.AnomalyPoint) string {
-	return str.MD5(fmt.Sprintf("%d_%s_%d_%d_%s", ruleId, vector.Labels.String(), datasourceId, vector.Severity, vector.Query))
+	return str.MD5(fmt.Sprintf("%d_%s_%d_%d", ruleId, vector.Labels.String(), datasourceId, vector.Severity))
 }

 func TagHash(vector common.AnomalyPoint) string {
--- a/alert/record/prom_rule.go
+++ b/alert/record/prom_rule.go
@@ -6,7 +6,6 @@ import (
 	"strings"
 	"time"

-	"github.com/ccfos/nightingale/v6/alert/astats"
 	"github.com/ccfos/nightingale/v6/models"
 	"github.com/ccfos/nightingale/v6/prom"
 	"github.com/ccfos/nightingale/v6/pushgw/writer"
@@ -19,18 +18,18 @@ type RecordRuleContext struct {
 	datasourceId int64
 	quit         chan struct{}

-	rule        *models.RecordingRule
+	rule *models.RecordingRule
+	// writers     *writer.WritersType
 	promClients *prom.PromClientMap
-	stats       *astats.Stats
 }

-func NewRecordRuleContext(rule *models.RecordingRule, datasourceId int64, promClients *prom.PromClientMap, writers *writer.WritersType, stats *astats.Stats) *RecordRuleContext {
+func NewRecordRuleContext(rule *models.RecordingRule, datasourceId int64, promClients *prom.PromClientMap, writers *writer.WritersType) *RecordRuleContext {
 	return &RecordRuleContext{
 		datasourceId: datasourceId,
 		quit:         make(chan struct{}),
 		rule:         rule,
 		promClients:  promClients,
-		stats:        stats,
+		//writers:      writers,
 	}
 }

@@ -55,23 +54,20 @@ func (rrc *RecordRuleContext) Start() {
 	if interval <= 0 {
 		interval = 10
 	}
-
-	ticker := time.NewTicker(time.Duration(interval) * time.Second)
 	go func() {
-		defer ticker.Stop()
 		for {
 			select {
 			case <-rrc.quit:
 				return
-			case <-ticker.C:
+			default:
 				rrc.Eval()
+				time.Sleep(time.Duration(interval) * time.Second)
 			}
 		}
 	}()
 }

 func (rrc *RecordRuleContext) Eval() {
-	rrc.stats.CounterRecordEval.WithLabelValues().Inc()
 	promql := strings.TrimSpace(rrc.rule.PromQl)
 	if promql == "" {
 		logger.Errorf("eval:%s promql is blank", rrc.Key())
@@ -80,20 +76,17 @@ func (rrc *RecordRuleContext) Eval() {

 	if rrc.promClients.IsNil(rrc.datasourceId) {
 		logger.Errorf("eval:%s reader client is nil", rrc.Key())
-		rrc.stats.CounterRecordEvalErrorTotal.WithLabelValues().Inc()
 		return
 	}

 	value, warnings, err := rrc.promClients.GetCli(rrc.datasourceId).Query(context.Background(), promql, time.Now())
 	if err != nil {
 		logger.Errorf("eval:%s promql:%s, error:%v", rrc.Key(), promql, err)
-		rrc.stats.CounterRecordEvalErrorTotal.WithLabelValues().Inc()
 		return
 	}

 	if len(warnings) > 0 {
 		logger.Errorf("eval:%s promql:%s, warnings:%v", rrc.Key(), promql, warnings)
-		rrc.stats.CounterRecordEvalErrorTotal.WithLabelValues().Inc()
 		return
 	}

--- a/alert/record/sample.go
+++ b/alert/record/sample.go
@@ -15,7 +15,7 @@ const (
 	LabelName = "__name__"
 )

-func ConvertToTimeSeries(value model.Value, rule *models.RecordingRule) (lst []prompb.TimeSeries) {
+func ConvertToTimeSeries(value model.Value, rule *models.RecordingRule) (lst []*prompb.TimeSeries) {
 	switch value.Type() {
 	case model.ValVector:
 		items, ok := value.(model.Vector)
@@ -31,7 +31,7 @@ func ConvertToTimeSeries(value model.Value, rule *models.RecordingRule) (lst []p
 			s.Timestamp = time.Unix(item.Timestamp.Unix(), 0).UnixNano() / 1e6
 			s.Value = float64(item.Value)
 			l := labelsToLabelsProto(item.Metric, rule)
-			lst = append(lst, prompb.TimeSeries{
+			lst = append(lst, &prompb.TimeSeries{
 				Labels:  l,
 				Samples: []prompb.Sample{s},
 			})
@@ -63,7 +63,7 @@ func ConvertToTimeSeries(value model.Value, rule *models.RecordingRule) (lst []p
 					Value:     float64(v.Value),
 				})
 			}
-			lst = append(lst, prompb.TimeSeries{
+			lst = append(lst, &prompb.TimeSeries{
 				Labels:  l,
 				Samples: slst,
 			})
@@ -78,7 +78,7 @@ func ConvertToTimeSeries(value model.Value, rule *models.RecordingRule) (lst []p
 			return
 		}

-		lst = append(lst, prompb.TimeSeries{
+		lst = append(lst, &prompb.TimeSeries{
 			Labels:  nil,
 			Samples: []prompb.Sample{{Value: float64(item.Value), Timestamp: time.Unix(item.Timestamp.Unix(), 0).UnixNano() / 1e6}},
 		})
@@ -89,9 +89,9 @@ func ConvertToTimeSeries(value model.Value, rule *models.RecordingRule) (lst []p
 	return
 }

-func labelsToLabelsProto(labels model.Metric, rule *models.RecordingRule) (result []prompb.Label) {
+func labelsToLabelsProto(labels model.Metric, rule *models.RecordingRule) (result []*prompb.Label) {
 	//name
-	nameLs := prompb.Label{
+	nameLs := &prompb.Label{
 		Name:  LabelName,
 		Value: rule.Name,
 	}
@@ -101,7 +101,7 @@ func labelsToLabelsProto(labels model.Metric, rule *models.RecordingRule) (resul
 			continue
 		}
 		if model.LabelNameRE.MatchString(string(k)) {
-			result = append(result, prompb.Label{
+			result = append(result, &prompb.Label{
 				Name:  string(k),
 				Value: string(v),
 			})
@@ -111,7 +111,7 @@ func labelsToLabelsProto(labels model.Metric, rule *models.RecordingRule) (resul
 		for _, v := range rule.AppendTagsJSON {
 			index := strings.Index(v, "=")
 			if model.LabelNameRE.MatchString(v[:index]) {
-				result = append(result, prompb.Label{
+				result = append(result, &prompb.Label{
 					Name:  v[:index],
 					Value: v[index+1:],
 				})
--- a/alert/record/scheduler.go
+++ b/alert/record/scheduler.go
@@ -72,7 +72,7 @@ func (s *Scheduler) syncRecordRules() {
 				continue
 			}

-			recordRule := NewRecordRuleContext(rule, dsId, s.promClients, s.writers, s.stats)
+			recordRule := NewRecordRuleContext(rule, dsId, s.promClients, s.writers)
 			recordRules[recordRule.Hash()] = recordRule
 		}
 	}
--- a/alert/router/router_event.go
+++ b/alert/router/router_event.go
@@ -72,6 +72,8 @@ func (rt *Router) pushEventToQueue(c *gin.Context) {
 	event.NotifyChannels = strings.Join(event.NotifyChannelsJSON, " ")
 	event.NotifyGroups = strings.Join(event.NotifyGroupsJSON, " ")

+	rt.AlertStats.CounterAlertsTotal.WithLabelValues(event.Cluster).Inc()
+
 	dispatch.LogEvent(event, "http_push_queue")
 	if !queue.EventQueue.PushFront(event) {
 		msg := fmt.Sprintf("event:%+v push_queue err: queue is full", event)
@@ -85,8 +87,7 @@ func (rt *Router) eventPersist(c *gin.Context) {
 	var event *models.AlertCurEvent
 	ginx.BindJSON(c, &event)
 	event.FE2DB()
-	err := models.EventPersist(rt.Ctx, event)
-	ginx.NewRender(c).Data(event.Id, err)
+	ginx.NewRender(c).Message(models.EventPersist(rt.Ctx, event))
 }

 type eventForm struct {
--- a/alert/sender/callback.go
+++ b/alert/sender/callback.go
@@ -1,13 +1,11 @@
 package sender

 import (
-	"encoding/json"
 	"strconv"
 	"strings"
 	"time"

 	"github.com/ccfos/nightingale/v6/alert/aconf"
-	"github.com/ccfos/nightingale/v6/alert/astats"
 	"github.com/ccfos/nightingale/v6/memsto"
 	"github.com/ccfos/nightingale/v6/models"
 	"github.com/ccfos/nightingale/v6/pkg/ctx"
@@ -17,8 +15,7 @@ import (
 	"github.com/toolkits/pkg/logger"
 )

-func SendCallbacks(ctx *ctx.Context, urls []string, event *models.AlertCurEvent, targetCache *memsto.TargetCacheType, userCache *memsto.UserCacheType,
-	ibexConf aconf.Ibex, stats *astats.Stats) {
+func SendCallbacks(ctx *ctx.Context, urls []string, event *models.AlertCurEvent, targetCache *memsto.TargetCacheType, userCache *memsto.UserCacheType, ibexConf aconf.Ibex) {
 	for _, url := range urls {
 		if url == "" {
 			continue
@@ -35,11 +32,9 @@ func SendCallbacks(ctx *ctx.Context, urls []string, event *models.AlertCurEvent,
 			url = "http://" + url
 		}

-		stats.AlertNotifyTotal.WithLabelValues("rule_callback").Inc()
 		resp, code, err := poster.PostJSON(url, 5*time.Second, event, 3)
 		if err != nil {
 			logger.Errorf("event_callback_fail(rule_id=%d url=%s), resp: %s, err: %v, code: %d", event.RuleId, url, string(resp), err, code)
-			stats.AlertNotifyErrorTotal.WithLabelValues("rule_callback").Inc()
 		} else {
 			logger.Infof("event_callback_succ(rule_id=%d url=%s), resp: %s, code: %d", event.RuleId, url, string(resp), code)
 		}
@@ -55,7 +50,6 @@ type TaskForm struct {
 	Pause     string   `json:"pause"`
 	Script    string   `json:"script"`
 	Args      string   `json:"args"`
-	Stdin     string   `json:"stdin"`
 	Action    string   `json:"action"`
 	Creator   string   `json:"creator"`
 	Hosts     []string `json:"hosts"`
@@ -96,7 +90,7 @@ func handleIbex(ctx *ctx.Context, url string, event *models.AlertCurEvent, targe
 		return
 	}

-	tpl, err := models.TaskTplGetById(ctx, id)
+	tpl, err := models.TaskTplGet(ctx, "id = ?", id)
 	if err != nil {
 		logger.Errorf("event_callback_ibex: failed to get tpl: %v", err)
 		return
@@ -120,30 +114,6 @@ func handleIbex(ctx *ctx.Context, url string, event *models.AlertCurEvent, targe
 		return
 	}

-	tagsMap := make(map[string]string)
-	for i := 0; i < len(event.TagsJSON); i++ {
-		pair := strings.TrimSpace(event.TagsJSON[i])
-		if pair == "" {
-			continue
-		}
-
-		arr := strings.Split(pair, "=")
-		if len(arr) != 2 {
-			continue
-		}
-
-		tagsMap[arr[0]] = arr[1]
-	}
-	// 附加告警级别  告警触发值标签
-	tagsMap["alert_severity"] = strconv.Itoa(event.Severity)
-	tagsMap["alert_trigger_value"] = event.TriggerValue
-
-	tags, err := json.Marshal(tagsMap)
-	if err != nil {
-		logger.Errorf("event_callback_ibex: failed to marshal tags to json: %v", tagsMap)
-		return
-	}
-
 	// call ibex
 	in := TaskForm{
 		Title:     tpl.Title + " FH: " + host,
@@ -154,7 +124,6 @@ func handleIbex(ctx *ctx.Context, url string, event *models.AlertCurEvent, targe
 		Pause:     tpl.Pause,
 		Script:    tpl.Script,
 		Args:      tpl.Args,
-		Stdin:     string(tags),
 		Action:    "start",
 		Creator:   tpl.UpdateBy,
 		Hosts:     []string{host},
--- a/alert/sender/dingtalk.go
+++ b/alert/sender/dingtalk.go
@@ -5,7 +5,6 @@ import (
 	"strings"
 	"time"

-	"github.com/ccfos/nightingale/v6/alert/astats"
 	"github.com/ccfos/nightingale/v6/models"
 	"github.com/ccfos/nightingale/v6/pkg/poster"

@@ -33,7 +32,7 @@ type DingtalkSender struct {
 }

 func (ds *DingtalkSender) Send(ctx MessageContext) {
-	if len(ctx.Users) == 0 || len(ctx.Events) == 0 {
+	if len(ctx.Users) == 0 || ctx.Rule == nil || ctx.Event == nil {
 		return
 	}

@@ -41,7 +40,7 @@ func (ds *DingtalkSender) Send(ctx MessageContext) {
 	if len(urls) == 0 {
 		return
 	}
-	message := BuildTplMessage(ds.tpl, ctx.Events)
+	message := BuildTplMessage(ds.tpl, ctx.Event)

 	for _, url := range urls {
 		var body dingtalk
@@ -50,7 +49,7 @@ func (ds *DingtalkSender) Send(ctx MessageContext) {
 			body = dingtalk{
 				Msgtype: "markdown",
 				Markdown: dingtalkMarkdown{
-					Title: ctx.Events[0].RuleName,
+					Title: ctx.Event.RuleName,
 					Text:  message,
 				},
 			}
@@ -58,7 +57,7 @@ func (ds *DingtalkSender) Send(ctx MessageContext) {
 			body = dingtalk{
 				Msgtype: "markdown",
 				Markdown: dingtalkMarkdown{
-					Title: ctx.Events[0].RuleName,
+					Title: ctx.Event.RuleName,
 					Text:  message + "\n" + strings.Join(ats, " "),
 				},
 				At: dingtalkAt{
@@ -67,8 +66,7 @@ func (ds *DingtalkSender) Send(ctx MessageContext) {
 				},
 			}
 		}
-
-		doSend(url, body, models.Dingtalk, ctx.Stats)
+		ds.doSend(url, body)
 	}
 }

@@ -83,7 +81,7 @@ func (ds *DingtalkSender) extract(users []*models.User) ([]string, []string) {
 		}
 		if token, has := user.ExtractToken(models.Dingtalk); has {
 			url := token
-			if !strings.HasPrefix(token, "https://") && !strings.HasPrefix(token, "http://") {
+			if !strings.HasPrefix(token, "https://") {
 				url = "https://oapi.dingtalk.com/robot/send?access_token=" + token
 			}
 			urls = append(urls, url)
@@ -92,14 +90,11 @@ func (ds *DingtalkSender) extract(users []*models.User) ([]string, []string) {
 	return urls, ats
 }

-func doSend(url string, body interface{}, channel string, stats *astats.Stats) {
-	stats.AlertNotifyTotal.WithLabelValues(channel).Inc()
-
+func (ds *DingtalkSender) doSend(url string, body dingtalk) {
 	res, code, err := poster.PostJSON(url, time.Second*5, body, 3)
 	if err != nil {
-		logger.Errorf("%s_sender: result=fail url=%s code=%d error=%v response=%s", channel, url, code, err, string(res))
-		stats.AlertNotifyErrorTotal.WithLabelValues(channel).Inc()
+		logger.Errorf("dingtalk_sender: result=fail url=%s code=%d error=%v response=%s", url, code, err, string(res))
 	} else {
-		logger.Infof("%s_sender: result=succ url=%s code=%d response=%s", channel, url, code, string(res))
+		logger.Infof("dingtalk_sender: result=succ url=%s code=%d response=%s", url, code, string(res))
 	}
 }
--- a/alert/sender/email.go
+++ b/alert/sender/email.go
@@ -2,7 +2,6 @@ package sender

 import (
 	"crypto/tls"
-	"errors"
 	"html/template"
 	"time"

@@ -23,21 +22,19 @@ type EmailSender struct {
 }

 func (es *EmailSender) Send(ctx MessageContext) {
-	if len(ctx.Users) == 0 || len(ctx.Events) == 0 {
+	if len(ctx.Users) == 0 || ctx.Rule == nil || ctx.Event == nil {
 		return
 	}
 	tos := extract(ctx.Users)
 	var subject string

 	if es.subjectTpl != nil {
-		subject = BuildTplMessage(es.subjectTpl, []*models.AlertCurEvent{ctx.Events[0]})
+		subject = BuildTplMessage(es.subjectTpl, ctx.Event)
 	} else {
-		subject = ctx.Events[0].RuleName
+		subject = ctx.Event.RuleName
 	}
-	content := BuildTplMessage(es.contentTpl, ctx.Events)
+	content := BuildTplMessage(es.contentTpl, ctx.Event)
 	es.WriteEmail(subject, content, tos)
-
-	ctx.Stats.AlertNotifyTotal.WithLabelValues(models.Email).Add(float64(len(tos)))
 }

 func extract(users []*models.User) []string {
@@ -50,7 +47,7 @@ func extract(users []*models.User) []string {
 	return tos
 }

-func SendEmail(subject, content string, tos []string, stmp aconf.SMTPConfig) error {
+func (es *EmailSender) SendEmail(subject, content string, tos []string, stmp aconf.SMTPConfig) {
 	conf := stmp

 	d := gomail.NewDialer(conf.Host, conf.Port, conf.User, conf.Pass)
@@ -67,9 +64,8 @@ func SendEmail(subject, content string, tos []string, stmp aconf.SMTPConfig) err

 	err := d.DialAndSend(m)
 	if err != nil {
-		return errors.New("email_sender: failed to send: " + err.Error())
+		logger.Errorf("email_sender: failed to send: %v", err)
 	}
-	return nil
 }

 func (es *EmailSender) WriteEmail(subject, content string, tos []string) {
@@ -100,21 +96,19 @@ var mailQuit = make(chan struct{})
 func RestartEmailSender(smtp aconf.SMTPConfig) {
 	close(mailQuit)
 	mailQuit = make(chan struct{})
-	startEmailSender(smtp)
+	StartEmailSender(smtp)
 }

-func InitEmailSender(smtp aconf.SMTPConfig) {
+func StartEmailSender(smtp aconf.SMTPConfig) {
 	mailch = make(chan *gomail.Message, 100000)
-	startEmailSender(smtp)
-}

-func startEmailSender(smtp aconf.SMTPConfig) {
 	conf := smtp
+
 	if conf.Host == "" || conf.Port == 0 {
 		logger.Warning("SMTP configurations invalid")
 		return
 	}
-	logger.Infof("start email sender... conf.Host:%+v,conf.Port:%+v", conf.Host, conf.Port)
+	logger.Infof("start email sender... %+v", conf)

 	d := gomail.NewDialer(conf.Host, conf.Port, conf.User, conf.Pass)
 	if conf.InsecureSkipVerify {
--- a/alert/sender/feishu.go
+++ b/alert/sender/feishu.go
@@ -3,8 +3,12 @@ package sender
 import (
 	"html/template"
 	"strings"
+	"time"

 	"github.com/ccfos/nightingale/v6/models"
+	"github.com/ccfos/nightingale/v6/pkg/poster"
+
+	"github.com/toolkits/pkg/logger"
 )

 type feishuContent struct {
@@ -27,11 +31,11 @@ type FeishuSender struct {
 }

 func (fs *FeishuSender) Send(ctx MessageContext) {
-	if len(ctx.Users) == 0 || len(ctx.Events) == 0 {
+	if len(ctx.Users) == 0 || ctx.Rule == nil || ctx.Event == nil {
 		return
 	}
 	urls, ats := fs.extract(ctx.Users)
-	message := BuildTplMessage(fs.tpl, ctx.Events)
+	message := BuildTplMessage(fs.tpl, ctx.Event)
 	for _, url := range urls {
 		body := feishu{
 			Msgtype: "text",
@@ -45,7 +49,7 @@ func (fs *FeishuSender) Send(ctx MessageContext) {
 				IsAtAll:   false,
 			}
 		}
-		doSend(url, body, models.Feishu, ctx.Stats)
+		fs.doSend(url, body)
 	}
 }

@@ -59,7 +63,7 @@ func (fs *FeishuSender) extract(users []*models.User) ([]string, []string) {
 		}
 		if token, has := user.ExtractToken(models.Feishu); has {
 			url := token
-			if !strings.HasPrefix(token, "https://") && !strings.HasPrefix(token, "http://") {
+			if !strings.HasPrefix(token, "https://") {
 				url = "https://open.feishu.cn/open-apis/bot/v2/hook/" + token
 			}
 			urls = append(urls, url)
@@ -67,3 +71,12 @@ func (fs *FeishuSender) extract(users []*models.User) ([]string, []string) {
 	}
 	return urls, ats
 }
+
+func (fs *FeishuSender) doSend(url string, body feishu) {
+	res, code, err := poster.PostJSON(url, time.Second*5, body, 3)
+	if err != nil {
+		logger.Errorf("feishu_sender: result=fail url=%s code=%d error=%v response=%s", url, code, err, string(res))
+	} else {
+		logger.Infof("feishu_sender: result=succ url=%s code=%d response=%s", url, code, string(res))
+	}
+}
--- a/alert/sender/feishucard.go
+++ b/alert/sender/feishucard.go
@@ -1,131 +0,0 @@
-package sender
-
-import (
-	"fmt"
-	"html/template"
-	"strings"
-
-	"github.com/ccfos/nightingale/v6/models"
-)
-
-type Conf struct {
-	WideScreenMode bool `json:"wide_screen_mode"`
-	EnableForward  bool `json:"enable_forward"`
-}
-
-type Te struct {
-	Content string `json:"content"`
-	Tag     string `json:"tag"`
-}
-
-type Element struct {
-	Tag      string    `json:"tag"`
-	Text     Te        `json:"text"`
-	Content  string    `json:"content"`
-	Elements []Element `json:"elements"`
-}
-
-type Titles struct {
-	Content string `json:"content"`
-	Tag     string `json:"tag"`
-}
-
-type Headers struct {
-	Title    Titles `json:"title"`
-	Template string `json:"template"`
-}
-
-type Cards struct {
-	Config   Conf      `json:"config"`
-	Elements []Element `json:"elements"`
-	Header   Headers   `json:"header"`
-}
-
-type feishuCard struct {
-	feishu
-	Card Cards `json:"card"`
-}
-
-type FeishuCardSender struct {
-	tpl *template.Template
-}
-
-const (
-	Recovered = "recovered"
-	Triggered = "triggered"
-)
-
-var (
-	body = feishuCard{
-		feishu: feishu{Msgtype: "interactive"},
-		Card: Cards{
-			Config: Conf{
-				WideScreenMode: true,
-				EnableForward:  true,
-			},
-			Header: Headers{
-				Title: Titles{
-					Tag: "plain_text",
-				},
-			},
-			Elements: []Element{
-				{
-					Tag: "div",
-					Text: Te{
-						Tag: "lark_md",
-					},
-				},
-				{
-					Tag: "hr",
-				},
-				{
-					Tag: "note",
-					Elements: []Element{
-						{
-							Tag: "lark_md",
-						},
-					},
-				},
-			},
-		},
-	}
-)
-
-func (fs *FeishuCardSender) Send(ctx MessageContext) {
-	if len(ctx.Users) == 0 || len(ctx.Events) == 0 {
-		return
-	}
-	urls, _ := fs.extract(ctx.Users)
-	message := BuildTplMessage(fs.tpl, ctx.Events)
-	color := "red"
-	lowerUnicode := strings.ToLower(message)
-	if strings.Count(lowerUnicode, Recovered) > 0 && strings.Count(lowerUnicode, Triggered) > 0 {
-		color = "orange"
-	} else if strings.Count(lowerUnicode, Recovered) > 0 {
-		color = "green"
-	}
-
-	SendTitle := fmt.Sprintf("🔔 %s", ctx.Events[0].RuleName)
-	body.Card.Header.Title.Content = SendTitle
-	body.Card.Header.Template = color
-	body.Card.Elements[0].Text.Content = message
-	body.Card.Elements[2].Elements[0].Content = SendTitle
-	for _, url := range urls {
-		doSend(url, body, models.FeishuCard, ctx.Stats)
-	}
-}
-
-func (fs *FeishuCardSender) extract(users []*models.User) ([]string, []string) {
-	urls := make([]string, 0, len(users))
-	ats := make([]string, 0)
-	for i := range users {
-		if token, has := users[i].ExtractToken(models.FeishuCard); has {
-			url := token
-			if !strings.HasPrefix(token, "https://") && !strings.HasPrefix(token, "http://") {
-				url = "https://open.feishu.cn/open-apis/bot/v2/hook/" + strings.TrimSpace(token)
-			}
-			urls = append(urls, url)
-		}
-	}
-	return urls, ats
-}
--- a/alert/sender/mm.go
+++ b/alert/sender/mm.go
@@ -4,9 +4,10 @@ import (
 	"html/template"
 	"net/url"
 	"strings"
+	"time"

-	"github.com/ccfos/nightingale/v6/alert/astats"
 	"github.com/ccfos/nightingale/v6/models"
+	"github.com/ccfos/nightingale/v6/pkg/poster"

 	"github.com/toolkits/pkg/logger"
 )
@@ -14,7 +15,6 @@ import (
 type MatterMostMessage struct {
 	Text   string
 	Tokens []string
-	Stats  *astats.Stats
 }

 type mm struct {
@@ -28,7 +28,7 @@ type MmSender struct {
 }

 func (ms *MmSender) Send(ctx MessageContext) {
-	if len(ctx.Users) == 0 || len(ctx.Events) == 0 {
+	if len(ctx.Users) == 0 || ctx.Rule == nil || ctx.Event == nil {
 		return
 	}

@@ -36,12 +36,11 @@ func (ms *MmSender) Send(ctx MessageContext) {
 	if len(urls) == 0 {
 		return
 	}
-	message := BuildTplMessage(ms.tpl, ctx.Events)
+	message := BuildTplMessage(ms.tpl, ctx.Event)

 	SendMM(MatterMostMessage{
 		Text:   message,
 		Tokens: urls,
-		Stats:  ctx.Stats,
 	})
 }

@@ -88,7 +87,13 @@ func SendMM(message MatterMostMessage) {
 				Username: username,
 				Text:     txt + message.Text,
 			}
-			doSend(ur, body, models.Mm, message.Stats)
+
+			res, code, err := poster.PostJSON(ur, time.Second*5, body, 3)
+			if err != nil {
+				logger.Errorf("mm_sender: result=fail url=%s code=%d error=%v response=%s", ur, code, err, string(res))
+			} else {
+				logger.Infof("mm_sender: result=succ url=%s code=%d response=%s", ur, code, string(res))
+			}
 		}
 	}
 }
--- a/alert/sender/plugin.go
+++ b/alert/sender/plugin.go
@@ -6,7 +6,6 @@ import (
 	"os/exec"
 	"time"

-	"github.com/ccfos/nightingale/v6/alert/astats"
 	"github.com/ccfos/nightingale/v6/models"

 	"github.com/toolkits/pkg/file"
@@ -14,22 +13,20 @@ import (
 	"github.com/toolkits/pkg/sys"
 )

-func MayPluginNotify(noticeBytes []byte, notifyScript models.NotifyScript, stats *astats.Stats) {
+func MayPluginNotify(noticeBytes []byte, notifyScript models.NotifyScript) {
 	if len(noticeBytes) == 0 {
 		return
 	}
-	alertingCallScript(noticeBytes, notifyScript, stats)
+	alertingCallScript(noticeBytes, notifyScript)
 }

-func alertingCallScript(stdinBytes []byte, notifyScript models.NotifyScript, stats *astats.Stats) {
+func alertingCallScript(stdinBytes []byte, notifyScript models.NotifyScript) {
 	// not enable or no notify.py? do nothing
 	config := notifyScript
 	if !config.Enable || config.Content == "" {
 		return
 	}

-	channel := "script"
-	stats.AlertNotifyTotal.WithLabelValues(channel).Inc()
 	fpath := ".notify_scriptt"
 	if config.Type == 1 {
 		fpath = config.Content
@@ -39,7 +36,6 @@ func alertingCallScript(stdinBytes []byte, notifyScript models.NotifyScript, sta
 			oldContent, err := file.ToString(fpath)
 			if err != nil {
 				logger.Errorf("event_script_notify_fail: read script file err: %v", err)
-				stats.AlertNotifyErrorTotal.WithLabelValues(channel).Inc()
 				return
 			}

@@ -52,14 +48,12 @@ func alertingCallScript(stdinBytes []byte, notifyScript models.NotifyScript, sta
 			_, err := file.WriteString(fpath, config.Content)
 			if err != nil {
 				logger.Errorf("event_script_notify_fail: write script file err: %v", err)
-				stats.AlertNotifyErrorTotal.WithLabelValues(channel).Inc()
 				return
 			}

 			err = os.Chmod(fpath, 0777)
 			if err != nil {
 				logger.Errorf("event_script_notify_fail: chmod script file err: %v", err)
-				stats.AlertNotifyErrorTotal.WithLabelValues(channel).Inc()
 				return
 			}
 		}
@@ -89,14 +83,13 @@ func alertingCallScript(stdinBytes []byte, notifyScript models.NotifyScript, sta

 		if err != nil {
 			logger.Errorf("event_script_notify_fail: kill process %s occur error %v", fpath, err)
-			stats.AlertNotifyErrorTotal.WithLabelValues(channel).Inc()
 		}
+
 		return
 	}

 	if err != nil {
 		logger.Errorf("event_script_notify_fail: exec script %s occur error: %v, output: %s", fpath, err, buf.String())
-		stats.AlertNotifyErrorTotal.WithLabelValues(channel).Inc()
 		return
 	}

--- a/alert/sender/sender.go
+++ b/alert/sender/sender.go
@@ -5,7 +5,6 @@ import (
 	"html/template"

 	"github.com/ccfos/nightingale/v6/alert/aconf"
-	"github.com/ccfos/nightingale/v6/alert/astats"
 	"github.com/ccfos/nightingale/v6/memsto"
 	"github.com/ccfos/nightingale/v6/models"
 )
@@ -18,14 +17,13 @@ type (

 	// MessageContext 一个event所生成的告警通知的上下文
 	MessageContext struct {
-		Users  []*models.User
-		Rule   *models.AlertRule
-		Events []*models.AlertCurEvent
-		Stats  *astats.Stats
+		Users []*models.User
+		Rule  *models.AlertRule
+		Event *models.AlertCurEvent
 	}
 )

-func NewSender(key string, tpls map[string]*template.Template, smtp ...aconf.SMTPConfig) Sender {
+func NewSender(key string, tpls map[string]*template.Template, smtp aconf.SMTPConfig) Sender {
 	switch key {
 	case models.Dingtalk:
 		return &DingtalkSender{tpl: tpls[models.Dingtalk]}
@@ -33,10 +31,8 @@ func NewSender(key string, tpls map[string]*template.Template, smtp ...aconf.SMT
 		return &WecomSender{tpl: tpls[models.Wecom]}
 	case models.Feishu:
 		return &FeishuSender{tpl: tpls[models.Feishu]}
-	case models.FeishuCard:
-		return &FeishuCardSender{tpl: tpls[models.FeishuCard]}
 	case models.Email:
-		return &EmailSender{subjectTpl: tpls[models.EmailSubject], contentTpl: tpls[models.Email], smtp: smtp[0]}
+		return &EmailSender{subjectTpl: tpls["mailsubject"], contentTpl: tpls[models.Email], smtp: smtp}
 	case models.Mm:
 		return &MmSender{tpl: tpls[models.Mm]}
 	case models.Telegram:
@@ -45,33 +41,23 @@ func NewSender(key string, tpls map[string]*template.Template, smtp ...aconf.SMT
 	return nil
 }

-func BuildMessageContext(rule *models.AlertRule, events []*models.AlertCurEvent, uids []int64, userCache *memsto.UserCacheType, stats *astats.Stats) MessageContext {
+func BuildMessageContext(rule *models.AlertRule, event *models.AlertCurEvent, uids []int64, userCache *memsto.UserCacheType) MessageContext {
 	users := userCache.GetByUserIds(uids)
 	return MessageContext{
-		Rule:   rule,
-		Events: events,
-		Users:  users,
-		Stats:  stats,
+		Rule:  rule,
+		Event: event,
+		Users: users,
 	}
 }

-type BuildTplMessageFunc func(tpl *template.Template, events []*models.AlertCurEvent) string
-
-var BuildTplMessage BuildTplMessageFunc = buildTplMessage
-
-func buildTplMessage(tpl *template.Template, events []*models.AlertCurEvent) string {
+func BuildTplMessage(tpl *template.Template, event *models.AlertCurEvent) string {
 	if tpl == nil {
 		return "tpl for current sender not found, please check configuration"
 	}

-	var content string
-	for _, event := range events {
-		var body bytes.Buffer
-		if err := tpl.Execute(&body, event); err != nil {
-			return err.Error()
-		}
-		content += body.String() + "\n\n"
+	var body bytes.Buffer
+	if err := tpl.Execute(&body, event); err != nil {
+		return err.Error()
 	}
-
-	return content
+	return body.String()
 }
--- a/alert/sender/telegram.go
+++ b/alert/sender/telegram.go
@@ -3,9 +3,10 @@ package sender
 import (
 	"html/template"
 	"strings"
+	"time"

-	"github.com/ccfos/nightingale/v6/alert/astats"
 	"github.com/ccfos/nightingale/v6/models"
+	"github.com/ccfos/nightingale/v6/pkg/poster"

 	"github.com/toolkits/pkg/logger"
 )
@@ -13,7 +14,6 @@ import (
 type TelegramMessage struct {
 	Text   string
 	Tokens []string
-	Stats  *astats.Stats
 }

 type telegram struct {
@@ -26,16 +26,15 @@ type TelegramSender struct {
 }

 func (ts *TelegramSender) Send(ctx MessageContext) {
-	if len(ctx.Users) == 0 || len(ctx.Events) == 0 {
+	if len(ctx.Users) == 0 || ctx.Rule == nil || ctx.Event == nil {
 		return
 	}
 	tokens := ts.extract(ctx.Users)
-	message := BuildTplMessage(ts.tpl, ctx.Events)
+	message := BuildTplMessage(ts.tpl, ctx.Event)

 	SendTelegram(TelegramMessage{
 		Text:   message,
 		Tokens: tokens,
-		Stats:  ctx.Stats,
 	})
 }

@@ -56,7 +55,7 @@ func SendTelegram(message TelegramMessage) {
 			continue
 		}
 		var url string
-		if strings.HasPrefix(message.Tokens[i], "https://") || strings.HasPrefix(message.Tokens[i], "http://") {
+		if strings.HasPrefix(message.Tokens[i], "https://") {
 			url = message.Tokens[i]
 		} else {
 			array := strings.Split(message.Tokens[i], "/")
@@ -73,6 +72,11 @@ func SendTelegram(message TelegramMessage) {
 			Text:      message.Text,
 		}

-		doSend(url, body, models.Telegram, message.Stats)
+		res, code, err := poster.PostJSON(url, time.Second*5, body, 3)
+		if err != nil {
+			logger.Errorf("telegram_sender: result=fail url=%s code=%d error=%v response=%s", url, code, err, string(res))
+		} else {
+			logger.Infof("telegram_sender: result=succ url=%s code=%d response=%s", url, code, string(res))
+		}
 	}
 }
--- a/alert/sender/webhook.go
+++ b/alert/sender/webhook.go
@@ -3,17 +3,16 @@ package sender
 import (
 	"bytes"
 	"encoding/json"
-	"io"
+	"io/ioutil"
 	"net/http"
 	"time"

-	"github.com/ccfos/nightingale/v6/alert/astats"
 	"github.com/ccfos/nightingale/v6/models"

 	"github.com/toolkits/pkg/logger"
 )

-func SendWebhooks(webhooks []*models.Webhook, event *models.AlertCurEvent, stats *astats.Stats) {
+func SendWebhooks(webhooks []*models.Webhook, event *models.AlertCurEvent) {
 	for _, conf := range webhooks {
 		if conf.Url == "" || !conf.Enable {
 			continue
@@ -51,11 +50,9 @@ func SendWebhooks(webhooks []*models.Webhook, event *models.AlertCurEvent, stats
 			Timeout: time.Duration(conf.Timeout) * time.Second,
 		}

-		stats.AlertNotifyTotal.WithLabelValues("webhook").Inc()
 		var resp *http.Response
 		resp, err = client.Do(req)
 		if err != nil {
-			stats.AlertNotifyErrorTotal.WithLabelValues("webhook").Inc()
 			logger.Errorf("event_webhook_fail, ruleId: [%d], eventId: [%d], url: [%s], error: [%s]", event.RuleId, event.Id, conf.Url, err)
 			continue
 		}
@@ -63,7 +60,7 @@ func SendWebhooks(webhooks []*models.Webhook, event *models.AlertCurEvent, stats
 		var body []byte
 		if resp.Body != nil {
 			defer resp.Body.Close()
-			body, _ = io.ReadAll(resp.Body)
+			body, _ = ioutil.ReadAll(resp.Body)
 		}

 		logger.Debugf("event_webhook_succ, url: %s, response code: %d, body: %s", conf.Url, resp.StatusCode, string(body))
--- a/alert/sender/wecom.go
+++ b/alert/sender/wecom.go
@@ -3,8 +3,12 @@ package sender
 import (
 	"html/template"
 	"strings"
+	"time"

 	"github.com/ccfos/nightingale/v6/models"
+	"github.com/ccfos/nightingale/v6/pkg/poster"
+
+	"github.com/toolkits/pkg/logger"
 )

 type wecomMarkdown struct {
@@ -21,11 +25,11 @@ type WecomSender struct {
 }

 func (ws *WecomSender) Send(ctx MessageContext) {
-	if len(ctx.Users) == 0 || len(ctx.Events) == 0 {
+	if len(ctx.Users) == 0 || ctx.Rule == nil || ctx.Event == nil {
 		return
 	}
 	urls := ws.extract(ctx.Users)
-	message := BuildTplMessage(ws.tpl, ctx.Events)
+	message := BuildTplMessage(ws.tpl, ctx.Event)
 	for _, url := range urls {
 		body := wecom{
 			Msgtype: "markdown",
@@ -33,7 +37,7 @@ func (ws *WecomSender) Send(ctx MessageContext) {
 				Content: message,
 			},
 		}
-		doSend(url, body, models.Wecom, ctx.Stats)
+		ws.doSend(url, body)
 	}
 }

@@ -42,7 +46,7 @@ func (ws *WecomSender) extract(users []*models.User) []string {
 	for _, user := range users {
 		if token, has := user.ExtractToken(models.Wecom); has {
 			url := token
-			if !strings.HasPrefix(token, "https://") && !strings.HasPrefix(token, "http://") {
+			if !strings.HasPrefix(token, "https://") {
 				url = "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=" + token
 			}
 			urls = append(urls, url)
@@ -50,3 +54,12 @@ func (ws *WecomSender) extract(users []*models.User) []string {
 	}
 	return urls
 }
+
+func (ws *WecomSender) doSend(url string, body wecom) {
+	res, code, err := poster.PostJSON(url, time.Second*5, body, 3)
+	if err != nil {
+		logger.Errorf("wecom_sender: result=fail url=%s code=%d error=%v response=%s", url, code, err, string(res))
+	} else {
+		logger.Infof("wecom_sender: result=succ url=%s code=%d response=%s", url, code, string(res))
+	}
+}
--- a/center/cconf/conf.go
+++ b/center/cconf/conf.go
@@ -8,7 +8,6 @@ type Center struct {
 	I18NHeaderKey          string
 	MetricDesc             MetricDescType
 	AnonymousAccess        AnonymousAccess
-	UseFileAssets          bool
 }

 type Plugin struct {
--- a/center/cconf/ops.go
+++ b/center/cconf/ops.go
@@ -1,11 +1,9 @@
 package cconf

 import (
-	"fmt"
 	"path"

 	"github.com/toolkits/pkg/file"
-	"gopkg.in/yaml.v2"
 )

 var Operations = Operation{}
@@ -38,140 +36,3 @@ func GetAllOps(ops []Ops) []string {
 	}
 	return ret
 }
-
-func MergeOperationConf() error {
-	opsBuiltIn := Operation{}
-	err := yaml.Unmarshal([]byte(builtInOps), &opsBuiltIn)
-	if err != nil {
-		return fmt.Errorf("cannot parse builtInOps: %s", err.Error())
-	}
-	configOpsMap := make(map[string]struct{})
-	for _, op := range Operations.Ops {
-		configOpsMap[op.Name] = struct{}{}
-	}
-	//If the opBu.Name is not a constant in the target (Operations.Ops), add Ops from the built-in options
-	for _, opBu := range opsBuiltIn.Ops {
-		if _, has := configOpsMap[opBu.Name]; !has {
-			Operations.Ops = append(Operations.Ops, opBu)
-		}
-	}
-	return nil
-}
-
-const (
-	builtInOps = `
-ops:
- name: dashboards
-  cname: 仪表盘
-  ops:
-    - "/dashboards"
-    - "/dashboards/add"
-    - "/dashboards/put"
-    - "/dashboards/del"
-    - "/dashboards-built-in"
-
- name: alert
-  cname: 告警规则
-  ops:
-    - "/alert-rules"
-    - "/alert-rules/add"
-    - "/alert-rules/put"
-    - "/alert-rules/del"
-    - "/alert-rules-built-in"
- name: alert-mutes
-  cname: 告警静默管理
-  ops:
-    - "/alert-mutes"
-    - "/alert-mutes/add"
-    - "/alert-mutes/put"
-    - "/alert-mutes/del"
-  
- name: alert-subscribes
-  cname: 告警订阅管理
-  ops:
-    - "/alert-subscribes"
-    - "/alert-subscribes/add"
-    - "/alert-subscribes/put"
-    - "/alert-subscribes/del"
-
- name: alert-events  
-  cname: 告警事件管理
-  ops:
-    - "/alert-cur-events"
-    - "/alert-cur-events/del"
-    - "/alert-his-events" 
-
- name: recording-rules
-  cname: 记录规则管理
-  ops:
-    - "/recording-rules"
-    - "/recording-rules/add"
-    - "/recording-rules/put"
-    - "/recording-rules/del"
-
- name: metric
-  cname: 时序指标
-  ops:
-  - "/metric/explorer"
-  - "/object/explorer"
-
- name: log
-  cname: 日志分析
-  ops:
-  - "/log/explorer"
-  - "/log/index-patterns"
-
- name: targets
-  cname: 基础设施
-  ops:
-    - "/targets"
-    - "/targets/add"
-    - "/targets/put"
-    - "/targets/del"
-
- name: job
-  cname: 任务管理
-  ops:
-    - "/job-tpls"
-    - "/job-tpls/add"
-    - "/job-tpls/put"
-    - "/job-tpls/del"
-    - "/job-tasks"
-    - "/job-tasks/add"
-    - "/job-tasks/put"
-
- name: user
-  cname: 用户管理
-  ops:
-  - "/users"
-  - "/user-groups"
-  - "/user-groups/add"
-  - "/user-groups/put"
-  - "/user-groups/del"
-
- name: permissions
-  cname: 权限管理
-  ops:
-  - "/permissions"
-
- name: busi-groups
-  cname: 业务分组管理
-  ops:
-  - "/busi-groups"
-  - "/busi-groups/add"
-  - "/busi-groups/put"
-  - "/busi-groups/del"
-
- name: system
-  cname: 系统信息
-  ops:
-  - "/help/variable-configs"
-  - "/help/version"
-  - "/help/servers"
-  - "/help/source"
-  - "/help/sso"
-  - "/help/notification-tpls"
-  - "/help/notification-settings"
-  - "/help/migrate"
-`
-)
--- a/center/cconf/plugin.go
+++ b/center/cconf/plugin.go
@@ -15,14 +15,8 @@ var Plugins = []Plugin{
 	},
 	{
 		Id:       3,
-		Category: "loki",
-		Type:     "loki",
-		TypeName: "Loki",
-	},
-	{
-		Id:       4,
-		Category: "timeseries",
-		Type:     "tdengine",
-		TypeName: "TDengine",
+		Category: "logging",
+		Type:     "jaeger",
+		TypeName: "Jaeger",
 	},
 }
--- a/center/cconf/rsa/rsa_conf.go
+++ b/center/cconf/rsa/rsa_conf.go
@@ -1,105 +0,0 @@
-package rsa
-
-import (
-	"os"
-
-	"github.com/ccfos/nightingale/v6/models"
-	"github.com/ccfos/nightingale/v6/pkg/ctx"
-	"github.com/ccfos/nightingale/v6/pkg/httpx"
-	"github.com/ccfos/nightingale/v6/pkg/secu"
-
-	"github.com/pkg/errors"
-	"github.com/toolkits/pkg/file"
-	"github.com/toolkits/pkg/logger"
-)
-
-func InitRSAConfig(ctx *ctx.Context, rsaConfig *httpx.RSAConfig) error {
-
-	// 1.Load RSA keys from Database
-	rsaPassWord, err := models.ConfigsGet(ctx, models.RSA_PASSWORD)
-	if err != nil {
-		return errors.WithMessagef(err, "cannot query config(%s)", models.RSA_PASSWORD)
-	}
-	privateKeyVal, err := models.ConfigsGet(ctx, models.RSA_PRIVATE_KEY)
-	if err != nil {
-		return errors.WithMessagef(err, "cannot query config(%s)", models.RSA_PRIVATE_KEY)
-	}
-	publicKeyVal, err := models.ConfigsGet(ctx, models.RSA_PUBLIC_KEY)
-	if err != nil {
-		return errors.WithMessagef(err, "cannot query config(%s)", models.RSA_PUBLIC_KEY)
-	}
-	if rsaPassWord != "" && privateKeyVal != "" && publicKeyVal != "" {
-		rsaConfig.RSAPassWord = rsaPassWord
-		rsaConfig.RSAPrivateKey = []byte(privateKeyVal)
-		rsaConfig.RSAPublicKey = []byte(publicKeyVal)
-		return nil
-	}
-
-	// 2.Read RSA configuration from file if exists
-	if file.IsExist(rsaConfig.RSAPrivateKeyPath) && file.IsExist(rsaConfig.RSAPublicKeyPath) {
-		//password already read from config
-		rsaConfig.RSAPrivateKey, rsaConfig.RSAPublicKey, err = readConfigFile(rsaConfig)
-		if err != nil {
-			return errors.WithMessage(err, "failed to read rsa config from file")
-		}
-		return nil
-	}
-	// 3.Generate RSA keys if not exist
-	rsaConfig.RSAPassWord, rsaConfig.RSAPrivateKey, rsaConfig.RSAPublicKey, err = initRSAKeyPairs(ctx, rsaConfig.RSAPassWord)
-	if err != nil {
-		return errors.WithMessage(err, "failed to generate rsa key pair")
-	}
-	return nil
-}
-
-func initRSAKeyPairs(ctx *ctx.Context, rsaPassWord string) (password string, privateByte, publicByte []byte, err error) {
-
-	// Generate RSA keys
-
-	// Generate RSA password
-	if rsaPassWord != "" {
-		logger.Debug("Using existing RSA password")
-		password = rsaPassWord
-		err = models.ConfigsSet(ctx, models.RSA_PASSWORD, password)
-		if err != nil {
-			err = errors.WithMessagef(err, "failed to set config(%s)", models.RSA_PASSWORD)
-			return
-		}
-	} else {
-		password, err = models.InitRSAPassWord(ctx)
-		if err != nil {
-			err = errors.WithMessage(err, "failed to generate rsa password")
-			return
-		}
-	}
-	privateByte, publicByte, err = secu.GenerateRsaKeyPair(password)
-	if err != nil {
-		err = errors.WithMessage(err, "failed to generate rsa key pair")
-		return
-	}
-	// Save generated RSA keys
-	err = models.ConfigsSet(ctx, models.RSA_PRIVATE_KEY, string(privateByte))
-	if err != nil {
-		err = errors.WithMessagef(err, "failed to set config(%s)", models.RSA_PRIVATE_KEY)
-		return
-	}
-	err = models.ConfigsSet(ctx, models.RSA_PUBLIC_KEY, string(publicByte))
-	if err != nil {
-		err = errors.WithMessagef(err, "failed to set config(%s)", models.RSA_PUBLIC_KEY)
-		return
-	}
-	return
-}
-
-func readConfigFile(rsaConfig *httpx.RSAConfig) (privateBuf, publicBuf []byte, err error) {
-	publicBuf, err = os.ReadFile(rsaConfig.RSAPublicKeyPath)
-	if err != nil {
-		err = errors.WithMessagef(err, "could not read RSAPublicKeyPath %q", rsaConfig.RSAPublicKeyPath)
-		return
-	}
-	privateBuf, err = os.ReadFile(rsaConfig.RSAPrivateKeyPath)
-	if err != nil {
-		err = errors.WithMessagef(err, "could not read RSAPrivateKeyPath %q", rsaConfig.RSAPrivateKeyPath)
-	}
-	return
-}
--- a/center/cconf/sql_tpl.go
+++ b/center/cconf/sql_tpl.go
@@ -1,15 +0,0 @@
-package cconf
-
-var TDengineSQLTpl = map[string]string{
-	"load5":                "SELECT _wstart as ts, last(load5) FROM $database.system WHERE host = '$server' and _ts >= $from and _ts <= $to interval($interval) fill(null)",
-	"process_total":        "SELECT _wstart as ts, last(total) FROM $database.processes WHERE host = '$server' and _ts >= $from and _ts <= $to interval($interval) fill(null)",
-	"thread_total":         "SELECT _wstart as ts, last(total) FROM $database.threads WHERE host = '$server' and _ts >= $from and _ts <= $to interval($interval) fill(null)",
-	"cpu_idle":             "SELECT _wstart as ts, last(usage_idle) * -1 + 100 FROM $database.cpu WHERE (host = '$server' and cpu = 'cpu-total') and _ts >= $from and _ts <= $to interval($interval) fill(null)",
-	"mem_used_percent":     "SELECT _wstart as ts, last(used_percent) FROM $database.mem WHERE (host = '$server') and _ts >= $from and _ts <= $to interval($interval) fill(null)",
-	"disk_used_percent":    "SELECT _wstart as ts, last(used_percent) FROM $database.disk WHERE (host = '$server' and path = '/') and _ts >= $from and _ts <= $to interval($interval) fill(null)",
-	"cpu_context_switches": "select ts, derivative(context_switches, 1s, 0) as context FROM (SELECT _wstart as ts, avg(context_switches) as context_switches FROM $database.kernel WHERE host = '$server' and _ts >= $from and _ts <= $to interval($interval) )",
-	"tcp":                  "SELECT _wstart as ts, avg(tcp_close) as CLOSED, avg(tcp_close_wait) as CLOSE_WAIT, avg(tcp_closing) as CLOSING, avg(tcp_established) as ESTABLISHED, avg(tcp_fin_wait1) as FIN_WAIT1, avg(tcp_fin_wait2) as FIN_WAIT2, avg(tcp_last_ack) as LAST_ACK, avg(tcp_syn_recv) as SYN_RECV, avg(tcp_syn_sent) as SYN_SENT, avg(tcp_time_wait) as TIME_WAIT FROM $database.netstat WHERE host = '$server' and _ts >= $from and _ts <= $to interval($interval)",
-	"net_bytes_recv":       "SELECT _wstart as ts, derivative(bytes_recv,1s, 1) as bytes_in FROM $database.net WHERE host = '$server' and interface = '$netif' and _ts >= $from and _ts <= $to group by tbname",
-	"net_bytes_sent":       "SELECT _wstart as ts, derivative(bytes_sent,1s, 1) as bytes_out FROM $database.net WHERE host = '$server' and interface = '$netif' and _ts >= $from and _ts <= $to group by tbname",
-	"disk_total":           "SELECT _wstart as ts, avg(total) AS total, avg(used) as used FROM $database.disk WHERE   path = '$mountpoint' and _ts >= $from and _ts <= $to  interval($interval) group by host",
-}
--- a/center/center.go
+++ b/center/center.go
@@ -8,25 +8,19 @@ import (
 	"github.com/ccfos/nightingale/v6/alert/astats"
 	"github.com/ccfos/nightingale/v6/alert/process"
 	"github.com/ccfos/nightingale/v6/center/cconf"
-	"github.com/ccfos/nightingale/v6/center/cconf/rsa"
-	"github.com/ccfos/nightingale/v6/center/cstats"
 	"github.com/ccfos/nightingale/v6/center/metas"
 	"github.com/ccfos/nightingale/v6/center/sso"
 	"github.com/ccfos/nightingale/v6/conf"
-	"github.com/ccfos/nightingale/v6/dumper"
 	"github.com/ccfos/nightingale/v6/memsto"
 	"github.com/ccfos/nightingale/v6/models"
-	"github.com/ccfos/nightingale/v6/models/migrate"
 	"github.com/ccfos/nightingale/v6/pkg/ctx"
 	"github.com/ccfos/nightingale/v6/pkg/httpx"
 	"github.com/ccfos/nightingale/v6/pkg/i18nx"
 	"github.com/ccfos/nightingale/v6/pkg/logx"
-	"github.com/ccfos/nightingale/v6/pkg/version"
 	"github.com/ccfos/nightingale/v6/prom"
 	"github.com/ccfos/nightingale/v6/pushgw/idents"
 	"github.com/ccfos/nightingale/v6/pushgw/writer"
 	"github.com/ccfos/nightingale/v6/storage"
-	"github.com/ccfos/nightingale/v6/tdengine"

 	alertrt "github.com/ccfos/nightingale/v6/alert/router"
 	centerrt "github.com/ccfos/nightingale/v6/center/router"
@@ -42,31 +36,21 @@ func Initialize(configDir string, cryptoKey string) (func(), error) {
 	cconf.LoadMetricsYaml(configDir, config.Center.MetricsYamlFile)
 	cconf.LoadOpsYaml(configDir, config.Center.OpsYamlFile)

-	cconf.MergeOperationConf()
-
 	logxClean, err := logx.Init(config.Log)
 	if err != nil {
 		return nil, err
 	}

-	i18nx.Init(configDir)
-	cstats.Init()
+	i18nx.Init()

 	db, err := storage.New(config.DB)
 	if err != nil {
 		return nil, err
 	}
 	ctx := ctx.NewContext(context.Background(), db, true)
-	migrate.Migrate(db)
 	models.InitRoot(ctx)

-	err = rsa.InitRSAConfig(ctx, &config.HTTP.RSA)
-	if err != nil {
-		return nil, err
-	}
-
-	var redis storage.Redis
-	redis, err = storage.NewRedis(config.Redis)
+	redis, err := storage.NewRedis(config.Redis)
 	if err != nil {
 		return nil, err
 	}
@@ -79,29 +63,22 @@ func Initialize(configDir string, cryptoKey string) (func(), error) {

 	sso := sso.Init(config.Center, ctx)

-	configCache := memsto.NewConfigCache(ctx, syncStats, config.HTTP.RSA.RSAPrivateKey, config.HTTP.RSA.RSAPassWord)
 	busiGroupCache := memsto.NewBusiGroupCache(ctx, syncStats)
 	targetCache := memsto.NewTargetCache(ctx, syncStats, redis)
 	dsCache := memsto.NewDatasourceCache(ctx, syncStats)
 	alertMuteCache := memsto.NewAlertMuteCache(ctx, syncStats)
 	alertRuleCache := memsto.NewAlertRuleCache(ctx, syncStats)
-	notifyConfigCache := memsto.NewNotifyConfigCache(ctx, configCache)
-	userCache := memsto.NewUserCache(ctx, syncStats)
-	userGroupCache := memsto.NewUserGroupCache(ctx, syncStats)
+	notifyConfigCache := memsto.NewNotifyConfigCache(ctx)

 	promClients := prom.NewPromClient(ctx, config.Alert.Heartbeat)
-	tdengineClients := tdengine.NewTdengineClient(ctx, config.Alert.Heartbeat)

 	externalProcessors := process.NewExternalProcessors()
-	alert.Start(config.Alert, config.Pushgw, syncStats, alertStats, externalProcessors, targetCache, busiGroupCache, alertMuteCache, alertRuleCache, notifyConfigCache, dsCache, ctx, promClients, tdengineClients, userCache, userGroupCache)
+	alert.Start(config.Alert, config.Pushgw, syncStats, alertStats, externalProcessors, targetCache, busiGroupCache, alertMuteCache, alertRuleCache, notifyConfigCache, dsCache, ctx, promClients)

 	writers := writer.NewWriters(config.Pushgw)

-	go version.GetGithubVersion()
-
 	alertrtRouter := alertrt.New(config.HTTP, config.Alert, alertMuteCache, targetCache, busiGroupCache, alertStats, ctx, externalProcessors)
-	centerRouter := centerrt.New(config.HTTP, config.Center, cconf.Operations, dsCache, notifyConfigCache, promClients, tdengineClients,
-		redis, sso, ctx, metas, idents, targetCache, userCache, userGroupCache)
+	centerRouter := centerrt.New(config.HTTP, config.Center, cconf.Operations, dsCache, notifyConfigCache, promClients, redis, sso, ctx, metas, targetCache)
 	pushgwRouter := pushgwrt.New(config.HTTP, config.Pushgw, targetCache, busiGroupCache, idents, writers, ctx)

 	r := httpx.GinEngine(config.Global.RunMode, config.HTTP)
@@ -109,7 +86,6 @@ func Initialize(configDir string, cryptoKey string) (func(), error) {
 	centerRouter.Config(r)
 	alertrtRouter.Config(r)
 	pushgwRouter.Config(r)
-	dumper.ConfigRouter(r)

 	httpClean := httpx.Init(config.HTTP, r)

--- a/center/router/router.go
+++ b/center/router/router.go
@@ -3,8 +3,6 @@ package router
 import (
 	"fmt"
 	"net/http"
-	"path"
-	"runtime"
 	"strings"
 	"time"

@@ -17,17 +15,12 @@ import (
 	"github.com/ccfos/nightingale/v6/pkg/aop"
 	"github.com/ccfos/nightingale/v6/pkg/ctx"
 	"github.com/ccfos/nightingale/v6/pkg/httpx"
-	"github.com/ccfos/nightingale/v6/pkg/version"
 	"github.com/ccfos/nightingale/v6/prom"
-	"github.com/ccfos/nightingale/v6/pushgw/idents"
 	"github.com/ccfos/nightingale/v6/storage"
-	"github.com/ccfos/nightingale/v6/tdengine"

 	"github.com/gin-gonic/gin"
 	"github.com/rakyll/statik/fs"
-	"github.com/toolkits/pkg/ginx"
 	"github.com/toolkits/pkg/logger"
-	"github.com/toolkits/pkg/runner"
 )

 type Router struct {
@@ -37,20 +30,15 @@ type Router struct {
 	DatasourceCache   *memsto.DatasourceCacheType
 	NotifyConfigCache *memsto.NotifyConfigCacheType
 	PromClients       *prom.PromClientMap
-	TdendgineClients  *tdengine.TdengineClientMap
 	Redis             storage.Redis
 	MetaSet           *metas.Set
-	IdentSet          *idents.Set
 	TargetCache       *memsto.TargetCacheType
 	Sso               *sso.SsoClient
-	UserCache         *memsto.UserCacheType
-	UserGroupCache    *memsto.UserGroupCacheType
 	Ctx               *ctx.Context
-
-	DatasourceCheckHook func(*gin.Context) bool
 }

-func New(httpConfig httpx.Config, center cconf.Center, operations cconf.Operation, ds *memsto.DatasourceCacheType, ncc *memsto.NotifyConfigCacheType, pc *prom.PromClientMap, tdendgineClients *tdengine.TdengineClientMap, redis storage.Redis, sso *sso.SsoClient, ctx *ctx.Context, metaSet *metas.Set, idents *idents.Set, tc *memsto.TargetCacheType, uc *memsto.UserCacheType, ugc *memsto.UserGroupCacheType) *Router {
+func New(httpConfig httpx.Config, center cconf.Center, operations cconf.Operation, ds *memsto.DatasourceCacheType, ncc *memsto.NotifyConfigCacheType,
+	pc *prom.PromClientMap, redis storage.Redis, sso *sso.SsoClient, ctx *ctx.Context, metaSet *metas.Set, tc *memsto.TargetCacheType) *Router {
 	return &Router{
 		HTTP:              httpConfig,
 		Center:            center,
@@ -58,17 +46,11 @@ func New(httpConfig httpx.Config, center cconf.Center, operations cconf.Operatio
 		DatasourceCache:   ds,
 		NotifyConfigCache: ncc,
 		PromClients:       pc,
-		TdendgineClients:  tdendgineClients,
 		Redis:             redis,
 		MetaSet:           metaSet,
-		IdentSet:          idents,
 		TargetCache:       tc,
 		Sso:               sso,
-		UserCache:         uc,
-		UserGroupCache:    ugc,
 		Ctx:               ctx,
-
-		DatasourceCheckHook: func(ctx *gin.Context) bool { return false },
 	}
 }

@@ -113,32 +95,10 @@ func (rt *Router) configNoRoute(r *gin.Engine, fs *http.FileSystem) {
 		suffix := arr[len(arr)-1]

 		switch suffix {
-		case "png", "jpeg", "jpg", "svg", "ico", "gif", "css", "js", "html", "htm", "gz", "zip", "map", "ttf":
-			if !rt.Center.UseFileAssets {
-				c.FileFromFS(c.Request.URL.Path, *fs)
-			} else {
-				cwdarr := []string{"/"}
-				if runtime.GOOS == "windows" {
-					cwdarr[0] = ""
-				}
-				cwdarr = append(cwdarr, strings.Split(runner.Cwd, "/")...)
-				cwdarr = append(cwdarr, "pub")
-				cwdarr = append(cwdarr, strings.Split(c.Request.URL.Path, "/")...)
-				c.File(path.Join(cwdarr...))
-			}
+		case "png", "jpeg", "jpg", "svg", "ico", "gif", "css", "js", "html", "htm", "gz", "zip", "map":
+			c.FileFromFS(c.Request.URL.Path, *fs)
 		default:
-			if !rt.Center.UseFileAssets {
-				c.FileFromFS("/", *fs)
-			} else {
-				cwdarr := []string{"/"}
-				if runtime.GOOS == "windows" {
-					cwdarr[0] = ""
-				}
-				cwdarr = append(cwdarr, strings.Split(runner.Cwd, "/")...)
-				cwdarr = append(cwdarr, "pub")
-				cwdarr = append(cwdarr, "index.html")
-				c.File(path.Join(cwdarr...))
-			}
+			c.FileFromFS("/", *fs)
 		}
 	})
 }
@@ -153,10 +113,7 @@ func (rt *Router) Config(r *gin.Engine) {
 	if err != nil {
 		logger.Errorf("cannot create statik fs: %v", err)
 	}
-
-	if !rt.Center.UseFileAssets {
-		r.StaticFS("/pub", statikFS)
-	}
+	r.StaticFS("/pub", statikFS)

 	pagesPrefix := "/api/n9e"
 	pages := r.Group(pagesPrefix)
@@ -167,38 +124,18 @@ func (rt *Router) Config(r *gin.Engine) {
 			pages.POST("/query-range-batch", rt.promBatchQueryRange)
 			pages.POST("/query-instant-batch", rt.promBatchQueryInstant)
 			pages.GET("/datasource/brief", rt.datasourceBriefs)
-
-			pages.POST("/ds-query", rt.QueryData)
-			pages.POST("/logs-query", rt.QueryLog)
-
-			pages.POST("/tdengine-databases", rt.tdengineDatabases)
-			pages.POST("/tdengine-tables", rt.tdengineTables)
-			pages.POST("/tdengine-columns", rt.tdengineColumns)
-
-			pages.GET("/sql-template", rt.QuerySqlTemplate)
 		} else {
 			pages.Any("/proxy/:id/*url", rt.auth(), rt.dsProxy)
 			pages.POST("/query-range-batch", rt.auth(), rt.promBatchQueryRange)
 			pages.POST("/query-instant-batch", rt.auth(), rt.promBatchQueryInstant)
 			pages.GET("/datasource/brief", rt.auth(), rt.datasourceBriefs)
-
-			pages.POST("/ds-query", rt.auth(), rt.QueryData)
-			pages.POST("/logs-query", rt.auth(), rt.QueryLog)
-
-			pages.POST("/tdengine-databases", rt.auth(), rt.tdengineDatabases)
-			pages.POST("/tdengine-tables", rt.auth(), rt.tdengineTables)
-			pages.POST("/tdengine-columns", rt.auth(), rt.tdengineColumns)
 		}

 		pages.POST("/auth/login", rt.jwtMock(), rt.loginPost)
-		pages.POST("/auth/logout", rt.jwtMock(), rt.auth(), rt.logoutPost)
+		pages.POST("/auth/logout", rt.jwtMock(), rt.logoutPost)
 		pages.POST("/auth/refresh", rt.jwtMock(), rt.refreshPost)
-		pages.POST("/auth/captcha", rt.jwtMock(), rt.generateCaptcha)
-		pages.POST("/auth/captcha-verify", rt.jwtMock(), rt.captchaVerify)
-		pages.GET("/auth/ifshowcaptcha", rt.ifShowCaptcha)

 		pages.GET("/auth/sso-config", rt.ssoConfigNameGet)
-		pages.GET("/auth/rsa-config", rt.rsaConfigGet)
 		pages.GET("/auth/redirect", rt.loginRedirect)
 		pages.GET("/auth/redirect/cas", rt.loginRedirectCas)
 		pages.GET("/auth/redirect/oauth", rt.loginRedirectOAuth)
@@ -266,7 +203,6 @@ func (rt *Router) Config(r *gin.Engine) {
 		pages.GET("/builtin-boards-cates", rt.auth(), rt.user(), rt.builtinBoardCateGets)
 		pages.POST("/builtin-boards-detail", rt.auth(), rt.user(), rt.builtinBoardDetailGets)
 		pages.GET("/integrations/icon/:cate/:name", rt.builtinIcon)
-		pages.GET("/integrations/makedown/:cate", rt.builtinMarkdown)

 		pages.GET("/busi-group/:id/boards", rt.auth(), rt.user(), rt.perm("/dashboards"), rt.bgro(), rt.boardGets)
 		pages.POST("/busi-group/:id/boards", rt.auth(), rt.user(), rt.perm("/dashboards/add"), rt.bgrw(), rt.boardAdd)
@@ -292,7 +228,6 @@ func (rt *Router) Config(r *gin.Engine) {
 		pages.PUT("/busi-group/:id/alert-rules/fields", rt.auth(), rt.user(), rt.perm("/alert-rules/put"), rt.bgrw(), rt.alertRulePutFields)
 		pages.PUT("/busi-group/:id/alert-rule/:arid", rt.auth(), rt.user(), rt.perm("/alert-rules/put"), rt.alertRulePutByFE)
 		pages.GET("/alert-rule/:arid", rt.auth(), rt.user(), rt.perm("/alert-rules"), rt.alertRuleGet)
-		pages.PUT("/busi-group/alert-rule/validate", rt.auth(), rt.user(), rt.perm("/alert-rules/put"), rt.alertRuleValidation)

 		pages.GET("/busi-group/:id/recording-rules", rt.auth(), rt.user(), rt.perm("/recording-rules"), rt.recordingRuleGets)
 		pages.POST("/busi-group/:id/recording-rules", rt.auth(), rt.user(), rt.perm("/recording-rules/add"), rt.bgrw(), rt.recordingRuleAddByFE)
@@ -302,7 +237,6 @@ func (rt *Router) Config(r *gin.Engine) {
 		pages.PUT("/busi-group/:id/recording-rules/fields", rt.auth(), rt.user(), rt.perm("/recording-rules/put"), rt.recordingRulePutFields)

 		pages.GET("/busi-group/:id/alert-mutes", rt.auth(), rt.user(), rt.perm("/alert-mutes"), rt.bgro(), rt.alertMuteGetsByBG)
-		pages.POST("/busi-group/:id/alert-mutes/preview", rt.auth(), rt.user(), rt.perm("/alert-mutes/add"), rt.bgrw(), rt.alertMutePreview)
 		pages.POST("/busi-group/:id/alert-mutes", rt.auth(), rt.user(), rt.perm("/alert-mutes/add"), rt.bgrw(), rt.alertMuteAdd)
 		pages.DELETE("/busi-group/:id/alert-mutes", rt.auth(), rt.user(), rt.perm("/alert-mutes/del"), rt.bgrw(), rt.alertMuteDel)
 		pages.PUT("/busi-group/:id/alert-mute/:amid", rt.auth(), rt.user(), rt.perm("/alert-mutes/put"), rt.alertMutePutByFE)
@@ -328,7 +262,6 @@ func (rt *Router) Config(r *gin.Engine) {
 		pages.POST("/alert-cur-events/card/details", rt.auth(), rt.alertCurEventsCardDetails)
 		pages.GET("/alert-his-events/list", rt.auth(), rt.alertHisEventsList)
 		pages.DELETE("/alert-cur-events", rt.auth(), rt.user(), rt.perm("/alert-cur-events/del"), rt.alertCurEventDel)
-		pages.GET("/alert-cur-events/stats", rt.auth(), rt.alertCurEventsStatistics)

 		pages.GET("/alert-aggr-views", rt.auth(), rt.alertAggrViewGets)
 		pages.DELETE("/alert-aggr-views", rt.auth(), rt.user(), rt.alertAggrViewDel)
@@ -367,63 +300,30 @@ func (rt *Router) Config(r *gin.Engine) {
 		pages.PUT("/role/:id/ops", rt.auth(), rt.admin(), rt.roleBindOperation)
 		pages.GET("/operation", rt.operations)

-		pages.GET("/notify-tpls", rt.auth(), rt.user(), rt.perm("/help/notification-tpls"), rt.notifyTplGets)
+		pages.GET("/notify-tpls", rt.auth(), rt.admin(), rt.notifyTplGets)
 		pages.PUT("/notify-tpl/content", rt.auth(), rt.admin(), rt.notifyTplUpdateContent)
 		pages.PUT("/notify-tpl", rt.auth(), rt.admin(), rt.notifyTplUpdate)
-		pages.POST("/notify-tpl", rt.auth(), rt.admin(), rt.notifyTplAdd)
-		pages.DELETE("/notify-tpl/:id", rt.auth(), rt.admin(), rt.notifyTplDel)
 		pages.POST("/notify-tpl/preview", rt.auth(), rt.admin(), rt.notifyTplPreview)

 		pages.GET("/sso-configs", rt.auth(), rt.admin(), rt.ssoConfigGets)
 		pages.PUT("/sso-config", rt.auth(), rt.admin(), rt.ssoConfigUpdate)

-		pages.GET("/webhooks", rt.auth(), rt.user(), rt.webhookGets)
+		pages.GET("/webhooks", rt.auth(), rt.admin(), rt.webhookGets)
 		pages.PUT("/webhooks", rt.auth(), rt.admin(), rt.webhookPuts)

-		pages.GET("/notify-script", rt.auth(), rt.user(), rt.perm("/help/notification-settings"), rt.notifyScriptGet)
+		pages.GET("/notify-script", rt.auth(), rt.admin(), rt.notifyScriptGet)
 		pages.PUT("/notify-script", rt.auth(), rt.admin(), rt.notifyScriptPut)

-		pages.GET("/notify-channel", rt.auth(), rt.user(), rt.perm("/help/notification-settings"), rt.notifyChannelGets)
+		pages.GET("/notify-channel", rt.auth(), rt.admin(), rt.notifyChannelGets)
 		pages.PUT("/notify-channel", rt.auth(), rt.admin(), rt.notifyChannelPuts)

-		pages.GET("/notify-contact", rt.auth(), rt.user(), rt.perm("/help/notification-settings"), rt.notifyContactGets)
+		pages.GET("/notify-contact", rt.auth(), rt.admin(), rt.notifyContactGets)
 		pages.PUT("/notify-contact", rt.auth(), rt.admin(), rt.notifyContactPuts)

-		pages.GET("/notify-config", rt.auth(), rt.user(), rt.perm("/help/notification-settings"), rt.notifyConfigGet)
+		pages.GET("/notify-config", rt.auth(), rt.admin(), rt.notifyConfigGet)
 		pages.PUT("/notify-config", rt.auth(), rt.admin(), rt.notifyConfigPut)
-		pages.PUT("/smtp-config-test", rt.auth(), rt.admin(), rt.attemptSendEmail)
-
-		pages.GET("/es-index-pattern", rt.auth(), rt.esIndexPatternGet)
-		pages.GET("/es-index-pattern-list", rt.auth(), rt.esIndexPatternGetList)
-		pages.POST("/es-index-pattern", rt.auth(), rt.admin(), rt.esIndexPatternAdd)
-		pages.PUT("/es-index-pattern", rt.auth(), rt.admin(), rt.esIndexPatternPut)
-		pages.DELETE("/es-index-pattern", rt.auth(), rt.admin(), rt.esIndexPatternDel)
-
-		pages.GET("/user-variable-configs", rt.auth(), rt.user(), rt.perm("/help/variable-configs"), rt.userVariableConfigGets)
-		pages.POST("/user-variable-config", rt.auth(), rt.user(), rt.perm("/help/variable-configs"), rt.userVariableConfigAdd)
-		pages.PUT("/user-variable-config/:id", rt.auth(), rt.user(), rt.perm("/help/variable-configs"), rt.userVariableConfigPut)
-		pages.DELETE("/user-variable-config/:id", rt.auth(), rt.user(), rt.perm("/help/variable-configs"), rt.userVariableConfigDel)
-
-		pages.GET("/config", rt.auth(), rt.admin(), rt.configGetByKey)
-		pages.PUT("/config", rt.auth(), rt.admin(), rt.configPutByKey)
-
 	}

-	r.GET("/api/n9e/versions", func(c *gin.Context) {
-		v := version.Version
-		lastIndex := strings.LastIndex(version.Version, "-")
-		if lastIndex != -1 {
-			v = version.Version[:lastIndex]
-		}
-
-		gv := version.GithubVersion.Load()
-		if gv != nil {
-			ginx.NewRender(c).Data(gin.H{"version": v, "github_verison": gv.(string)}, nil)
-		} else {
-			ginx.NewRender(c).Data(gin.H{"version": v, "github_verison": ""}, nil)
-		}
-	})
-
 	if rt.HTTP.APIForService.Enable {
 		service := r.Group("/v1/n9e")
 		if len(rt.HTTP.APIForService.BasicAuth) > 0 {
@@ -469,8 +369,6 @@ func (rt *Router) Config(r *gin.Engine) {
 			service.GET("/alert-his-events", rt.alertHisEventsList)
 			service.GET("/alert-his-event/:eid", rt.alertHisEventGet)

-			service.GET("/task-tpl/:tid", rt.taskTplGetByService)
-
 			service.GET("/config/:id", rt.configGet)
 			service.GET("/configs", rt.configsGet)
 			service.GET("/config", rt.configGetByKey)
@@ -486,8 +384,6 @@ func (rt *Router) Config(r *gin.Engine) {
 			service.GET("/notify-tpls", rt.notifyTplGets)

 			service.POST("/task-record-add", rt.taskRecordAdd)
-
-			service.GET("/user-variable/decrypt", rt.userVariableGetDecryptByService)
 		}
 	}

--- a/center/router/router_alert_aggr_view.go
+++ b/center/router/router_alert_aggr_view.go
@@ -69,11 +69,6 @@ func (rt *Router) alertAggrViewPut(c *gin.Context) {
 			return
 		}
 	}
-	view.Name = f.Name
-	view.Rule = f.Rule
-	view.Cate = f.Cate
-	if view.CreateBy == 0 {
-		view.CreateBy = me.Id
-	}
-	ginx.NewRender(c).Message(view.Update(rt.Ctx))
+
+	ginx.NewRender(c).Message(view.Update(rt.Ctx, f.Name, f.Rule, f.Cate, me.Id))
 }
--- a/center/router/router_alert_cur_event.go
+++ b/center/router/router_alert_cur_event.go
@@ -4,7 +4,6 @@ import (
 	"net/http"
 	"sort"
 	"strings"
-	"time"

 	"github.com/ccfos/nightingale/v6/models"

@@ -183,19 +182,10 @@ func (rt *Router) alertCurEventDel(c *gin.Context) {
 	ginx.BindJSON(c, &f)
 	f.Verify()

-	rt.checkCurEventBusiGroupRWPermission(c, f.Ids)
-
-	ginx.NewRender(c).Message(models.AlertCurEventDel(rt.Ctx, f.Ids))
-}
-
-func (rt *Router) checkCurEventBusiGroupRWPermission(c *gin.Context, ids []int64) {
 	set := make(map[int64]struct{})

-	// event group id is 0, ignore perm check
-	set[0] = struct{}{}
-
-	for i := 0; i < len(ids); i++ {
-		event, err := models.AlertCurEventGetById(rt.Ctx, ids[i])
+	for i := 0; i < len(f.Ids); i++ {
+		event, err := models.AlertCurEventGetById(rt.Ctx, f.Ids[i])
 		ginx.Dangerous(err)

 		if _, has := set[event.GroupId]; !has {
@@ -203,6 +193,8 @@ func (rt *Router) checkCurEventBusiGroupRWPermission(c *gin.Context, ids []int64
 			set[event.GroupId] = struct{}{}
 		}
 	}
+
+	ginx.NewRender(c).Message(models.AlertCurEventDel(rt.Ctx, f.Ids))
 }

 func (rt *Router) alertCurEventGet(c *gin.Context) {
@@ -216,8 +208,3 @@ func (rt *Router) alertCurEventGet(c *gin.Context) {

 	ginx.NewRender(c).Data(event, nil)
 }
-
-func (rt *Router) alertCurEventsStatistics(c *gin.Context) {
-
-	ginx.NewRender(c).Data(models.AlertCurEventStatistics(rt.Ctx, time.Now()), nil)
-}
--- a/center/router/router_alert_rule.go
+++ b/center/router/router_alert_rule.go
@@ -2,7 +2,6 @@ package router

 import (
 	"net/http"
-	"strconv"
 	"strings"
 	"time"

@@ -272,54 +271,3 @@ func (rt *Router) alertRuleGet(c *gin.Context) {

 	ginx.NewRender(c).Data(ar, err)
 }
-
-// pre validation before save rule
-func (rt *Router) alertRuleValidation(c *gin.Context) {
-	var f models.AlertRule //new
-	ginx.BindJSON(c, &f)
-
-	if len(f.NotifyChannelsJSON) > 0 && len(f.NotifyGroupsJSON) > 0 { //Validation NotifyChannels
-		ngids := make([]int64, 0, len(f.NotifyChannelsJSON))
-		for i := range f.NotifyGroupsJSON {
-			id, _ := strconv.ParseInt(f.NotifyGroupsJSON[i], 10, 64)
-			ngids = append(ngids, id)
-		}
-		userGroups := rt.UserGroupCache.GetByUserGroupIds(ngids)
-		uids := make([]int64, 0)
-		for i := range userGroups {
-			uids = append(uids, userGroups[i].UserIds...)
-		}
-		users := rt.UserCache.GetByUserIds(uids)
-		//If any users have a certain notify channel's token, it will be okay. Otherwise, this notify channel is absent of tokens.
-		ancs := make([]string, 0, len(f.NotifyChannelsJSON)) //absent Notify Channels
-		for i := range f.NotifyChannelsJSON {
-			flag := true
-			//ignore non-default channels
-			switch f.NotifyChannelsJSON[i] {
-			case models.Dingtalk, models.Wecom, models.Feishu, models.Mm,
-				models.Telegram, models.Email, models.FeishuCard:
-				// do nothing
-			default:
-				continue
-			}
-			//default channels
-			for ui := range users {
-				if _, b := users[ui].ExtractToken(f.NotifyChannelsJSON[i]); b {
-					flag = false
-					break
-				}
-			}
-			if flag {
-				ancs = append(ancs, f.NotifyChannelsJSON[i])
-			}
-		}
-
-		if len(ancs) > 0 {
-			ginx.NewRender(c).Message("All users are missing notify channel configurations. Please check for missing tokens (each channel should be configured with at least one user). %s", ancs)
-			return
-		}
-
-	}
-
-	ginx.NewRender(c).Message("")
-}
--- a/center/router/router_alert_subscribe.go
+++ b/center/router/router_alert_subscribe.go
@@ -14,18 +14,21 @@ import (
 func (rt *Router) alertSubscribeGets(c *gin.Context) {
 	bgid := ginx.UrlParamInt64(c, "id")
 	lst, err := models.AlertSubscribeGets(rt.Ctx, bgid)
-	ginx.Dangerous(err)
+	if err == nil {
+		ugcache := make(map[int64]*models.UserGroup)
+		for i := 0; i < len(lst); i++ {
+			ginx.Dangerous(lst[i].FillUserGroups(rt.Ctx, ugcache))
+		}

-	ugcache := make(map[int64]*models.UserGroup)
-	rulecache := make(map[int64]string)
+		rulecache := make(map[int64]string)
+		for i := 0; i < len(lst); i++ {
+			ginx.Dangerous(lst[i].FillRuleName(rt.Ctx, rulecache))
+		}

-	for i := 0; i < len(lst); i++ {
-		ginx.Dangerous(lst[i].FillUserGroups(rt.Ctx, ugcache))
-		ginx.Dangerous(lst[i].FillRuleName(rt.Ctx, rulecache))
-		ginx.Dangerous(lst[i].FillDatasourceIds(rt.Ctx))
-		ginx.Dangerous(lst[i].DB2FE())
+		for i := 0; i < len(lst); i++ {
+			ginx.Dangerous(lst[i].FillDatasourceIds(rt.Ctx))
+		}
 	}
-
 	ginx.NewRender(c).Data(lst, err)
 }

@@ -80,9 +83,6 @@ func (rt *Router) alertSubscribePut(c *gin.Context) {
 			rt.Ctx,
 			"name",
 			"disabled",
-			"prod",
-			"cate",
-			"datasource_ids",
 			"cluster",
 			"rule_id",
 			"tags",
@@ -96,9 +96,7 @@ func (rt *Router) alertSubscribePut(c *gin.Context) {
 			"webhooks",
 			"for_duration",
 			"redefine_webhooks",
-			"severities",
-			"extra_config",
-			"busi_groups",
+			"datasource_ids",
 		))
 	}

--- a/center/router/router_builtin.go
+++ b/center/router/router_builtin.go
@@ -78,7 +78,7 @@ func (rt *Router) builtinBoardCateGets(c *gin.Context) {
 	}

 	me := c.MustGet("user").(*models.User)
-	builtinFavoritesMap, err := models.BuiltinCateGetByUserId(rt.Ctx, me.Id)
+	buildinFavoritesMap, err := models.BuiltinCateGetByUserId(rt.Ctx, me.Id)
 	if err != nil {
 		logger.Warningf("get builtin favorites fail: %v", err)
 	}
@@ -91,9 +91,6 @@ func (rt *Router) builtinBoardCateGets(c *gin.Context) {
 		boardCate.Name = dir
 		files, err := file.FilesUnder(fp + "/" + dir + "/dashboards")
 		ginx.Dangerous(err)
-		if len(files) == 0 {
-			continue
-		}

 		var boards []Payload
 		for _, f := range files {
@@ -117,7 +114,7 @@ func (rt *Router) builtinBoardCateGets(c *gin.Context) {
 		}
 		boardCate.Boards = boards

-		if _, ok := builtinFavoritesMap[dir]; ok {
+		if _, ok := buildinFavoritesMap[dir]; ok {
 			boardCate.Favorite = true
 		}

@@ -173,7 +170,7 @@ func (rt *Router) builtinAlertCateGets(c *gin.Context) {
 	}

 	me := c.MustGet("user").(*models.User)
-	builtinFavoritesMap, err := models.BuiltinCateGetByUserId(rt.Ctx, me.Id)
+	buildinFavoritesMap, err := models.BuiltinCateGetByUserId(rt.Ctx, me.Id)
 	if err != nil {
 		logger.Warningf("get builtin favorites fail: %v", err)
 	}
@@ -210,7 +207,7 @@ func (rt *Router) builtinAlertCateGets(c *gin.Context) {
 			alertCate.IconUrl = fmt.Sprintf("/api/n9e/integrations/icon/%s/%s", dir, iconFiles[0])
 		}

-		if _, ok := builtinFavoritesMap[dir]; ok {
+		if _, ok := buildinFavoritesMap[dir]; ok {
 			alertCate.Favorite = true
 		}

@@ -233,7 +230,7 @@ func (rt *Router) builtinAlertRules(c *gin.Context) {
 	}

 	me := c.MustGet("user").(*models.User)
-	builtinFavoritesMap, err := models.BuiltinCateGetByUserId(rt.Ctx, me.Id)
+	buildinFavoritesMap, err := models.BuiltinCateGetByUserId(rt.Ctx, me.Id)
 	if err != nil {
 		logger.Warningf("get builtin favorites fail: %v", err)
 	}
@@ -246,9 +243,6 @@ func (rt *Router) builtinAlertRules(c *gin.Context) {
 		alertCate.Name = dir
 		files, err := file.FilesUnder(fp + "/" + dir + "/alerts")
 		ginx.Dangerous(err)
-		if len(files) == 0 {
-			continue
-		}

 		alertRules := make(map[string][]models.AlertRule)
 		for _, f := range files {
@@ -274,7 +268,7 @@ func (rt *Router) builtinAlertRules(c *gin.Context) {
 			alertCate.IconUrl = fmt.Sprintf("/api/n9e/integrations/icon/%s/%s", dir, iconFiles[0])
 		}

-		if _, ok := builtinFavoritesMap[dir]; ok {
+		if _, ok := buildinFavoritesMap[dir]; ok {
 			alertCate.Favorite = true
 		}

@@ -315,26 +309,3 @@ func (rt *Router) builtinIcon(c *gin.Context) {
 	iconPath := fp + "/" + cate + "/icon/" + ginx.UrlParamStr(c, "name")
 	c.File(path.Join(iconPath))
 }
-
-func (rt *Router) builtinMarkdown(c *gin.Context) {
-	fp := rt.Center.BuiltinIntegrationsDir
-	if fp == "" {
-		fp = path.Join(runner.Cwd, "integrations")
-	}
-	cate := ginx.UrlParamStr(c, "cate")
-
-	var markdown []byte
-	markdownDir := fp + "/" + cate + "/markdown"
-	markdownFiles, err := file.FilesUnder(markdownDir)
-	if err != nil {
-		logger.Warningf("get markdown fail: %v", err)
-	} else if len(markdownFiles) > 0 {
-		f := markdownFiles[0]
-		fn := markdownDir + "/" + f
-		markdown, err = file.ReadBytes(fn)
-		if err != nil {
-			logger.Warningf("get collect fail: %v", err)
-		}
-	}
-	ginx.NewRender(c).Data(string(markdown), nil)
-}
--- a/center/router/router_captcha.go
+++ b/center/router/router_captcha.go
@@ -1,114 +0,0 @@
-package router
-
-import (
-	"context"
-	"time"
-
-	"github.com/ccfos/nightingale/v6/storage"
-	"github.com/gin-gonic/gin"
-	captcha "github.com/mojocn/base64Captcha"
-	"github.com/toolkits/pkg/ginx"
-	"github.com/toolkits/pkg/logger"
-)
-
-type CaptchaRedisStore struct {
-	redis storage.Redis
-}
-
-func (s *CaptchaRedisStore) Set(id string, value string) error {
-	ctx := context.Background()
-	err := s.redis.Set(ctx, id, value, time.Duration(300*time.Second)).Err()
-	if err != nil {
-		logger.Errorf("captcha id set to redis error : %s", err.Error())
-		return err
-	}
-	return nil
-}
-
-func (s *CaptchaRedisStore) Get(id string, clear bool) string {
-	ctx := context.Background()
-	val, err := s.redis.Get(ctx, id).Result()
-	if err != nil {
-		logger.Errorf("captcha id get from redis error : %s", err.Error())
-		return ""
-	}
-
-	if clear {
-		s.redis.Del(ctx, id)
-	}
-
-	return val
-}
-
-func (s *CaptchaRedisStore) Verify(id, answer string, clear bool) bool {
-
-	old := s.Get(id, clear)
-	return old == answer
-}
-
-func (rt *Router) newCaptchaRedisStore() *CaptchaRedisStore {
-	if captchaStore == nil {
-		captchaStore = &CaptchaRedisStore{redis: rt.Redis}
-	}
-	return captchaStore
-}
-
-var captchaStore *CaptchaRedisStore
-
-type CaptchaReqBody struct {
-	Id          string
-	VerifyValue string
-}
-
-// 生成图形验证码
-func (rt *Router) generateCaptcha(c *gin.Context) {
-	var driver = captcha.NewDriverMath(60, 200, 0, captcha.OptionShowHollowLine, nil, nil, []string{"wqy-microhei.ttc"})
-	cc := captcha.NewCaptcha(driver, rt.newCaptchaRedisStore())
-	//data:image/png;base64
-	id, b64s, err := cc.Generate()
-
-	if err != nil {
-		ginx.NewRender(c).Message(err)
-		return
-	}
-
-	ginx.NewRender(c).Data(gin.H{
-		"imgdata":   b64s,
-		"captchaid": id,
-	}, nil)
-}
-
-// 验证
-func (rt *Router) captchaVerify(c *gin.Context) {
-
-	var param CaptchaReqBody
-	ginx.BindJSON(c, &param)
-
-	//verify the captcha
-	if captchaStore.Verify(param.Id, param.VerifyValue, true) {
-		ginx.NewRender(c).Message("")
-		return
-	}
-	ginx.NewRender(c).Message("incorrect verification code")
-}
-
-// 验证码开关
-func (rt *Router) ifShowCaptcha(c *gin.Context) {
-
-	if rt.HTTP.ShowCaptcha.Enable {
-		ginx.NewRender(c).Data(gin.H{
-			"show": true,
-		}, nil)
-		return
-	}
-
-	ginx.NewRender(c).Data(gin.H{
-		"show": false,
-	}, nil)
-}
-
-// 验证
-func CaptchaVerify(id string, value string) bool {
-	//verify the captcha
-	return captchaStore.Verify(id, value, true)
-}
--- a/center/router/router_configs.go
+++ b/center/router/router_configs.go
@@ -2,7 +2,6 @@ package router

 import (
 	"github.com/ccfos/nightingale/v6/models"
-	"time"

 	"github.com/gin-gonic/gin"
 	"github.com/toolkits/pkg/ginx"
@@ -26,49 +25,28 @@ func (rt *Router) configGetByKey(c *gin.Context) {
 	ginx.NewRender(c).Data(config, err)
 }

-func (rt *Router) configPutByKey(c *gin.Context) {
-	var f models.Configs
-	ginx.BindJSON(c, &f)
-	username := c.MustGet("username").(string)
-	ginx.NewRender(c).Message(models.ConfigsSetWithUname(rt.Ctx, f.Ckey, f.Cval, username))
-}
-
 func (rt *Router) configsDel(c *gin.Context) {
 	var f idsForm
 	ginx.BindJSON(c, &f)
 	ginx.NewRender(c).Message(models.ConfigsDel(rt.Ctx, f.Ids))
 }

-func (rt *Router) configsPut(c *gin.Context) { //for APIForService
+func (rt *Router) configsPut(c *gin.Context) {
 	var arr []models.Configs
 	ginx.BindJSON(c, &arr)
-	username := c.GetString("user")
-	if username == "" {
-		username = "default"
-	}
-	now := time.Now().Unix()
+
 	for i := 0; i < len(arr); i++ {
-		arr[i].UpdateBy = username
-		arr[i].UpdateAt = now
 		ginx.Dangerous(arr[i].Update(rt.Ctx))
 	}

 	ginx.NewRender(c).Message(nil)
 }

-func (rt *Router) configsPost(c *gin.Context) { //for APIForService
+func (rt *Router) configsPost(c *gin.Context) {
 	var arr []models.Configs
 	ginx.BindJSON(c, &arr)
-	username := c.GetString("user")
-	if username == "" {
-		username = "default"
-	}
-	now := time.Now().Unix()
+
 	for i := 0; i < len(arr); i++ {
-		arr[i].CreateBy = username
-		arr[i].UpdateBy = username
-		arr[i].CreateAt = now
-		arr[i].UpdateAt = now
 		ginx.Dangerous(arr[i].Add(rt.Ctx))
 	}

--- a/center/router/router_datasource.go
+++ b/center/router/router_datasource.go
@@ -3,7 +3,6 @@ package router
 import (
 	"crypto/tls"
 	"fmt"
-	"io"
 	"net/http"
 	"net/url"
 	"strings"
@@ -26,11 +25,6 @@ type listReq struct {
 }

 func (rt *Router) datasourceList(c *gin.Context) {
-	if rt.DatasourceCheckHook(c) {
-		Render(c, []int{}, nil)
-		return
-	}
-
 	var req listReq
 	ginx.BindJSON(c, &req)

@@ -71,11 +65,6 @@ func (rt *Router) datasourceBriefs(c *gin.Context) {
 }

 func (rt *Router) datasourceUpsert(c *gin.Context) {
-	if rt.DatasourceCheckHook(c) {
-		Render(c, []int{}, nil)
-		return
-	}
-
 	var req models.Datasource
 	ginx.BindJSON(c, &req)
 	username := Username(c)
@@ -116,10 +105,6 @@ func DatasourceCheck(ds models.Datasource) error {
 		return fmt.Errorf("url is empty")
 	}

-	if !strings.HasPrefix(ds.HTTPJson.Url, "http") {
-		return fmt.Errorf("url must start with http or https")
-	}
-
 	client := &http.Client{
 		Transport: &http.Transport{
 			TLSClientConfig: &tls.Config{
@@ -138,33 +123,16 @@ func DatasourceCheck(ds models.Datasource) error {
 	if ds.PluginType == models.PROMETHEUS {
 		subPath := "/api/v1/query"
 		query := url.Values{}
-		if ds.HTTPJson.IsLoki() {
+		if strings.Contains(fullURL, "loki") {
 			subPath = "/api/v1/labels"
+			query.Add("start", "1")
+			query.Add("end", "2")
 		} else {
 			query.Add("query", "1+1")
 		}
 		fullURL = fmt.Sprintf("%s%s?%s", ds.HTTPJson.Url, subPath, query.Encode())

-		req, err = http.NewRequest("GET", fullURL, nil)
-		if err != nil {
-			logger.Errorf("Error creating request: %v", err)
-			return fmt.Errorf("request url:%s failed", fullURL)
-		}
-	} else if ds.PluginType == models.TDENGINE {
-		fullURL = fmt.Sprintf("%s/rest/sql", ds.HTTPJson.Url)
-		req, err = http.NewRequest("POST", fullURL, strings.NewReader("show databases"))
-		if err != nil {
-			logger.Errorf("Error creating request: %v", err)
-			return fmt.Errorf("request url:%s failed", fullURL)
-		}
-	}
-
-	if ds.PluginType == models.LOKI {
-		subPath := "/api/v1/labels"
-
-		fullURL = fmt.Sprintf("%s%s", ds.HTTPJson.Url, subPath)
-
-		req, err = http.NewRequest("GET", fullURL, nil)
+		req, err = http.NewRequest("POST", fullURL, nil)
 		if err != nil {
 			logger.Errorf("Error creating request: %v", err)
 			return fmt.Errorf("request url:%s failed", fullURL)
@@ -188,19 +156,13 @@ func DatasourceCheck(ds models.Datasource) error {

 	if resp.StatusCode != 200 {
 		logger.Errorf("Error making request: %v\n", resp.StatusCode)
-		body, _ := io.ReadAll(resp.Body)
-		return fmt.Errorf("request url:%s failed code:%d body:%s", fullURL, resp.StatusCode, string(body))
+		return fmt.Errorf("request url:%s failed code:%d", fullURL, resp.StatusCode)
 	}

 	return nil
 }

 func (rt *Router) datasourceGet(c *gin.Context) {
-	if rt.DatasourceCheckHook(c) {
-		Render(c, []int{}, nil)
-		return
-	}
-
 	var req models.Datasource
 	ginx.BindJSON(c, &req)
 	err := req.Get(rt.Ctx)
@@ -208,11 +170,6 @@ func (rt *Router) datasourceGet(c *gin.Context) {
 }

 func (rt *Router) datasourceUpdataStatus(c *gin.Context) {
-	if rt.DatasourceCheckHook(c) {
-		Render(c, []int{}, nil)
-		return
-	}
-
 	var req models.Datasource
 	ginx.BindJSON(c, &req)
 	username := Username(c)
@@ -222,11 +179,6 @@ func (rt *Router) datasourceUpdataStatus(c *gin.Context) {
 }

 func (rt *Router) datasourceDel(c *gin.Context) {
-	if rt.DatasourceCheckHook(c) {
-		Render(c, []int{}, nil)
-		return
-	}
-
 	var ids []int64
 	ginx.BindJSON(c, &ids)
 	err := models.DatasourceDel(rt.Ctx, ids)
--- a/center/router/router_es_index_pattern.go
+++ b/center/router/router_es_index_pattern.go
@@ -1,81 +0,0 @@
-package router
-
-import (
-	"net/http"
-	"time"
-
-	"github.com/ccfos/nightingale/v6/models"
-	"github.com/gin-gonic/gin"
-	"github.com/toolkits/pkg/ginx"
-)
-
-// 创建 ES Index Pattern
-func (rt *Router) esIndexPatternAdd(c *gin.Context) {
-	var f models.EsIndexPattern
-	ginx.BindJSON(c, &f)
-
-	username := c.MustGet("username").(string)
-	now := time.Now().Unix()
-	f.CreateAt = now
-	f.CreateBy = username
-	f.UpdateAt = now
-	f.UpdateBy = username
-
-	err := f.Add(rt.Ctx)
-	ginx.NewRender(c).Message(err)
-}
-
-// 更新 ES Index Pattern
-func (rt *Router) esIndexPatternPut(c *gin.Context) {
-	var f models.EsIndexPattern
-	ginx.BindJSON(c, &f)
-
-	id := ginx.QueryInt64(c, "id")
-
-	esIndexPattern, err := models.EsIndexPatternGetById(rt.Ctx, id)
-	ginx.Dangerous(err)
-
-	if esIndexPattern == nil {
-		ginx.NewRender(c, http.StatusNotFound).Message("No such EsIndexPattern")
-		return
-	}
-
-	f.UpdateBy = c.MustGet("username").(string)
-
-	ginx.NewRender(c).Message(esIndexPattern.Update(rt.Ctx, f))
-}
-
-// 删除 ES Index Pattern
-func (rt *Router) esIndexPatternDel(c *gin.Context) {
-	var f idsForm
-	ginx.BindJSON(c, &f)
-
-	if len(f.Ids) == 0 {
-		ginx.Bomb(http.StatusBadRequest, "ids empty")
-	}
-
-	ginx.NewRender(c).Message(models.EsIndexPatternDel(rt.Ctx, f.Ids))
-}
-
-// ES Index Pattern列表
-func (rt *Router) esIndexPatternGetList(c *gin.Context) {
-	datasourceId := ginx.QueryInt64(c, "datasource_id", 0)
-
-	var lst []*models.EsIndexPattern
-	var err error
-	if datasourceId != 0 {
-		lst, err = models.EsIndexPatternGets(rt.Ctx, "datasource_id = ?", datasourceId)
-	} else {
-		lst, err = models.EsIndexPatternGets(rt.Ctx, "")
-	}
-
-	ginx.NewRender(c).Data(lst, err)
-}
-
-// ES Index Pattern 单个数据
-func (rt *Router) esIndexPatternGet(c *gin.Context) {
-	id := ginx.QueryInt64(c, "id")
-
-	item, err := models.EsIndexPatternGet(rt.Ctx, "id=?", id)
-	ginx.NewRender(c).Data(item, err)
-}
--- a/center/router/router_funcs.go
+++ b/center/router/router_funcs.go
@@ -44,10 +44,6 @@ func (rt *Router) statistic(c *gin.Context) {
 		statistics, err = models.DatasourceStatistics(rt.Ctx)
 		ginx.NewRender(c).Data(statistics, err)
 		return
-	case "user_variable":
-		statistics, err = models.ConfigsUserVariableStatistics(rt.Ctx)
-		ginx.NewRender(c).Data(statistics, err)
-		return
 	default:
 		ginx.Bomb(http.StatusBadRequest, "invalid name")
 	}
--- a/center/router/router_heartbeat.go
+++ b/center/router/router_heartbeat.go
@@ -4,15 +4,12 @@ import (
 	"compress/gzip"
 	"encoding/json"
 	"io/ioutil"
-	"sort"
-	"strings"
 	"time"

 	"github.com/ccfos/nightingale/v6/models"

 	"github.com/gin-gonic/gin"
 	"github.com/toolkits/pkg/ginx"
-	"github.com/toolkits/pkg/logger"
 )

 func (rt *Router) heartbeat(c *gin.Context) {
@@ -38,52 +35,17 @@ func (rt *Router) heartbeat(c *gin.Context) {
 	err = json.Unmarshal(bs, &req)
 	ginx.Dangerous(err)

-	// maybe from pushgw
-	if req.Offset == 0 {
-		req.Offset = (time.Now().UnixMilli() - req.UnixTime)
-	}
-
-	if req.RemoteAddr == "" {
-		req.RemoteAddr = c.ClientIP()
-	}
-
+	req.Offset = (time.Now().UnixMilli() - req.UnixTime)
+	req.RemoteAddr = c.ClientIP()
 	rt.MetaSet.Set(req.Hostname, req)
-	var items = make(map[string]struct{})
-	items[req.Hostname] = struct{}{}
-	rt.IdentSet.MSet(items)

-	if target, has := rt.TargetCache.Get(req.Hostname); has && target != nil {
-		gid := ginx.QueryInt64(c, "gid", 0)
-		hostIp := strings.TrimSpace(req.HostIp)
+	gid := ginx.QueryInt64(c, "gid", 0)

-		filed := make(map[string]interface{})
-		if gid != 0 && gid != target.GroupId {
-			filed["group_id"] = gid
+	if gid != 0 {
+		target, has := rt.TargetCache.Get(req.Hostname)
+		if has && target.GroupId != gid {
+			err = models.TargetUpdateBgid(rt.Ctx, []string{req.Hostname}, gid, false)
 		}
-
-		if hostIp != "" && hostIp != target.HostIp {
-			filed["host_ip"] = hostIp
-		}
-
-		if len(req.GlobalLabels) > 0 {
-			lst := []string{}
-			for k, v := range req.GlobalLabels {
-				lst = append(lst, k+"="+v)
-			}
-			sort.Strings(lst)
-			labels := strings.Join(lst, " ")
-			if target.Tags != labels {
-				filed["tags"] = labels
-			}
-		}
-
-		if len(filed) > 0 {
-			err := target.UpdateFieldsMap(rt.Ctx, filed)
-			if err != nil {
-				logger.Errorf("update target fields failed, err: %v", err)
-			}
-		}
-		logger.Debugf("heartbeat field:%+v target: %v", filed, *target)
 	}

 	ginx.NewRender(c).Message(err)
--- a/center/router/router_login.go
+++ b/center/router/router_login.go
@@ -1,7 +1,6 @@
 package router

 import (
-	"encoding/base64"
 	"fmt"
 	"net/http"
 	"strconv"
@@ -13,7 +12,6 @@ import (
 	"github.com/ccfos/nightingale/v6/pkg/ldapx"
 	"github.com/ccfos/nightingale/v6/pkg/oauth2x"
 	"github.com/ccfos/nightingale/v6/pkg/oidcx"
-	"github.com/ccfos/nightingale/v6/pkg/secu"
 	"github.com/pelletier/go-toml/v2"

 	"github.com/dgrijalva/jwt-go"
@@ -23,40 +21,20 @@ import (
 )

 type loginForm struct {
-	Username    string `json:"username" binding:"required"`
-	Password    string `json:"password" binding:"required"`
-	Captchaid   string `json:"captchaid"`
-	Verifyvalue string `json:"verifyvalue"`
+	Username string `json:"username" binding:"required"`
+	Password string `json:"password" binding:"required"`
 }

 func (rt *Router) loginPost(c *gin.Context) {
 	var f loginForm
 	ginx.BindJSON(c, &f)
-	logger.Infof("username:%s login from:%s", f.Username, c.ClientIP())

-	if rt.HTTP.ShowCaptcha.Enable {
-		if !CaptchaVerify(f.Captchaid, f.Verifyvalue) {
-			ginx.NewRender(c).Message("incorrect verification code")
-			return
-		}
-	}
-	authPassWord := f.Password
-	// need decode
-	if rt.HTTP.RSA.OpenRSA {
-		decPassWord, err := secu.Decrypt(f.Password, rt.HTTP.RSA.RSAPrivateKey, rt.HTTP.RSA.RSAPassWord)
-		if err != nil {
-			logger.Errorf("RSA Decrypt failed: %v username: %s", err, f.Username)
-			ginx.NewRender(c).Message(err)
-			return
-		}
-		authPassWord = decPassWord
-	}
-	user, err := models.PassLogin(rt.Ctx, f.Username, authPassWord)
+	user, err := models.PassLogin(rt.Ctx, f.Username, f.Password)
 	if err != nil {
 		// pass validate fail, try ldap
 		if rt.Sso.LDAP.Enable {
 			roles := strings.Join(rt.Sso.LDAP.DefaultRoles, " ")
-			user, err = models.LdapLogin(rt.Ctx, f.Username, authPassWord, roles, rt.Sso.LDAP)
+			user, err = models.LdapLogin(rt.Ctx, f.Username, f.Password, roles, rt.Sso.LDAP)
 			if err != nil {
 				logger.Debugf("ldap login failed: %v username: %s", err, f.Username)
 				ginx.NewRender(c).Message(err)
@@ -89,7 +67,6 @@ func (rt *Router) loginPost(c *gin.Context) {
 }

 func (rt *Router) logoutPost(c *gin.Context) {
-	logger.Infof("username:%s login from:%s", c.GetString("username"), c.ClientIP())
 	metadata, err := rt.extractTokenMetadata(c.Request)
 	if err != nil {
 		ginx.NewRender(c, http.StatusBadRequest).Message("failed to parse jwt token")
@@ -230,7 +207,7 @@ func (rt *Router) loginCallback(c *gin.Context) {

 	ret, err := rt.Sso.OIDC.Callback(rt.Redis, c.Request.Context(), code, state)
 	if err != nil {
-		logger.Errorf("sso_callback fail. code:%s, state:%s, get ret: %+v. error: %v", code, state, ret, err)
+		logger.Debugf("sso.callback() get ret %+v error %v", ret, err)
 		ginx.NewRender(c).Data(CallbackOutput{}, err)
 		return
 	}
@@ -515,23 +492,10 @@ type SsoConfigOutput struct {
 }

 func (rt *Router) ssoConfigNameGet(c *gin.Context) {
-	var oidcDisplayName, casDisplayName, oauthDisplayName string
-	if rt.Sso.OIDC != nil {
-		oidcDisplayName = rt.Sso.OIDC.GetDisplayName()
-	}
-
-	if rt.Sso.CAS != nil {
-		casDisplayName = rt.Sso.CAS.GetDisplayName()
-	}
-
-	if rt.Sso.OAuth2 != nil {
-		oauthDisplayName = rt.Sso.OAuth2.GetDisplayName()
-	}
-
 	ginx.NewRender(c).Data(SsoConfigOutput{
-		OidcDisplayName:  oidcDisplayName,
-		CasDisplayName:   casDisplayName,
-		OauthDisplayName: oauthDisplayName,
+		OidcDisplayName:  rt.Sso.OIDC.GetDisplayName(),
+		CasDisplayName:   rt.Sso.CAS.GetDisplayName(),
+		OauthDisplayName: rt.Sso.OAuth2.GetDisplayName(),
 	}, nil)
 }

@@ -556,7 +520,8 @@ func (rt *Router) ssoConfigUpdate(c *gin.Context) {
 		var config oidcx.Config
 		err := toml.Unmarshal([]byte(f.Content), &config)
 		ginx.Dangerous(err)
-		rt.Sso.OIDC, err = oidcx.New(config)
+
+		err = rt.Sso.OIDC.Reload(config)
 		ginx.Dangerous(err)
 	case "CAS":
 		var config cas.Config
@@ -572,19 +537,3 @@ func (rt *Router) ssoConfigUpdate(c *gin.Context) {

 	ginx.NewRender(c).Message(nil)
 }
-
-type RSAConfigOutput struct {
-	OpenRSA      bool
-	RSAPublicKey string
-}
-
-func (rt *Router) rsaConfigGet(c *gin.Context) {
-	publicKey := ""
-	if len(rt.HTTP.RSA.RSAPublicKey) > 0 {
-		publicKey = base64.StdEncoding.EncodeToString(rt.HTTP.RSA.RSAPublicKey)
-	}
-	ginx.NewRender(c).Data(RSAConfigOutput{
-		OpenRSA:      rt.HTTP.RSA.OpenRSA,
-		RSAPublicKey: publicKey,
-	}, nil)
-}
--- a/center/router/router_mute.go
+++ b/center/router/router_mute.go
@@ -5,7 +5,6 @@ import (
 	"strings"
 	"time"

-	"github.com/ccfos/nightingale/v6/alert/common"
 	"github.com/ccfos/nightingale/v6/models"

 	"github.com/gin-gonic/gin"
@@ -30,41 +29,16 @@ func (rt *Router) alertMuteGets(c *gin.Context) {
 }

 func (rt *Router) alertMuteAdd(c *gin.Context) {
-
 	var f models.AlertMute
 	ginx.BindJSON(c, &f)

 	username := c.MustGet("username").(string)
 	f.CreateBy = username
 	f.GroupId = ginx.UrlParamInt64(c, "id")
+
 	ginx.NewRender(c).Message(f.Add(rt.Ctx))
 }

-// Preview events (alert_cur_event) that match the mute strategy based on the following criteria:
-// business group ID (group_id, group_id), product (prod, rule_prod),
-// alert event severity (severities, severity), and event tags (tags, tags).
-// For products of type not 'host', also consider the category (cate, cate) and datasource ID (datasource_ids, datasource_id).
-func (rt *Router) alertMutePreview(c *gin.Context) {
-	//Generally the match of events would be less.
-
-	var f models.AlertMute
-	ginx.BindJSON(c, &f)
-	f.GroupId = ginx.UrlParamInt64(c, "id")
-	ginx.Dangerous(f.Verify()) //verify and parse tags json to ITags
-	events, err := models.AlertCurEventGetsFromAlertMute(rt.Ctx, &f)
-	ginx.Dangerous(err)
-
-	matchEvents := make([]*models.AlertCurEvent, 0, len(events))
-	for i := 0; i < len(events); i++ {
-		events[i].DB2Mem()
-		if common.MatchTags(events[i].TagsMap, f.ITags) {
-			matchEvents = append(matchEvents, events[i])
-		}
-	}
-	ginx.NewRender(c).Data(matchEvents, err)
-
-}
-
 func (rt *Router) alertMuteAddByService(c *gin.Context) {
 	var f models.AlertMute
 	ginx.BindJSON(c, &f)
--- a/center/router/router_notify_config.go
+++ b/center/router/router_notify_config.go
@@ -2,19 +2,15 @@ package router

 import (
 	"encoding/json"
-	"fmt"
-	"strings"

 	"github.com/ccfos/nightingale/v6/alert/aconf"
 	"github.com/ccfos/nightingale/v6/alert/sender"
 	"github.com/ccfos/nightingale/v6/memsto"
 	"github.com/ccfos/nightingale/v6/models"
-	"github.com/ccfos/nightingale/v6/pkg/tplx"
+	"github.com/pelletier/go-toml/v2"

 	"github.com/gin-gonic/gin"
-	"github.com/pelletier/go-toml/v2"
 	"github.com/toolkits/pkg/ginx"
-	"github.com/toolkits/pkg/str"
 )

 func (rt *Router) webhookGets(c *gin.Context) {
@@ -45,8 +41,8 @@ func (rt *Router) webhookPuts(c *gin.Context) {

 	data, err := json.Marshal(webhooks)
 	ginx.Dangerous(err)
-	username := c.MustGet("username").(string)
-	ginx.NewRender(c).Message(models.ConfigsSetWithUname(rt.Ctx, models.WEBHOOKKEY, string(data), username))
+
+	ginx.NewRender(c).Message(models.ConfigsSet(rt.Ctx, models.WEBHOOKKEY, string(data)))
 }

 func (rt *Router) notifyScriptGet(c *gin.Context) {
@@ -69,8 +65,8 @@ func (rt *Router) notifyScriptPut(c *gin.Context) {

 	data, err := json.Marshal(notifyScript)
 	ginx.Dangerous(err)
-	username := c.MustGet("username").(string)
-	ginx.NewRender(c).Message(models.ConfigsSetWithUname(rt.Ctx, models.NOTIFYSCRIPT, string(data), username))
+
+	ginx.NewRender(c).Message(models.ConfigsSet(rt.Ctx, models.NOTIFYSCRIPT, string(data)))
 }

 func (rt *Router) notifyChannelGets(c *gin.Context) {
@@ -105,8 +101,8 @@ func (rt *Router) notifyChannelPuts(c *gin.Context) {

 	data, err := json.Marshal(notifyChannels)
 	ginx.Dangerous(err)
-	username := c.MustGet("username").(string)
-	ginx.NewRender(c).Message(models.ConfigsSetWithUname(rt.Ctx, models.NOTIFYCHANNEL, string(data), username))
+
+	ginx.NewRender(c).Message(models.ConfigsSet(rt.Ctx, models.NOTIFYCHANNEL, string(data)))
 }

 func (rt *Router) notifyContactGets(c *gin.Context) {
@@ -141,8 +137,8 @@ func (rt *Router) notifyContactPuts(c *gin.Context) {

 	data, err := json.Marshal(notifyContacts)
 	ginx.Dangerous(err)
-	username := c.MustGet("username").(string)
-	ginx.NewRender(c).Message(models.ConfigsSetWithUname(rt.Ctx, models.NOTIFYCONTACT, string(data), username))
+
+	ginx.NewRender(c).Message(models.ConfigsSet(rt.Ctx, models.NOTIFYCONTACT, string(data)))
 }

 func (rt *Router) notifyConfigGet(c *gin.Context) {
@@ -162,12 +158,10 @@ func (rt *Router) notifyConfigGet(c *gin.Context) {
 func (rt *Router) notifyConfigPut(c *gin.Context) {
 	var f models.Configs
 	ginx.BindJSON(c, &f)
-	userVariableMap := rt.NotifyConfigCache.ConfigCache.Get()
-	text := tplx.ReplaceTemplateUseText(f.Ckey, f.Cval, userVariableMap)
 	switch f.Ckey {
 	case models.SMTP:
 		var smtp aconf.SMTPConfig
-		err := toml.Unmarshal([]byte(text), &smtp)
+		err := toml.Unmarshal([]byte(f.Cval), &smtp)
 		ginx.Dangerous(err)
 	case models.IBEX:
 		var ibex aconf.Ibex
@@ -176,55 +170,24 @@ func (rt *Router) notifyConfigPut(c *gin.Context) {
 	default:
 		ginx.Bomb(200, "key %s can not modify", f.Ckey)
 	}
-	username := c.MustGet("username").(string)
-	//insert or update build-in config
-	ginx.Dangerous(models.ConfigsSetWithUname(rt.Ctx, f.Ckey, f.Cval, username))
+
+	err := models.ConfigsSet(rt.Ctx, f.Ckey, f.Cval)
+	if err != nil {
+		ginx.Bomb(200, err.Error())
+	}
+
 	if f.Ckey == models.SMTP {
 		// 重置邮件发送器
+		var smtp aconf.SMTPConfig
+		err := toml.Unmarshal([]byte(f.Cval), &smtp)
+		ginx.Dangerous(err)
+
+		if smtp.Host == "" || smtp.Port == 0 {
+			ginx.Bomb(200, "smtp host or port can not be empty")
+		}

-		smtp, errSmtp := SmtpValidate(text)
-		ginx.Dangerous(errSmtp)
 		go sender.RestartEmailSender(smtp)
 	}

 	ginx.NewRender(c).Message(nil)
 }
-func SmtpValidate(text string) (aconf.SMTPConfig, error) {
-	var smtp aconf.SMTPConfig
-	var err error
-
-	err = toml.Unmarshal([]byte(text), &smtp)
-	if err != nil {
-		return smtp, err
-	}
-	if smtp.Host == "" || smtp.Port == 0 {
-		return smtp, fmt.Errorf("smtp host or port can not be empty")
-	}
-	return smtp, err
-}
-
-type form struct {
-	models.Configs
-	Email string `json:"email"`
-}
-
-// After configuring the aconf.SMTPConfig, users can choose to perform a test. In this test, the function attempts to send an email
-func (rt *Router) attemptSendEmail(c *gin.Context) {
-	var f form
-	ginx.BindJSON(c, &f)
-
-	if f.Email = strings.TrimSpace(f.Email); f.Email == "" || !str.IsMail(f.Email) {
-		ginx.Bomb(200, "email(%s) invalid", f.Email)
-	}
-
-	if f.Ckey != models.SMTP {
-		ginx.Bomb(200, "config(%v) invalid", f)
-	}
-	userVariableMap := rt.NotifyConfigCache.ConfigCache.Get()
-	text := tplx.ReplaceTemplateUseText(f.Ckey, f.Cval, userVariableMap)
-	smtp, err := SmtpValidate(text)
-	ginx.Dangerous(err)
-
-	ginx.NewRender(c).Message(sender.SendEmail("Email test", "email content", []string{f.Email}, smtp))
-
-}
--- a/center/router/router_notify_tpl.go
+++ b/center/router/router_notify_tpl.go
@@ -10,25 +10,12 @@ import (
 	"github.com/ccfos/nightingale/v6/center/cconf"
 	"github.com/ccfos/nightingale/v6/models"
 	"github.com/ccfos/nightingale/v6/pkg/tplx"
-
 	"github.com/gin-gonic/gin"
 	"github.com/toolkits/pkg/ginx"
-	"github.com/toolkits/pkg/str"
 )

 func (rt *Router) notifyTplGets(c *gin.Context) {
-	m := make(map[string]struct{})
-	for _, channel := range models.DefaultChannels {
-		m[channel] = struct{}{}
-	}
-	m[models.EmailSubject] = struct{}{}
-
 	lst, err := models.NotifyTplGets(rt.Ctx)
-	for i := 0; i < len(lst); i++ {
-		if _, exists := m[lst[i].Channel]; exists {
-			lst[i].BuiltIn = true
-		}
-	}

 	ginx.NewRender(c).Data(lst, err)
 }
@@ -36,7 +23,11 @@ func (rt *Router) notifyTplGets(c *gin.Context) {
 func (rt *Router) notifyTplUpdateContent(c *gin.Context) {
 	var f models.NotifyTpl
 	ginx.BindJSON(c, &f)
-	ginx.Dangerous(templateValidate(f))
+
+	if err := templateValidate(f); err != nil {
+		ginx.NewRender(c).Message(err.Error())
+		return
+	}

 	ginx.NewRender(c).Message(f.UpdateContent(rt.Ctx))
 }
@@ -44,28 +35,16 @@ func (rt *Router) notifyTplUpdateContent(c *gin.Context) {
 func (rt *Router) notifyTplUpdate(c *gin.Context) {
 	var f models.NotifyTpl
 	ginx.BindJSON(c, &f)
-	ginx.Dangerous(templateValidate(f))
+
+	if err := templateValidate(f); err != nil {
+		ginx.NewRender(c).Message(err.Error())
+		return
+	}

 	ginx.NewRender(c).Message(f.Update(rt.Ctx))
 }

 func templateValidate(f models.NotifyTpl) error {
-	if len(f.Channel) > 32 {
-		return fmt.Errorf("channel length should not exceed 32")
-	}
-
-	if str.Dangerous(f.Channel) {
-		return fmt.Errorf("channel should not contain dangerous characters")
-	}
-
-	if len(f.Name) > 255 {
-		return fmt.Errorf("name length should not exceed 255")
-	}
-
-	if str.Dangerous(f.Name) {
-		return fmt.Errorf("name should not contain dangerous characters")
-	}
-
 	if f.Content == "" {
 		return nil
 	}
@@ -86,7 +65,10 @@ func templateValidate(f models.NotifyTpl) error {
 func (rt *Router) notifyTplPreview(c *gin.Context) {
 	var event models.AlertCurEvent
 	err := json.Unmarshal([]byte(cconf.EVENT_EXAMPLE), &event)
-	ginx.Dangerous(err)
+	if err != nil {
+		ginx.NewRender(c).Message(err.Error())
+		return
+	}

 	var f models.NotifyTpl
 	ginx.BindJSON(c, &f)
@@ -124,25 +106,3 @@ func (rt *Router) notifyTplPreview(c *gin.Context) {

 	ginx.NewRender(c).Data(ret, nil)
 }
-
-// add new notify template
-func (rt *Router) notifyTplAdd(c *gin.Context) {
-	var f models.NotifyTpl
-	ginx.BindJSON(c, &f)
-	f.Channel = strings.TrimSpace(f.Channel)
-	ginx.Dangerous(templateValidate(f))
-
-	count, err := models.NotifyTplCountByChannel(rt.Ctx, f.Channel)
-	ginx.Dangerous(err)
-	if count != 0 {
-		ginx.Bomb(200, "Refuse to create duplicate channel(unique)")
-	}
-	ginx.NewRender(c).Message(f.Create(rt.Ctx))
-}
-
-// delete notify template, not allowed to delete the system defaults(models.DefaultChannels)
-func (rt *Router) notifyTplDel(c *gin.Context) {
-	f := new(models.NotifyTpl)
-	id := ginx.UrlParamInt64(c, "id")
-	ginx.NewRender(c).Message(f.NotifyTplDelete(rt.Ctx, id))
-}
--- a/center/router/router_proxy.go
+++ b/center/router/router_proxy.go
@@ -3,20 +3,17 @@ package router
 import (
 	"context"
 	"crypto/tls"
-	"fmt"
 	"net"
 	"net/http"
 	"net/http/httputil"
 	"net/url"
 	"strings"
-	"sync"
 	"time"

 	pkgprom "github.com/ccfos/nightingale/v6/pkg/prom"
 	"github.com/gin-gonic/gin"
 	"github.com/prometheus/common/model"
 	"github.com/toolkits/pkg/ginx"
-	"github.com/toolkits/pkg/logger"
 )

 type queryFormItem struct {
@@ -34,14 +31,10 @@ type batchQueryForm struct {
 func (rt *Router) promBatchQueryRange(c *gin.Context) {
 	var f batchQueryForm
 	ginx.Dangerous(c.BindJSON(&f))
-	var lst []model.Value

 	cli := rt.PromClients.GetCli(f.DatasourceId)
-	if cli == nil {
-		logger.Warningf("no such datasource id: %d", f.DatasourceId)
-		ginx.NewRender(c).Data(lst, nil)
-		return
-	}
+
+	var lst []model.Value

 	for _, item := range f.Queries {
 		r := pkgprom.Range{
@@ -73,14 +66,9 @@ func (rt *Router) promBatchQueryInstant(c *gin.Context) {
 	var f batchInstantForm
 	ginx.Dangerous(c.BindJSON(&f))

-	var lst []model.Value
-
 	cli := rt.PromClients.GetCli(f.DatasourceId)
-	if cli == nil {
-		logger.Warningf("no such datasource id: %d", f.DatasourceId)
-		ginx.NewRender(c).Data(lst, nil)
-		return
-	}
+
+	var lst []model.Value

 	for _, item := range f.Queries {
 		resp, _, err := cli.Query(context.Background(), item.Query, time.Unix(item.Time, 0))
@@ -151,77 +139,21 @@ func (rt *Router) dsProxy(c *gin.Context) {
 		http.Error(w, err.Error(), http.StatusBadGateway)
 	}

-	transport, has := transportGet(dsId, ds.UpdatedAt)
-	if !has {
-		transport = &http.Transport{
-			TLSClientConfig: &tls.Config{InsecureSkipVerify: ds.HTTPJson.TLS.SkipTlsVerify},
-			Proxy:           http.ProxyFromEnvironment,
-			DialContext: (&net.Dialer{
-				Timeout: time.Duration(ds.HTTPJson.DialTimeout) * time.Millisecond,
-			}).DialContext,
-			ResponseHeaderTimeout: time.Duration(ds.HTTPJson.Timeout) * time.Millisecond,
-			MaxIdleConnsPerHost:   ds.HTTPJson.MaxIdleConnsPerHost,
-		}
-		transportPut(dsId, ds.UpdatedAt, transport)
-	}
-
-	modifyResponse := func(r *http.Response) error {
-		if r.StatusCode == http.StatusUnauthorized {
-			logger.Warningf("proxy path:%s unauthorized access ", c.Request.URL.Path)
-			return fmt.Errorf("unauthorized access")
-		}
-
-		return nil
+	transport := &http.Transport{
+		TLSClientConfig: &tls.Config{InsecureSkipVerify: ds.HTTPJson.TLS.SkipTlsVerify},
+		Proxy:           http.ProxyFromEnvironment,
+		DialContext: (&net.Dialer{
+			Timeout: time.Duration(ds.HTTPJson.DialTimeout) * time.Millisecond,
+		}).DialContext,
+		ResponseHeaderTimeout: time.Duration(ds.HTTPJson.Timeout) * time.Millisecond,
+		MaxIdleConnsPerHost:   ds.HTTPJson.MaxIdleConnsPerHost,
 	}

 	proxy := &httputil.ReverseProxy{
-		Director:       director,
-		Transport:      transport,
-		ErrorHandler:   errFunc,
-		ModifyResponse: modifyResponse,
+		Director:     director,
+		Transport:    transport,
+		ErrorHandler: errFunc,
 	}

 	proxy.ServeHTTP(c.Writer, c.Request)
-
-}
-
-var (
-	transports     = map[int64]http.RoundTripper{}
-	updatedAts     = map[int64]int64{}
-	transportsLock = &sync.Mutex{}
-)
-
-func transportGet(dsid, newUpdatedAt int64) (http.RoundTripper, bool) {
-	transportsLock.Lock()
-	defer transportsLock.Unlock()
-
-	tran, has := transports[dsid]
-	if !has {
-		return nil, false
-	}
-
-	oldUpdateAt, has := updatedAts[dsid]
-	if !has {
-		oldtran := tran.(*http.Transport)
-		oldtran.CloseIdleConnections()
-		delete(transports, dsid)
-		return nil, false
-	}
-
-	if oldUpdateAt != newUpdatedAt {
-		oldtran := tran.(*http.Transport)
-		oldtran.CloseIdleConnections()
-		delete(transports, dsid)
-		delete(updatedAts, dsid)
-		return nil, false
-	}
-
-	return tran, has
-}
-
-func transportPut(dsid, updatedat int64, tran http.RoundTripper) {
-	transportsLock.Lock()
-	transports[dsid] = tran
-	updatedAts[dsid] = updatedat
-	transportsLock.Unlock()
 }
--- a/center/router/router_role.go
+++ b/center/router/router_role.go
@@ -4,7 +4,6 @@ import (
 	"net/http"
 	"strings"

-	"github.com/ccfos/nightingale/v6/center/cconf"
 	"github.com/ccfos/nightingale/v6/models"

 	"github.com/gin-gonic/gin"
@@ -18,15 +17,6 @@ func (rt *Router) rolesGets(c *gin.Context) {

 func (rt *Router) permsGets(c *gin.Context) {
 	user := c.MustGet("user").(*models.User)
-	if user.IsAdmin() {
-		var lst []string
-		for _, ops := range cconf.Operations.Ops {
-			lst = append(lst, ops.Ops...)
-		}
-		ginx.NewRender(c).Data(lst, nil)
-		return
-	}
-
 	lst, err := models.OperationsOfRole(rt.Ctx, strings.Fields(user.Roles))
 	ginx.NewRender(c).Data(lst, err)
 }
--- a/center/router/router_server.go
+++ b/center/router/router_server.go
@@ -28,12 +28,6 @@ func (rt *Router) serverHeartbeat(c *gin.Context) {

 func (rt *Router) serversActive(c *gin.Context) {
 	datasourceId := ginx.QueryInt64(c, "dsid")
-	engineName := ginx.QueryStr(c, "engine_name", "")
-	if engineName != "" {
-		servers, err := models.AlertingEngineGetsInstances(rt.Ctx, "engine_cluster = ? and clock > ?", engineName, time.Now().Unix()-30)
-		ginx.NewRender(c).Data(servers, err)
-		return
-	}

 	servers, err := models.AlertingEngineGetsInstances(rt.Ctx, "datasource_id = ? and clock > ?", datasourceId, time.Now().Unix()-30)
 	ginx.NewRender(c).Data(servers, err)
--- a/center/router/router_target.go
+++ b/center/router/router_target.go
@@ -45,32 +45,12 @@ func (rt *Router) targetGets(c *gin.Context) {
 	bgid := ginx.QueryInt64(c, "bgid", -1)
 	query := ginx.QueryStr(c, "query", "")
 	limit := ginx.QueryInt(c, "limit", 30)
-	downtime := ginx.QueryInt64(c, "downtime", 0)
 	dsIds := queryDatasourceIds(c)

-	var bgids []int64
-	var err error
-	if bgid == -1 {
-		user := c.MustGet("user").(*models.User)
-		if !user.IsAdmin() {
-			// 如果是非 admin 用户，全部对象的情况，找到用户有权限的业务组
-			userGroupIds, err := models.MyGroupIds(rt.Ctx, user.Id)
-			ginx.Dangerous(err)
-
-			bgids, err = models.BusiGroupIds(rt.Ctx, userGroupIds)
-			ginx.Dangerous(err)
-
-			// 将未分配业务组的对象也加入到列表中
-			bgids = append(bgids, 0)
-		}
-	} else {
-		bgids = append(bgids, bgid)
-	}
-
-	total, err := models.TargetTotal(rt.Ctx, bgids, dsIds, query, downtime)
+	total, err := models.TargetTotal(rt.Ctx, bgid, dsIds, query)
 	ginx.Dangerous(err)

-	list, err := models.TargetGets(rt.Ctx, bgids, dsIds, query, downtime, limit, ginx.Offset(c, limit))
+	list, err := models.TargetGets(rt.Ctx, bgid, dsIds, query, limit, ginx.Offset(c, limit))
 	ginx.Dangerous(err)

 	if err == nil {
@@ -81,12 +61,6 @@ func (rt *Router) targetGets(c *gin.Context) {
 		for i := 0; i < len(list); i++ {
 			ginx.Dangerous(list[i].FillGroup(rt.Ctx, cache))
 			keys = append(keys, models.WrapIdent(list[i].Ident))
-
-			if now.Unix()-list[i].UpdateAt < 60 {
-				list[i].TargetUp = 2
-			} else if now.Unix()-list[i].UpdateAt < 180 {
-				list[i].TargetUp = 1
-			}
 		}

 		if len(keys) > 0 {
@@ -106,6 +80,10 @@ func (rt *Router) targetGets(c *gin.Context) {
 			}

 			for i := 0; i < len(list); i++ {
+				if now.Unix()-list[i].UpdateAt < 120 {
+					list[i].TargetUp = 1
+				}
+
 				if meta, ok := metaMap[list[i].Ident]; ok {
 					list[i].FillMeta(meta)
 				} else {
--- a/center/router/router_task.go
+++ b/center/router/router_task.go
@@ -92,7 +92,6 @@ func (f *taskForm) Verify() error {
 	if f.Script == "" {
 		return fmt.Errorf("arg(script) is required")
 	}
-	f.Script = strings.Replace(f.Script, "\r\n", "\n", -1)

 	if str.Dangerous(f.Args) {
 		return fmt.Errorf("arg(args) is dangerous")
--- a/center/router/router_task_tpl.go
+++ b/center/router/router_task_tpl.go
@@ -48,19 +48,6 @@ func (rt *Router) taskTplGet(c *gin.Context) {
 	}, err)
 }

-func (rt *Router) taskTplGetByService(c *gin.Context) {
-	tid := ginx.UrlParamInt64(c, "tid")
-
-	tpl, err := models.TaskTplGetById(rt.Ctx, tid)
-	ginx.Dangerous(err)
-
-	if tpl == nil {
-		ginx.Bomb(404, "no such task template")
-	}
-
-	ginx.NewRender(c).Data(tpl, err)
-}
-
 type taskTplForm struct {
 	Title     string   `json:"title" binding:"required"`
 	Batch     int      `json:"batch"`
--- a/center/router/router_tdengine.go
+++ b/center/router/router_tdengine.go
@@ -1,117 +0,0 @@
-package router
-
-import (
-	"net/http"
-
-	"github.com/ccfos/nightingale/v6/center/cconf"
-	"github.com/ccfos/nightingale/v6/models"
-
-	"github.com/gin-gonic/gin"
-	"github.com/toolkits/pkg/ginx"
-	"github.com/toolkits/pkg/logger"
-)
-
-type databasesQueryForm struct {
-	Cate         string `json:"cate" form:"cate"`
-	DatasourceId int64  `json:"datasource_id" form:"datasource_id"`
-}
-
-func (rt *Router) tdengineDatabases(c *gin.Context) {
-	var f databasesQueryForm
-	ginx.BindJSON(c, &f)
-
-	tdClient := rt.TdendgineClients.GetCli(f.DatasourceId)
-	if tdClient == nil {
-		ginx.NewRender(c, http.StatusNotFound).Message("No such datasource")
-		return
-	}
-
-	databases, err := tdClient.GetDatabases()
-	ginx.NewRender(c).Data(databases, err)
-}
-
-type tablesQueryForm struct {
-	Cate         string `json:"cate"`
-	DatasourceId int64  `json:"datasource_id" `
-	Database     string `json:"db"`
-	IsStable     bool   `json:"is_stable"`
-}
-
-// get tdengine tables
-func (rt *Router) tdengineTables(c *gin.Context) {
-	var f tablesQueryForm
-	ginx.BindJSON(c, &f)
-
-	tdClient := rt.TdendgineClients.GetCli(f.DatasourceId)
-	if tdClient == nil {
-		ginx.NewRender(c, http.StatusNotFound).Message("No such datasource")
-		return
-	}
-
-	tables, err := tdClient.GetTables(f.Database, f.IsStable)
-	ginx.NewRender(c).Data(tables, err)
-}
-
-type columnsQueryForm struct {
-	Cate         string `json:"cate"`
-	DatasourceId int64  `json:"datasource_id" `
-	Database     string `json:"db"`
-	Table        string `json:"table"`
-}
-
-// get tdengine columns
-func (rt *Router) tdengineColumns(c *gin.Context) {
-	var f columnsQueryForm
-	ginx.BindJSON(c, &f)
-
-	tdClient := rt.TdendgineClients.GetCli(f.DatasourceId)
-	if tdClient == nil {
-		ginx.NewRender(c, http.StatusNotFound).Message("No such datasource")
-		return
-	}
-
-	columns, err := tdClient.GetColumns(f.Database, f.Table)
-	ginx.NewRender(c).Data(columns, err)
-}
-
-func (rt *Router) QueryData(c *gin.Context) {
-	var f models.QueryParam
-	ginx.BindJSON(c, &f)
-
-	var resp []*models.DataResp
-	var err error
-	tdClient := rt.TdendgineClients.GetCli(f.DatasourceId)
-	for _, q := range f.Querys {
-		datas, err := tdClient.Query(q)
-		ginx.Dangerous(err)
-		resp = append(resp, datas...)
-	}
-
-	ginx.NewRender(c).Data(resp, err)
-}
-
-func (rt *Router) QueryLog(c *gin.Context) {
-	var f models.QueryParam
-	ginx.BindJSON(c, &f)
-
-	tdClient := rt.TdendgineClients.GetCli(f.DatasourceId)
-	if len(f.Querys) == 0 {
-		ginx.Bomb(200, "querys is empty")
-		return
-	}
-
-	data, err := tdClient.QueryLog(f.Querys[0])
-	logger.Debugf("tdengine query:%s result: %+v", f.Querys[0], data)
-	ginx.NewRender(c).Data(data, err)
-}
-
-// query sql template
-func (rt *Router) QuerySqlTemplate(c *gin.Context) {
-	cate := ginx.QueryStr(c, "cate")
-	m := make(map[string]string)
-	switch cate {
-	case models.TDENGINE:
-		m = cconf.TDengineSQLTpl
-	}
-	ginx.NewRender(c).Data(m, nil)
-}
--- a/center/router/router_user_variable_config.go
+++ b/center/router/router_user_variable_config.go
@@ -1,70 +0,0 @@
-package router
-
-import (
-	"strings"
-	"time"
-
-	"github.com/ccfos/nightingale/v6/models"
-
-	"github.com/gin-gonic/gin"
-	"github.com/toolkits/pkg/ginx"
-)
-
-func (rt *Router) userVariableConfigGets(context *gin.Context) {
-	userVariables, err := models.ConfigsGetUserVariable(rt.Ctx)
-	ginx.NewRender(context).Data(userVariables, err)
-}
-func (rt *Router) userVariableConfigAdd(context *gin.Context) {
-	var f models.Configs
-	ginx.BindJSON(context, &f)
-	f.Ckey = strings.TrimSpace(f.Ckey)
-	//insert external config. needs to make sure not plaintext for an encrypted type config
-	username := context.MustGet("username").(string)
-	now := time.Now().Unix()
-	f.CreateBy = username
-	f.UpdateBy = username
-	f.CreateAt = now
-	f.UpdateAt = now
-	ginx.NewRender(context).Message(models.ConfigsUserVariableInsert(rt.Ctx, f))
-
-}
-
-func (rt *Router) userVariableConfigPut(context *gin.Context) {
-	var f models.Configs
-	ginx.BindJSON(context, &f)
-	f.Id = ginx.UrlParamInt64(context, "id")
-	f.Ckey = strings.TrimSpace(f.Ckey)
-	f.UpdateBy = context.MustGet("username").(string)
-	f.UpdateAt = time.Now().Unix()
-
-	user := context.MustGet("user").(*models.User)
-	if !user.IsAdmin() && f.CreateBy != user.Username {
-		// only admin or creator can update
-		ginx.Bomb(403, "no permission")
-	}
-
-	ginx.NewRender(context).Message(models.ConfigsUserVariableUpdate(rt.Ctx, f))
-}
-
-func (rt *Router) userVariableConfigDel(context *gin.Context) {
-	id := ginx.UrlParamInt64(context, "id")
-	configs, err := models.ConfigGet(rt.Ctx, id)
-	ginx.Dangerous(err)
-
-	user := context.MustGet("user").(*models.User)
-	if !user.IsAdmin() && configs.CreateBy != user.Username {
-		// only admin or creator can delete
-		ginx.Bomb(403, "no permission")
-	}
-
-	if configs != nil && configs.External == models.ConfigExternal {
-		ginx.NewRender(context).Message(models.ConfigsDel(rt.Ctx, []int64{id}))
-	} else {
-		ginx.NewRender(context).Message(nil)
-	}
-}
-
-func (rt *Router) userVariableGetDecryptByService(context *gin.Context) {
-	decryptMap, decryptErr := models.ConfigUserVariableGetDecryptMap(rt.Ctx, rt.HTTP.RSA.RSAPrivateKey, rt.HTTP.RSA.RSAPassWord)
-	ginx.NewRender(context).Data(decryptMap, decryptErr)
-}
--- a/center/sso/init.go
+++ b/center/sso/init.go
@@ -29,8 +29,6 @@ Port = 389
 BaseDn = 'dc=example,dc=org'
 BindUser = 'cn=manager,dc=example,dc=org'
 BindPass = '*******'
-# openldap format e.g. (&(uid=%s))
-# AD format e.g. (&(sAMAccountName=%s))
 AuthFilter = '(&(uid=%s))'
 CoverAttributes = true
 TLS = false
--- a/cli/upgrade/upgrade.go
+++ b/cli/upgrade/upgrade.go
@@ -18,9 +18,9 @@ func Upgrade(configFile string) error {
 		return err
 	}

-	ctx := ctx.NewContext(context.Background(), db, true)
+	ctx := ctx.NewContext(context.Background(), db, false)
 	for _, cluster := range config.Clusters {
-		count, err := models.GetDatasourcesCountByName(ctx, cluster.Name)
+		count, err := models.GetDatasourcesCountBy(ctx, "", "", cluster.Name)
 		if err != nil {
 			logger.Errorf("get datasource %s count error: %v", cluster.Name, err)
 			continue
--- a/cli/upgrade/upgrade.sql
+++ b/cli/upgrade/upgrade.sql
@@ -8,13 +8,6 @@ insert into `role_operation`(role_name, operation) values('Standard', '/trace/ex
 insert into `role_operation`(role_name, operation) values('Standard', '/alert-rules-built-in');
 insert into `role_operation`(role_name, operation) values('Standard', '/dashboards-built-in');
 insert into `role_operation`(role_name, operation) values('Standard', '/trace/dependencies');
-insert into `role_operation`(role_name, operation) values('Standard', '/help/servers');
-insert into `role_operation`(role_name, operation) values('Standard', '/help/migrate');
-
-insert into `role_operation`(role_name, operation) values('Admin', '/help/source');
-insert into `role_operation`(role_name, operation) values('Admin', '/help/sso');
-insert into `role_operation`(role_name, operation) values('Admin', '/help/notification-tpls');
-insert into `role_operation`(role_name, operation) values('Admin', '/help/notification-settings');

 alter table `board` add built_in tinyint(1) not null default 0 comment '0:false 1:true';
 alter table `board` add hide tinyint(1) not null default 0 comment '0:false 1:true';
--- a/cmd/alert/main.go
+++ b/cmd/alert/main.go
@@ -17,7 +17,7 @@ import (

 var (
 	showVersion = flag.Bool("version", false, "Show version.")
-	configDir   = flag.String("configs", osx.GetEnv("N9E_ALERT_CONFIGS", "etc"), "Specify configuration directory.(env:N9E_ALERT_CONFIGS)")
+	configDir   = flag.String("configs", osx.GetEnv("N9E_CONFIGS", "etc"), "Specify configuration directory.(env:N9E_CONFIGS)")
 	cryptoKey   = flag.String("crypto-key", "", "Specify the secret key for configuration file field encryption.")
 )

--- a/cmd/center/main.go
+++ b/cmd/center/main.go
@@ -12,7 +12,6 @@ import (
 	"github.com/ccfos/nightingale/v6/pkg/osx"
 	"github.com/ccfos/nightingale/v6/pkg/version"

-	"github.com/toolkits/pkg/net/tcpx"
 	"github.com/toolkits/pkg/runner"
 )

@@ -32,8 +31,6 @@ func main() {

 	printEnv()

-	tcpx.WaitHosts()
-
 	cleanFunc, err := center.Initialize(*configDir, *cryptoKey)
 	if err != nil {
 		log.Fatalln("failed to initialize:", err)
--- a/cmd/edge/edge.go
+++ b/cmd/edge/edge.go
@@ -1,81 +0,0 @@
-package main
-
-import (
-	"context"
-	"errors"
-	"fmt"
-
-	"github.com/ccfos/nightingale/v6/alert"
-	"github.com/ccfos/nightingale/v6/alert/astats"
-	"github.com/ccfos/nightingale/v6/alert/process"
-	"github.com/ccfos/nightingale/v6/conf"
-	"github.com/ccfos/nightingale/v6/dumper"
-	"github.com/ccfos/nightingale/v6/memsto"
-	"github.com/ccfos/nightingale/v6/pkg/ctx"
-	"github.com/ccfos/nightingale/v6/pkg/httpx"
-	"github.com/ccfos/nightingale/v6/pkg/logx"
-	"github.com/ccfos/nightingale/v6/prom"
-	"github.com/ccfos/nightingale/v6/pushgw/idents"
-	"github.com/ccfos/nightingale/v6/pushgw/writer"
-	"github.com/ccfos/nightingale/v6/tdengine"
-
-	alertrt "github.com/ccfos/nightingale/v6/alert/router"
-	pushgwrt "github.com/ccfos/nightingale/v6/pushgw/router"
-)
-
-func Initialize(configDir string, cryptoKey string) (func(), error) {
-	config, err := conf.InitConfig(configDir, cryptoKey)
-	if err != nil {
-		return nil, fmt.Errorf("failed to init config: %v", err)
-	}
-
-	logxClean, err := logx.Init(config.Log)
-	if err != nil {
-		return nil, err
-	}
-	//check CenterApi is default value
-	if len(config.CenterApi.Addrs) < 1 {
-		return nil, errors.New("failed to init config: the CenterApi configuration is missing")
-	}
-	ctx := ctx.NewContext(context.Background(), nil, false, config.CenterApi)
-
-	syncStats := memsto.NewSyncStats()
-
-	targetCache := memsto.NewTargetCache(ctx, syncStats, nil)
-	busiGroupCache := memsto.NewBusiGroupCache(ctx, syncStats)
-	idents := idents.New(ctx)
-	writers := writer.NewWriters(config.Pushgw)
-	pushgwRouter := pushgwrt.New(config.HTTP, config.Pushgw, targetCache, busiGroupCache, idents, writers, ctx)
-	r := httpx.GinEngine(config.Global.RunMode, config.HTTP)
-	pushgwRouter.Config(r)
-
-	if !config.Alert.Disable {
-		configCache := memsto.NewConfigCache(ctx, syncStats, nil, "")
-		alertStats := astats.NewSyncStats()
-		dsCache := memsto.NewDatasourceCache(ctx, syncStats)
-		alertMuteCache := memsto.NewAlertMuteCache(ctx, syncStats)
-		alertRuleCache := memsto.NewAlertRuleCache(ctx, syncStats)
-		notifyConfigCache := memsto.NewNotifyConfigCache(ctx, configCache)
-		userCache := memsto.NewUserCache(ctx, syncStats)
-		userGroupCache := memsto.NewUserGroupCache(ctx, syncStats)
-
-		promClients := prom.NewPromClient(ctx, config.Alert.Heartbeat)
-		tdengineClients := tdengine.NewTdengineClient(ctx, config.Alert.Heartbeat)
-		externalProcessors := process.NewExternalProcessors()
-
-		alert.Start(config.Alert, config.Pushgw, syncStats, alertStats, externalProcessors, targetCache, busiGroupCache, alertMuteCache,
-			alertRuleCache, notifyConfigCache, dsCache, ctx, promClients, tdengineClients, userCache, userGroupCache)
-
-		alertrtRouter := alertrt.New(config.HTTP, config.Alert, alertMuteCache, targetCache, busiGroupCache, alertStats, ctx, externalProcessors)
-
-		alertrtRouter.Config(r)
-	}
-
-	dumper.ConfigRouter(r)
-	httpClean := httpx.Init(config.HTTP, r)
-
-	return func() {
-		logxClean()
-		httpClean()
-	}, nil
-}
--- a/cmd/edge/main.go
+++ b/cmd/edge/main.go
@@ -1,68 +0,0 @@
-package main
-
-import (
-	"flag"
-	"fmt"
-	"log"
-	"os"
-	"os/signal"
-	"syscall"
-
-	"github.com/ccfos/nightingale/v6/pkg/osx"
-	"github.com/ccfos/nightingale/v6/pkg/version"
-
-	"github.com/toolkits/pkg/runner"
-)
-
-var (
-	showVersion = flag.Bool("version", false, "Show version.")
-	configDir   = flag.String("configs", osx.GetEnv("N9E_EDGE_CONFIGS", "etc"), "Specify configuration directory.(env:N9E_EDGE_CONFIGS)")
-	cryptoKey   = flag.String("crypto-key", "", "Specify the secret key for configuration file field encryption.")
-)
-
-func main() {
-	flag.Parse()
-
-	if *showVersion {
-		fmt.Println(version.Version)
-		os.Exit(0)
-	}
-
-	printEnv()
-
-	cleanFunc, err := Initialize(*configDir, *cryptoKey)
-	if err != nil {
-		log.Fatalln("failed to initialize:", err)
-	}
-
-	code := 1
-	sc := make(chan os.Signal, 1)
-	signal.Notify(sc, syscall.SIGHUP, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT)
-
-EXIT:
-	for {
-		sig := <-sc
-		fmt.Println("received signal:", sig.String())
-		switch sig {
-		case syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGINT:
-			code = 0
-			break EXIT
-		case syscall.SIGHUP:
-			// reload configuration?
-		default:
-			break EXIT
-		}
-	}
-
-	cleanFunc()
-	fmt.Println("process exited")
-	os.Exit(code)
-}
-
-func printEnv() {
-	runner.Init()
-	fmt.Println("runner.cwd:", runner.Cwd)
-	fmt.Println("runner.hostname:", runner.Hostname)
-	fmt.Println("runner.fd_limits:", runner.FdLimits())
-	fmt.Println("runner.vm_limits:", runner.VMLimits())
-}
--- a/cmd/pushgw/main.go
+++ b/cmd/pushgw/main.go
@@ -17,7 +17,7 @@ import (

 var (
 	showVersion = flag.Bool("version", false, "Show version.")
-	configDir   = flag.String("configs", osx.GetEnv("N9E_PUSHGW_CONFIGS", "etc"), "Specify configuration directory.(env:N9E_PUSHGW_CONFIGS)")
+	configDir   = flag.String("configs", osx.GetEnv("N9E_CONFIGS", "etc"), "Specify configuration directory.(env:N9E_CONFIGS)")
 	cryptoKey   = flag.String("crypto-key", "", "Specify the secret key for configuration file field encryption.")
 )

--- a/conf/conf.go
+++ b/conf/conf.go
@@ -14,6 +14,8 @@ import (
 	"github.com/ccfos/nightingale/v6/pkg/ormx"
 	"github.com/ccfos/nightingale/v6/pushgw/pconf"
 	"github.com/ccfos/nightingale/v6/storage"
+
+	"github.com/gin-gonic/gin"
 )

 type ConfigType struct {
@@ -30,10 +32,8 @@ type ConfigType struct {
 }

 type CenterApi struct {
-	Addrs         []string
-	BasicAuthUser string
-	BasicAuthPass string
-	Timeout       int64
+	Addrs     []string
+	BasicAuth gin.Accounts
 }

 type GlobalConfig struct {
@@ -48,7 +48,7 @@ func InitConfig(configDir, cryptoKey string) (*ConfigType, error) {
 	}

 	config.Pushgw.PreCheck()
-	config.Alert.PreCheck(configDir)
+	config.Alert.PreCheck()
 	config.Center.PreCheck()

 	err := decryptConfig(config, cryptoKey)
--- a/doc/community-governance.md
+++ b/doc/community-governance.md
@@ -77,3 +77,4 @@ Committer 记录并公示于 **[COMMITTERS](https://github.com/ccfos/nightingale
 2. 提问之前请先搜索 [Github Issues](https://github.com/ccfos/nightingale/issues "Github Issue")；
 3. 我们优先推荐通过提交 [Github Issue](https://github.com/ccfos/nightingale/issues "Github Issue") 来提问，如果[有问题点击这里](https://github.com/ccfos/nightingale/issues/new?assignees=&labels=kind%2Fbug&template=bug_report.yml "有问题点击这里") | [有需求建议点击这里](https://github.com/ccfos/nightingale/issues/new?assignees=&labels=kind%2Ffeature&template=enhancement.md "有需求建议点击这里")；

+最后，我们推荐你加入微信群，针对相关开放式问题，相互交流咨询 (请先加好友：[UlricGO](https://www.gitlink.org.cn/UlricQin/gist/tree/master/self.jpeg "UlricGO") 备注：夜莺加群+姓名+公司，交流群里会有开发者团队和专业、热心的群友回答问题)。
--- a/doc/img/n9e-arch-latest.png
+++ b/doc/img/n9e-arch-latest.png
--- a/doc/img/n9e-screenshot-gif-v6.gif
+++ b/doc/img/n9e-screenshot-gif-v6.gif
--- a/docker/.dockerignore
+++ b/docker/.dockerignore
@@ -1,5 +1,7 @@
-compose-host-network
-compose-postgres
-compose-bridge
+ibexetc
 initsql
+mysqletc
+n9eetc
+prometc
 build.sh
+docker-compose.yaml
--- a/docker/Dockerfile.goreleaser
+++ b/docker/Dockerfile.goreleaser
@@ -5,7 +5,8 @@ WORKDIR /app
 ADD n9e /app/
 ADD etc /app/
 ADD integrations /app/integrations/
-RUN pip install requests
+ADD --chmod=755 https://github.com/ufoscout/docker-compose-wait/releases/download/2.11.0/wait_x86_64 /wait
+RUN chmod +x /wait

 EXPOSE 17000

--- a/docker/Dockerfile.goreleaser.arm64
+++ b/docker/Dockerfile.goreleaser.arm64
@@ -1,3 +1,4 @@
+FROM flashcatcloud/toolbox:v0.0.1 as toolbox
 FROM --platform=$TARGETPLATFORM python:3-slim


@@ -5,6 +6,7 @@ WORKDIR /app
 ADD n9e /app/
 ADD etc /app/
 ADD integrations /app/integrations/
+COPY --chmod=755  --from=toolbox /toolbox/wait_aarch64 /wait

 EXPOSE 17000

--- a/docker/compose-host-network/etc-categraf/config.toml
+++ b/docker/compose-host-network/etc-categraf/config.toml
--- a/docker/compose-bridge/etc-categraf/input.cpu/cpu.toml
+++ b/docker/compose-bridge/etc-categraf/input.cpu/cpu.toml
--- a/docker/compose-host-network/etc-categraf/input.disk/disk.toml
+++ b/docker/compose-host-network/etc-categraf/input.disk/disk.toml
--- a/docker/compose-bridge/etc-categraf/input.diskio/diskio.toml
+++ b/docker/compose-bridge/etc-categraf/input.diskio/diskio.toml
--- a/docker/compose-postgres/categraf/conf/input.docker/docker.toml
+++ b/docker/compose-postgres/categraf/conf/input.docker/docker.toml
--- a/docker/compose-bridge/etc-categraf/input.kernel/kernel.toml
+++ b/docker/compose-bridge/etc-categraf/input.kernel/kernel.toml
--- a/docker/categraf/conf/input.kernel_vmstat/kernel_vmstat.toml
+++ b/docker/categraf/conf/input.kernel_vmstat/kernel_vmstat.toml
--- a/docker/categraf/conf/input.linux_sysctl_fs/linux_sysctl_fs.toml
+++ b/docker/categraf/conf/input.linux_sysctl_fs/linux_sysctl_fs.toml
--- a/docker/compose-bridge/etc-categraf/input.mem/mem.toml
+++ b/docker/compose-bridge/etc-categraf/input.mem/mem.toml
--- a/docker/compose-bridge/etc-categraf/input.net/net.toml
+++ b/docker/compose-bridge/etc-categraf/input.net/net.toml
--- a/docker/compose-host-network/etc-categraf/input.netstat/netstat.toml
+++ b/docker/compose-host-network/etc-categraf/input.netstat/netstat.toml
--- a/docker/compose-bridge/etc-categraf/input.processes/processes.toml
+++ b/docker/compose-bridge/etc-categraf/input.processes/processes.toml
--- a/docker/compose-bridge/etc-categraf/input.system/system.toml
+++ b/docker/compose-bridge/etc-categraf/input.system/system.toml
--- a/docker/compose-bridge/docker-compose.yaml
+++ b/docker/compose-bridge/docker-compose.yaml
@@ -1,132 +0,0 @@
-version: "3.7"
-
-networks:
-  nightingale:
-    driver: bridge
-
-services:
-  mysql:
-    image: "mysql:8"
-    container_name: mysql
-    hostname: mysql
-    restart: always
-    environment:
-      TZ: Asia/Shanghai
-      MYSQL_ROOT_PASSWORD: 1234
-    volumes:
-      - ./mysqldata:/var/lib/mysql/
-      - ../initsql:/docker-entrypoint-initdb.d/
-      - ./etc-mysql/my.cnf:/etc/my.cnf
-    networks:
-      - nightingale
-    ports:
-      - "3306:3306"
-
-  redis:
-    image: "redis:6.2"
-    container_name: redis
-    hostname: redis
-    restart: always
-    environment:
-      TZ: Asia/Shanghai
-    networks:
-      - nightingale
-    ports:
-      - "6379:6379"
-
-  # prometheus:
-  #   image: prom/prometheus
-  #   container_name: prometheus
-  #   hostname: prometheus
-  #   restart: always
-  #   environment:
-  #     TZ: Asia/Shanghai
-  #   volumes:
-  #     - ./etc-prometheus:/etc/prometheus
-  #   command:
-  #     - "--config.file=/etc/prometheus/prometheus.yml"
-  #     - "--storage.tsdb.path=/prometheus"
-  #     - "--web.console.libraries=/usr/share/prometheus/console_libraries"
-  #     - "--web.console.templates=/usr/share/prometheus/consoles"
-  #     - "--enable-feature=remote-write-receiver"
-  #     - "--query.lookback-delta=2m"
-  #   networks:
-  #     - nightingale
-  #   ports:
-  #     - "9090:9090"
-
-  victoriametrics:
-    image: victoriametrics/victoria-metrics:v1.79.12
-    container_name: victoriametrics
-    hostname: victoriametrics
-    restart: always
-    environment:
-      TZ: Asia/Shanghai
-    ports:
-      - "8428:8428"
-    networks:
-      - nightingale
-    command:
-      - "--loggerTimezone=Asia/Shanghai"
-
-  ibex:
-    image: flashcatcloud/ibex:v1.2.0
-    container_name: ibex
-    hostname: ibex
-    restart: always
-    environment:
-      GIN_MODE: release
-      TZ: Asia/Shanghai
-      WAIT_HOSTS: mysql:3306
-    volumes:
-      - ./etc-ibex:/app/etc
-    networks:
-      - nightingale
-    ports:
-      - "10090:10090"
-      - "20090:20090"
-    depends_on:
-      - mysql
-    command: >
-      sh -c "/app/ibex server"
-
-  nightingale:
-    image: flashcatcloud/nightingale:latest
-    container_name: nightingale
-    hostname: nightingale
-    restart: always
-    environment:
-      GIN_MODE: release
-      TZ: Asia/Shanghai
-      WAIT_HOSTS: mysql:3306, redis:6379
-    volumes:
-      - ./etc-nightingale:/app/etc
-    networks:
-      - nightingale
-    ports:
-      - "17000:17000"
-    depends_on:
-      - mysql
-      - redis
-      - victoriametrics
-    command: >
-      sh -c "/app/n9e"
-
-  categraf:
-    image: "flashcatcloud/categraf:latest"
-    container_name: "categraf"
-    hostname: "categraf01"
-    restart: always
-    environment:
-      TZ: Asia/Shanghai
-      HOST_PROC: /hostfs/proc
-      HOST_SYS: /hostfs/sys
-      HOST_MOUNT_PREFIX: /hostfs
-      WAIT_HOSTS: nightingale:17000, ibex:20090
-    volumes:
-      - ./etc-categraf:/etc/categraf/conf
-      - /:/hostfs
-    networks:
-      - nightingale
-    depends_on:
-      - nightingale
--- a/docker/compose-bridge/etc-categraf/config.toml
+++ b/docker/compose-bridge/etc-categraf/config.toml
@@ -1,83 +0,0 @@
-[global]
-# whether print configs
-print_configs = false
-
-# add label(agent_hostname) to series
-# "" -> auto detect hostname
-# "xx" -> use specified string xx
-# "$hostname" -> auto detect hostname
-# "$ip" -> auto detect ip
-# "$hostname-$ip" -> auto detect hostname and ip to replace the vars
-hostname = "$HOSTNAME"
-
-# will not add label(agent_hostname) if true
-omit_hostname = false
-
-# s | ms
-precision = "ms"
-
-# global collect interval
-interval = 15
-
-[global.labels]
-source="categraf"
-# region = "shanghai"
-# env = "localhost"
-
-[writer_opt]
-# default: 2000
-batch = 2000
-# channel(as queue) size
-chan_size = 10000
-
-[[writers]]
-url = "http://nightingale:17000/prometheus/v1/write"
-
-# Basic auth username
-basic_auth_user = ""
-
-# Basic auth password
-basic_auth_pass = ""
-
-# timeout settings, unit: ms
-timeout = 5000
-dial_timeout = 2500
-max_idle_conns_per_host = 100
-
-[http]
-enable = false
-address = ":9100"
-print_access = false
-run_mode = "release"
-
-[heartbeat]
-enable = true
-
-# report os version cpu.util mem.util metadata
-url = "http://nightingale:17000/v1/n9e/heartbeat"
-
-# interval, unit: s
-interval = 10
-
-# Basic auth username
-basic_auth_user = ""
-
-# Basic auth password
-basic_auth_pass = ""
-
-## Optional headers
-# headers = ["X-From", "categraf", "X-Xyz", "abc"]
-
-# timeout settings, unit: ms
-timeout = 5000
-dial_timeout = 2500
-max_idle_conns_per_host = 100
-
-[ibex]
-enable = true
-## ibex flush interval
-interval = "1000ms"
-## n9e ibex server rpc address
-servers = ["ibex:20090"]
-## temp script dir
-meta_dir = "./meta"
--- a/docker/compose-bridge/etc-categraf/input.disk/disk.toml
+++ b/docker/compose-bridge/etc-categraf/input.disk/disk.toml
@@ -1,10 +0,0 @@
-# # collect interval
-# interval = 15
-
-# # By default stats will be gathered for all mount points.
-# # Set mount_points will restrict the stats to only the specified mount points.
-mount_points = ["/"]
-
-# Ignore mount points by filesystem type.
-ignore_fs = ["tmpfs", "devtmpfs", "devfs", "iso9660", "overlay", "aufs", "squashfs", "nsfs"]
-
--- a/docker/compose-bridge/etc-categraf/input.prometheus/prometheus.toml
+++ b/docker/compose-bridge/etc-categraf/input.prometheus/prometheus.toml
@@ -1,4 +0,0 @@
-[[instances]]
-urls = [
-    "http://nightingale:17000/metrics"
-]
--- a/docker/compose-bridge/etc-ibex/server.conf
+++ b/docker/compose-bridge/etc-ibex/server.conf
@@ -1,97 +0,0 @@
-# debug, release
-RunMode = "release"
-
-[Log]
-# log write dir
-Dir = "logs-server"
-# log level: DEBUG INFO WARNING ERROR
-Level = "DEBUG"
-# stdout, stderr, file
-Output = "stdout"
-# # rotate by time
-# KeepHours: 4
-# # rotate by size
-# RotateNum = 3
-# # unit: MB
-# RotateSize = 256
-
-[HTTP]
-Enable = true
-# http listening address
-Host = "0.0.0.0"
-# http listening port
-Port = 10090
-# https cert file path
-CertFile = ""
-# https key file path
-KeyFile = ""
-# whether print access log
-PrintAccessLog = true
-# whether enable pprof
-PProf = false
-# http graceful shutdown timeout, unit: s
-ShutdownTimeout = 30
-# max content length: 64M
-MaxContentLength = 67108864
-# http server read timeout, unit: s
-ReadTimeout = 20
-# http server write timeout, unit: s
-WriteTimeout = 40
-# http server idle timeout, unit: s
-IdleTimeout = 120
-
-[BasicAuth]
-# using when call apis
-ibex = "ibex"
-
-[RPC]
-Listen = "0.0.0.0:20090"
-
-[Heartbeat]
-# auto detect if blank
-IP = ""
-# unit: ms
-Interval = 1000
-
-[Output]
-# database | remote
-ComeFrom = "database"
-AgtdPort = 2090
-
-[Gorm]
-# enable debug mode or not
-Debug = false
-# mysql postgres
-DBType = "mysql"
-# unit: s
-MaxLifetime = 7200
-# max open connections
-MaxOpenConns = 150
-# max idle connections
-MaxIdleConns = 50
-# table prefix
-TablePrefix = ""
-
-[MySQL]
-# mysql address host:port
-Address = "mysql:3306"
-# mysql username
-User = "root"
-# mysql password
-Password = "1234"
-# database name
-DBName = "ibex"
-# connection params
-Parameters = "charset=utf8mb4&parseTime=True&loc=Local&allowNativePasswords=true"
-
-[Postgres]
-# pg address host:port
-Address = "postgres:5432"
-# pg user
-User = "root"
-# pg password
-Password = "1234"
-# database name
-DBName = "ibex"
-# ssl mode
-SSLMode = "disable"
--- a/docker/compose-bridge/etc-nightingale/config.toml
+++ b/docker/compose-bridge/etc-nightingale/config.toml
@@ -1,183 +0,0 @@
-[Global]
-RunMode = "release"
-
-[Log]
-# log write dir
-Dir = "logs"
-# log level: DEBUG INFO WARNING ERROR
-Level = "DEBUG"
-# stdout, stderr, file
-Output = "stdout"
-# # rotate by time
-# KeepHours = 4
-# # rotate by size
-# RotateNum = 3
-# # unit: MB
-# RotateSize = 256
-
-[HTTP]
-# http listening address
-Host = "0.0.0.0"
-# http listening port
-Port = 17000
-# https cert file path
-CertFile = ""
-# https key file path
-KeyFile = ""
-# whether print access log
-PrintAccessLog = false
-# whether enable pprof
-PProf = false
-# expose prometheus /metrics?
-ExposeMetrics = true
-# http graceful shutdown timeout, unit: s
-ShutdownTimeout = 30
-# max content length: 64M
-MaxContentLength = 67108864
-# http server read timeout, unit: s
-ReadTimeout = 20
-# http server write timeout, unit: s
-WriteTimeout = 40
-# http server idle timeout, unit: s
-IdleTimeout = 120
-
-[HTTP.ShowCaptcha]
-Enable = false 
-
-[HTTP.APIForAgent]
-Enable = true 
-# [HTTP.APIForAgent.BasicAuth]
-# user001 = "ccc26da7b9aba533cbb263a36c07dcc5"
-
-[HTTP.APIForService]
-Enable = true 
-[HTTP.APIForService.BasicAuth]
-user001 = "ccc26da7b9aba533cbb263a36c07dcc5"
-
-[HTTP.JWTAuth]
-# signing key
-SigningKey = "5b94a0fd640fe2765af826acfe42d151"
-# unit: min
-AccessExpired = 1500
-# unit: min
-RefreshExpired = 10080
-RedisKeyPrefix = "/jwt/"
-
-[HTTP.ProxyAuth]
-# if proxy auth enabled, jwt auth is disabled
-Enable = false
-# username key in http proxy header
-HeaderUserNameKey = "X-User-Name"
-DefaultRoles = ["Standard"]
-
-[HTTP.RSA]
-# open RSA
-OpenRSA = false
-# Before replacing the key file, make sure that there are no encrypted variables in the database "configs".
-# It is recommended to decrypt and remove all encrypted values from the database before replacing the key file.
-# This will prevent any potential issues with accessing or decrypting the variables using the new key file.
-# RSA public key (auto carete)
-RSAPublicKeyPath = "etc/rsa/public.pem"
-# RSA private key (auto carete)
-RSAPrivateKeyPath = "etc/rsa/private.pem"
-# RSA private key password
-RSAPassWord = "n9e@n9e!"
-
-[DB]
-# postgres: DSN="host=127.0.0.1 port=5432 user=root dbname=n9e_v6 password=1234 sslmode=disable"
-DSN="root:1234@tcp(mysql:3306)/n9e_v6?charset=utf8mb4&parseTime=True&loc=Local&allowNativePasswords=true"
-# enable debug mode or not
-Debug = false
-# mysql postgres
-DBType = "mysql"
-# unit: s
-MaxLifetime = 7200
-# max open connections
-MaxOpenConns = 150
-# max idle connections
-MaxIdleConns = 50
-# table prefix
-TablePrefix = ""
-# enable auto migrate or not
-# EnableAutoMigrate = false
-
-[Redis]
-# address, ip:port or ip1:port,ip2:port for cluster and sentinel(SentinelAddrs)
-Address = "redis:6379"
-# Username = ""
-# Password = ""
-# DB = 0
-# UseTLS = false
-# TLSMinVersion = "1.2"
-# standalone cluster sentinel
-RedisType = "standalone"
-# Mastername for sentinel type
-# MasterName = "mymaster"
-# SentinelUsername = ""
-# SentinelPassword = ""
-
-[Alert]
-[Alert.Heartbeat]
-# auto detect if blank
-IP = ""
-# unit ms
-Interval = 1000
-EngineName = "default"
-
-# [Alert.Alerting]
-# NotifyConcurrency = 10
-
-[Center]
-MetricsYamlFile = "./etc/metrics.yaml"
-I18NHeaderKey = "X-Language"
-
-[Center.AnonymousAccess]
-PromQuerier = false
-AlertDetail = false
-
-[Pushgw]
-# use target labels in database instead of in series
-LabelRewrite = true
-# # default busigroup key name
-# BusiGroupLabelKey = "busigroup"
-# ForceUseServerTS = false
-
-# [Pushgw.DebugSample]
-# ident = "xx"
-# __name__ = "xx"
-
-# [Pushgw.WriterOpt]
-# QueueMaxSize = 1000000
-# QueuePopSize = 1000
-
-[[Pushgw.Writers]] 
-# Url = "http://127.0.0.1:8480/insert/0/prometheus/api/v1/write"
-Url = "http://victoriametrics:8428/api/v1/write"
-# Basic auth username
-BasicAuthUser = ""
-# Basic auth password
-BasicAuthPass = ""
-# timeout settings, unit: ms
-Headers = ["X-From", "n9e"]
-Timeout = 10000
-DialTimeout = 3000
-TLSHandshakeTimeout = 30000
-ExpectContinueTimeout = 1000
-IdleConnTimeout = 90000
-# time duration, unit: ms
-KeepAlive = 30000
-MaxConnsPerHost = 0
-MaxIdleConns = 100
-MaxIdleConnsPerHost = 100
-## Optional TLS Config
-# UseTLS = false
-# TLSCA = "/etc/n9e/ca.pem"
-# TLSCert = "/etc/n9e/cert.pem"
-# TLSKey = "/etc/n9e/key.pem"
-# InsecureSkipVerify = false
-# [[Writers.WriteRelabels]]
-# Action = "replace"
-# SourceLabels = ["__address__"]
-# Regex = "([^:]+)(?::\\d+)?"
-# Replacement = "$1:80"
-# TargetLabel = "__address__"
--- a/docker/compose-bridge/etc-nightingale/metrics.yaml
+++ b/docker/compose-bridge/etc-nightingale/metrics.yaml
@@ -1,774 +0,0 @@
-zh:
-  ip_conntrack_count: 连接跟踪表条目总数（单位：int, count）
-  ip_conntrack_max: 连接跟踪表最大容量（单位：int, size）
-  cpu_usage_idle: CPU空闲率（单位：%）
-  cpu_usage_active: CPU使用率（单位：%）
-  cpu_usage_system: CPU内核态时间占比（单位：%）
-  cpu_usage_user: CPU用户态时间占比（单位：%）
-  cpu_usage_nice: 低优先级用户态CPU时间占比，也就是进程nice值被调整为1-19之间的CPU时间。这里注意，nice可取值范围是-20到19，数值越大，优先级反而越低（单位：%）
-  cpu_usage_iowait: CPU等待I/O的时间占比（单位：%）
-  cpu_usage_irq: CPU处理硬中断的时间占比（单位：%）
-  cpu_usage_softirq: CPU处理软中断的时间占比（单位：%）
-  cpu_usage_steal: 在虚拟机环境下有该指标，表示CPU被其他虚拟机争用的时间占比，超过20就表示争抢严重（单位：%）
-  cpu_usage_guest: 通过虚拟化运行其他操作系统的时间，也就是运行虚拟机的CPU时间占比（单位：%）
-  cpu_usage_guest_nice: 以低优先级运行虚拟机的时间占比（单位：%）
-
-  disk_free: 硬盘分区剩余量（单位：byte）
-  disk_used: 硬盘分区使用量（单位：byte）
-  disk_used_percent: 硬盘分区使用率（单位：%）
-  disk_total: 硬盘分区总量（单位：byte）
-  disk_inodes_free: 硬盘分区inode剩余量
-  disk_inodes_used: 硬盘分区inode使用量
-  disk_inodes_total: 硬盘分区inode总量
-
-  diskio_io_time: 从设备视角来看I/O请求总时间，队列中有I/O请求就计数（单位：毫秒），counter类型，需要用函数求rate才有使用价值
-  diskio_iops_in_progress: 已经分配给设备驱动且尚未完成的IO请求，不包含在队列中但尚未分配给设备驱动的IO请求，gauge类型
-  diskio_merged_reads: 相邻读请求merge读的次数，counter类型
-  diskio_merged_writes: 相邻写请求merge写的次数，counter类型
-  diskio_read_bytes: 读取的byte数量，counter类型，需要用函数求rate才有使用价值
-  diskio_read_time: 读请求总时间（单位：毫秒），counter类型，需要用函数求rate才有使用价值
-  diskio_reads: 读请求次数，counter类型，需要用函数求rate才有使用价值
-  diskio_weighted_io_time: 从I/O请求视角来看I/O等待总时间，如果同时有多个I/O请求，时间会叠加（单位：毫秒）
-  diskio_write_bytes: 写入的byte数量，counter类型，需要用函数求rate才有使用价值
-  diskio_write_time: 写请求总时间（单位：毫秒），counter类型，需要用函数求rate才有使用价值
-  diskio_writes: 写请求次数，counter类型，需要用函数求rate才有使用价值
-
-  kernel_boot_time: 内核启动时间
-  kernel_context_switches: 内核上下文切换次数
-  kernel_entropy_avail: linux系统内部的熵池
-  kernel_interrupts: 内核中断次数
-  kernel_processes_forked: fork的进程数
-
-  mem_active: 活跃使用的内存总数(包括cache和buffer内存)
-  mem_available: 可用内存大小(bytes)
-  mem_available_percent: 内存剩余百分比(0~100)
-  mem_buffered: 用来给文件做缓冲大小
-  mem_cached: 被高速缓冲存储器（cache memory）用的内存的大小（等于 diskcache minus SwapCache ）
-  mem_commit_limit: 根据超额分配比率（'vm.overcommit_ratio'），这是当前在系统上分配可用的内存总量，这个限制只是在模式2('vm.overcommit_memory')时启用
-  mem_committed_as: 目前在系统上分配的内存量。是所有进程申请的内存的总和
-  mem_dirty: 等待被写回到磁盘的内存大小
-  mem_free: 空闲内存大小(bytes)
-  mem_high_free: 未被使用的高位内存大小
-  mem_high_total: 高位内存总大小（Highmem是指所有内存高于860MB的物理内存,Highmem区域供用户程序使用，或用于页面缓存。该区域不是直接映射到内核空间。内核必须使用不同的手法使用该段内存）
-  mem_huge_page_size: 每个大页的大小
-  mem_huge_pages_free: 池中尚未分配的 HugePages 数量
-  mem_huge_pages_total: 预留HugePages的总个数
-  mem_inactive: 空闲的内存数(包括free和avalible的内存)
-  mem_low_free: 未被使用的低位大小
-  mem_low_total: 低位内存总大小,低位可以达到高位内存一样的作用，而且它还能够被内核用来记录一些自己的数据结构
-  mem_mapped: 设备和文件等映射的大小
-  mem_page_tables: 管理内存分页页面的索引表的大小
-  mem_shared: 多个进程共享的内存总额
-  mem_slab: 内核数据结构缓存的大小，可以减少申请和释放内存带来的消耗
-  mem_sreclaimable: 可收回Slab的大小
-  mem_sunreclaim: 不可收回Slab的大小（SUnreclaim+SReclaimable＝Slab）
-  mem_swap_cached: 被高速缓冲存储器（cache memory）用的交换空间的大小，已经被交换出来的内存，但仍然被存放在swapfile中。用来在需要的时候很快的被替换而不需要再次打开I/O端口
-  mem_swap_free: 未被使用交换空间的大小
-  mem_swap_total: 交换空间的总大小
-  mem_total: 内存总数
-  mem_used: 已用内存数
-  mem_used_percent: 已用内存数百分比(0~100)
-  mem_vmalloc_chunk: 最大的连续未被使用的vmalloc区域
-  mem_vmalloc_totalL: 可以vmalloc虚拟内存大小
-  mem_vmalloc_used: vmalloc已使用的虚拟内存大小
-  mem_write_back: 正在被写回到磁盘的内存大小
-  mem_write_back_tmp: FUSE用于临时写回缓冲区的内存
-
-  net_bytes_recv: 网卡收包总数(bytes)，计算每秒速率时需要用到rate/irate函数
-  net_bytes_sent: 网卡发包总数(bytes)，计算每秒速率时需要用到rate/irate函数
-  net_drop_in: 网卡收丢包数量
-  net_drop_out: 网卡发丢包数量
-  net_err_in: 网卡收包错误数量
-  net_err_out: 网卡发包错误数量
-  net_packets_recv: 网卡收包数量
-  net_packets_sent: 网卡发包数量
-  net_bits_recv: 网卡收包总数(bits)，计算每秒速率时需要用到rate/irate函数
-  net_bits_sent: 网卡发包总数(bits)，计算每秒速率时需要用到rate/irate函数
-
-  netstat_tcp_established: ESTABLISHED状态的网络链接数
-  netstat_tcp_fin_wait1: FIN_WAIT1状态的网络链接数
-  netstat_tcp_fin_wait2: FIN_WAIT2状态的网络链接数
-  netstat_tcp_last_ack: LAST_ACK状态的网络链接数
-  netstat_tcp_listen: LISTEN状态的网络链接数
-  netstat_tcp_syn_recv: SYN_RECV状态的网络链接数
-  netstat_tcp_syn_sent: SYN_SENT状态的网络链接数
-  netstat_tcp_time_wait: TIME_WAIT状态的网络链接数
-  netstat_udp_socket: UDP状态的网络链接数
-
-  netstat_sockets_used: 已使用的所有协议套接字总量
-  netstat_tcp_inuse: 正在使用（正在侦听）的TCP套接字数量
-  netstat_tcp_orphan: 无主（不属于任何进程）的TCP连接数（无用、待销毁的TCP socket数）
-  netstat_tcp_tw: TIME_WAIT状态的TCP连接数
-  netstat_tcp_alloc: 已分配（已建立、已申请到sk_buff）的TCP套接字数量
-  netstat_tcp_mem: TCP套接字内存Page使用量
-  netstat_udp_inuse: 在使用的UDP套接字数量
-  netstat_udp_mem: UDP套接字内存Page使用量
-  netstat_udplite_inuse: 正在使用的 udp lite 数量
-  netstat_raw_inuse: 正在使用的 raw socket 数量
-  netstat_frag_inuse: ip fragement 数量
-  netstat_frag_memory: ip fragement 已经分配的内存(byte）
-
-  #[ping]
-  ping_percent_packet_loss: ping数据包丢失百分比(%)
-  ping_result_code: ping返回码('0','1')
-
-  net_response_result_code: 网络探测结果，0表示正常，非0表示异常
-  net_response_response_time: 网络探测时延，单位：秒
-
-  processes_blocked: 不可中断的睡眠状态下的进程数('U','D','L')
-  processes_dead: 回收中的进程数('X')
-  processes_idle: 挂起的空闲进程数('I')
-  processes_paging: 分页进程数('P')
-  processes_running: 运行中的进程数('R')
-  processes_sleeping: 可中断进程数('S')
-  processes_stopped: 暂停状态进程数('T')
-  processes_total: 总进程数
-  processes_total_threads: 总线程数
-  processes_unknown: 未知状态进程数
-  processes_zombies: 僵尸态进程数('Z')
-
-  swap_used_percent: Swap空间换出数据量
-
-  system_load1: 1分钟平均load值
-  system_load5: 5分钟平均load值
-  system_load15: 15分钟平均load值
-  system_load_norm_1: 1分钟平均load值/逻辑CPU个数
-  system_load_norm_5: 5分钟平均load值/逻辑CPU个数
-  system_load_norm_15: 15分钟平均load值/逻辑CPU个数
-  system_n_users: 用户数
-  system_n_cpus: CPU核数
-  system_uptime: 系统启动时间
-
-  nginx_accepts: 自nginx启动起,与客户端建立过得连接总数
-  nginx_active: 当前nginx正在处理的活动连接数,等于Reading/Writing/Waiting总和
-  nginx_handled: 自nginx启动起,处理过的客户端连接总数
-  nginx_reading: 正在读取HTTP请求头部的连接总数
-  nginx_requests: 自nginx启动起,处理过的客户端请求总数,由于存在HTTP Krrp-Alive请求,该值会大于handled值
-  nginx_upstream_check_fall: upstream_check模块检测到后端失败的次数
-  nginx_upstream_check_rise: upstream_check模块对后端的检测次数
-  nginx_upstream_check_status_code: 后端upstream的状态,up为1,down为0
-  nginx_waiting: 开启 keep-alive 的情况下,这个值等于 active – (reading+writing), 意思就是 Nginx 已经处理完正在等候下一次请求指令的驻留连接
-  nginx_writing: 正在向客户端发送响应的连接总数
-
-  http_response_content_length: HTTP消息实体的传输长度
-  http_response_http_response_code: http响应状态码
-  http_response_response_time: http响应用时
-  http_response_result_code: url探测结果0为正常否则url无法访问
-
-  # [aws cloudwatch rds]
-  cloudwatch_aws_rds_bin_log_disk_usage_average: rds 磁盘使用平均值
-  cloudwatch_aws_rds_bin_log_disk_usage_maximum: rds 磁盘使用量最大值
-  cloudwatch_aws_rds_bin_log_disk_usage_minimum: rds binlog 磁盘使用量最低
-  cloudwatch_aws_rds_bin_log_disk_usage_sample_count: rds binlog 磁盘使用情况样本计数
-  cloudwatch_aws_rds_bin_log_disk_usage_sum: rds binlog 磁盘使用总和
-  cloudwatch_aws_rds_burst_balance_average: rds 突发余额平均值
-  cloudwatch_aws_rds_burst_balance_maximum: rds 突发余额最大值
-  cloudwatch_aws_rds_burst_balance_minimum: rds 突发余额最低
-  cloudwatch_aws_rds_burst_balance_sample_count: rds 突发平衡样本计数
-  cloudwatch_aws_rds_burst_balance_sum: rds 突发余额总和
-  cloudwatch_aws_rds_cpu_utilization_average: rds cpu 利用率平均值
-  cloudwatch_aws_rds_cpu_utilization_maximum: rds cpu 利用率最大值
-  cloudwatch_aws_rds_cpu_utilization_minimum: rds cpu 利用率最低
-  cloudwatch_aws_rds_cpu_utilization_sample_count: rds cpu 利用率样本计数
-  cloudwatch_aws_rds_cpu_utilization_sum: rds cpu 利用率总和
-  cloudwatch_aws_rds_database_connections_average: rds 数据库连接平均值
-  cloudwatch_aws_rds_database_connections_maximum: rds 数据库连接数最大值
-  cloudwatch_aws_rds_database_connections_minimum: rds 数据库连接最小
-  cloudwatch_aws_rds_database_connections_sample_count: rds 数据库连接样本数
-  cloudwatch_aws_rds_database_connections_sum: rds 数据库连接总和
-  cloudwatch_aws_rds_db_load_average: rds db 平均负载
-  cloudwatch_aws_rds_db_load_cpu_average: rds db 负载 cpu 平均值
-  cloudwatch_aws_rds_db_load_cpu_maximum: rds db 负载 cpu 最大值
-  cloudwatch_aws_rds_db_load_cpu_minimum: rds db 负载 cpu 最小值
-  cloudwatch_aws_rds_db_load_cpu_sample_count: rds db 加载 CPU 样本数
-  cloudwatch_aws_rds_db_load_cpu_sum: rds db 加载cpu总和
-  cloudwatch_aws_rds_db_load_maximum: rds 数据库负载最大值
-  cloudwatch_aws_rds_db_load_minimum: rds 数据库负载最小值
-  cloudwatch_aws_rds_db_load_non_cpu_average: rds 加载非 CPU 平均值
-  cloudwatch_aws_rds_db_load_non_cpu_maximum: rds 加载非 cpu 最大值
-  cloudwatch_aws_rds_db_load_non_cpu_minimum: rds 加载非 cpu 最小值
-  cloudwatch_aws_rds_db_load_non_cpu_sample_count: rds 加载非 cpu 样本计数
-  cloudwatch_aws_rds_db_load_non_cpu_sum: rds 加载非cpu总和
-  cloudwatch_aws_rds_db_load_sample_count: rds db 加载样本计数
-  cloudwatch_aws_rds_db_load_sum: rds db 负载总和
-  cloudwatch_aws_rds_disk_queue_depth_average: rds 磁盘队列深度平均值
-  cloudwatch_aws_rds_disk_queue_depth_maximum: rds 磁盘队列深度最大值
-  cloudwatch_aws_rds_disk_queue_depth_minimum: rds 磁盘队列深度最小值
-  cloudwatch_aws_rds_disk_queue_depth_sample_count: rds 磁盘队列深度样本计数
-  cloudwatch_aws_rds_disk_queue_depth_sum: rds 磁盘队列深度总和
-  cloudwatch_aws_rds_ebs_byte_balance__average: rds ebs 字节余额平均值
-  cloudwatch_aws_rds_ebs_byte_balance__maximum: rds ebs 字节余额最大值
-  cloudwatch_aws_rds_ebs_byte_balance__minimum: rds ebs 字节余额最低
-  cloudwatch_aws_rds_ebs_byte_balance__sample_count: rds ebs 字节余额样本数
-  cloudwatch_aws_rds_ebs_byte_balance__sum: rds ebs 字节余额总和
-  cloudwatch_aws_rds_ebsio_balance__average: rds ebsio 余额平均值
-  cloudwatch_aws_rds_ebsio_balance__maximum: rds ebsio 余额最大值
-  cloudwatch_aws_rds_ebsio_balance__minimum: rds ebsio 余额最低
-  cloudwatch_aws_rds_ebsio_balance__sample_count: rds ebsio 平衡样本计数
-  cloudwatch_aws_rds_ebsio_balance__sum: rds ebsio 余额总和
-  cloudwatch_aws_rds_free_storage_space_average: rds 免费存储空间平均
-  cloudwatch_aws_rds_free_storage_space_maximum: rds 最大可用存储空间
-  cloudwatch_aws_rds_free_storage_space_minimum: rds 最低可用存储空间
-  cloudwatch_aws_rds_free_storage_space_sample_count: rds 可用存储空间样本数
-  cloudwatch_aws_rds_free_storage_space_sum: rds 免费存储空间总和
-  cloudwatch_aws_rds_freeable_memory_average: rds 可用内存平均值
-  cloudwatch_aws_rds_freeable_memory_maximum: rds 最大可用内存
-  cloudwatch_aws_rds_freeable_memory_minimum: rds 最小可用内存
-  cloudwatch_aws_rds_freeable_memory_sample_count: rds 可释放内存样本数
-  cloudwatch_aws_rds_freeable_memory_sum: rds 可释放内存总和
-  cloudwatch_aws_rds_lvm_read_iops_average: rds lvm 读取 iops 平均值
-  cloudwatch_aws_rds_lvm_read_iops_maximum: rds lvm 读取 iops 最大值
-  cloudwatch_aws_rds_lvm_read_iops_minimum: rds lvm 读取 iops 最低
-  cloudwatch_aws_rds_lvm_read_iops_sample_count: rds lvm 读取 iops 样本计数
-  cloudwatch_aws_rds_lvm_read_iops_sum: rds lvm 读取 iops 总和
-  cloudwatch_aws_rds_lvm_write_iops_average: rds lvm 写入 iops 平均值
-  cloudwatch_aws_rds_lvm_write_iops_maximum: rds lvm 写入 iops 最大值
-  cloudwatch_aws_rds_lvm_write_iops_minimum: rds lvm 写入 iops 最低
-  cloudwatch_aws_rds_lvm_write_iops_sample_count: rds lvm 写入 iops 样本计数
-  cloudwatch_aws_rds_lvm_write_iops_sum: rds lvm 写入 iops 总和
-  cloudwatch_aws_rds_network_receive_throughput_average: rds 网络接收吞吐量平均
-  cloudwatch_aws_rds_network_receive_throughput_maximum: rds 网络接收吞吐量最大值
-  cloudwatch_aws_rds_network_receive_throughput_minimum: rds 网络接收吞吐量最小值
-  cloudwatch_aws_rds_network_receive_throughput_sample_count: rds 网络接收吞吐量样本计数
-  cloudwatch_aws_rds_network_receive_throughput_sum: rds 网络接收吞吐量总和
-  cloudwatch_aws_rds_network_transmit_throughput_average: rds 网络传输吞吐量平均值
-  cloudwatch_aws_rds_network_transmit_throughput_maximum: rds 网络传输吞吐量最大
-  cloudwatch_aws_rds_network_transmit_throughput_minimum: rds 网络传输吞吐量最小值
-  cloudwatch_aws_rds_network_transmit_throughput_sample_count: rds 网络传输吞吐量样本计数
-  cloudwatch_aws_rds_network_transmit_throughput_sum: rds 网络传输吞吐量总和
-  cloudwatch_aws_rds_read_iops_average: rds 读取 iops 平均值
-  cloudwatch_aws_rds_read_iops_maximum: rds 最大读取 iops
-  cloudwatch_aws_rds_read_iops_minimum: rds 读取 iops 最低
-  cloudwatch_aws_rds_read_iops_sample_count: rds 读取 iops 样本计数
-  cloudwatch_aws_rds_read_iops_sum: rds 读取 iops 总和
-  cloudwatch_aws_rds_read_latency_average: rds 读取延迟平均值
-  cloudwatch_aws_rds_read_latency_maximum: rds 读取延迟最大值
-  cloudwatch_aws_rds_read_latency_minimum: rds 最小读取延迟
-  cloudwatch_aws_rds_read_latency_sample_count: rds 读取延迟样本计数
-  cloudwatch_aws_rds_read_latency_sum: rds 读取延迟总和
-  cloudwatch_aws_rds_read_throughput_average: rds 读取吞吐量平均值
-  cloudwatch_aws_rds_read_throughput_maximum: rds 最大读取吞吐量
-  cloudwatch_aws_rds_read_throughput_minimum: rds 最小读取吞吐量
-  cloudwatch_aws_rds_read_throughput_sample_count: rds 读取吞吐量样本计数
-  cloudwatch_aws_rds_read_throughput_sum: rds 读取吞吐量总和
-  cloudwatch_aws_rds_swap_usage_average: rds 交换使用平均值
-  cloudwatch_aws_rds_swap_usage_maximum: rds 交换使用最大值
-  cloudwatch_aws_rds_swap_usage_minimum: rds 交换使用量最低
-  cloudwatch_aws_rds_swap_usage_sample_count: rds 交换使用示例计数
-  cloudwatch_aws_rds_swap_usage_sum: rds 交换使用总和
-  cloudwatch_aws_rds_write_iops_average: rds 写入 iops 平均值
-  cloudwatch_aws_rds_write_iops_maximum: rds 写入 iops 最大值
-  cloudwatch_aws_rds_write_iops_minimum: rds 写入 iops 最低
-  cloudwatch_aws_rds_write_iops_sample_count: rds 写入 iops 样本计数
-  cloudwatch_aws_rds_write_iops_sum: rds 写入 iops 总和
-  cloudwatch_aws_rds_write_latency_average: rds 写入延迟平均值
-  cloudwatch_aws_rds_write_latency_maximum: rds 最大写入延迟
-  cloudwatch_aws_rds_write_latency_minimum: rds 写入延迟最小值
-  cloudwatch_aws_rds_write_latency_sample_count: rds 写入延迟样本计数
-  cloudwatch_aws_rds_write_latency_sum: rds 写入延迟总和
-  cloudwatch_aws_rds_write_throughput_average: rds 写入吞吐量平均值
-  cloudwatch_aws_rds_write_throughput_maximum: rds 最大写入吞吐量
-  cloudwatch_aws_rds_write_throughput_minimum: rds 写入吞吐量最小值
-  cloudwatch_aws_rds_write_throughput_sample_count: rds 写入吞吐量样本计数
-  cloudwatch_aws_rds_write_throughput_sum: rds 写入吞吐量总和
-
-en:
-  ip_conntrack_count: the number of entries in the conntrack table（unit：int, count）
-  ip_conntrack_max: the max capacity of the conntrack table（unit：int, size）
-  cpu_usage_idle: "CPU idle rate(unit：%)"
-  cpu_usage_active: "CPU usage rate(unit：%)"
-  cpu_usage_system: "CPU kernel state time proportion(unit：%)"
-  cpu_usage_user: "CPU user attitude time proportion(unit：%)"
-  cpu_usage_nice: "The proportion of low priority CPU time, that is, the process NICE value is adjusted to the CPU time between 1-19. Note here that the value range of NICE is -20 to 19, the larger the value, the lower the priority, the lower the priority(unit：%)"
-  cpu_usage_iowait: "CPU waiting for I/O time proportion(unit：%)"
-  cpu_usage_irq: "CPU processing hard interrupt time proportion(unit：%)"
-  cpu_usage_softirq: "CPU processing soft interrupt time proportion(unit：%)"
-  cpu_usage_steal: "In the virtual machine environment, there is this indicator, which means that the CPU is used by other virtual machines for the proportion of time.(unit：%)"
-  cpu_usage_guest: "The time to run other operating systems by virtualization, that is, the proportion of CPU time running the virtual machine(unit：%)"
-  cpu_usage_guest_nice: "The proportion of time to run the virtual machine at low priority(unit：%)"
-
-  disk_free: "The remaining amount of the hard disk partition (unit: byte)"
-  disk_used: "Hard disk partitional use (unit: byte)"
-  disk_used_percent: "Hard disk partitional use rate (unit:%)"
-  disk_total: "Total amount of hard disk partition (unit: byte)"
-  disk_inodes_free: "Hard disk partition INODE remaining amount"
-  disk_inodes_used: "Hard disk partition INODE usage amount"
-  disk_inodes_total: "The total amount of hard disk partition INODE"
-
-  diskio_io_time: "From the perspective of the device perspective, the total time of I/O request, the I/O request in the queue is count (unit: millisecond), the counter type, you need to use the function to find the value"
-  diskio_iops_in_progress: "IO requests that have been assigned to device -driven and have not yet been completed, not included in the queue but not yet assigned to the device -driven IO request, Gauge type"
-  diskio_merged_reads: "The number of times of adjacent reading request Merge, the counter type"
-  diskio_merged_writes: "The number of times the request Merge writes, the counter type"
-  diskio_read_bytes: "The number of byte reads, the counter type, you need to use the function to find the Rate to use the value"
-  diskio_read_time: "The total time of reading request (unit: millisecond), the counter type, you need to use the function to find the Rate to have the value of use"
-  diskio_reads: "Read the number of requests, the counter type, you need to use the function to find the Rate to use the value"
-  diskio_weighted_io_time: "From the perspective of the I/O request perspective, I/O wait for the total time. If there are multiple I/O requests at the same time, the time will be superimposed (unit: millisecond)"
-  diskio_write_bytes: "The number of bytes written, the counter type, you need to use the function to find the Rate to use the value"
-  diskio_write_time: "The total time of the request (unit: millisecond), the counter type, you need to use the function to find the rate to have the value of use"
-  diskio_writes: "Write the number of requests, the counter type, you need to use the function to find the rate to use value"
-
-  kernel_boot_time: "Kernel startup time"
-  kernel_context_switches: "Number of kernel context switching times"
-  kernel_entropy_avail: "Entropy pool inside the Linux system"
-  kernel_interrupts: "Number of kernel interruption"
-  kernel_processes_forked: "ForK's process number"
-
-  mem_active: "The total number of memory (including Cache and BUFFER memory)"
-  mem_available: "Application can use memory numbers"
-  mem_available_percent: "Memory remaining percentage (0 ~ 100)"
-  mem_buffered: "Used to make buffer size for the file"
-  mem_cached: "The size of the memory used by the cache memory (equal to diskcache minus Swap Cache )"
-  mem_commit_limit: "According to the over allocation ratio ('vm.overCommit _ Ratio'), this is the current total memory that can be allocated on the system."
-  mem_committed_as: "Currently allocated on the system. It is the sum of the memory of all process applications"
-  mem_dirty: "Waiting to be written back to the memory size of the disk"
-  mem_free: "Senior memory number"
-  mem_high_free: "Unused high memory size"
-  mem_high_total: "The total memory size of the high memory (Highmem refers to all the physical memory that is higher than 860 MB of memory, the HighMem area is used for user programs, or for page cache. This area is not directly mapped to the kernel space. The kernels must use different methods to use this section of memory. )"
-  mem_huge_page_size: "The size of each big page"
-  mem_huge_pages_free: "The number of Huge Pages in the pool that have not been allocated"
-  mem_huge_pages_total: "Reserve the total number of Huge Pages"
-  mem_inactive: "Free memory (including the memory of free and avalible)"
-  mem_low_free: "Unused low size"
-  mem_low_total: "The total size of the low memory memory can achieve the same role of high memory, and it can be used by the kernel to record some of its own data structure"
-  mem_mapped: "The size of the mapping of equipment and files"
-  mem_page_tables: "The size of the index table of the management of the memory paging page"
-  mem_shared: "The total memory shared by multiple processes"
-  mem_slab: "The size of the kernel data structure cache can reduce the consumption of application and release memory"
-  mem_sreclaimable: "The size of the SLAB can be recovered"
-  mem_sunreclaim: "The size of the SLAB cannot be recovered(SUnreclaim+SReclaimable＝Slab)"
-  mem_swap_cached: "The size of the swap space used by the cache memory (cache memory), the memory that has been swapped out, but is still stored in the swapfile. Used to be quickly replaced when needed without opening the I/O port again"
-  mem_swap_free: "The size of the switching space is not used"
-  mem_swap_total: "The total size of the exchange space"
-  mem_total: "Total memory"
-  mem_used: "Memory number"
-  mem_used_percent: "The memory has been used by several percentage (0 ~ 100)"
-  mem_vmalloc_chunk: "The largest continuous unused vmalloc area"
-  mem_vmalloc_totalL: "You can vmalloc virtual memory size"
-  mem_vmalloc_used: "Vmalloc's virtual memory size"
-  mem_write_back: "The memory size of the disk is being written back to the disk"
-  mem_write_back_tmp: "Fuse is used to temporarily write back the memory of the buffer area"
-
-  net_bytes_recv: "Total inbound traffic(bytes) of network card"
-  net_bytes_sent: "Total outbound traffic(bytes) of network card"
-  net_bits_recv: "Total inbound traffic(bits) of network card"
-  net_bits_sent: "Total outbound traffic(bits) of network card"
-  net_drop_in: "The number of packets for network cards"
-  net_drop_out: "The number of packets issued by the network card"
-  net_err_in: "The number of incorrect packets of the network card"
-  net_err_out: "Number of incorrect number of network cards"
-  net_packets_recv: "Net card collection quantity"
-  net_packets_sent: "Number of network card issuance"
-
-  netstat_tcp_established: "ESTABLISHED status network link number"
-  netstat_tcp_fin_wait1: "FIN _ WAIT1 status network link number"
-  netstat_tcp_fin_wait2: "FIN _ WAIT2 status number of network links"
-  netstat_tcp_last_ack: "LAST_ ACK status number of network links"
-  netstat_tcp_listen: "Number of network links in Listen status"
-  netstat_tcp_syn_recv: "SYN _ RECV status number of network links"
-  netstat_tcp_syn_sent: "SYN _ SENT status number of network links"
-  netstat_tcp_time_wait: "Time _ WAIT status network link number"
-  netstat_udp_socket: "Number of network links in UDP status"
-
-  processes_blocked: "The number of processes in the unreprudible sleep state('U','D','L')"
-  processes_dead: "Number of processes in recycling('X')"
-  processes_idle: "Number of idle processes hanging('I')"
-  processes_paging: "Number of paging processes('P')"
-  processes_running: "Number of processes during operation('R')"
-  processes_sleeping: "Can interrupt the number of processes('S')"
-  processes_stopped: "Pushing status process number('T')"
-  processes_total: "Total process number"
-  processes_total_threads: "Number of threads"
-  processes_unknown: "Unknown status process number"
-  processes_zombies: "Number of zombies('Z')"
-
-  swap_used_percent: "SWAP space replace the data volume"
-
-  system_load1: "1 minute average load value"
-  system_load5: "5 minutes average load value"
-  system_load15: "15 minutes average load value"
-  system_load_norm_1: "1 minute average load value/logical CPU number"
-  system_load_norm_5: "5 minutes average load value/logical CPU number"
-  system_load_norm_15: "15 minutes average load value/logical CPU number"
-  system_n_users: "User number"
-  system_n_cpus: "CPU nuclear number"
-  system_uptime: "System startup time"
-
-  nginx_accepts: "Since Nginx started, the total number of connections has been established with the client"
-  nginx_active: "The current number of activity connections that Nginx is being processed is equal to Reading/Writing/Waiting"
-  nginx_handled: "Starting from Nginx, the total number of client connections that have been processed"
-  nginx_reading: "Reading the total number of connections on the http request header"
-  nginx_requests: "Since nginx is started, the total number of client requests processed, due to the existence of HTTP Krrp - Alive requests, this value will be greater than the handled value"
-  nginx_upstream_check_fall: "UPStream_CHECK module detects the number of back -end failures"
-  nginx_upstream_check_rise: "UPSTREAM _ Check module to detect the number of back -end"
-  nginx_upstream_check_status_code: "The state of the backstream is 1, and the down is 0"
-  nginx_waiting: "When keep-alive is enabled, this value is equal to active – (reading+writing), which means that Nginx has processed the resident connection that is waiting for the next request command"
-  nginx_writing: "The total number of connections to send a response to the client"
-
-  http_response_content_length: "HTTP message entity transmission length"
-  http_response_http_response_code: "http response status code"
-  http_response_response_time: "When http ring application"
-  http_response_result_code: "URL detection result 0 is normal, otherwise the URL cannot be accessed"
-
-  # [mysqld_exporter]
-  mysql_global_status_uptime: The number of seconds that the server has been up.(Gauge)
-  mysql_global_status_uptime_since_flush_status: The number of seconds since the most recent FLUSH STATUS statement.(Gauge)
-  mysql_global_status_queries: The number of statements executed by the server. This variable includes statements executed within stored programs, unlike the Questions variable. It does not count COM_PING or COM_STATISTICS commands.(Counter)
-  mysql_global_status_threads_connected: The number of currently open connections.(Counter)
-  mysql_global_status_connections: The number of connection attempts (successful or not) to the MySQL server.(Gauge)
-  mysql_global_status_max_used_connections: The maximum number of connections that have been in use simultaneously since the server started.(Gauge)
-  mysql_global_status_threads_running: The number of threads that are not sleeping.(Gauge)
-  mysql_global_status_questions: The number of statements executed by the server. This includes only statements sent to the server by clients and not statements executed within stored programs, unlike the Queries variable. This variable does not count COM_PING, COM_STATISTICS, COM_STMT_PREPARE, COM_STMT_CLOSE, or COM_STMT_RESET commands.(Counter)
-  mysql_global_status_threads_cached: The number of threads in the thread cache.(Counter)
-  mysql_global_status_threads_created: The number of threads created to handle connections. If Threads_created is big, you may want to increase the thread_cache_size value. The cache miss rate can be calculated as Threads_created/Connections.(Counter)
-  mysql_global_status_created_tmp_tables: The number of internal temporary tables created by the server while executing statements.(Counter)
-  mysql_global_status_created_tmp_disk_tables: The number of internal on-disk temporary tables created by the server while executing statements. You can compare the number of internal on-disk temporary tables created to the total number of internal temporary tables created by comparing Created_tmp_disk_tables and Created_tmp_tables values.(Counter)
-  mysql_global_status_created_tmp_files: How many temporary files mysqld has created.(Counter)
-  mysql_global_status_select_full_join: The number of joins that perform table scans because they do not use indexes. If this value is not 0, you should carefully check the indexes of your tables.(Counter)
-  mysql_global_status_select_full_range_join: The number of joins that used a range search on a reference table.(Counter)
-  mysql_global_status_select_range: The number of joins that used ranges on the first table. This is normally not a critical issue even if the value is quite large.(Counter)
-  mysql_global_status_select_range_check: The number of joins without keys that check for key usage after each row. If this is not 0, you should carefully check the indexes of your tables.(Counter)
-  mysql_global_status_select_scan: The number of joins that did a full scan of the first table.(Counter)
-  mysql_global_status_sort_rows: The number of sorted rows.(Counter)
-  mysql_global_status_sort_range: The number of sorts that were done using ranges.(Counter)
-  mysql_global_status_sort_merge_passes: The number of merge passes that the sort algorithm has had to do. If this value is large, you should consider increasing the value of the sort_buffer_size system variable.(Counter)
-  mysql_global_status_sort_scan: The number of sorts that were done by scanning the table.(Counter)
-  mysql_global_status_slow_queries: The number of queries that have taken more than long_query_time seconds. This counter increments regardless of whether the slow query log is enabled.(Counter)
-  mysql_global_status_aborted_connects: The number of failed attempts to connect to the MySQL server.(Counter)
-  mysql_global_status_aborted_clients: The number of connections that were aborted because the client died without closing the connection properly.(Counter)
-  mysql_global_status_table_locks_immediate: The number of times that a request for a table lock could be granted immediately. Locks Immediate rising and falling is normal activity.(Counter)
-  mysql_global_status_table_locks_waited: The number of times that a request for a table lock could not be granted immediately and a wait was needed. If this is high and you have performance problems, you should first optimize your queries, and then either split your table or tables or use replication.(Counter)
-  mysql_global_status_bytes_received: The number of bytes received from all clients.(Counter)
-  mysql_global_status_bytes_sent: The number of bytes sent to all clients.(Counter)
-  mysql_global_status_innodb_page_size: InnoDB page size (default 16KB). Many values are counted in pages; the page size enables them to be easily converted to bytes.(Gauge)
-  mysql_global_status_buffer_pool_pages: The number of pages in the InnoDB buffer pool.(Gauge)
-  mysql_global_status_commands_total: The number of times each xxx statement has been executed.(Counter)
-  mysql_global_status_handlers_total: Handler statistics are internal statistics on how MySQL is selecting, updating, inserting, and modifying rows, tables, and indexes. This is in fact the layer between the Storage Engine and MySQL.(Counter)
-  mysql_global_status_opened_files: The number of files that have been opened with my_open() (a mysys library function). Parts of the server that open files without using this function do not increment the count.(Counter)
-  mysql_global_status_open_tables: The number of tables that are open.(Gauge)
-  mysql_global_status_opened_tables: The number of tables that have been opened. If Opened_tables is big, your table_open_cache value is probably too small.(Counter)
-  mysql_global_status_table_open_cache_hits: The number of hits for open tables cache lookups.(Counter)
-  mysql_global_status_table_open_cache_misses: The number of misses for open tables cache lookups.(Counter)
-  mysql_global_status_table_open_cache_overflows: The number of overflows for the open tables cache.(Counter)
-  mysql_global_status_innodb_num_open_files: The number of files InnoDB currently holds open.(Gauge)
-  mysql_global_status_connection_errors_total: These variables provide information about errors that occur during the client connection process.(Counter)
-  mysql_global_status_innodb_buffer_pool_read_requests: The number of logical read requests.(Counter)
-  mysql_global_status_innodb_buffer_pool_reads: The number of logical reads that InnoDB could not satisfy from the buffer pool, and had to read directly from disk.(Counter)
-
-  mysql_global_variables_thread_cache_size: How many threads the server should cache for reuse.(Gauge)
-  mysql_global_variables_max_connections: The maximum permitted number of simultaneous client connections.(Gauge)
-  mysql_global_variables_innodb_buffer_pool_size: The size in bytes of the buffer pool, the memory area where InnoDB caches table and index data. The default value is 134217728 bytes (128MB).(Gauge)
-  mysql_global_variables_innodb_log_buffer_size: The size in bytes of the buffer that InnoDB uses to write to the log files on disk.(Gauge)
-  mysql_global_variables_key_buffer_size: Index blocks for MyISAM tables are buffered and are shared by all threads.(Gauge)
-  mysql_global_variables_query_cache_size: The amount of memory allocated for caching query results.(Gauge)
-  mysql_global_variables_table_open_cache: The number of open tables for all threads.(Gauge)
-  mysql_global_variables_open_files_limit: The number of file descriptors available to mysqld from the operating system.(Gauge)
-
-  # [redis_exporter]
-  redis_active_defrag_running: When activedefrag is enabled, this indicates whether defragmentation is currently active, and the CPU percentage it intends to utilize.
-  redis_allocator_active_bytes: Total bytes in the allocator active pages, this includes external-fragmentation.
-  redis_allocator_allocated_bytes: Total bytes allocated form the allocator, including internal-fragmentation. Normally the same as used_memory.
-  redis_allocator_frag_bytes: Delta between allocator_active and allocator_allocated. See note about mem_fragmentation_bytes.
-  redis_allocator_frag_ratio: Ratio between allocator_active and allocator_allocated. This is the true (external) fragmentation metric (not mem_fragmentation_ratio).
-  redis_allocator_resident_bytes: Total bytes resident (RSS) in the allocator, this includes pages that can be released to the OS (by MEMORY PURGE, or just waiting).
-  redis_allocator_rss_bytes: Delta between allocator_resident and allocator_active.
-  redis_allocator_rss_ratio: Ratio between allocator_resident and allocator_active. This usually indicates pages that the allocator can and probably will soon release back to the OS.
-  redis_aof_current_rewrite_duration_sec: Duration of the on-going AOF rewrite operation if any.
-  redis_aof_enabled: Flag indicating AOF logging is activated.
-  redis_aof_last_bgrewrite_status: Status of the last AOF rewrite operation.
-  redis_aof_last_cow_size_bytes: The size in bytes of copy-on-write memory during the last AOF rewrite operation.
-  redis_aof_last_rewrite_duration_sec: Duration of the last AOF rewrite operation in seconds.
-  redis_aof_last_write_status: Status of the last write operation to the AOF.
-  redis_aof_rewrite_in_progress: Flag indicating a AOF rewrite operation is on-going.
-  redis_aof_rewrite_scheduled: Flag indicating an AOF rewrite operation will be scheduled once the on-going RDB save is complete.
-  redis_blocked_clients: Number of clients pending on a blocking call (BLPOP, BRPOP, BRPOPLPUSH, BLMOVE, BZPOPMIN, BZPOPMAX).
-  redis_client_recent_max_input_buffer_bytes: Biggest input buffer among current client connections.
-  redis_client_recent_max_output_buffer_bytes: Biggest output buffer among current client connections.
-  redis_cluster_enabled: Indicate Redis cluster is enabled.
-  redis_commands_duration_seconds_total: The total CPU time consumed by these commands.(Counter)
-  redis_commands_processed_total: Total number of commands processed by the server.(Counter)
-  redis_commands_total: The number of calls that reached command execution (not rejected).(Counter)
-  redis_config_maxclients: The value of the maxclients configuration directive. This is the upper limit for the sum of connected_clients, connected_slaves and cluster_connections.
-  redis_config_maxmemory: The value of the maxmemory configuration directive.
-  redis_connected_clients: Number of client connections (excluding connections from replicas).
-  redis_connected_slaves: Number of connected replicas.
-  redis_connections_received_total: Total number of connections accepted by the server.(Counter)
-  redis_cpu_sys_children_seconds_total: System CPU consumed by the background processes.(Counter)
-  redis_cpu_sys_seconds_total: System CPU consumed by the Redis server, which is the sum of system CPU consumed by all threads of the server process (main thread and background threads).(Counter)
-  redis_cpu_user_children_seconds_total: User CPU consumed by the background processes.(Counter)
-  redis_cpu_user_seconds_total: User CPU consumed by the Redis server, which is the sum of user CPU consumed by all threads of the server process (main thread and background threads).(Counter)
-  redis_db_keys: Total number of keys by DB.
-  redis_db_keys_expiring: Total number of expiring keys by DB
-  redis_defrag_hits: Number of value reallocations performed by active the defragmentation process.
-  redis_defrag_misses: Number of aborted value reallocations started by the active defragmentation process.
-  redis_defrag_key_hits: Number of keys that were actively defragmented.
-  redis_defrag_key_misses: Number of keys that were skipped by the active defragmentation process.
-  redis_evicted_keys_total: Number of evicted keys due to maxmemory limit.(Counter)
-  redis_expired_keys_total: Total number of key expiration events.(Counter)
-  redis_expired_stale_percentage: The percentage of keys probably expired.
-  redis_expired_time_cap_reached_total: The count of times that active expiry cycles have stopped early.
-  redis_exporter_last_scrape_connect_time_seconds: The duration(in seconds) to connect when scrape.
-  redis_exporter_last_scrape_duration_seconds: The last scrape duration.
-  redis_exporter_last_scrape_error: The last scrape error status.
-  redis_exporter_scrape_duration_seconds_count: Durations of scrapes by the exporter
-  redis_exporter_scrape_duration_seconds_sum: Durations of scrapes by the exporter
-  redis_exporter_scrapes_total: Current total redis scrapes.(Counter)
-  redis_instance_info: Information about the Redis instance.
-  redis_keyspace_hits_total: Hits total.(Counter)
-  redis_keyspace_misses_total: Misses total.(Counter)
-  redis_last_key_groups_scrape_duration_milliseconds: Duration of the last key group metrics scrape in milliseconds.
-  redis_last_slow_execution_duration_seconds: The amount of time needed for last slow execution, in seconds.
-  redis_latest_fork_seconds: The amount of time needed for last fork, in seconds.
-  redis_lazyfree_pending_objects: The number of objects waiting to be freed (as a result of calling UNLINK, or FLUSHDB and FLUSHALL with the ASYNC option).
-  redis_master_repl_offset: The server's current replication offset.
-  redis_mem_clients_normal: Memory used by normal clients.(Gauge)
-  redis_mem_clients_slaves: Memory used by replica clients - Starting Redis 7.0, replica buffers share memory with the replication backlog, so this field can show 0 when replicas don't trigger an increase of memory usage.
-  redis_mem_fragmentation_bytes: Delta between used_memory_rss and used_memory. Note that when the total fragmentation bytes is low (few megabytes), a high ratio (e.g. 1.5 and above) is not an indication of an issue.
-  redis_mem_fragmentation_ratio: Ratio between used_memory_rss and used_memory. Note that this doesn't only includes fragmentation, but also other process overheads (see the allocator_* metrics), and also overheads like code, shared libraries, stack, etc.
-  redis_mem_not_counted_for_eviction_bytes: (Gauge)
-  redis_memory_max_bytes: Max memory limit in bytes.
-  redis_memory_used_bytes: Total number of bytes allocated by Redis using its allocator (either standard libc, jemalloc, or an alternative allocator such as tcmalloc)
-  redis_memory_used_dataset_bytes: The size in bytes of the dataset (used_memory_overhead subtracted from used_memory)
-  redis_memory_used_lua_bytes: Number of bytes used by the Lua engine.
-  redis_memory_used_overhead_bytes: The sum in bytes of all overheads that the server allocated for managing its internal data structures.
-  redis_memory_used_peak_bytes: Peak memory consumed by Redis (in bytes)
-  redis_memory_used_rss_bytes: Number of bytes that Redis allocated as seen by the operating system (a.k.a resident set size). This is the number reported by tools such as top(1) and ps(1)
-  redis_memory_used_scripts_bytes: Number of bytes used by cached Lua scripts
-  redis_memory_used_startup_bytes: Initial amount of memory consumed by Redis at startup in bytes
-  redis_migrate_cached_sockets_total: The number of sockets open for MIGRATE purposes
-  redis_net_input_bytes_total: Total input bytes(Counter)
-  redis_net_output_bytes_total: Total output bytes(Counter)
-  redis_process_id: Process ID
-  redis_pubsub_channels: Global number of pub/sub channels with client subscriptions
-  redis_pubsub_patterns: Global number of pub/sub pattern with client subscriptions
-  redis_rdb_bgsave_in_progress: Flag indicating a RDB save is on-going
-  redis_rdb_changes_since_last_save: Number of changes since the last dump
-  redis_rdb_current_bgsave_duration_sec: Duration of the on-going RDB save operation if any
-  redis_rdb_last_bgsave_duration_sec: Duration of the last RDB save operation in seconds
-  redis_rdb_last_bgsave_status: Status of the last RDB save operation
-  redis_rdb_last_cow_size_bytes: The size in bytes of copy-on-write memory during the last RDB save operation
-  redis_rdb_last_save_timestamp_seconds: Epoch-based timestamp of last successful RDB save
-  redis_rejected_connections_total: Number of connections rejected because of maxclients limit(Counter)
-  redis_repl_backlog_first_byte_offset: The master offset of the replication backlog buffer
-  redis_repl_backlog_history_bytes: Size in bytes of the data in the replication backlog buffer
-  redis_repl_backlog_is_active: Flag indicating replication backlog is active
-  redis_replica_partial_resync_accepted: The number of accepted partial resync requests(Gauge)
-  redis_replica_partial_resync_denied: The number of denied partial resync requests(Gauge)
-  redis_replica_resyncs_full: The number of full resyncs with replicas
-  redis_replication_backlog_bytes: Memory used by replication backlog
-  redis_second_repl_offset: The offset up to which replication IDs are accepted.
-  redis_slave_expires_tracked_keys: The number of keys tracked for expiry purposes (applicable only to writable replicas)(Gauge)
-  redis_slowlog_last_id: Last id of slowlog
-  redis_slowlog_length: Total slowlog
-  redis_start_time_seconds: Start time of the Redis instance since unix epoch in seconds.
-  redis_target_scrape_request_errors_total: Errors in requests to the exporter
-  redis_up: Flag indicating redis instance is up
-  redis_uptime_in_seconds: Number of seconds since Redis server start
-
-  # [windows_exporter]
-  windows_cpu_clock_interrupts_total: Total number of received and serviced clock tick interrupts(counter)
-  windows_cpu_core_frequency_mhz: Core frequency in megahertz(gauge)
-  windows_cpu_cstate_seconds_total: Time spent in low-power idle state(counter)
-  windows_cpu_dpcs_total: Total number of received and serviced deferred procedure calls (DPCs)(counter)
-  windows_cpu_idle_break_events_total: Total number of time processor was woken from idle(counter)
-  windows_cpu_interrupts_total: Total number of received and serviced hardware interrupts(counter)
-  windows_cpu_parking_status: Parking Status represents whether a processor is parked or not(gauge)
-  windows_cpu_processor_performance: Processor Performance is the average performance of the processor while it is executing instructions, as a percentage of the nominal performance of the processor. On some processors, Processor Performance may exceed 100%(gauge)
-  windows_cpu_time_total: Time that processor spent in different modes (idle, user, system, ...)(counter)
-  windows_cs_hostname: Labeled system hostname information as provided by ComputerSystem.DNSHostName and ComputerSystem.Domain(gauge)
-  windows_cs_logical_processors: ComputerSystem.NumberOfLogicalProcessors(gauge)
-  windows_cs_physical_memory_bytes: ComputerSystem.TotalPhysicalMemory(gauge)
-  windows_exporter_build_info: A metric with a constant '1' value labeled by version, revision, branch, and goversion from which windows_exporter was built.(gauge)
-  windows_exporter_collector_duration_seconds: Duration of a collection.(gauge)
-  windows_exporter_collector_success: Whether the collector was successful.(gauge)
-  windows_exporter_collector_timeout: Whether the collector timed out.(gauge)
-  windows_exporter_perflib_snapshot_duration_seconds: Duration of perflib snapshot capture(gauge)
-  windows_logical_disk_free_bytes: Free space in bytes (LogicalDisk.PercentFreeSpace)(gauge)
-  windows_logical_disk_idle_seconds_total: Seconds that the disk was idle (LogicalDisk.PercentIdleTime)(counter)
-  windows_logical_disk_read_bytes_total: The number of bytes transferred from the disk during read operations (LogicalDisk.DiskReadBytesPerSec)(counter)
-  windows_logical_disk_read_latency_seconds_total: Shows the average time, in seconds, of a read operation from the disk (LogicalDisk.AvgDiskSecPerRead)(counter)
-  windows_logical_disk_read_seconds_total: Seconds that the disk was busy servicing read requests (LogicalDisk.PercentDiskReadTime)(counter)
-  windows_logical_disk_read_write_latency_seconds_total: Shows the time, in seconds, of the average disk transfer (LogicalDisk.AvgDiskSecPerTransfer)(counter)
-  windows_logical_disk_reads_total: The number of read operations on the disk (LogicalDisk.DiskReadsPerSec)(counter)
-  windows_logical_disk_requests_queued: The number of requests queued to the disk (LogicalDisk.CurrentDiskQueueLength)(gauge)
-  windows_logical_disk_size_bytes: Total space in bytes (LogicalDisk.PercentFreeSpace_Base)(gauge)
-  windows_logical_disk_split_ios_total: The number of I/Os to the disk were split into multiple I/Os (LogicalDisk.SplitIOPerSec)(counter)
-  windows_logical_disk_write_bytes_total: The number of bytes transferred to the disk during write operations (LogicalDisk.DiskWriteBytesPerSec)(counter)
-  windows_logical_disk_write_latency_seconds_total: Shows the average time, in seconds, of a write operation to the disk (LogicalDisk.AvgDiskSecPerWrite)(counter)
-  windows_logical_disk_write_seconds_total: Seconds that the disk was busy servicing write requests (LogicalDisk.PercentDiskWriteTime)(counter)
-  windows_logical_disk_writes_total: The number of write operations on the disk (LogicalDisk.DiskWritesPerSec)(counter)
-  windows_net_bytes_received_total: (Network.BytesReceivedPerSec)(counter)
-  windows_net_bytes_sent_total: (Network.BytesSentPerSec)(counter)
-  windows_net_bytes_total: (Network.BytesTotalPerSec)(counter)
-  windows_net_current_bandwidth: (Network.CurrentBandwidth)(gauge)
-  windows_net_packets_outbound_discarded_total: (Network.PacketsOutboundDiscarded)(counter)
-  windows_net_packets_outbound_errors_total: (Network.PacketsOutboundErrors)(counter)
-  windows_net_packets_received_discarded_total: (Network.PacketsReceivedDiscarded)(counter)
-  windows_net_packets_received_errors_total: (Network.PacketsReceivedErrors)(counter)
-  windows_net_packets_received_total: (Network.PacketsReceivedPerSec)(counter)
-  windows_net_packets_received_unknown_total: (Network.PacketsReceivedUnknown)(counter)
-  windows_net_packets_sent_total: (Network.PacketsSentPerSec)(counter)
-  windows_net_packets_total: (Network.PacketsPerSec)(counter)
-  windows_os_info: OperatingSystem.Caption, OperatingSystem.Version(gauge)
-  windows_os_paging_free_bytes: OperatingSystem.FreeSpaceInPagingFiles(gauge)
-  windows_os_paging_limit_bytes: OperatingSystem.SizeStoredInPagingFiles(gauge)
-  windows_os_physical_memory_free_bytes: OperatingSystem.FreePhysicalMemory(gauge)
-  windows_os_process_memory_limix_bytes: OperatingSystem.MaxProcessMemorySize(gauge)
-  windows_os_processes: OperatingSystem.NumberOfProcesses(gauge)
-  windows_os_processes_limit: OperatingSystem.MaxNumberOfProcesses(gauge)
-  windows_os_time: OperatingSystem.LocalDateTime(gauge)
-  windows_os_timezone: OperatingSystem.LocalDateTime(gauge)
-  windows_os_users: OperatingSystem.NumberOfUsers(gauge)
-  windows_os_virtual_memory_bytes: OperatingSystem.TotalVirtualMemorySize(gauge)
-  windows_os_virtual_memory_free_bytes: OperatingSystem.FreeVirtualMemory(gauge)
-  windows_os_visible_memory_bytes: OperatingSystem.TotalVisibleMemorySize(gauge)
-  windows_service_info: A metric with a constant '1' value labeled with service information(gauge)
-  windows_service_start_mode: The start mode of the service (StartMode)(gauge)
-  windows_service_state: The state of the service (State)(gauge)
-  windows_service_status: The status of the service (Status)(gauge)
-  windows_system_context_switches_total: Total number of context switches (WMI source is PerfOS_System.ContextSwitchesPersec)(counter)
-  windows_system_exception_dispatches_total: Total number of exceptions dispatched (WMI source is PerfOS_System.ExceptionDispatchesPersec)(counter)
-  windows_system_processor_queue_length: Length of processor queue (WMI source is PerfOS_System.ProcessorQueueLength)(gauge)
-  windows_system_system_calls_total: Total number of system calls (WMI source is PerfOS_System.SystemCallsPersec)(counter)
-  windows_system_system_up_time: System boot time (WMI source is PerfOS_System.SystemUpTime)(gauge)
-  windows_system_threads: Current number of threads (WMI source is PerfOS_System.Threads)(gauge)
-
-  # [node_exporter]
-  # SYSTEM
-  # CPU context switch 次数
-  node_context_switches_total: context_switches
-  # Interrupts 次数
-  node_intr_total: Interrupts
-  # 运行的进程数
-  node_procs_running: Processes in runnable state
-  # 熵池大小
-  node_entropy_available_bits: Entropy available to random number generators
-  node_time_seconds: System time in seconds since epoch (1970)
-  node_boot_time_seconds: Node boot time, in unixtime
-  # CPU
-  node_cpu_seconds_total: Seconds the CPUs spent in each mode
-  node_load1: cpu load 1m
-  node_load5: cpu load 5m
-  node_load15: cpu load 15m
-
-  # MEM
-  # 内核态
-  # 内核用于缓存数据结构供自己使用的内存
-  node_memory_Slab_bytes: Memory used by the kernel to cache data structures for its own use
-  # slab中可回收的部分
-  node_memory_SReclaimable_bytes: SReclaimable - Part of Slab, that might be reclaimed, such as caches
-  # slab中不可回收的部分
-  node_memory_SUnreclaim_bytes: Part of Slab, that cannot be reclaimed on memory pressure
-  # Vmalloc内存区的大小
-  node_memory_VmallocTotal_bytes: Total size of vmalloc memory area
-  # vmalloc已分配的内存，虚拟地址空间上的连续的内存
-  node_memory_VmallocUsed_bytes: Amount of vmalloc area which is used
-  # vmalloc区可用的连续最大快的大小，通过此指标可以知道vmalloc可分配连续内存的最大值
-  node_memory_VmallocChunk_bytes: Largest contigious block of vmalloc area which is free
-  # 内存的硬件故障删除掉的内存页的总大小
-  node_memory_HardwareCorrupted_bytes: Amount of RAM that the kernel identified as corrupted / not working
-  # 用于在虚拟和物理内存地址之间映射的内存
-  node_memory_PageTables_bytes: Memory used to map between virtual and physical memory addresses (gauge)
-  # 内核栈内存，常驻内存，不可回收
-  node_memory_KernelStack_bytes: Kernel memory stack. This is not reclaimable
-  # 用来访问高端内存，复制高端内存的临时buffer，称为“bounce buffering”，会降低I/O 性能
-  node_memory_Bounce_bytes: Memory used for block device bounce buffers
-  #用户态
-  # 单个巨页大小
-  node_memory_Hugepagesize_bytes: Huge Page size
-  # 系统分配的常驻巨页数
-  node_memory_HugePages_Total: Total size of the pool of huge pages
-  # 系统空闲的巨页数
-  node_memory_HugePages_Free: Huge pages in the pool that are not yet allocated
-  # 进程已申请但未使用的巨页数
-  node_memory_HugePages_Rsvd: Huge pages for which a commitment to allocate from the pool has been made, but no allocation
-  # 超过系统设定的常驻HugePages数量的个数
-  node_memory_HugePages_Surp: Huge pages in the pool above the value in /proc/sys/vm/nr_hugepages
-  # 透明巨页 Transparent HugePages (THP)
-  node_memory_AnonHugePages_bytes: Memory in anonymous huge pages
-  # inactivelist中的File-backed内存
-  node_memory_Inactive_file_bytes: File-backed memory on inactive LRU list
-  # inactivelist中的Anonymous内存
-  node_memory_Inactive_anon_bytes: Anonymous and swap cache on inactive LRU list, including tmpfs (shmem)
-  # activelist中的File-backed内存
-  node_memory_Active_file_bytes: File-backed memory on active LRU list
-  # activelist中的Anonymous内存
-  node_memory_Active_anon_bytes: Anonymous and swap cache on active least-recently-used (LRU) list, including tmpfs
-  # 禁止换出的页，对应 Unevictable 链表
-  node_memory_Unevictable_bytes: Amount of unevictable memory that can't be swapped out for a variety of reasons
-  # 共享内存
-  node_memory_Shmem_bytes: Used shared memory (shared between several processes, thus including RAM disks)
-  # 匿名页内存大小
-  node_memory_AnonPages_bytes: Memory in user pages not backed by files
-  # 被关联的内存页大小
-  node_memory_Mapped_bytes: Used memory in mapped pages files which have been mmaped, such as libraries
-  # file-backed内存页缓存大小
-  node_memory_Cached_bytes: Parked file data (file content) cache
-  # 系统中有多少匿名页曾经被swap-out、现在又被swap-in并且swap-in之后页面中的内容一直没发生变化
-  node_memory_SwapCached_bytes: Memory that keeps track of pages that have been fetched from swap but not yet been modified
-  # 被mlock()系统调用锁定的内存大小
-  node_memory_Mlocked_bytes: Size of pages locked to memory using the mlock() system call
-  # 块设备(block device)所占用的缓存页
-  node_memory_Buffers_bytes: Block device (e.g. harddisk) cache
-  node_memory_SwapTotal_bytes: Memory information field SwapTotal_bytes
-  node_memory_SwapFree_bytes: Memory information field SwapFree_bytes
-
-  # DISK
-  node_filesystem_avail_bytes: Filesystem space available to non-root users in byte
-  node_filesystem_free_bytes: Filesystem free space in bytes
-  node_filesystem_size_bytes: Filesystem size in bytes
-  node_filesystem_files_free: Filesystem total free file nodes
-  node_filesystem_files: Filesystem total free file nodes
-  node_filefd_maximum: Max open files
-  node_filefd_allocated: Open files
-  node_filesystem_readonly: Filesystem read-only status
-  node_filesystem_device_error: Whether an error occurred while getting statistics for the given device
-  node_disk_reads_completed_total: The total number of reads completed successfully
-  node_disk_writes_completed_total: The total number of writes completed successfully
-  node_disk_reads_merged_total: The number of reads merged
-  node_disk_writes_merged_total: The number of writes merged
-  node_disk_read_bytes_total: The total number of bytes read successfully
-  node_disk_written_bytes_total: The total number of bytes written successfully
-  node_disk_io_time_seconds_total: Total seconds spent doing I/Os
-  node_disk_read_time_seconds_total: The total number of seconds spent by all reads
-  node_disk_write_time_seconds_total: The total number of seconds spent by all writes
-  node_disk_io_time_weighted_seconds_total: The weighted of seconds spent doing I/Os
-
-  # NET
-  node_network_receive_bytes_total: Network device statistic receive_bytes (counter)
-  node_network_transmit_bytes_total: Network device statistic transmit_bytes (counter)
-  node_network_receive_packets_total: Network device statistic receive_bytes
-  node_network_transmit_packets_total: Network device statistic transmit_bytes
-  node_network_receive_errs_total: Network device statistic receive_errs
-  node_network_transmit_errs_total: Network device statistic transmit_errs
-  node_network_receive_drop_total: Network device statistic receive_drop
-  node_network_transmit_drop_total: Network device statistic transmit_drop
-  node_nf_conntrack_entries: Number of currently allocated flow entries for connection tracking
-  node_sockstat_TCP_alloc: Number of TCP sockets in state alloc
-  node_sockstat_TCP_inuse: Number of TCP sockets in state inuse
-  node_sockstat_TCP_orphan: Number of TCP sockets in state orphan
-  node_sockstat_TCP_tw: Number of TCP sockets in state tw
-  node_netstat_Tcp_CurrEstab: Statistic TcpCurrEstab
-  node_sockstat_sockets_used: Number of IPv4 sockets in use
-
-  # [kafka_exporter]
-  kafka_brokers: count of kafka_brokers (gauge)
-  kafka_topic_partitions: Number of partitions for this Topic (gauge)
-  kafka_topic_partition_current_offset: Current Offset of a Broker at Topic/Partition (gauge)
-  kafka_consumergroup_current_offset: Current Offset of a ConsumerGroup at Topic/Partition (gauge)
-  kafka_consumer_lag_millis: Current approximation of consumer lag for a ConsumerGroup at Topic/Partition (gauge)
-  kafka_topic_partition_under_replicated_partition: 1 if Topic/Partition is under Replicated
-
-  # [zookeeper_exporter]
-  zk_znode_count: The total count of znodes stored
-  zk_ephemerals_count: The number of Ephemerals nodes
-  zk_watch_count: The number of watchers setup over Zookeeper nodes.
-  zk_approximate_data_size: Size of data in bytes that a zookeeper server has in its data tree
-  zk_outstanding_requests: Number of currently executing requests
-  zk_packets_sent: Count of the number of zookeeper packets sent from a server
-  zk_packets_received: Count of the number of zookeeper packets received by a server
-  zk_num_alive_connections: Number of active clients connected to a zookeeper server
-  zk_open_file_descriptor_count: Number of file descriptors that a zookeeper server has open
-  zk_max_file_descriptor_count: Maximum number of file descriptors that a zookeeper server can open
-  zk_avg_latency: Average time in milliseconds for requests to be processed
-  zk_min_latency: Maximum time in milliseconds for a request to be processed
-  zk_max_latency: Minimum time in milliseconds for a request to be processed
--- a/docker/compose-bridge/etc-nightingale/script/notify.bak.py
+++ b/docker/compose-bridge/etc-nightingale/script/notify.bak.py
@@ -1,216 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: UTF-8 -*-
-import sys
-import json
-import urllib2
-import smtplib
-from email.mime.text import MIMEText
-
-reload(sys)
-sys.setdefaultencoding('utf8')
-
-notify_channel_funcs = {
-  "email":"email",
-  "sms":"sms",
-  "voice":"voice",
-  "dingtalk":"dingtalk",
-  "wecom":"wecom",
-  "feishu":"feishu"
-}
-
-mail_host = "smtp.163.com"
-mail_port = 994
-mail_user = "ulricqin"
-mail_pass = "password"
-mail_from = "ulricqin@163.com"
-
-class Sender(object):
-    @classmethod
-    def send_email(cls, payload):
-        if mail_user == "ulricqin" and mail_pass == "password":
-            print("invalid smtp configuration")
-            return
-
-        users = payload.get('event').get("notify_users_obj")
-
-        emails = {}
-        for u in users:
-            if u.get("email"):
-                emails[u.get("email")] = 1
-
-        if not emails:
-            return
-
-        recipients = emails.keys()
-        mail_body = payload.get('tpls').get("email.tpl", "email.tpl not found")
-        message = MIMEText(mail_body, 'html', 'utf-8')
-        message['From'] = mail_from
-        message['To'] = ", ".join(recipients)
-        message["Subject"] = payload.get('tpls').get("subject.tpl", "subject.tpl not found")
-
-        try:
-            smtp = smtplib.SMTP_SSL(mail_host, mail_port)
-            smtp.login(mail_user, mail_pass)
-            smtp.sendmail(mail_from, recipients, message.as_string())
-            smtp.close()
-        except smtplib.SMTPException, error:
-            print(error)
-
-    @classmethod
-    def send_wecom(cls, payload):
-        users = payload.get('event').get("notify_users_obj")
-
-        tokens = {}
-
-        for u in users:
-            contacts = u.get("contacts")
-            if contacts.get("wecom_robot_token", ""):
-                tokens[contacts.get("wecom_robot_token", "")] = 1
-
-        opener = urllib2.build_opener(urllib2.HTTPHandler())
-        method = "POST"
-
-        for t in tokens:
-            url = "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key={}".format(t)
-            body = {
-                "msgtype": "markdown",
-                "markdown": {
-                    "content": payload.get('tpls').get("wecom.tpl", "wecom.tpl not found")
-                }
-            }
-            request = urllib2.Request(url, data=json.dumps(body))
-            request.add_header("Content-Type",'application/json;charset=utf-8')
-            request.get_method = lambda: method
-            try:
-                connection = opener.open(request)
-                print(connection.read())
-            except urllib2.HTTPError, error:
-                print(error)
-
-    @classmethod
-    def send_dingtalk(cls, payload):
-        event = payload.get('event')
-        users = event.get("notify_users_obj")
-
-        rule_name = event.get("rule_name")
-        event_state = "Triggered"
-        if event.get("is_recovered"):
-            event_state = "Recovered"
-
-        tokens = {}
-        phones = {}
-
-        for u in users:
-            if u.get("phone"):
-                phones[u.get("phone")] = 1
-
-            contacts = u.get("contacts")
-            if contacts.get("dingtalk_robot_token", ""):
-                tokens[contacts.get("dingtalk_robot_token", "")] = 1
-
-        opener = urllib2.build_opener(urllib2.HTTPHandler())
-        method = "POST"
-
-        for t in tokens:
-            url = "https://oapi.dingtalk.com/robot/send?access_token={}".format(t)
-            body = {
-                "msgtype": "markdown",
-                "markdown": {
-                    "title": "{} - {}".format(event_state, rule_name),
-                    "text": payload.get('tpls').get("dingtalk.tpl", "dingtalk.tpl not found") + ' '.join(["@"+i for i in phones.keys()])
-                },
-                "at": {
-                    "atMobiles": phones.keys(),
-                    "isAtAll": False
-                }
-            }
-            request = urllib2.Request(url, data=json.dumps(body))
-            request.add_header("Content-Type",'application/json;charset=utf-8')
-            request.get_method = lambda: method
-            try:
-                connection = opener.open(request)
-                print(connection.read())
-            except urllib2.HTTPError, error:
-                print(error)
-
-    @classmethod
-    def send_feishu(cls, payload):
-        users = payload.get('event').get("notify_users_obj")
-
-        tokens = {}
-        phones = {}
-
-        for u in users:
-            if u.get("phone"):
-                phones[u.get("phone")] = 1
-
-            contacts = u.get("contacts")
-            if contacts.get("feishu_robot_token", ""):
-                tokens[contacts.get("feishu_robot_token", "")] = 1
-
-        opener = urllib2.build_opener(urllib2.HTTPHandler())
-        method = "POST"
-
-        for t in tokens:
-            url = "https://open.feishu.cn/open-apis/bot/v2/hook/{}".format(t)
-            body = {
-                "msg_type": "text",
-                "content": {
-                    "text": payload.get('tpls').get("feishu.tpl", "feishu.tpl not found")
-                },
-                "at": {
-                    "atMobiles": phones.keys(),
-                    "isAtAll": False
-                }
-            }
-            request = urllib2.Request(url, data=json.dumps(body))
-            request.add_header("Content-Type",'application/json;charset=utf-8')
-            request.get_method = lambda: method
-            try:
-                connection = opener.open(request)
-                print(connection.read())
-            except urllib2.HTTPError, error:
-                print(error)
-
-    @classmethod
-    def send_sms(cls, payload):
-        users = payload.get('event').get("notify_users_obj")
-        phones = {}
-        for u in users:
-            if u.get("phone"):
-                phones[u.get("phone")] = 1
-        if phones:
-            print("send_sms not implemented, phones: {}".format(phones.keys()))
-
-    @classmethod
-    def send_voice(cls, payload):
-        users = payload.get('event').get("notify_users_obj")
-        phones = {}
-        for u in users:
-            if u.get("phone"):
-                phones[u.get("phone")] = 1
-        if phones:
-            print("send_voice not implemented, phones: {}".format(phones.keys()))
-
-def main():
-    payload = json.load(sys.stdin)
-    with open(".payload", 'w') as f:
-        f.write(json.dumps(payload, indent=4))
-    for ch in payload.get('event').get('notify_channels'):
-        send_func_name = "send_{}".format(notify_channel_funcs.get(ch.strip()))
-        if not hasattr(Sender, send_func_name):
-            print("function: {} not found", send_func_name)
-            continue
-        send_func = getattr(Sender, send_func_name)
-        send_func(payload)
-
-def hello():
-    print("hello nightingale")
-
-if __name__ == "__main__":
-    if len(sys.argv) == 1:
-        main()
-    elif sys.argv[1] == "hello":
-        hello()
-    else:
-        print("I am confused")
--- a/Show More
+++ b/Show More