refactor: build event tags

.gitignore

@@ -58,10 +58,6 @@ _test
 .idea
 .index
 .vscode
-.issue
-.issue/*
-.cursor
-.claude
 .DS_Store
 .cache-loader
 .payload

README.md

@@ -3,7 +3,7 @@
     <img src="doc/img/Nightingale_L_V.png" alt="nightingale - cloud native monitoring" width="100" /></a>
 </p>
 <p align="center">
-  <b>Open-Source Alerting Expert</b>
+  <b>开源告警管理专家 一体化的可观测平台</b>
 </p>
 
 <p align="center">
@@ -25,91 +25,85 @@
 
 
 
-[English](./README.md) | [中文](./README_zh.md)
+[English](./README_en.md) | [中文](./README.md)
 
-## 🎯 What is Nightingale
+## 夜莺 Nightingale 是什么
 
-Nightingale is an open-source monitoring project that focuses on alerting. Similar to Grafana, Nightingale also connects with various existing data sources. However, while Grafana emphasizes visualization, Nightingale places greater emphasis on the alerting engine, as well as the processing and distribution of alarms.
+> 夜莺 Nightingale 是什么，解决什么问题？以大家都很熟悉的 Grafana 做个类比，Grafana 擅长对接各种各样的数据源，然后提供灵活、强大、好看的可视化面板。夜莺则擅长对接各种多样的数据源，提供灵活、强大、高效的监控告警管理能力。从发展路径和定位来说，夜莺和 Grafana 很像，可以总结为一句话：可视化就用 Grafana，监控告警就找夜莺。
+>
+> 在可视化领域，Grafana 是毫无争议的领导者，Grafana 在影响力、装机量、用户群、开发者数量等各个维度的数字上，相比夜莺都是追赶的榜样。巨无霸往往都是从一个切入点打开局面的，Grafana Labs 有了在可视化领域 Grafana 这个王牌，逐步扩展到整个可观测性方向，比如 Logging 维度有 Loki，Tracing 维度有 Tempo，Profiling 维度有收购来的 Pyroscope，On-call 维度有同样是收购来的 Grafana-OnCall 项目，还有时序数据库 Mimir、eBPF 采集器 Beyla、OpenTelemetry 采集器 Alloy、前端监控 SDK Faro，最终构成了一个完整的可观测性工具矩阵，但整个飞轮都是从 Grafana 项目开始转动起来的。
+>
+>夜莺，则是从监控告警这个切入点打开局面，也逐步横向做了相应扩展，比如夜莺也自研了可视化面板，如果你想有一个 all-in-one 的监控告警+可视化的工具，那么用夜莺也是正确的选择；比如 OnCall 方向，夜莺可以和 [Flashduty SaaS](https://flashcat.cloud/product/flashcat-duty/) 服务无缝的集成；在采集器方向，夜莺有配套的 [Categraf](https://flashcat.cloud/product/categraf)，可以一个采集器中管理所有的 exporter，并同时支持指标和日志的采集，极大减轻工程师维护的采集器数量和工作量（这个点太痛了，你可能也遇到过业务团队吐槽采集器数量比业务应用进程数量还多的窘况吧）。
 
-> The Nightingale project was initially developed and open-sourced by DiDi.inc. On May 11, 2022, it was donated to the Open Source Development Committee of the China Computer Federation (CCF ODC).
+夜莺 Nightingale 作为一款开源云原生监控工具，最初由滴滴开发和开源，并于 2022 年 5 月 11 日，捐赠予中国计算机学会开源发展委员会（CCF ODC），为 CCF ODC 成立后接受捐赠的第一个开源项目。在 GitHub 上有超过 10000 颗星，是广受关注和使用的开源监控工具。夜莺的核心研发团队，也是 Open-Falcon 项目原核心研发人员，从 2014 年（Open-Falcon 是 2014 年开源）算起来，也有 10 年了，只为把监控做到极致。
 
-![](https://n9e.github.io/img/global/arch-bg.png)
 
-## 💡 How Nightingale Works
+## 快速开始
+- 👉 [文档中心](https://flashcat.cloud/docs/) | [下载中心](https://flashcat.cloud/download/nightingale/)
+- ❤️ [报告 Bug](https://github.com/ccfos/nightingale/issues/new?assignees=&labels=&projects=&template=question.yml)
+- ℹ️ 为了提供更快速的访问体验，上述文档和下载站点托管于 [FlashcatCloud](https://flashcat.cloud)
+- 💡 前后端代码分离，前端代码仓库：[https://github.com/n9e/fe](https://github.com/n9e/fe)
 
-Many users have already collected metrics and log data. In this case, you can connect your storage repositories (such as VictoriaMetrics, ElasticSearch, etc.) as data sources in Nightingale. This allows you to configure alerting rules and notification rules within Nightingale, enabling the generation and distribution of alarms.
+## 功能特点
 
-![Nightingale Product Architecture](doc/img/readme/20240221152601.png)
+- 对接多种时序库，实现统一监控告警管理：支持对接的时序库包括 Prometheus、VictoriaMetrics、Thanos、Mimir、M3DB、TDengine 等。
+- 对接日志库，实现针对日志的监控告警：支持对接的日志库包括 ElasticSearch、Loki 等。
+- 专业告警能力：内置支持多种告警规则，可以扩展支持常见通知媒介，支持告警屏蔽/抑制/订阅/自愈、告警事件管理。
+- 高性能可视化引擎：支持多种图表样式，内置众多 Dashboard 模版，也可导入 Grafana 模版，开箱即用，开源协议商业友好。
+- 支持常见采集器：支持 [Categraf](https://flashcat.cloud/product/categraf)、Telegraf、Grafana-agent、Datadog-agent、各种 Exporter 作为采集器，没有什么数据是不能监控的。
+- 👀无缝搭配 [Flashduty](https://flashcat.cloud/product/flashcat-duty/)：实现告警聚合收敛、认领、升级、排班、IM集成，确保告警处理不遗漏，减少打扰，高效协同。
 
-Nightingale itself does not provide monitoring data collection capabilities. We recommend using [Categraf](https://github.com/flashcatcloud/categraf) as the collector, which integrates seamlessly with Nightingale.
 
-[Categraf](https://github.com/flashcatcloud/categraf) can collect monitoring data from operating systems, network devices, various middleware, and databases. It pushes this data to Nightingale via the `Prometheus Remote Write` protocol. Nightingale then stores the monitoring data in a time-series database (such as Prometheus, VictoriaMetrics, etc.) and provides alerting and visualization capabilities.
+## 截图演示
 
-For certain edge data centers with poor network connectivity to the central Nightingale server, we offer a distributed deployment mode for the alerting engine. In this mode, even if the network is disconnected, the alerting functionality remains unaffected.
 
-![Edge Deployment Mode](doc/img/readme/20240222102119.png)
+你可以在页面的右上角，切换语言和主题，目前我们支持英语、简体中文、繁体中文。
 
-> In the above diagram, Data Center A has a good network with the central data center, so it uses the Nightingale process in the central data center as the alerting engine. Data Center B has a poor network with the central data center, so it deploys `n9e-edge` as the alerting engine to handle alerting for its own data sources.
+![语言切换](doc/img/readme/n9e-switch-i18n.png)
 
-## 🔕 Alert Noise Reduction, Escalation, and Collaboration
+即时查询，类似 Prometheus 内置的查询分析页面，做 ad-hoc 查询，夜莺做了一些 UI 优化，同时提供了一些内置 promql 指标，让不太了解 promql 的用户也可以快速查询。
 
-Nightingale focuses on being an alerting engine, responsible for generating alarms and flexibly distributing them based on rules. It supports 20 built-in notification medias (such as phone calls, SMS, email, DingTalk, Slack, etc.).
+![即时查询](doc/img/readme/20240513103305.png)
 
-If you have more advanced requirements, such as:
-- Want to consolidate events from multiple monitoring systems into one platform for unified noise reduction, response handling, and data analysis.
-- Want to support personnel scheduling, practice on-call culture, and support alert escalation (to avoid missing alerts) and collaborative handling.
+当然，也可以直接通过指标视图查看，有了指标视图，即时查询基本可以不用了，或者只有高端玩家使用即时查询，普通用户直接通过指标视图查询即可。
 
-Then Nightingale is not suitable. It is recommended that you choose on-call products such as PagerDuty and FlashDuty. These products are simple and easy to use.
+![指标视图](doc/img/readme/20240513103530.png)
 
-## 🗨️ Communication Channels
+夜莺内置了常用仪表盘，可以直接导入使用。也可以导入 Grafana 仪表盘，不过只能兼容 Grafana 基本图表，如果已经习惯了 Grafana 建议继续使用 Grafana 看图，把夜莺作为一个告警引擎使用。
 
-- **Report Bugs:** It is highly recommended to submit issues via the [Nightingale GitHub Issue tracker](https://github.com/ccfos/nightingale/issues/new?assignees=&labels=kind%2Fbug&projects=&template=bug_report.yml).
-- **Documentation:** For more information, we recommend thoroughly browsing the [Nightingale Documentation Site](https://n9e.github.io/).
+![内置仪表盘](doc/img/readme/20240513103628.png)
 
-## 🔑 Key Features
+除了内置的仪表盘，也内置了很多告警规则，开箱即用。
 
-![Nightingale Alerting rules](doc/img/readme/2025-05-23_18-43-37.png)
+![内置告警规则](doc/img/readme/20240513103825.png)
 
-- Nightingale supports alerting rules, mute rules, subscription rules, and notification rules. It natively supports 20 types of notification media and allows customization of message templates.  
-- It supports event pipelines for Pipeline processing of alarms, facilitating automated integration with in-house systems. For example, it can append metadata to alarms or perform relabeling on events. 
-- It introduces the concept of business groups and a permission system to manage various rules in a categorized manner.  
-- Many databases and middleware come with built-in alert rules that can be directly imported and used. It also supports direct import of Prometheus alerting rules.  
-- It supports alerting self-healing, which automatically triggers a script to execute predefined logic after an alarm is generated—such as cleaning up disk space or capturing the current system state.
 
-![Nightingale Alarm Dashboard](doc/img/readme/2025-05-30_08-49-28.png)
 
-- Nightingale archives historical alarms and supports multi-dimensional query and statistics.  
-- It supports flexible aggregation grouping, allowing a clear view of the distribution of alarms across the company.
+## 产品架构
 
-![Nightingale Integration Center](doc/img/readme/2025-05-23_18-46-06.png)
+社区使用夜莺最多的场景就是使用夜莺做告警引擎，对接多套时序库，统一告警规则管理。绘图仍然使用 Grafana 居多。作为一个告警引擎，夜莺的产品架构如下：
 
-- Nightingale has built-in metric descriptions, dashboards, and alerting rules for common operating systems, middleware, and databases, which are contributed by the community with varying quality.  
-- It directly receives data via multiple protocols such as Remote Write, OpenTSDB, Datadog, and Falcon, integrates with various Agents.  
-- It supports data sources like Prometheus, ElasticSearch, Loki, ClickHouse, MySQL, Postgres, allowing alerting based on data from these sources.  
-- Nightingale can be easily embedded into internal enterprise systems (e.g. Grafana, CMDB), and even supports configuring menu visibility for these embedded systems.
+![产品架构](doc/img/readme/20240221152601.png)
 
-![Nightingale dashboards](doc/img/readme/2025-05-23_18-49-02.png)
+对于个别边缘机房，如果和中心夜莺服务端网络链路不好，希望提升告警可用性，我们也提供边缘机房告警引擎下沉部署模式，这个模式下，即便网络割裂，告警功能也不受影响。
 
-- Nightingale supports dashboard functionality, including common chart types, and comes with pre-built dashboards. The image above is a screenshot of one of these dashboards.  
-- If you are already accustomed to Grafana, it is recommended to continue using Grafana for visualization, as Grafana has deeper expertise in this area.  
-- For machine-related monitoring data collected by Categraf, it is advisable to use Nightingale's built-in dashboards for viewing. This is because Categraf's metric naming follows Telegraf's convention, which differs from that of Node Exporter.  
-- Due to Nightingale's concept of business groups (where machines can belong to different groups), there may be scenarios where you only want to view machines within the current business group on the dashboard. Thus, Nightingale's dashboards can be linked with business groups for interactive filtering.
+![边缘部署模式](doc/img/readme/20240222102119.png)
 
-## 🌟 Stargazers over time
 
+## 交流渠道
+- 报告Bug，优先推荐提交[夜莺GitHub Issue](https://github.com/ccfos/nightingale/issues/new?assignees=&labels=kind%2Fbug&projects=&template=bug_report.yml)
+- 关注[这个公众号](https://gitlink.org.cn/UlricQin)了解更多夜莺动态和知识
+- 加我微信：`picobyte`（我已关闭好友验证）拉入微信群，备注：`夜莺互助群`
+
+## 广受关注
 [![Stargazers over time](https://api.star-history.com/svg?repos=ccfos/nightingale&type=Date)](https://star-history.com/#ccfos/nightingale&Date)
 
-## 🔥 Users
-
-![User Logos](doc/img/readme/logos.png)
-
-## 🤝 Community Co-Building
-
-- ❇️ Please read the [Nightingale Open Source Project and Community Governance Draft](./doc/community-governance.md). We sincerely welcome every user, developer, company, and organization to use Nightingale, actively report bugs, submit feature requests, share best practices, and help build a professional and active open-source community.
-- ❤️ Nightingale Contributors
+## 社区共建
+- ❇️ 请阅读浏览[夜莺开源项目和社区治理架构草案](./doc/community-governance.md)，真诚欢迎每一位用户、开发者、公司以及组织，使用夜莺监控、积极反馈 Bug、提交功能需求、分享最佳实践，共建专业、活跃的夜莺开源社区。
+- ❤️ 夜莺贡献者
 <a href="https://github.com/ccfos/nightingale/graphs/contributors">
   <img src="https://contrib.rocks/image?repo=ccfos/nightingale" />
 </a>
 
-## 📜 License
+## License
 - [Apache License V2.0](https://github.com/didi/nightingale/blob/main/LICENSE)

README_en.md

@@ -0,0 +1,113 @@
+<p align="center">
+  <a href="https://github.com/ccfos/nightingale">
+    <img src="doc/img/Nightingale_L_V.png" alt="nightingale - cloud native monitoring" width="100" /></a>
+</p>
+<p align="center">
+  <b>Open-source Alert Management Expert, an Integrated Observability Platform</b>
+</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">
+<img alt="GitHub forks" src="https://img.shields.io/github/forks/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 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>
+
+
+
+[English](./README_en.md) | [中文](./README.md)
+
+## What is Nightingale
+
+Nightingale is an open-source project focused on alerting. Similar to Grafana's data source integration approach, Nightingale also connects with various existing data sources. However, while Grafana focuses on visualization, Nightingale focuses on alerting engines.
+
+Originally developed and open-sourced by Didi, Nightingale was donated to the China Computer Federation Open Source Development Committee (CCF ODC) on May 11, 2022, becoming the first open-source project accepted by the CCF ODC after its establishment. 
+
+
+## Quick Start
+
+- 👉 [Documentation](https://flashcat.cloud/docs/) | [Download](https://flashcat.cloud/download/nightingale/)
+- ❤️ [Report a Bug](https://github.com/ccfos/nightingale/issues/new?assignees=&labels=&projects=&template=question.yml)
+- ℹ️ For faster access, the above documentation and download sites are hosted on [FlashcatCloud](https://flashcat.cloud).
+
+## Features
+
+- **Integration with Multiple Time-Series Databases:** Supports integration with various time-series databases such as Prometheus, VictoriaMetrics, Thanos, Mimir, M3DB, and TDengine, enabling unified alert management.
+- **Advanced Alerting Capabilities:** Comes with built-in support for multiple alerting rules, extensible to common notification channels. It also supports alert suppression, silencing, subscription, self-healing, and alert event management.
+- **High-Performance Visualization Engine:** Offers various chart styles with numerous built-in dashboard templates and the ability to import Grafana templates. Ready to use with a business-friendly open-source license.
+- **Support for Common Collectors:** Compatible with [Categraf](https://flashcat.cloud/product/categraf), Telegraf, Grafana-agent, Datadog-agent, and various exporters as collectors—there's no data that can't be monitored.
+- **Seamless Integration with [Flashduty](https://flashcat.cloud/product/flashcat-duty/):** Enables alert aggregation, acknowledgment, escalation, scheduling, and IM integration, ensuring no alerts are missed, reducing unnecessary interruptions, and enhancing efficient collaboration.
+
+
+## Screenshots
+
+You can switch languages and themes in the top right corner. We now support English, Simplified Chinese, and Traditional Chinese. 
+
+![18n switch](doc/img/readme/n9e-switch-i18n.png)
+
+### Instant Query
+
+Similar to the built-in query analysis page in Prometheus, Nightingale offers an ad-hoc query feature with UI enhancements. It also provides built-in PromQL metrics, allowing users unfamiliar with PromQL to quickly perform queries.
+
+![Instant Query](doc/img/readme/20240513103305.png)
+
+### Metric View
+
+Alternatively, you can use the Metric View to access data. With this feature, Instant Query becomes less necessary, as it caters more to advanced users. Regular users can easily perform queries using the Metric View.
+
+![Metric View](doc/img/readme/20240513103530.png)
+
+### Built-in Dashboards
+
+Nightingale includes commonly used dashboards that can be imported and used directly. You can also import Grafana dashboards, although compatibility is limited to basic Grafana charts. If you’re accustomed to Grafana, it’s recommended to continue using it for visualization, with Nightingale serving as an alerting engine.
+
+![Built-in Dashboards](doc/img/readme/20240513103628.png)
+
+### Built-in Alert Rules
+
+In addition to the built-in dashboards, Nightingale also comes with numerous alert rules that are ready to use out of the box.
+
+![Built-in Alert Rules](doc/img/readme/20240513103825.png)
+
+
+
+## Architecture
+
+In most community scenarios, Nightingale is primarily used as an alert engine, integrating with multiple time-series databases to unify alert rule management. Grafana remains the preferred tool for visualization. As an alert engine, the product architecture of Nightingale is as follows:
+
+![Product Architecture](doc/img/readme/20240221152601.png)
+
+For certain edge data centers with poor network connectivity to the central Nightingale server, we offer a distributed deployment mode for the alert engine. In this mode, even if the network is disconnected, the alerting functionality remains unaffected.
+
+![Edge Deployment Mode](doc/img/readme/20240222102119.png)
+
+
+## Communication Channels
+
+- **Report Bugs:** It is highly recommended to submit issues via the [Nightingale GitHub Issue tracker](https://github.com/ccfos/nightingale/issues/new?assignees=&labels=kind%2Fbug&projects=&template=bug_report.yml).
+- **Documentation:** For more information, we recommend thoroughly browsing the [Nightingale Documentation Site](https://flashcat.cloud/docs/content/flashcat-monitor/nightingale-v7/introduction/).
+
+## Stargazers over time
+
+[![Stargazers over time](https://api.star-history.com/svg?repos=ccfos/nightingale&type=Date)](https://star-history.com/#ccfos/nightingale&Date)
+
+## Community Co-Building
+
+- ❇️ Please read the [Nightingale Open Source Project and Community Governance Draft](./doc/community-governance.md). We sincerely welcome every user, developer, company, and organization to use Nightingale, actively report bugs, submit feature requests, share best practices, and help build a professional and active open-source community.
+-  ❤️ 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)

README_zh.md

@@ -1,120 +0,0 @@
-<p align="center">
-  <a href="https://github.com/ccfos/nightingale">
-    <img src="doc/img/Nightingale_L_V.png" alt="nightingale - cloud native monitoring" width="100" /></a>
-</p>
-<p align="center">
-  <b>开源告警管理专家</b>
-</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">
-<img alt="GitHub forks" src="https://img.shields.io/github/forks/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 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>
-
-
-
-[English](./README.md) | [中文](./README_zh.md)
-
-## 夜莺是什么
-
-夜莺监控（Nightingale）是一款侧重告警的监控类开源项目。类似 Grafana 的数据源集成方式，夜莺也是对接多种既有的数据源，不过 Grafana 侧重在可视化，夜莺是侧重在告警引擎、告警事件的处理和分发。
-
-> 夜莺监控项目，最初由滴滴开发和开源，并于 2022 年 5 月 11 日，捐赠予中国计算机学会开源发展委员会（CCF ODC），为 CCF ODC 成立后接受捐赠的第一个开源项目。
-
-![](https://n9e.github.io/img/global/arch-bg.png)
-
-## 夜莺的工作逻辑
-
-很多用户已经自行采集了指标、日志数据，此时就把存储库（VictoriaMetrics、ElasticSearch等）作为数据源接入夜莺，即可在夜莺里配置告警规则、通知规则，完成告警事件的生成和派发。
-
-![夜莺产品架构](doc/img/readme/20240221152601.png)
-
-夜莺项目本身不提供监控数据采集能力。推荐您使用 [Categraf](https://github.com/flashcatcloud/categraf) 作为采集器，可以和夜莺丝滑对接。
-
-[Categraf](https://github.com/flashcatcloud/categraf) 可以采集操作系统、网络设备、各类中间件、数据库的监控数据，通过 Remote Write 协议推送给夜莺，夜莺把监控数据转存到时序库（如 Prometheus、VictoriaMetrics 等），并提供告警和可视化能力。
-
-对于个别边缘机房，如果和中心夜莺服务端网络链路不好，希望提升告警可用性，夜莺也提供边缘机房告警引擎下沉部署模式，这个模式下，即便边缘和中心端网络割裂，告警功能也不受影响。
-
-![边缘部署模式](doc/img/readme/20240222102119.png)
-
-> 上图中，机房A和中心机房的网络链路很好，所以直接由中心端的夜莺进程做告警引擎，机房B和中心机房的网络链路不好，所以在机房B部署了 `n9e-edge` 做告警引擎，对机房B的数据源做告警判定。
-
-## 告警降噪、升级、协同
-
-夜莺的侧重点是做告警引擎，即负责产生告警事件，并根据规则做灵活派发，内置支持 20 种通知媒介（电话、短信、邮件、钉钉、飞书、企微、Slack 等）。
-
-如果您有更高级的需求，比如：
-
-- 想要把公司的多套监控系统产生的事件聚拢到一个平台，统一做收敛降噪、响应处理、数据分析
-- 想要支持人员的排班，践行 On-call 文化，想要支持告警认领、升级（避免遗漏）、协同处理
-
-那夜莺是不合适的，推荐您选用 [FlashDuty](https://flashcat.cloud/product/flashcat-duty/) 这样的 On-call 产品，产品简单易用，也有免费套餐。
-
-
-## 相关资料 & 交流渠道
-- 📚 [夜莺介绍PPT](https://mp.weixin.qq.com/s/Mkwx_46xrltSq8NLqAIYow) 对您了解夜莺各项关键特性会有帮助（PPT链接在文末）
-- 👉 [文档中心](https://flashcat.cloud/docs/) 为了更快的访问速度，站点托管在 [FlashcatCloud](https://flashcat.cloud)
-- ❤️ [报告 Bug](https://github.com/ccfos/nightingale/issues/new?assignees=&labels=&projects=&template=question.yml) 写清楚问题描述、复现步骤、截图等信息，更容易得到答案
-- 💡 前后端代码分离，前端代码仓库：[https://github.com/n9e/fe](https://github.com/n9e/fe)
-- 🎯 关注[这个公众号](https://gitlink.org.cn/UlricQin)了解更多夜莺动态和知识
-- 🌟 加我微信：`picobyte`（我已关闭好友验证）拉入微信群，备注：`夜莺互助群`，如果已经把夜莺上到生产环境，可联系我拉入资深监控用户群
-
-
-## 关键特性简介
-
-![夜莺告警规则](doc/img/readme/2025-05-23_18-43-37.png)
-
-- 夜莺支持告警规则、屏蔽规则、订阅规则、通知规则，内置支持 20 种通知媒介，支持消息模板自定义
-- 支持事件管道，对告警事件做 Pipeline 处理，方便和自有系统做自动化整合，比如给告警事件附加一些元信息，对事件做 relabel
-- 支持业务组概念，引入权限体系，分门别类管理各类规则
-- 很多数据库、中间件内置了告警规则，可以直接导入使用，也可以直接导入 Prometheus 的告警规则
-- 支持告警自愈，即告警之后自动触发一个脚本执行一些预定义的逻辑，比如清理一下磁盘、抓一下现场等
-
-![夜莺事件大盘](doc/img/readme/2025-05-30_08-49-28.png)
-
-- 夜莺存档了历史告警事件，支持多维度的查询和统计
-- 支持灵活的聚合分组，一目了然看到公司的告警事件分布情况
-
-![夜莺集成中心](doc/img/readme/2025-05-23_18-46-06.png)
-
-- 夜莺内置常用操作系统、中间件、数据库的的指标说明、仪表盘、告警规则，不过都是社区贡献的，整体也是参差不齐
-- 夜莺直接接收 Remote Write、OpenTSDB、Datadog、Falcon 等多种协议的数据，故而可以和各类 Agent 对接
-- 夜莺支持 Prometheus、ElasticSearch、Loki、TDEngine 等多种数据源，可以对其中的数据做告警
-- 夜莺可以很方便内嵌企业内部系统，比如 Grafana、CMDB 等，甚至可以配置这些内嵌系统的菜单可见性
-
-
-![夜莺仪表盘](doc/img/readme/2025-05-23_18-49-02.png)
-
-- 夜莺支持仪表盘功能，支持常见的图表类型，也内置了一些仪表盘，上图是其中一个仪表盘的截图。
-- 如果你已经习惯了 Grafana，建议仍然使用 Grafana 看图。Grafana 在看图方面道行更深。
-- 机器相关的监控数据，如果是 Categraf 采集的，建议使用夜莺自带的仪表盘查看，因为 Categraf 的指标命名 Follow 的是 Telegraf 的命名方式，和 Node Exporter 不同
-- 因为夜莺有个业务组的概念，机器可以归属不同的业务组，有时在仪表盘里只想查看当前所属业务组的机器，所以夜莺的仪表盘可以和业务组联动
-
-## 广受关注
-[![Stargazers over time](https://api.star-history.com/svg?repos=ccfos/nightingale&type=Date)](https://star-history.com/#ccfos/nightingale&Date)
-
-## 感谢众多企业的信赖
-
-![夜莺客户](doc/img/readme/logos.png)
-
-## 社区共建
-- ❇️ 请阅读浏览[夜莺开源项目和社区治理架构草案](./doc/community-governance.md)，真诚欢迎每一位用户、开发者、公司以及组织，使用夜莺监控、积极反馈 Bug、提交功能需求、分享最佳实践，共建专业、活跃的夜莺开源社区。
-- ❤️ 夜莺贡献者
-<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)

alert/astats/stats.go

@@ -25,7 +25,6 @@ type Stats struct {
 	CounterHeartbeatErrorTotal  *prometheus.CounterVec
 	CounterSubEventTotal        *prometheus.CounterVec
 	GaugeQuerySeriesCount       *prometheus.GaugeVec
-	GaugeRuleEvalDuration       *prometheus.GaugeVec
 	GaugeNotifyRecordQueueSize  prometheus.Gauge
 }
 
@@ -137,13 +136,6 @@ func NewSyncStats() *Stats {
 		Help:      "The size of notify record queue.",
 	})
 
-	GaugeRuleEvalDuration := prometheus.NewGaugeVec(prometheus.GaugeOpts{
-		Namespace: namespace,
-		Subsystem: subsystem,
-		Name:      "rule_eval_duration_ms",
-		Help:      "Duration of rule eval in milliseconds.",
-	}, []string{"rule_id", "datasource_id"})
-
 	CounterVarFillingQuery := prometheus.NewCounterVec(prometheus.CounterOpts{
 		Namespace: namespace,
 		Subsystem: subsystem,
@@ -166,7 +158,6 @@ func NewSyncStats() *Stats {
 		CounterHeartbeatErrorTotal,
 		CounterSubEventTotal,
 		GaugeQuerySeriesCount,
-		GaugeRuleEvalDuration,
 		GaugeNotifyRecordQueueSize,
 		CounterVarFillingQuery,
 	)
@@ -186,7 +177,6 @@ func NewSyncStats() *Stats {
 		CounterHeartbeatErrorTotal:  CounterHeartbeatErrorTotal,
 		CounterSubEventTotal:        CounterSubEventTotal,
 		GaugeQuerySeriesCount:       GaugeQuerySeriesCount,
-		GaugeRuleEvalDuration:       GaugeRuleEvalDuration,
 		GaugeNotifyRecordQueueSize:  GaugeNotifyRecordQueueSize,
 		CounterVarFillingQuery:      CounterVarFillingQuery,
 	}

alert/common/key.go

@@ -35,9 +35,9 @@ func MatchGroupsName(groupName string, groupFilter []models.TagFilter) bool {
 func matchTag(value string, filter models.TagFilter) bool {
 	switch filter.Func {
 	case "==":
-		return strings.TrimSpace(fmt.Sprintf("%v", filter.Value)) == strings.TrimSpace(value)
+		return strings.TrimSpace(filter.Value) == strings.TrimSpace(value)
 	case "!=":
-		return strings.TrimSpace(fmt.Sprintf("%v", filter.Value)) != strings.TrimSpace(value)
+		return strings.TrimSpace(filter.Value) != strings.TrimSpace(value)
 	case "in":
 		_, has := filter.Vset[value]
 		return has

alert/dispatch/consume.go

@@ -110,6 +110,10 @@ func (e *Consumer) consumeOne(event *models.AlertCurEvent) {
 
 	e.persist(event)
 
+	if event.IsRecovered && event.NotifyRecovered == 0 {
+		return
+	}
+
 	e.dispatch.HandleEventNotify(event, false)
 }
 

alert/dispatch/dispatch.go

@@ -16,6 +16,7 @@ import (
 	"github.com/ccfos/nightingale/v6/alert/astats"
 	"github.com/ccfos/nightingale/v6/alert/common"
 	"github.com/ccfos/nightingale/v6/alert/pipeline"
+	"github.com/ccfos/nightingale/v6/alert/pipeline/processor/relabel"
 	"github.com/ccfos/nightingale/v6/alert/sender"
 	"github.com/ccfos/nightingale/v6/memsto"
 	"github.com/ccfos/nightingale/v6/models"
@@ -24,15 +25,6 @@ import (
 	"github.com/toolkits/pkg/logger"
 )
 
-var ShouldSkipNotify func(*ctx.Context, *models.AlertCurEvent, int64) bool
-var SendByNotifyRule func(*ctx.Context, *memsto.UserCacheType, *memsto.UserGroupCacheType, *memsto.NotifyChannelCacheType,
-	[]*models.AlertCurEvent, int64, *models.NotifyConfig, *models.NotifyChannelConfig, *models.MessageTemplate)
-
-func init() {
-	ShouldSkipNotify = shouldSkipNotify
-	SendByNotifyRule = SendNotifyRuleMessage
-}
-
 type Dispatch struct {
 	alertRuleCache      *memsto.AlertRuleCacheType
 	userCache           *memsto.UserCacheType
@@ -54,8 +46,9 @@ type Dispatch struct {
 	tpls             map[string]*template.Template
 	ExtraSenders     map[string]sender.Sender
 	BeforeSenderHook func(*models.AlertCurEvent) bool
-	ctx              *ctx.Context
-	Astats           *astats.Stats
+
+	ctx    *ctx.Context
+	Astats *astats.Stats
 
 	RwLock sync.RWMutex
 }
@@ -64,7 +57,7 @@ type Dispatch struct {
 func NewDispatch(alertRuleCache *memsto.AlertRuleCacheType, userCache *memsto.UserCacheType, userGroupCache *memsto.UserGroupCacheType,
 	alertSubscribeCache *memsto.AlertSubscribeCacheType, targetCache *memsto.TargetCacheType, notifyConfigCache *memsto.NotifyConfigCacheType,
 	taskTplsCache *memsto.TaskTplCache, notifyRuleCache *memsto.NotifyRuleCacheType, notifyChannelCache *memsto.NotifyChannelCacheType,
-	messageTemplateCache *memsto.MessageTemplateCacheType, eventProcessorCache *memsto.EventProcessorCacheType, alerting aconf.Alerting, c *ctx.Context, astats *astats.Stats) *Dispatch {
+	messageTemplateCache *memsto.MessageTemplateCacheType, eventProcessorCache *memsto.EventProcessorCacheType, alerting aconf.Alerting, ctx *ctx.Context, astats *astats.Stats) *Dispatch {
 	notify := &Dispatch{
 		alertRuleCache:       alertRuleCache,
 		userCache:            userCache,
@@ -85,14 +78,11 @@ func NewDispatch(alertRuleCache *memsto.AlertRuleCacheType, userCache *memsto.Us
 		ExtraSenders:     make(map[string]sender.Sender),
 		BeforeSenderHook: func(*models.AlertCurEvent) bool { return true },
 
-		ctx:    c,
+		ctx:    ctx,
 		Astats: astats,
 	}
 
-	pipeline.Init()
-
-	// 设置通知记录回调函数
-	notifyChannelCache.SetNotifyRecordFunc(sender.NotifyRecord)
+	relabel.Init()
 
 	return notify
 }
@@ -160,8 +150,8 @@ func (e *Dispatch) reloadTpls() error {
 
 func (e *Dispatch) HandleEventWithNotifyRule(eventOrigin *models.AlertCurEvent) {
 
-	if len(eventOrigin.NotifyRuleIds) > 0 {
-		for _, notifyRuleId := range eventOrigin.NotifyRuleIds {
+	if len(eventOrigin.NotifyRuleIDs) > 0 {
+		for _, notifyRuleId := range eventOrigin.NotifyRuleIDs {
 			// 深拷贝新的 event，避免并发修改 event 冲突
 			eventCopy := eventOrigin.DeepCopy()
 
@@ -174,10 +164,8 @@ func (e *Dispatch) HandleEventWithNotifyRule(eventOrigin *models.AlertCurEvent)
 			if !notifyRule.Enable {
 				continue
 			}
-			eventCopy.NotifyRuleId = notifyRuleId
-			eventCopy.NotifyRuleName = notifyRule.Name
 
-			var processors []models.Processor
+			var processors []pipeline.Processor
 			for _, pipelineConfig := range notifyRule.PipelineConfigs {
 				if !pipelineConfig.Enable {
 					continue
@@ -194,35 +182,31 @@ func (e *Dispatch) HandleEventWithNotifyRule(eventOrigin *models.AlertCurEvent)
 					continue
 				}
 
-				processors = append(processors, e.eventProcessorCache.GetProcessorsById(pipelineConfig.PipelineId)...)
+				for _, p := range eventPipeline.Processors {
+					processor, err := pipeline.GetProcessorByType(p.Typ, p.Config)
+					if err != nil {
+						logger.Warningf("notify_id: %d, event:%+v, processor:%+v type not found", notifyRuleId, eventCopy, p)
+						continue
+					}
+					processors = append(processors, processor)
+				}
 			}
 
 			for _, processor := range processors {
-				var res string
-				var err error
 				logger.Infof("before processor notify_id: %d, event:%+v, processor:%+v", notifyRuleId, eventCopy, processor)
-				eventCopy, res, err = processor.Process(e.ctx, eventCopy)
+				processor.Process(e.ctx, eventCopy)
+				logger.Infof("after processor notify_id: %d, event:%+v, processor:%+v", notifyRuleId, eventCopy, processor)
 				if eventCopy == nil {
-					logger.Warningf("after processor notify_id: %d, event:%+v, processor:%+v, event is nil", notifyRuleId, eventCopy, processor)
-					sender.NotifyRecord(e.ctx, []*models.AlertCurEvent{eventOrigin}, notifyRuleId, "", "", res, errors.New("drop by processor"))
+					logger.Warningf("notify_id: %d, event:%+v, processor:%+v, event is nil", notifyRuleId, eventCopy, processor)
 					break
 				}
-				logger.Infof("after processor notify_id: %d, event:%+v, processor:%+v, res:%v, err:%v", notifyRuleId, eventCopy, processor, res, err)
-			}
-
-			if ShouldSkipNotify(e.ctx, eventCopy, notifyRuleId) {
-				logger.Infof("notify_id: %d, event:%+v, should skip notify", notifyRuleId, eventCopy)
-				continue
 			}
 
 			// notify
 			for i := range notifyRule.NotifyConfigs {
-				err := NotifyRuleMatchCheck(&notifyRule.NotifyConfigs[i], eventCopy)
-				if err != nil {
-					logger.Errorf("notify_id: %d, event:%+v, channel_id:%d, template_id: %d, notify_config:%+v, err:%v", notifyRuleId, eventCopy, notifyRule.NotifyConfigs[i].ChannelID, notifyRule.NotifyConfigs[i].TemplateID, notifyRule.NotifyConfigs[i], err)
+				if !NotifyRuleApplicable(&notifyRule.NotifyConfigs[i], eventCopy) {
 					continue
 				}
-
 				notifyChannel := e.notifyChannelCache.Get(notifyRule.NotifyConfigs[i].ChannelID)
 				messageTemplate := e.messageTemplateCache.Get(notifyRule.NotifyConfigs[i].TemplateID)
 				if notifyChannel == nil {
@@ -238,25 +222,14 @@ func (e *Dispatch) HandleEventWithNotifyRule(eventOrigin *models.AlertCurEvent)
 					continue
 				}
 
-				go SendByNotifyRule(e.ctx, e.userCache, e.userGroupCache, e.notifyChannelCache, []*models.AlertCurEvent{eventCopy}, notifyRuleId, &notifyRule.NotifyConfigs[i], notifyChannel, messageTemplate)
+				// todo go send
+				// todo 聚合 event
+				go e.sendV2([]*models.AlertCurEvent{eventCopy}, notifyRuleId, &notifyRule.NotifyConfigs[i], notifyChannel, messageTemplate)
 			}
 		}
 	}
 }
 
-func shouldSkipNotify(ctx *ctx.Context, event *models.AlertCurEvent, notifyRuleId int64) bool {
-	if event == nil {
-		// 如果 eventCopy 为 nil，说明 eventCopy 被 processor drop 掉了, 不再发送通知
-		return true
-	}
-
-	if event.IsRecovered && event.NotifyRecovered == 0 {
-		// 如果 eventCopy 是恢复事件，且 NotifyRecovered 为 0，则不发送通知
-		return true
-	}
-	return false
-}
-
 func pipelineApplicable(pipeline *models.EventPipeline, event *models.AlertCurEvent) bool {
 	if pipeline == nil {
 		return true
@@ -296,7 +269,7 @@ func pipelineApplicable(pipeline *models.EventPipeline, event *models.AlertCurEv
 	return tagMatch && attributesMatch
 }
 
-func NotifyRuleMatchCheck(notifyConfig *models.NotifyConfig, event *models.AlertCurEvent) error {
+func NotifyRuleApplicable(notifyConfig *models.NotifyConfig, event *models.AlertCurEvent) bool {
 	tm := time.Unix(event.TriggerTime, 0)
 	triggerTime := tm.Format("15:04")
 	triggerWeek := int(tm.Weekday())
@@ -348,10 +321,6 @@ func NotifyRuleMatchCheck(notifyConfig *models.NotifyConfig, event *models.Alert
 		}
 	}
 
-	if !timeMatch {
-		return fmt.Errorf("event time not match time filter")
-	}
-
 	severityMatch := false
 	for i := range notifyConfig.Severities {
 		if notifyConfig.Severities[i] == event.Severity {
@@ -359,10 +328,6 @@ func NotifyRuleMatchCheck(notifyConfig *models.NotifyConfig, event *models.Alert
 		}
 	}
 
-	if !severityMatch {
-		return fmt.Errorf("event severity not match severity filter")
-	}
-
 	tagMatch := true
 	if len(notifyConfig.LabelKeys) > 0 {
 		for i := range notifyConfig.LabelKeys {
@@ -374,32 +339,23 @@ func NotifyRuleMatchCheck(notifyConfig *models.NotifyConfig, event *models.Alert
 		tagFilters, err := models.ParseTagFilter(notifyConfig.LabelKeys)
 		if err != nil {
 			logger.Errorf("notify send failed to parse tag filter: %v event:%+v notify_config:%+v", err, event, notifyConfig)
-			return fmt.Errorf("failed to parse tag filter: %v", err)
+			return false
 		}
 		tagMatch = common.MatchTags(event.TagsMap, tagFilters)
 	}
 
-	if !tagMatch {
-		return fmt.Errorf("event tag not match tag filter")
-	}
-
 	attributesMatch := true
 	if len(notifyConfig.Attributes) > 0 {
 		tagFilters, err := models.ParseTagFilter(notifyConfig.Attributes)
 		if err != nil {
 			logger.Errorf("notify send failed to parse tag filter: %v event:%+v notify_config:%+v err:%v", tagFilters, event, notifyConfig, err)
-			return fmt.Errorf("failed to parse tag filter: %v", err)
+			return false
 		}
 
 		attributesMatch = common.MatchTags(event.JsonTagsAndValue(), tagFilters)
 	}
-
-	if !attributesMatch {
-		return fmt.Errorf("event attributes not match attributes filter")
-	}
-
 	logger.Infof("notify send timeMatch:%v severityMatch:%v tagMatch:%v attributesMatch:%v event:%+v notify_config:%+v", timeMatch, severityMatch, tagMatch, attributesMatch, event, notifyConfig)
-	return nil
+	return timeMatch && severityMatch && tagMatch && attributesMatch
 }
 
 func GetNotifyConfigParams(notifyConfig *models.NotifyConfig, contactKey string, userCache *memsto.UserCacheType, userGroupCache *memsto.UserGroupCacheType) ([]string, []int64, map[string]string) {
@@ -467,8 +423,7 @@ func GetNotifyConfigParams(notifyConfig *models.NotifyConfig, contactKey string,
 	return sendtos, flashDutyChannelIDs, customParams
 }
 
-func SendNotifyRuleMessage(ctx *ctx.Context, userCache *memsto.UserCacheType, userGroupCache *memsto.UserGroupCacheType, notifyChannelCache *memsto.NotifyChannelCacheType,
-	events []*models.AlertCurEvent, notifyRuleId int64, notifyConfig *models.NotifyConfig, notifyChannel *models.NotifyChannelConfig, messageTemplate *models.MessageTemplate) {
+func (e *Dispatch) sendV2(events []*models.AlertCurEvent, notifyRuleId int64, notifyConfig *models.NotifyConfig, notifyChannel *models.NotifyChannelConfig, messageTemplate *models.MessageTemplate) {
 	if len(events) == 0 {
 		logger.Errorf("notify_id: %d events is empty", notifyRuleId)
 		return
@@ -484,7 +439,10 @@ func SendNotifyRuleMessage(ctx *ctx.Context, userCache *memsto.UserCacheType, us
 		contactKey = notifyChannel.ParamConfig.UserInfo.ContactKey
 	}
 
-	sendtos, flashDutyChannelIDs, customParams := GetNotifyConfigParams(notifyConfig, contactKey, userCache, userGroupCache)
+	sendtos, flashDutyChannelIDs, customParams := GetNotifyConfigParams(notifyConfig, contactKey, e.userCache, e.userGroupCache)
+
+	e.Astats.GaugeNotifyRecordQueueSize.Inc()
+	defer e.Astats.GaugeNotifyRecordQueueSize.Dec()
 
 	switch notifyChannel.RequestType {
 	case "flashduty":
@@ -493,42 +451,43 @@ func SendNotifyRuleMessage(ctx *ctx.Context, userCache *memsto.UserCacheType, us
 		}
 
 		for i := range flashDutyChannelIDs {
-			start := time.Now()
-			respBody, err := notifyChannel.SendFlashDuty(events, flashDutyChannelIDs[i], notifyChannelCache.GetHttpClient(notifyChannel.ID))
-			respBody = fmt.Sprintf("duration: %d ms %s", time.Since(start).Milliseconds(), respBody)
+			respBody, err := notifyChannel.SendFlashDuty(events, flashDutyChannelIDs[i], e.notifyChannelCache.GetHttpClient(notifyChannel.ID))
 			logger.Infof("notify_id: %d, channel_name: %v, event:%+v, IntegrationUrl: %v dutychannel_id: %v, respBody: %v, err: %v", notifyRuleId, notifyChannel.Name, events[0], notifyChannel.RequestConfig.FlashDutyRequestConfig.IntegrationUrl, flashDutyChannelIDs[i], respBody, err)
-			sender.NotifyRecord(ctx, events, notifyRuleId, notifyChannel.Name, strconv.FormatInt(flashDutyChannelIDs[i], 10), respBody, err)
+			sender.NotifyRecord(e.ctx, events, notifyRuleId, notifyChannel.Name, strconv.FormatInt(flashDutyChannelIDs[i], 10), respBody, err)
 		}
-
+		return
 	case "http":
-		// 使用队列模式处理 http 通知
-		// 创建通知任务
-		task := &memsto.NotifyTask{
-			Events:        events,
-			NotifyRuleId:  notifyRuleId,
-			NotifyChannel: notifyChannel,
-			TplContent:    tplContent,
-			CustomParams:  customParams,
-			Sendtos:       sendtos,
+		if e.notifyChannelCache.HttpConcurrencyAdd(notifyChannel.ID) {
+			defer e.notifyChannelCache.HttpConcurrencyDone(notifyChannel.ID)
+		}
+		if notifyChannel.RequestConfig == nil {
+			logger.Warningf("notify_id: %d, channel_name: %v, event:%+v, request config not found", notifyRuleId, notifyChannel.Name, events[0])
 		}
 
-		// 将任务加入队列
-		success := notifyChannelCache.EnqueueNotifyTask(task)
-		if !success {
-			logger.Errorf("failed to enqueue notify task for channel %d, notify_id: %d", notifyChannel.ID, notifyRuleId)
-			// 如果入队失败，记录错误通知
-			sender.NotifyRecord(ctx, events, notifyRuleId, notifyChannel.Name, getSendTarget(customParams, sendtos), "", errors.New("failed to enqueue notify task, queue is full"))
+		if notifyChannel.RequestConfig.HTTPRequestConfig == nil {
+			logger.Warningf("notify_id: %d, channel_name: %v, event:%+v, http request config not found", notifyRuleId, notifyChannel.Name, events[0])
+		}
+
+		if NeedBatchContacts(notifyChannel.RequestConfig.HTTPRequestConfig) || len(sendtos) == 0 {
+			resp, err := notifyChannel.SendHTTP(events, tplContent, customParams, sendtos, e.notifyChannelCache.GetHttpClient(notifyChannel.ID))
+			logger.Infof("notify_id: %d, channel_name: %v, event:%+v, tplContent:%s, customParams:%v, userInfo:%+v, respBody: %v, err: %v", notifyRuleId, notifyChannel.Name, events[0], tplContent, customParams, sendtos, resp, err)
+
+			sender.NotifyRecord(e.ctx, events, notifyRuleId, notifyChannel.Name, getSendTarget(customParams, sendtos), resp, err)
+		} else {
+			for i := range sendtos {
+				resp, err := notifyChannel.SendHTTP(events, tplContent, customParams, []string{sendtos[i]}, e.notifyChannelCache.GetHttpClient(notifyChannel.ID))
+				logger.Infof("notify_id: %d, channel_name: %v, event:%+v, tplContent:%s, customParams:%v, userInfo:%+v, respBody: %v, err: %v", notifyRuleId, notifyChannel.Name, events[0], tplContent, customParams, sendtos[i], resp, err)
+				sender.NotifyRecord(e.ctx, events, notifyRuleId, notifyChannel.Name, getSendTarget(customParams, []string{sendtos[i]}), resp, err)
+			}
 		}
 
 	case "smtp":
-		notifyChannel.SendEmail(notifyRuleId, events, tplContent, sendtos, notifyChannelCache.GetSmtpClient(notifyChannel.ID))
+		notifyChannel.SendEmail(notifyRuleId, events, tplContent, sendtos, e.notifyChannelCache.GetSmtpClient(notifyChannel.ID))
 
 	case "script":
-		start := time.Now()
 		target, res, err := notifyChannel.SendScript(events, tplContent, customParams, sendtos)
-		res = fmt.Sprintf("duration: %d ms %s", time.Since(start).Milliseconds(), res)
 		logger.Infof("notify_id: %d, channel_name: %v, event:%+v, tplContent:%s, customParams:%v, target:%s, res:%s, err:%v", notifyRuleId, notifyChannel.Name, events[0], tplContent, customParams, target, res, err)
-		sender.NotifyRecord(ctx, events, notifyRuleId, notifyChannel.Name, target, res, err)
+		sender.NotifyRecord(e.ctx, events, notifyRuleId, notifyChannel.Name, target, res, err)
 	default:
 		logger.Warningf("notify_id: %d, channel_name: %v, event:%+v send type not found", notifyRuleId, notifyChannel.Name, events[0])
 	}
@@ -543,13 +502,13 @@ func NeedBatchContacts(requestConfig *models.HTTPRequestConfig) bool {
 // event: 告警/恢复事件
 // isSubscribe: 告警事件是否由subscribe的配置产生
 func (e *Dispatch) HandleEventNotify(event *models.AlertCurEvent, isSubscribe bool) {
-	go e.HandleEventWithNotifyRule(event)
-	if event.IsRecovered && event.NotifyRecovered == 0 {
+	rule := e.alertRuleCache.Get(event.RuleId)
+	if rule == nil {
 		return
 	}
 
-	rule := e.alertRuleCache.Get(event.RuleId)
-	if rule == nil {
+	if e.blockEventNotify(rule, event) {
+		logger.Infof("block event notify: rule_id:%d event:%+v", rule.Id, event)
 		return
 	}
 
@@ -580,6 +539,7 @@ func (e *Dispatch) HandleEventNotify(event *models.AlertCurEvent, isSubscribe bo
 		notifyTarget.AndMerge(handler(rule, event, notifyTarget, e))
 	}
 
+	go e.HandleEventWithNotifyRule(event)
 	go e.Send(rule, event, notifyTarget, isSubscribe)
 
 	// 如果是不是订阅规则出现的event, 则需要处理订阅规则的event
@@ -588,6 +548,25 @@ func (e *Dispatch) HandleEventNotify(event *models.AlertCurEvent, isSubscribe bo
 	}
 }
 
+func (e *Dispatch) blockEventNotify(rule *models.AlertRule, event *models.AlertCurEvent) bool {
+	ruleType := rule.GetRuleType()
+
+	// 若为机器则先看机器是否删除
+	if ruleType == models.HOST {
+		host, ok := e.targetCache.Get(event.TagsMap["ident"])
+		if !ok || host == nil {
+			return true
+		}
+	}
+
+	// 恢复通知，检测规则配置是否改变
+	// if event.IsRecovered && event.RuleHash != rule.Hash() {
+	// 	return true
+	// }
+
+	return false
+}
+
 func (e *Dispatch) handleSubs(event *models.AlertCurEvent) {
 	// handle alert subscribes
 	subscribes := make([]*models.AlertSubscribe, 0)
@@ -619,10 +598,6 @@ func (e *Dispatch) handleSub(sub *models.AlertSubscribe, event models.AlertCurEv
 		return
 	}
 
-	if !sub.MatchCate(event.Cate) {
-		return
-	}
-
 	if !common.MatchTags(event.TagsMap, sub.ITags) {
 		return
 	}

alert/dispatch/log.go

@@ -18,18 +18,17 @@ func LogEvent(event *models.AlertCurEvent, location string, err ...error) {
 	}
 
 	logger.Infof(
-		"event(%s %s) %s: rule_id=%d sub_id:%d notify_rule_ids:%v cluster:%s %v%s@%d last_eval_time:%d %s",
+		"event(%s %s) %s: rule_id=%d sub_id:%d notify_rule_ids:%v cluster:%s %v%s@%d %s",
 		event.Hash,
 		status,
 		location,
 		event.RuleId,
 		event.SubRuleId,
-		event.NotifyRuleIds,
+		event.NotifyRuleIDs,
 		event.Cluster,
 		event.TagsJSON,
 		event.TriggerValue,
 		event.TriggerTime,
-		event.LastEvalTime,
 		message,
 	)
 }

alert/eval/alert_rule.go

@@ -93,7 +93,7 @@ func (s *Scheduler) syncAlertRules() {
 		}
 
 		ruleType := rule.GetRuleType()
-		if rule.IsPrometheusRule() || rule.IsInnerRule() {
+		if rule.IsPrometheusRule() || rule.IsLokiRule() || rule.IsTdengineRule() || rule.IsClickHouseRule() || rule.IsElasticSearch() {
 			datasourceIds := s.datasourceCache.GetIDsByDsCateAndQueries(rule.Cate, rule.DatasourceQueries)
 			for _, dsId := range datasourceIds {
 				if !naming.DatasourceHashRing.IsHit(strconv.FormatInt(dsId, 10), fmt.Sprintf("%d", rule.Id), s.aconf.Heartbeat.Endpoint) {

alert/eval/eval.go

@@ -144,24 +144,14 @@ func (arw *AlertRuleWorker) Start() {
 }
 
 func (arw *AlertRuleWorker) Eval() {
-	begin := time.Now()
-	var message string
-
-	defer func() {
-		if len(message) == 0 {
-			logger.Infof("rule_eval:%s finished, duration:%v", arw.Key(), time.Since(begin))
-		} else {
-			logger.Infof("rule_eval:%s finished, duration:%v, message:%s", arw.Key(), time.Since(begin), message)
-		}
-	}()
-
+	logger.Infof("eval:%s started", arw.Key())
 	if arw.Processor.PromEvalInterval == 0 {
 		arw.Processor.PromEvalInterval = getPromEvalInterval(arw.Processor.ScheduleEntry.Schedule)
 	}
 
 	cachedRule := arw.Rule
 	if cachedRule == nil {
-		message = "rule not found"
+		// logger.Errorf("rule_eval:%s Rule not found", arw.Key())
 		return
 	}
 	arw.Processor.Stats.CounterRuleEval.WithLabelValues().Inc()
@@ -182,17 +172,16 @@ func (arw *AlertRuleWorker) Eval() {
 	case models.LOKI:
 		anomalyPoints, err = arw.GetPromAnomalyPoint(cachedRule.RuleConfig)
 	default:
-		anomalyPoints, recoverPoints, err = arw.GetAnomalyPoint(cachedRule, arw.Processor.DatasourceId())
+		anomalyPoints, recoverPoints = arw.GetAnomalyPoint(cachedRule, arw.Processor.DatasourceId())
 	}
 
 	if err != nil {
 		logger.Errorf("rule_eval:%s get anomaly point err:%s", arw.Key(), err.Error())
-		message = "failed to get anomaly points"
 		return
 	}
 
 	if arw.Processor == nil {
-		message = "processor is nil"
+		logger.Warningf("rule_eval:%s Processor is nil", arw.Key())
 		return
 	}
 
@@ -234,7 +223,7 @@ func (arw *AlertRuleWorker) Eval() {
 }
 
 func (arw *AlertRuleWorker) Stop() {
-	logger.Infof("rule_eval:%s stopped", arw.Key())
+	logger.Infof("rule_eval %s stopped", arw.Key())
 	close(arw.Quit)
 	c := arw.Scheduler.Stop()
 	<-c.Done()
@@ -243,10 +232,6 @@ func (arw *AlertRuleWorker) Stop() {
 
 func (arw *AlertRuleWorker) GetPromAnomalyPoint(ruleConfig string) ([]models.AnomalyPoint, error) {
 	var lst []models.AnomalyPoint
-	start := time.Now()
-	defer func() {
-		arw.Processor.Stats.GaugeRuleEvalDuration.WithLabelValues(fmt.Sprintf("%v", arw.Rule.Id), fmt.Sprintf("%v", arw.Processor.DatasourceId())).Set(float64(time.Since(start).Milliseconds()))
-	}()
 
 	var rule *models.PromRuleConfig
 	if err := json.Unmarshal([]byte(ruleConfig), &rule); err != nil {
@@ -757,10 +742,6 @@ func combine(paramKeys []string, paraMap map[string][]string, index int, current
 
 func (arw *AlertRuleWorker) GetHostAnomalyPoint(ruleConfig string) ([]models.AnomalyPoint, error) {
 	var lst []models.AnomalyPoint
-	start := time.Now()
-	defer func() {
-		arw.Processor.Stats.GaugeRuleEvalDuration.WithLabelValues(fmt.Sprintf("%v", arw.Rule.Id), fmt.Sprintf("%v", arw.Processor.DatasourceId())).Set(float64(time.Since(start).Milliseconds()))
-	}()
 
 	var rule *models.HostRuleConfig
 	if err := json.Unmarshal([]byte(ruleConfig), &rule); err != nil {
@@ -1433,18 +1414,13 @@ func fillVar(curRealQuery string, paramKey string, val string) string {
 	return curRealQuery
 }
 
-func (arw *AlertRuleWorker) GetAnomalyPoint(rule *models.AlertRule, dsId int64) ([]models.AnomalyPoint, []models.AnomalyPoint, error) {
+func (arw *AlertRuleWorker) GetAnomalyPoint(rule *models.AlertRule, dsId int64) ([]models.AnomalyPoint, []models.AnomalyPoint) {
 	// 获取查询和规则判断条件
-	start := time.Now()
-	defer func() {
-		arw.Processor.Stats.GaugeRuleEvalDuration.WithLabelValues(fmt.Sprintf("%v", arw.Rule.Id), fmt.Sprintf("%v", arw.Processor.DatasourceId())).Set(float64(time.Since(start).Milliseconds()))
-	}()
-
 	points := []models.AnomalyPoint{}
 	recoverPoints := []models.AnomalyPoint{}
 	ruleConfig := strings.TrimSpace(rule.RuleConfig)
 	if ruleConfig == "" {
-		logger.Warningf("rule_eval:%d ruleConfig is blank", rule.Id)
+		logger.Warningf("rule_eval:%d promql is blank", rule.Id)
 		arw.Processor.Stats.CounterRuleEvalErrorTotal.WithLabelValues(fmt.Sprintf("%v", arw.Processor.DatasourceId()), GET_RULE_CONFIG, arw.Processor.BusiGroupCache.GetNameByBusiGroupId(arw.Rule.GroupId), fmt.Sprintf("%v", arw.Rule.Id)).Inc()
 		arw.Processor.Stats.GaugeQuerySeriesCount.WithLabelValues(
 			fmt.Sprintf("%v", arw.Rule.Id),
@@ -1452,7 +1428,7 @@ func (arw *AlertRuleWorker) GetAnomalyPoint(rule *models.AlertRule, dsId int64)
 			"",
 		).Set(0)
 
-		return points, recoverPoints, fmt.Errorf("rule_eval:%d ruleConfig is blank", rule.Id)
+		return points, recoverPoints
 	}
 
 	var ruleQuery models.RuleQuery
@@ -1460,7 +1436,7 @@ func (arw *AlertRuleWorker) GetAnomalyPoint(rule *models.AlertRule, dsId int64)
 	if err != nil {
 		logger.Warningf("rule_eval:%d promql parse error:%s", rule.Id, err.Error())
 		arw.Processor.Stats.CounterRuleEvalErrorTotal.WithLabelValues(fmt.Sprintf("%v", arw.Processor.DatasourceId()), GET_RULE_CONFIG, arw.Processor.BusiGroupCache.GetNameByBusiGroupId(arw.Rule.GroupId), fmt.Sprintf("%v", arw.Rule.Id)).Inc()
-		return points, recoverPoints, fmt.Errorf("rule_eval:%d promql parse error:%s", rule.Id, err.Error())
+		return points, recoverPoints
 	}
 
 	arw.Inhibit = ruleQuery.Inhibit
@@ -1480,8 +1456,7 @@ func (arw *AlertRuleWorker) GetAnomalyPoint(rule *models.AlertRule, dsId int64)
 					fmt.Sprintf("%v", arw.Processor.DatasourceId()),
 					fmt.Sprintf("%v", i),
 				).Set(-2)
-
-				return points, recoverPoints, fmt.Errorf("rule_eval:%d datasource:%d not exists", rule.Id, dsId)
+				continue
 			}
 
 			ctx := context.WithValue(context.Background(), "delay", int64(rule.Delay))
@@ -1496,7 +1471,7 @@ func (arw *AlertRuleWorker) GetAnomalyPoint(rule *models.AlertRule, dsId int64)
 					fmt.Sprintf("%v", i),
 				).Set(-1)
 
-				return points, recoverPoints, fmt.Errorf("rule_eval:%d query data error: %v", rule.Id, err)
+				continue
 			}
 
 			arw.Processor.Stats.GaugeQuerySeriesCount.WithLabelValues(
@@ -1530,7 +1505,6 @@ func (arw *AlertRuleWorker) GetAnomalyPoint(rule *models.AlertRule, dsId int64)
 		for _, query := range ruleQuery.Queries {
 			ref, unit, err := GetQueryRefAndUnit(query)
 			if err != nil {
-				logger.Warningf("rule_eval rid:%d query:%+v get ref and unit error:%s", rule.Id, query, err.Error())
 				continue
 			}
 			unitMap[ref] = unit
@@ -1697,5 +1671,5 @@ func (arw *AlertRuleWorker) GetAnomalyPoint(rule *models.AlertRule, dsId int64)
 		}
 	}
 
-	return points, recoverPoints, nil
+	return points, recoverPoints
 }

alert/mute/mute.go

@@ -9,7 +9,6 @@ import (
 	"github.com/ccfos/nightingale/v6/memsto"
 	"github.com/ccfos/nightingale/v6/models"
 
-	"github.com/pkg/errors"
 	"github.com/toolkits/pkg/logger"
 )
 
@@ -45,12 +44,6 @@ func TimeSpanMuteStrategy(rule *models.AlertRule, event *models.AlertCurEvent) b
 	triggerTime := tm.Format("15:04")
 	triggerWeek := strconv.Itoa(int(tm.Weekday()))
 
-	if rule.EnableDaysOfWeek == "" {
-		// 如果规则没有配置生效时间，则默认全天生效
-
-		return false
-	}
-
 	enableStime := strings.Fields(rule.EnableStime)
 	enableEtime := strings.Fields(rule.EnableEtime)
 	enableDaysOfWeek := strings.Split(rule.EnableDaysOfWeek, ";")
@@ -136,8 +129,7 @@ func EventMuteStrategy(event *models.AlertCurEvent, alertMuteCache *memsto.Alert
 	}
 
 	for i := 0; i < len(mutes); i++ {
-		matched, _ := MatchMute(event, mutes[i])
-		if matched {
+		if matchMute(event, mutes[i]) {
 			return true, mutes[i].Id
 		}
 	}
@@ -145,12 +137,13 @@ func EventMuteStrategy(event *models.AlertCurEvent, alertMuteCache *memsto.Alert
 	return false, 0
 }
 
-// MatchMute 如果传入了clock这个可选参数，就表示使用这个clock表示的时间，否则就从event的字段中取TriggerTime
-func MatchMute(event *models.AlertCurEvent, mute *models.AlertMute, clock ...int64) (bool, error) {
+// matchMute 如果传入了clock这个可选参数，就表示使用这个clock表示的时间，否则就从event的字段中取TriggerTime
+func matchMute(event *models.AlertCurEvent, mute *models.AlertMute, clock ...int64) bool {
 	if mute.Disabled == 1 {
-		return false, errors.New("mute is disabled")
+		return false
 	}
 
+
 	// 如果不是全局的，判断 匹配的 datasource id
 	if len(mute.DatasourceIdsJson) != 0 && mute.DatasourceIdsJson[0] != 0 && event.DatasourceId != 0 {
 		idm := make(map[int64]struct{}, len(mute.DatasourceIdsJson))
@@ -160,26 +153,26 @@ func MatchMute(event *models.AlertCurEvent, mute *models.AlertMute, clock ...int
 
 		// 判断 event.datasourceId 是否包含在 idm 中
 		if _, has := idm[event.DatasourceId]; !has {
-			return false, errors.New("datasource id not match")
+			return false
 		}
 	}
 
 	if mute.MuteTimeType == models.TimeRange {
 		if !mute.IsWithinTimeRange(event.TriggerTime) {
-			return false, errors.New("event trigger time not within mute time range")
+			return false
 		}
 	} else if mute.MuteTimeType == models.Periodic {
 		ts := event.TriggerTime
 		if len(clock) > 0 {
 			ts = clock[0]
 		}
-
+		
 		if !mute.IsWithinPeriodicMute(ts) {
-			return false, errors.New("event trigger time not within periodic mute range")
+			return false
 		}
 	} else {
 		logger.Warningf("mute time type invalid, %d", mute.MuteTimeType)
-		return false, errors.New("mute time type invalid")
+		return false
 	}
 
 	var matchSeverity bool
@@ -195,14 +188,12 @@ func MatchMute(event *models.AlertCurEvent, mute *models.AlertMute, clock ...int
 	}
 
 	if !matchSeverity {
-		return false, errors.New("event severity not match mute severity")
+		return false
 	}
 
 	if mute.ITags == nil || len(mute.ITags) == 0 {
-		return true, nil
+		return true
 	}
-	if !common.MatchTags(event.TagsMap, mute.ITags) {
-		return false, errors.New("event tags not match mute tags")
-	}
-	return true, nil
+
+	return common.MatchTags(event.TagsMap, mute.ITags)
 }

alert/pipeline/pipeline.go

@@ -1,12 +1,12 @@
 package pipeline
 
 import (
-	_ "github.com/ccfos/nightingale/v6/alert/pipeline/processor/aisummary"
-	_ "github.com/ccfos/nightingale/v6/alert/pipeline/processor/callback"
-	_ "github.com/ccfos/nightingale/v6/alert/pipeline/processor/eventdrop"
-	_ "github.com/ccfos/nightingale/v6/alert/pipeline/processor/eventupdate"
-	_ "github.com/ccfos/nightingale/v6/alert/pipeline/processor/relabel"
+	"github.com/ccfos/nightingale/v6/models"
+	"github.com/ccfos/nightingale/v6/pkg/ctx"
 )
 
-func Init() {
+func Pipeline(ctx *ctx.Context, event *models.AlertCurEvent, processors []Processor) {
+	for _, processor := range processors {
+		processor.Process(ctx, event)
+	}
 }

alert/pipeline/processor.go

@@ -1,25 +1,33 @@
-package models
+package pipeline
 
 import (
 	"fmt"
 	"strings"
 
+	"github.com/ccfos/nightingale/v6/models"
 	"github.com/ccfos/nightingale/v6/pkg/ctx"
 )
 
+// Processor 是处理器接口，所有处理器类型都需要实现此接口
 type Processor interface {
-	Init(settings interface{}) (Processor, error) // 初始化配置
-	Process(ctx *ctx.Context, event *AlertCurEvent) (*AlertCurEvent, string, error)
-	// 处理器有三种情况：
-	// 1. 处理成功，返回处理后的事件
-	// 2. 处理成功，不需要返回处理后端事件，只返回处理结果，将处理结果放到 string 中，比如 eventdrop callback 处理器
-	// 3. 处理失败，返回错误，将错误放到 error 中
+	Init(settings interface{}) (Processor, error)          // 初始化配置
+	Process(ctx *ctx.Context, event *models.AlertCurEvent) // 处理告警事件
 }
 
+// NewProcessorFn 创建处理器的函数类型
 type NewProcessorFn func(settings interface{}) (Processor, error)
 
+// 处理器注册表，存储各种类型处理器的构造函数
 var processorRegister = map[string]NewProcessorFn{}
 
+// // ProcessorTypes 存储所有支持的处理器类型
+// var Processors map[int64]models.Processor
+
+// func init() {
+// 	Processors = make(map[int64]models.Processor)
+// }
+
+// RegisterProcessor 注册处理器类型
 func RegisterProcessor(typ string, p Processor) {
 	if _, found := processorRegister[typ]; found {
 		return
@@ -27,6 +35,7 @@ func RegisterProcessor(typ string, p Processor) {
 	processorRegister[typ] = p.Init
 }
 
+// GetProcessorByType 根据类型获取处理器实例
 func GetProcessorByType(typ string, settings interface{}) (Processor, error) {
 	typ = strings.TrimSpace(typ)
 	fn, found := processorRegister[typ]

alert/pipeline/processor/aisummary/ai_summary.go

@@ -1,244 +0,0 @@
-package aisummary
-
-import (
-	"bytes"
-	"crypto/tls"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"net/url"
-	"strconv"
-	"strings"
-	"text/template"
-	"time"
-
-	"github.com/ccfos/nightingale/v6/alert/pipeline/processor/callback"
-	"github.com/ccfos/nightingale/v6/alert/pipeline/processor/common"
-	"github.com/ccfos/nightingale/v6/models"
-	"github.com/ccfos/nightingale/v6/pkg/ctx"
-	"github.com/ccfos/nightingale/v6/pkg/tplx"
-)
-
-const (
-	HTTP_STATUS_SUCCESS_MAX = 299
-)
-
-// AISummaryConfig 配置结构体
-type AISummaryConfig struct {
-	callback.HTTPConfig
-	ModelName      string                 `json:"model_name"`
-	APIKey         string                 `json:"api_key"`
-	PromptTemplate string                 `json:"prompt_template"`
-	CustomParams   map[string]interface{} `json:"custom_params"`
-}
-
-type Message struct {
-	Role    string `json:"role"`
-	Content string `json:"content"`
-}
-
-type ChatCompletionResponse struct {
-	Choices []struct {
-		Message struct {
-			Content string `json:"content"`
-		} `json:"message"`
-	} `json:"choices"`
-}
-
-func init() {
-	models.RegisterProcessor("ai_summary", &AISummaryConfig{})
-}
-
-func (c *AISummaryConfig) Init(settings interface{}) (models.Processor, error) {
-	result, err := common.InitProcessor[*AISummaryConfig](settings)
-	return result, err
-}
-
-func (c *AISummaryConfig) Process(ctx *ctx.Context, event *models.AlertCurEvent) (*models.AlertCurEvent, string, error) {
-	if c.Client == nil {
-		if err := c.initHTTPClient(); err != nil {
-			return event, "", fmt.Errorf("failed to initialize HTTP client: %v processor: %v", err, c)
-		}
-	}
-
-	// 准备告警事件信息
-	eventInfo, err := c.prepareEventInfo(event)
-	if err != nil {
-		return event, "", fmt.Errorf("failed to prepare event info: %v processor: %v", err, c)
-	}
-
-	// 调用AI模型生成总结
-	summary, err := c.generateAISummary(eventInfo)
-	if err != nil {
-		return event, "", fmt.Errorf("failed to generate AI summary: %v processor: %v", err, c)
-	}
-
-	// 将总结添加到annotations字段
-	if event.AnnotationsJSON == nil {
-		event.AnnotationsJSON = make(map[string]string)
-	}
-	event.AnnotationsJSON["ai_summary"] = summary
-
-	// 更新Annotations字段
-	b, err := json.Marshal(event.AnnotationsJSON)
-	if err != nil {
-		return event, "", fmt.Errorf("failed to marshal annotations: %v processor: %v", err, c)
-	}
-	event.Annotations = string(b)
-
-	return event, "", nil
-}
-
-func (c *AISummaryConfig) initHTTPClient() error {
-	transport := &http.Transport{
-		TLSClientConfig: &tls.Config{InsecureSkipVerify: c.SkipSSLVerify},
-	}
-
-	if c.Proxy != "" {
-		proxyURL, err := url.Parse(c.Proxy)
-		if err != nil {
-			return fmt.Errorf("failed to parse proxy url: %v", err)
-		}
-		transport.Proxy = http.ProxyURL(proxyURL)
-	}
-
-	c.Client = &http.Client{
-		Timeout:   time.Duration(c.Timeout) * time.Millisecond,
-		Transport: transport,
-	}
-	return nil
-}
-
-func (c *AISummaryConfig) prepareEventInfo(event *models.AlertCurEvent) (string, error) {
-	var defs = []string{
-		"{{$event := .}}",
-	}
-
-	text := strings.Join(append(defs, c.PromptTemplate), "")
-	t, err := template.New("prompt").Funcs(template.FuncMap(tplx.TemplateFuncMap)).Parse(text)
-	if err != nil {
-		return "", fmt.Errorf("failed to parse prompt template: %v", err)
-	}
-
-	var body bytes.Buffer
-	err = t.Execute(&body, event)
-	if err != nil {
-		return "", fmt.Errorf("failed to execute prompt template: %v", err)
-	}
-
-	return body.String(), nil
-}
-
-func (c *AISummaryConfig) generateAISummary(eventInfo string) (string, error) {
-	// 构建基础请求参数
-	reqParams := map[string]interface{}{
-		"model": c.ModelName,
-		"messages": []Message{
-			{
-				Role:    "user",
-				Content: eventInfo,
-			},
-		},
-	}
-
-	// 合并自定义参数
-	for k, v := range c.CustomParams {
-		converted, err := convertCustomParam(v)
-		if err != nil {
-			return "", fmt.Errorf("failed to convert custom param %s: %v", k, err)
-		}
-		reqParams[k] = converted
-	}
-
-	// 序列化请求体
-	jsonData, err := json.Marshal(reqParams)
-	if err != nil {
-		return "", fmt.Errorf("failed to marshal request body: %v", err)
-	}
-
-	// 创建HTTP请求
-	req, err := http.NewRequest("POST", c.URL, bytes.NewBuffer(jsonData))
-	if err != nil {
-		return "", fmt.Errorf("failed to create request: %v", err)
-	}
-
-	// 设置请求头
-	req.Header.Set("Authorization", "Bearer "+c.APIKey)
-	req.Header.Set("Content-Type", "application/json")
-	for k, v := range c.Headers {
-		req.Header.Set(k, v)
-	}
-
-	// 发送请求
-	resp, err := c.Client.Do(req)
-	if err != nil {
-		return "", fmt.Errorf("failed to send request: %v", err)
-	}
-	defer resp.Body.Close()
-
-	// 检查响应状态码
-	if resp.StatusCode > HTTP_STATUS_SUCCESS_MAX {
-		body, _ := io.ReadAll(resp.Body)
-		return "", fmt.Errorf("unexpected status code: %d, body: %s", resp.StatusCode, string(body))
-	}
-
-	// 读取响应
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return "", fmt.Errorf("failed to read response body: %v", err)
-	}
-
-	// 解析响应
-	var chatResp ChatCompletionResponse
-	if err := json.Unmarshal(body, &chatResp); err != nil {
-		return "", fmt.Errorf("failed to unmarshal response: %v", err)
-	}
-
-	if len(chatResp.Choices) == 0 {
-		return "", fmt.Errorf("no response from AI model")
-	}
-
-	return chatResp.Choices[0].Message.Content, nil
-}
-
-// convertCustomParam 将前端传入的参数转换为正确的类型
-func convertCustomParam(value interface{}) (interface{}, error) {
-	if value == nil {
-		return nil, nil
-	}
-
-	// 如果是字符串，尝试转换为其他类型
-	if str, ok := value.(string); ok {
-		// 尝试转换为数字
-		if f, err := strconv.ParseFloat(str, 64); err == nil {
-			// 检查是否为整数
-			if f == float64(int64(f)) {
-				return int64(f), nil
-			}
-			return f, nil
-		}
-
-		// 尝试转换为布尔值
-		if b, err := strconv.ParseBool(str); err == nil {
-			return b, nil
-		}
-
-		// 尝试解析为JSON数组
-		if strings.HasPrefix(strings.TrimSpace(str), "[") {
-			var arr []interface{}
-			if err := json.Unmarshal([]byte(str), &arr); err == nil {
-				return arr, nil
-			}
-		}
-
-		// 尝试解析为JSON对象
-		if strings.HasPrefix(strings.TrimSpace(str), "{") {
-			var obj map[string]interface{}
-			if err := json.Unmarshal([]byte(str), &obj); err == nil {
-				return obj, nil
-			}
-		}
-	}
-	return value, nil
-}

alert/pipeline/processor/aisummary/ai_summary_test.go

@@ -1,139 +0,0 @@
-package aisummary
-
-import (
-	"testing"
-
-	"github.com/ccfos/nightingale/v6/alert/pipeline/processor/callback"
-	"github.com/ccfos/nightingale/v6/models"
-	"github.com/ccfos/nightingale/v6/pkg/ctx"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestAISummaryConfig_Process(t *testing.T) {
-	// 创建测试配置
-	config := &AISummaryConfig{
-		HTTPConfig: callback.HTTPConfig{
-			URL:           "https://generativelanguage.googleapis.com/v1beta/openai/chat/completions",
-			Timeout:       30000,
-			SkipSSLVerify: true,
-			Headers: map[string]string{
-				"Content-Type": "application/json",
-			},
-		},
-		ModelName:      "gemini-2.0-flash",
-		APIKey:         "*",
-		PromptTemplate: "告警规则：{{$event.RuleName}}\n严重程度：{{$event.Severity}}",
-		CustomParams: map[string]interface{}{
-			"temperature": 0.7,
-			"max_tokens":  2000,
-			"top_p":       0.9,
-		},
-	}
-
-	// 创建测试事件
-	event := &models.AlertCurEvent{
-		RuleName: "Test Rule",
-		Severity: 1,
-		TagsMap: map[string]string{
-			"host": "test-host",
-		},
-		AnnotationsJSON: map[string]string{
-			"description": "Test alert",
-		},
-	}
-
-	// 测试模板处理
-	eventInfo, err := config.prepareEventInfo(event)
-	assert.NoError(t, err)
-	assert.Contains(t, eventInfo, "Test Rule")
-	assert.Contains(t, eventInfo, "1")
-
-	// 测试配置初始化
-	processor, err := config.Init(config)
-	assert.NoError(t, err)
-	assert.NotNil(t, processor)
-
-	// 测试处理函数
-	result, _, err := processor.Process(&ctx.Context{}, event)
-	assert.NoError(t, err)
-	assert.NotNil(t, result)
-	assert.NotEmpty(t, result.AnnotationsJSON["ai_summary"])
-
-	// 展示处理结果
-	t.Log("\n=== 处理结果 ===")
-	t.Logf("告警规则: %s", result.RuleName)
-	t.Logf("严重程度: %d", result.Severity)
-	t.Logf("标签: %v", result.TagsMap)
-	t.Logf("原始注释: %v", result.AnnotationsJSON["description"])
-	t.Logf("AI总结: %s", result.AnnotationsJSON["ai_summary"])
-}
-
-func TestConvertCustomParam(t *testing.T) {
-	tests := []struct {
-		name     string
-		input    interface{}
-		expected interface{}
-		hasError bool
-	}{
-		{
-			name:     "nil value",
-			input:    nil,
-			expected: nil,
-			hasError: false,
-		},
-		{
-			name:     "string number to int64",
-			input:    "123",
-			expected: int64(123),
-			hasError: false,
-		},
-		{
-			name:     "string float to float64",
-			input:    "123.45",
-			expected: 123.45,
-			hasError: false,
-		},
-		{
-			name:     "string boolean to bool",
-			input:    "true",
-			expected: true,
-			hasError: false,
-		},
-		{
-			name:     "string false to bool",
-			input:    "false",
-			expected: false,
-			hasError: false,
-		},
-		{
-			name:     "JSON array string to slice",
-			input:    `["a", "b", "c"]`,
-			expected: []interface{}{"a", "b", "c"},
-			hasError: false,
-		},
-		{
-			name:     "JSON object string to map",
-			input:    `{"key": "value", "num": 123}`,
-			expected: map[string]interface{}{"key": "value", "num": float64(123)},
-			hasError: false,
-		},
-		{
-			name:     "plain string remains string",
-			input:    "hello world",
-			expected: "hello world",
-			hasError: false,
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			converted, err := convertCustomParam(test.input)
-			if test.hasError {
-				assert.Error(t, err)
-				return
-			}
-			assert.NoError(t, err)
-			assert.Equal(t, test.expected, converted)
-		})
-	}
-}

alert/pipeline/processor/callback/callback.go

@@ -1,103 +0,0 @@
-package callback
-
-import (
-	"crypto/tls"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"net/url"
-	"strings"
-	"time"
-
-	"github.com/ccfos/nightingale/v6/alert/pipeline/processor/common"
-	"github.com/ccfos/nightingale/v6/models"
-	"github.com/ccfos/nightingale/v6/pkg/ctx"
-	"github.com/toolkits/pkg/logger"
-)
-
-type HTTPConfig struct {
-	URL           string            `json:"url"`
-	Method        string            `json:"method,omitempty"`
-	Body          string            `json:"body,omitempty"`
-	Headers       map[string]string `json:"header"`
-	AuthUsername  string            `json:"auth_username"`
-	AuthPassword  string            `json:"auth_password"`
-	Timeout       int               `json:"timeout"` // 单位:ms
-	SkipSSLVerify bool              `json:"skip_ssl_verify"`
-	Proxy         string            `json:"proxy"`
-	Client        *http.Client      `json:"-"`
-}
-
-// RelabelConfig
-type CallbackConfig struct {
-	HTTPConfig
-}
-
-func init() {
-	models.RegisterProcessor("callback", &CallbackConfig{})
-}
-
-func (c *CallbackConfig) Init(settings interface{}) (models.Processor, error) {
-	result, err := common.InitProcessor[*CallbackConfig](settings)
-	return result, err
-}
-
-func (c *CallbackConfig) Process(ctx *ctx.Context, event *models.AlertCurEvent) (*models.AlertCurEvent, string, error) {
-	if c.Client == nil {
-		transport := &http.Transport{
-			TLSClientConfig: &tls.Config{InsecureSkipVerify: c.SkipSSLVerify},
-		}
-
-		if c.Proxy != "" {
-			proxyURL, err := url.Parse(c.Proxy)
-			if err != nil {
-				return event, "", fmt.Errorf("failed to parse proxy url: %v processor: %v", err, c)
-			} else {
-				transport.Proxy = http.ProxyURL(proxyURL)
-			}
-		}
-
-		c.Client = &http.Client{
-			Timeout:   time.Duration(c.Timeout) * time.Millisecond,
-			Transport: transport,
-		}
-	}
-
-	headers := make(map[string]string)
-	headers["Content-Type"] = "application/json"
-	for k, v := range c.Headers {
-		headers[k] = v
-	}
-
-	body, err := json.Marshal(event)
-	if err != nil {
-		return event, "", fmt.Errorf("failed to marshal event: %v processor: %v", err, c)
-	}
-
-	req, err := http.NewRequest("POST", c.URL, strings.NewReader(string(body)))
-	if err != nil {
-		return event, "", fmt.Errorf("failed to create request: %v processor: %v", err, c)
-	}
-
-	for k, v := range headers {
-		req.Header.Set(k, v)
-	}
-
-	if c.AuthUsername != "" && c.AuthPassword != "" {
-		req.SetBasicAuth(c.AuthUsername, c.AuthPassword)
-	}
-
-	resp, err := c.Client.Do(req)
-	if err != nil {
-		return event, "", fmt.Errorf("failed to send request: %v processor: %v", err, c)
-	}
-
-	b, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return event, "", fmt.Errorf("failed to read response body: %v processor: %v", err, c)
-	}
-
-	logger.Debugf("callback processor response body: %s", string(b))
-	return event, "callback success", nil
-}

alert/pipeline/processor/common/common.go

@@ -1,24 +0,0 @@
-package common
-
-import (
-	"encoding/json"
-)
-
-// InitProcessor 是一个通用的初始化处理器的方法
-// 使用泛型简化处理器初始化逻辑
-// T 必须是 models.Processor 接口的实现
-func InitProcessor[T any](settings interface{}) (T, error) {
-	var zero T
-	b, err := json.Marshal(settings)
-	if err != nil {
-		return zero, err
-	}
-
-	var result T
-	err = json.Unmarshal(b, &result)
-	if err != nil {
-		return zero, err
-	}
-
-	return result, nil
-}

alert/pipeline/processor/eventdrop/event_drop.go

@@ -1,60 +0,0 @@
-package eventdrop
-
-import (
-	"bytes"
-	"fmt"
-	"strings"
-	texttemplate "text/template"
-
-	"github.com/ccfos/nightingale/v6/alert/pipeline/processor/common"
-	"github.com/ccfos/nightingale/v6/models"
-	"github.com/ccfos/nightingale/v6/pkg/ctx"
-	"github.com/ccfos/nightingale/v6/pkg/tplx"
-	"github.com/toolkits/pkg/logger"
-)
-
-type EventDropConfig struct {
-	Content string `json:"content"`
-}
-
-func init() {
-	models.RegisterProcessor("event_drop", &EventDropConfig{})
-}
-
-func (c *EventDropConfig) Init(settings interface{}) (models.Processor, error) {
-	result, err := common.InitProcessor[*EventDropConfig](settings)
-	return result, err
-}
-
-func (c *EventDropConfig) Process(ctx *ctx.Context, event *models.AlertCurEvent) (*models.AlertCurEvent, string, error) {
-	// 使用背景是可以根据此处理器，实现对事件进行更加灵活的过滤的逻辑
-	// 在标签过滤和属性过滤都不满足需求时可以使用
-	// 如果模板执行结果为 true，则删除该事件
-
-	var defs = []string{
-		"{{ $event := . }}",
-		"{{ $labels := .TagsMap }}",
-		"{{ $value := .TriggerValue }}",
-	}
-
-	text := strings.Join(append(defs, c.Content), "")
-
-	tpl, err := texttemplate.New("eventdrop").Funcs(tplx.TemplateFuncMap).Parse(text)
-	if err != nil {
-		return event, "", fmt.Errorf("processor failed to parse template: %v processor: %v", err, c)
-	}
-
-	var body bytes.Buffer
-	if err = tpl.Execute(&body, event); err != nil {
-		return event, "", fmt.Errorf("processor failed to execute template: %v processor: %v", err, c)
-	}
-
-	result := strings.TrimSpace(body.String())
-	logger.Infof("processor eventdrop result: %v", result)
-	if result == "true" {
-		logger.Infof("processor eventdrop drop event: %v", event)
-		return nil, "drop event success", nil
-	}
-
-	return event, "drop event failed", nil
-}

alert/pipeline/processor/eventupdate/event_update.go

@@ -1,96 +0,0 @@
-package eventupdate
-
-import (
-	"crypto/tls"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"net/url"
-	"strings"
-	"time"
-
-	"github.com/ccfos/nightingale/v6/alert/pipeline/processor/callback"
-	"github.com/ccfos/nightingale/v6/alert/pipeline/processor/common"
-	"github.com/ccfos/nightingale/v6/models"
-	"github.com/ccfos/nightingale/v6/pkg/ctx"
-	"github.com/toolkits/pkg/logger"
-)
-
-// RelabelConfig
-type EventUpdateConfig struct {
-	callback.HTTPConfig
-}
-
-func init() {
-	models.RegisterProcessor("event_update", &EventUpdateConfig{})
-}
-
-func (c *EventUpdateConfig) Init(settings interface{}) (models.Processor, error) {
-	result, err := common.InitProcessor[*EventUpdateConfig](settings)
-	return result, err
-}
-
-func (c *EventUpdateConfig) Process(ctx *ctx.Context, event *models.AlertCurEvent) (*models.AlertCurEvent, string, error) {
-	if c.Client == nil {
-		transport := &http.Transport{
-			TLSClientConfig: &tls.Config{InsecureSkipVerify: c.SkipSSLVerify},
-		}
-
-		if c.Proxy != "" {
-			proxyURL, err := url.Parse(c.Proxy)
-			if err != nil {
-				return event, "", fmt.Errorf("failed to parse proxy url: %v processor: %v", err, c)
-			} else {
-				transport.Proxy = http.ProxyURL(proxyURL)
-			}
-		}
-
-		c.Client = &http.Client{
-			Timeout:   time.Duration(c.Timeout) * time.Millisecond,
-			Transport: transport,
-		}
-	}
-
-	headers := make(map[string]string)
-	headers["Content-Type"] = "application/json"
-	for k, v := range c.Headers {
-		headers[k] = v
-	}
-
-	body, err := json.Marshal(event)
-	if err != nil {
-		return event, "", fmt.Errorf("failed to marshal event: %v processor: %v", err, c)
-	}
-
-	req, err := http.NewRequest("POST", c.URL, strings.NewReader(string(body)))
-	if err != nil {
-		return event, "", fmt.Errorf("failed to create request: %v processor: %v", err, c)
-	}
-
-	for k, v := range headers {
-		req.Header.Set(k, v)
-	}
-
-	if c.AuthUsername != "" && c.AuthPassword != "" {
-		req.SetBasicAuth(c.AuthUsername, c.AuthPassword)
-	}
-
-	resp, err := c.Client.Do(req)
-	if err != nil {
-		return event, "", fmt.Errorf("failed to send request: %v processor: %v", err, c)
-	}
-
-	b, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return nil, "", fmt.Errorf("failed to read response body: %v processor: %v", err, c)
-	}
-	logger.Debugf("event update processor response body: %s", string(b))
-
-	err = json.Unmarshal(b, &event)
-	if err != nil {
-		return event, "", fmt.Errorf("failed to unmarshal response body: %v processor: %v", err, c)
-	}
-
-	return event, "", nil
-}

alert/pipeline/processor/relabel/relabel.go

@@ -1,11 +1,12 @@
 package relabel
 
 import (
+	"encoding/json"
 	"fmt"
 	"regexp"
 	"strings"
 
-	"github.com/ccfos/nightingale/v6/alert/pipeline/processor/common"
+	"github.com/ccfos/nightingale/v6/alert/pipeline"
 	"github.com/ccfos/nightingale/v6/models"
 	"github.com/ccfos/nightingale/v6/pkg/ctx"
 	"github.com/ccfos/nightingale/v6/pushgw/pconf"
@@ -15,10 +16,6 @@ import (
 	"github.com/prometheus/prometheus/prompb"
 )
 
-const (
-	REPLACE_DOT = "___"
-)
-
 // RelabelConfig
 type RelabelConfig struct {
 	SourceLabels  []string `json:"source_labels"`
@@ -33,16 +30,33 @@ type RelabelConfig struct {
 	Action        string `json:"action"`
 }
 
+func Init() {
+}
+
 func init() {
-	models.RegisterProcessor("relabel", &RelabelConfig{})
+	pipeline.RegisterProcessor("relabel", &RelabelConfig{})
 }
 
-func (r *RelabelConfig) Init(settings interface{}) (models.Processor, error) {
-	result, err := common.InitProcessor[*RelabelConfig](settings)
-	return result, err
+func (r *RelabelConfig) Init(settings interface{}) (pipeline.Processor, error) {
+	b, err := json.Marshal(settings)
+	if err != nil {
+		return nil, err
+	}
+
+	newProcessor := &RelabelConfig{}
+	err = json.Unmarshal(b, &newProcessor)
+	if err != nil {
+		return nil, err
+	}
+
+	return newProcessor, nil
 }
 
-func (r *RelabelConfig) Process(ctx *ctx.Context, event *models.AlertCurEvent) (*models.AlertCurEvent, string, error) {
+const (
+	REPLACE_DOT = "___"
+)
+
+func (r *RelabelConfig) Process(ctx *ctx.Context, event *models.AlertCurEvent) {
 	sourceLabels := make([]model.LabelName, len(r.SourceLabels))
 	for i := range r.SourceLabels {
 		sourceLabels[i] = model.LabelName(strings.ReplaceAll(r.SourceLabels[i], ".", REPLACE_DOT))
@@ -64,7 +78,6 @@ func (r *RelabelConfig) Process(ctx *ctx.Context, event *models.AlertCurEvent) (
 	}
 
 	EventRelabel(event, relabelConfigs)
-	return event, "", nil
 }
 
 func EventRelabel(event *models.AlertCurEvent, relabelConfigs []*pconf.RelabelConfig) {
@@ -93,6 +106,10 @@ func EventRelabel(event *models.AlertCurEvent, relabelConfigs []*pconf.RelabelCo
 		if relabelConfigs[i].Regex == "" {
 			relabelConfigs[i].Regex = "(.*)"
 		}
+
+		for j := range relabelConfigs[i].SourceLabels {
+			relabelConfigs[i].SourceLabels[j] = model.LabelName(strings.ReplaceAll(string(relabelConfigs[i].SourceLabels[j]), ".", REPLACE_DOT))
+		}
 	}
 
 	gotLabels := writer.Process(labels, relabelConfigs...)

alert/process/process.go

@@ -151,7 +151,7 @@ func (p *Processor) Handle(anomalyPoints []models.AnomalyPoint, from string, inh
 	eventsMap := make(map[string][]*models.AlertCurEvent)
 	for _, anomalyPoint := range anomalyPoints {
 		event := p.BuildEvent(anomalyPoint, from, now, ruleHash)
-		event.NotifyRuleIds = cachedRule.NotifyRuleIds
+		event.NotifyRuleIDs = cachedRule.NotifyRuleIds
 		// 如果 event 被 mute 了,本质也是 fire 的状态,这里无论如何都添加到 alertingKeys 中,防止 fire 的事件自动恢复了
 		hash := event.Hash
 		alertingKeys[hash] = struct{}{}
@@ -280,7 +280,7 @@ func Relabel(rule *models.AlertRule, event *models.AlertCurEvent) {
 
 	// need to keep the original label
 	event.OriginalTags = event.Tags
-	event.OriginalTagsJSON = event.TagsJSON
+	event.OriginalTagsJSON = make([]string, len(event.TagsJSON))
 
 	if len(rule.EventRelabelConfig) == 0 {
 		return
@@ -428,18 +428,17 @@ func (p *Processor) handleEvent(events []*models.AlertCurEvent) {
 			continue
 		}
 
-		var preEvalTime int64 // 第一个 pending event 的检测时间
+		var preTriggerTime int64 // 第一个 pending event 的触发时间
 		preEvent, has := p.pendings.Get(event.Hash)
 		if has {
 			p.pendings.UpdateLastEvalTime(event.Hash, event.LastEvalTime)
-			preEvalTime = preEvent.FirstEvalTime
+			preTriggerTime = preEvent.TriggerTime
 		} else {
-			event.FirstEvalTime = event.LastEvalTime
 			p.pendings.Set(event.Hash, event)
-			preEvalTime = event.FirstEvalTime
+			preTriggerTime = event.TriggerTime
 		}
 
-		if event.LastEvalTime-preEvalTime+int64(event.PromEvalInterval) >= int64(p.rule.PromForDuration) {
+		if event.LastEvalTime-preTriggerTime+int64(event.PromEvalInterval) >= int64(p.rule.PromForDuration) {
 			fireEvents = append(fireEvents, event)
 			if severity > event.Severity {
 				severity = event.Severity
@@ -468,18 +467,16 @@ func (p *Processor) fireEvent(event *models.AlertCurEvent) {
 		return
 	}
 
-	message := "unknown"
-	defer func() {
-		logger.Infof("rule_eval:%s event-hash-%s %s", p.Key(), event.Hash, message)
-	}()
-
+	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 {
-			message = "stalled, rule.notify_repeat_step is 0, no need to repeat notify"
+			logger.Debugf("rule_eval:%s event:%+v repeat is zero nothing to do", p.Key(), event)
+			// 说明不想重复通知，那就直接返回了，nothing to do
+			// do not need to send alert again
 			return
 		}
 
@@ -488,26 +485,21 @@ func (p *Processor) fireEvent(event *models.AlertCurEvent) {
 			if cachedRule.NotifyMaxNumber == 0 {
 				// 最大可以发送次数如果是0，表示不想限制最大发送次数，一直发即可
 				event.NotifyCurNumber = fired.NotifyCurNumber + 1
-				message = fmt.Sprintf("fired, notify_repeat_step_matched(%d >= %d + %d * 60) notify_max_number_ignore(#%d / %d)", event.LastEvalTime, fired.LastSentTime, cachedRule.NotifyRepeatStep, event.NotifyCurNumber, cachedRule.NotifyMaxNumber)
 				p.pushEventToQueue(event)
 			} else {
 				// 有最大发送次数的限制，就要看已经发了几次了，是否达到了最大发送次数
 				if fired.NotifyCurNumber >= cachedRule.NotifyMaxNumber {
-					message = fmt.Sprintf("stalled, notify_repeat_step_matched(%d >= %d + %d * 60) notify_max_number_not_matched(#%d / %d)", event.LastEvalTime, fired.LastSentTime, cachedRule.NotifyRepeatStep, fired.NotifyCurNumber, cachedRule.NotifyMaxNumber)
+					logger.Debugf("rule_eval:%s event:%+v reach max number", p.Key(), event)
 					return
 				} else {
 					event.NotifyCurNumber = fired.NotifyCurNumber + 1
-					message = fmt.Sprintf("fired, notify_repeat_step_matched(%d >= %d + %d * 60) notify_max_number_matched(#%d / %d)", event.LastEvalTime, fired.LastSentTime, cachedRule.NotifyRepeatStep, event.NotifyCurNumber, cachedRule.NotifyMaxNumber)
 					p.pushEventToQueue(event)
 				}
 			}
-		} else {
-			message = fmt.Sprintf("stalled, notify_repeat_step_not_matched(%d < %d + %d * 60)", event.LastEvalTime, fired.LastSentTime, cachedRule.NotifyRepeatStep)
 		}
 	} else {
 		event.NotifyCurNumber = 1
 		event.FirstTriggerTime = event.TriggerTime
-		message = fmt.Sprintf("fired, first_trigger_time: %d", event.FirstTriggerTime)
 		p.HandleFireEventHook(event)
 		p.pushEventToQueue(event)
 	}
@@ -545,7 +537,7 @@ func (p *Processor) RecoverAlertCurEventFromDb() {
 		if alertRule == nil {
 			continue
 		}
-		event.NotifyRuleIds = alertRule.NotifyRuleIds
+		event.NotifyRuleIDs = alertRule.NotifyRuleIds
 
 		if event.Cate == models.HOST {
 			target, exists := p.TargetCache.Get(event.TargetIdent)
@@ -585,9 +577,7 @@ func (p *Processor) fillTags(anomalyPoint models.AnomalyPoint) {
 	}
 
 	// handle rule tags
-	tags := p.rule.AppendTagsJSON
-	tags = append(tags, "rulename="+p.rule.Name)
-	for _, tag := range tags {
+	for _, tag := range p.rule.AppendTagsJSON {
 		arr := strings.SplitN(tag, "=", 2)
 
 		var defs = []string{
@@ -613,6 +603,8 @@ func (p *Processor) fillTags(anomalyPoint models.AnomalyPoint) {
 
 		tagsMap[arr[0]] = body.String()
 	}
+
+	tagsMap["rulename"] = p.rule.Name
 	p.tagsMap = tagsMap
 
 	// handle tagsArr

alert/record/prom_rule.go

@@ -56,13 +56,12 @@ func (rrc *RecordRuleContext) Key() string {
 }
 
 func (rrc *RecordRuleContext) Hash() string {
-	return str.MD5(fmt.Sprintf("%d_%s_%s_%d_%s_%s",
+	return str.MD5(fmt.Sprintf("%d_%s_%s_%d_%s",
 		rrc.rule.Id,
 		rrc.rule.CronPattern,
 		rrc.rule.PromQl,
 		rrc.datasourceId,
 		rrc.rule.AppendTags,
-		rrc.rule.Name,
 	))
 }
 

alert/sender/callback.go

@@ -1,7 +1,6 @@
 package sender
 
 import (
-	"fmt"
 	"html/template"
 	"net/url"
 	"strings"
@@ -135,9 +134,7 @@ func (c *DefaultCallBacker) CallBack(ctx CallBackContext) {
 
 func doSendAndRecord(ctx *ctx.Context, url, token string, body interface{}, channel string,
 	stats *astats.Stats, events []*models.AlertCurEvent) {
-	start := time.Now()
 	res, err := doSend(url, body, channel, stats)
-	res = fmt.Sprintf("duration: %d ms %s", time.Since(start).Milliseconds(), res)
 	NotifyRecord(ctx, events, 0, channel, token, res, err)
 }
 
@@ -169,9 +166,7 @@ func NotifyRecord(ctx *ctx.Context, evts []*models.AlertCurEvent, notifyRuleID i
 func doSend(url string, body interface{}, channel string, stats *astats.Stats) (string, error) {
 	stats.AlertNotifyTotal.WithLabelValues(channel).Inc()
 
-	start := time.Now()
 	res, code, err := poster.PostJSON(url, time.Second*5, body, 3)
-	res = []byte(fmt.Sprintf("duration: %d ms %s", time.Since(start).Milliseconds(), res))
 	if err != nil {
 		logger.Errorf("%s_sender: result=fail url=%s code=%d error=%v req:%v response=%s", channel, url, code, err, body, string(res))
 		stats.AlertNotifyErrorTotal.WithLabelValues(channel).Inc()

alert/sender/email.go

@@ -141,7 +141,7 @@ func updateSmtp(ctx *ctx.Context, ncc *memsto.NotifyConfigCacheType) {
 func startEmailSender(ctx *ctx.Context, smtp aconf.SMTPConfig) {
 	conf := smtp
 	if conf.Host == "" || conf.Port == 0 {
-		logger.Debug("SMTP configurations invalid")
+		logger.Warning("SMTP configurations invalid")
 		<-mailQuit
 		return
 	}

alert/sender/plugin.go

@@ -79,7 +79,6 @@ func alertingCallScript(ctx *ctx.Context, stdinBytes []byte, notifyScript models
 	cmd.Stdout = &buf
 	cmd.Stderr = &buf
 
-	start := time.Now()
 	err := startCmd(cmd)
 	if err != nil {
 		logger.Errorf("event_script_notify_fail: run cmd err: %v", err)
@@ -89,7 +88,6 @@ func alertingCallScript(ctx *ctx.Context, stdinBytes []byte, notifyScript models
 	err, isTimeout := sys.WrapTimeout(cmd, time.Duration(config.Timeout)*time.Second)
 
 	res := buf.String()
-	res = fmt.Sprintf("duration: %d ms %s", time.Since(start).Milliseconds(), res)
 
 	// 截断超出长度的输出
 	if len(res) > 512 {

alert/sender/webhook.go

@@ -99,9 +99,7 @@ func SingleSendWebhooks(ctx *ctx.Context, webhooks map[string]*models.Webhook, e
 	for _, conf := range webhooks {
 		retryCount := 0
 		for retryCount < 3 {
-			start := time.Now()
 			needRetry, res, err := sendWebhook(conf, event, stats)
-			res = fmt.Sprintf("duration: %d ms %s", time.Since(start).Milliseconds(), res)
 			NotifyRecord(ctx, []*models.AlertCurEvent{event}, 0, "webhook", conf.Url, res, err)
 			if !needRetry {
 				break
@@ -171,9 +169,7 @@ func StartConsumer(ctx *ctx.Context, queue *WebhookQueue, popSize int, webhook *
 
 			retryCount := 0
 			for retryCount < webhook.RetryCount {
-				start := time.Now()
 				needRetry, res, err := sendWebhook(webhook, events, stats)
-				res = fmt.Sprintf("duration: %d ms %s", time.Since(start).Milliseconds(), res)
 				go NotifyRecord(ctx, events, 0, "webhook", webhook.Url, res, err)
 				if !needRetry {
 					break

center/cconf/ops.go

@@ -85,221 +85,273 @@ func MergeOperationConf() error {
 const (
 	builtInOps = `
 ops:
-- name: Infrastructure
+- name: dashboards
+  cname: Dashboards
+  ops:
+    - name: "/dashboards"
+      cname: View Dashboards
+    - name: "/dashboards/add"
+      cname: Add Dashboard
+    - name: "/dashboards/put"
+      cname: Modify Dashboard
+    - name: "/dashboards/del"
+      cname: Delete Dashboard
+    - name: "/embedded-dashboards/put"
+      cname: Modify Embedded Dashboard
+    - name: "/embedded-dashboards"
+      cname: View Embedded Dashboard
+    - name: "/public-dashboards"
+      cname: View Public Dashboard
+
+- name: metric
+  cname: Time Series Metrics
+  ops:
+    - name: "/metric/explorer"
+      cname: View Metric Data
+    - name: "/object/explorer"
+      cname: View Object Data
+
+- name: builtin-metrics
+  cname: Metric Views
+  ops:
+    - name: "/metrics-built-in"
+      cname: View Built-in Metrics
+    - name: "/builtin-metrics/add"
+      cname: Add Built-in Metric
+    - name: "/builtin-metrics/put"
+      cname: Modify Built-in Metric
+    - name: "/builtin-metrics/del"
+      cname: Delete Built-in Metric
+
+- name: recording-rules
+  cname: Recording Rule Management
+  ops:
+    - name: "/recording-rules"
+      cname: View Recording Rules
+    - name: "/recording-rules/add"
+      cname: Add Recording Rule
+    - name: "/recording-rules/put"
+      cname: Modify Recording Rule
+    - name: "/recording-rules/del"
+      cname: Delete Recording Rule
+
+- name: log
+  cname: Log Analysis
+  ops:
+    - name: "/log/explorer"
+      cname: View Logs
+    - name: "/log/index-patterns"
+      cname: View Index Patterns
+    - name: "/log/index-patterns/add"
+      cname: Add Index Pattern
+    - name: "/log/index-patterns/put"
+      cname: Modify Index Pattern
+    - name: "/log/index-patterns/del"
+      cname: Delete Index Pattern
+
+
+- name: alert
+  cname: Alert Rules
+  ops:
+    - name: "/alert-rules"
+      cname: View Alert Rules
+    - name: "/alert-rules/add"
+      cname: Add Alert Rule
+    - name: "/alert-rules/put"
+      cname: Modify Alert Rule
+    - name: "/alert-rules/del"
+      cname: Delete Alert Rule
+
+- name: alert-mutes
+  cname: Alert Silence Management
+  ops:
+    - name: "/alert-mutes"
+      cname: View Alert Silences
+    - name: "/alert-mutes/add"
+      cname: Add Alert Silence
+    - name: "/alert-mutes/put"
+      cname: Modify Alert Silence
+    - name: "/alert-mutes/del"
+      cname: Delete Alert Silence
+  
+- name: alert-subscribes
+  cname: Alert Subscription Management
+  ops:
+    - name: "/alert-subscribes"
+      cname: View Alert Subscriptions
+    - name: "/alert-subscribes/add"
+      cname: Add Alert Subscription
+    - name: "/alert-subscribes/put"
+      cname: Modify Alert Subscription
+    - name: "/alert-subscribes/del"
+      cname: Delete Alert Subscription
+
+- name: alert-events  
+  cname: Alert Event Management
+  ops:
+    - name: "/alert-cur-events"
+      cname: View Current Alerts
+    - name: "/alert-cur-events/del"
+      cname: Delete Current Alert
+    - name: "/alert-his-events"
+      cname: View Historical Alerts
+
+- name: notification
+  cname: Alert Notification
+  ops:
+    - name: "/help/notification-settings"
+      cname: View Notification Settings
+    - name: "/help/notification-tpls"
+      cname: View Notification Templates
+
+- name: job
+  cname: Task Management
+  ops:
+    - name: "/job-tpls"
+      cname: View Task Templates
+    - name: "/job-tpls/add"
+      cname: Add Task Template
+    - name: "/job-tpls/put"
+      cname: Modify Task Template
+    - name: "/job-tpls/del"
+      cname: Delete Task Template
+    - name: "/job-tasks"
+      cname: View Task Instances
+    - name: "/job-tasks/add"
+      cname: Add Task Instance
+    - name: "/job-tasks/put"
+      cname: Modify Task Instance
+
+- name: targets
   cname: Infrastructure
   ops:
-    - name: /targets
-      cname: Host - View
-    - name: /targets/put
-      cname: Host - Modify
-    - name: /targets/del
-      cname: Host - Delete
-    - name: /targets/bind
-      cname: Host - Bind Uncategorized
+    - name: "/targets"
+      cname: View Objects
+    - name: "/targets/add"
+      cname: Add Object
+    - name: "/targets/put"
+      cname: Modify Object
+    - name: "/targets/del"
+      cname: Delete Object
+    - name: "/targets/bind"
+      cname: Bind Object
 
-- name: Explorer
-  cname: Explorer
+- name: user
+  cname: User Management
   ops:
-    - name: /metric/explorer
-      cname: Metrics Explorer
-    - name: /object/explorer
-      cname: Quick View
-    - name: /metrics-built-in
-      cname: Built-in Metric - View
-    - name: /builtin-metrics/add
-      cname: Built-in Metric - Add
-    - name: /builtin-metrics/put
-      cname: Built-in Metric - Modify
-    - name: /builtin-metrics/del
-      cname: Built-in Metric - Delete
-    - name: /recording-rules
-      cname: Recording Rule - View
-    - name: /recording-rules/add
-      cname: Recording Rule - Add
-    - name: /recording-rules/put
-      cname: Recording Rule - Modify
-    - name: /recording-rules/del
-      cname: Recording Rule - Delete
-    - name: /log/explorer
-      cname: Logs Explorer
-    - name: /log/index-patterns # 前端有个管理索引模式的页面，所以需要一个权限点来控制，后面应该改成侧拉板
-      cname: Index Pattern - View
-    - name: /log/index-patterns/add
-      cname: Index Pattern - Add
-    - name: /log/index-patterns/put
-      cname: Index Pattern - Modify
-    - name: /log/index-patterns/del
-      cname: Index Pattern - Delete
-    - name: /dashboards
-      cname: Dashboard - View
-    - name: /dashboards/add
-      cname: Dashboard - Add
-    - name: /dashboards/put
-      cname: Dashboard - Modify
-    - name: /dashboards/del
-      cname: Dashboard - Delete
-    - name: /public-dashboards
-      cname: Dashboard - View Public
+    - name: "/users"
+      cname: View User List
+    - name: "/user-groups"
+      cname: View User Groups
+    - name: "/user-groups/add"
+      cname: Add User Group
+    - name: "/user-groups/put"
+      cname: Modify User Group
+    - name: "/user-groups/del"
+      cname: Delete User Group
 
-- name: alerting
-  cname: Alerting
+- name: busi-groups
+  cname: Business Group Management
   ops:
-    - name: /alert-rules
-      cname: Alerting Rule - View
-    - name: /alert-rules/add
-      cname: Alerting Rule - Add
-    - name: /alert-rules/put
-      cname: Alerting Rule - Modify
-    - name: /alert-rules/del
-      cname: Alerting Rule - Delete
-    - name: /alert-mutes
-      cname: Mutting Rule - View
-    - name: /alert-mutes/add
-      cname: Mutting Rule - Add
-    - name: /alert-mutes/put
-      cname: Mutting Rule - Modify
-    - name: /alert-mutes/del
-      cname: Mutting Rule - Delete
-    - name: /alert-subscribes
-      cname: Subscribing Rule - View
-    - name: /alert-subscribes/add
-      cname: Subscribing Rule - Add
-    - name: /alert-subscribes/put
-      cname: Subscribing Rule - Modify
-    - name: /alert-subscribes/del
-      cname: Subscribing Rule - Delete
-    - name: /job-tpls
-      cname: Self-healing-Script - View
-    - name: /job-tpls/add
-      cname: Self-healing-Script - Add
-    - name: /job-tpls/put
-      cname: Self-healing-Script - Modify
-    - name: /job-tpls/del
-      cname: Self-healing-Script - Delete
-    - name: /job-tasks
-      cname: Self-healing-Job - View
-    - name: /job-tasks/add
-      cname: Self-healing-Job - Add
-    - name: /job-tasks/put
-      cname: Self-healing-Job - Modify
-    - name: /alert-cur-events
-      cname: Active Event - View
-    - name: /alert-cur-events/del
-      cname: Active Event - Delete
-    - name: /alert-his-events
-      cname: Historical Event - View
+    - name: "/busi-groups"
+      cname: View Business Groups
+    - name: "/busi-groups/add"
+      cname: Add Business Group
+    - name: "/busi-groups/put"
+      cname: Modify Business Group
+    - name: "/busi-groups/del"
+      cname: Delete Business Group
 
-- name: Notification
-  cname: Notification
+- name: permissions
+  cname: Permission Management
   ops:
-    - name: /notification-rules
-      cname: Notification Rule - View
-    - name: /notification-rules/add
-      cname: Notification Rule - Add
-    - name: /notification-rules/put
-      cname: Notification Rule - Modify
-    - name: /notification-rules/del
-      cname: Notification Rule - Delete
-    - name: /notification-channels
-      cname: Media Type - View
-    - name: /notification-channels/add
-      cname: Media Type - Add
-    - name: /notification-channels/put
-      cname: Media Type - Modify
-    - name: /notification-channels/del
-      cname: Media Type - Delete
-    - name: /notification-templates
-      cname: Message Template - View
-    - name: /notification-templates/add
-      cname: Message Template - Add
-    - name: /notification-templates/put
-      cname: Message Template - Modify
-    - name: /notification-templates/del
-      cname: Message Template - Delete
-    - name: /event-pipelines
-      cname: Event Pipeline - View
-    - name: /event-pipelines/add
-      cname: Event Pipeline - Add
-    - name: /event-pipelines/put
-      cname: Event Pipeline - Modify
-    - name: /event-pipelines/del
-      cname: Event Pipeline - Delete
-    - name: /help/notification-settings # 用于控制老版本的通知设置菜单是否展示
-      cname: Notification Settings - View
-    - name: /help/notification-tpls # 用于控制老版本的通知模板菜单是否展示
-      cname: Notification Templates - View
+    - name: "/permissions"
+      cname: View Permission Settings
+    
+- name: contacts
+  cname: User Contact Management
+  ops:
+    - name: "/contacts"
+      cname: User Contact Management
 
-- name: Integrations
-  cname: Integrations
+- name: built-in-components
+  cname: Template Center
   ops:
-    - name: /datasources # 用于控制能否看到数据源列表页面的菜单。只有 Admin 才能修改、删除数据源
-      cname: Data Source - View
-    - name: /components
-      cname: Component - View
-    - name: /components/add
-      cname: Component - Add
-    - name: /components/put
-      cname: Component - Modify
-    - name: /components/del
-      cname: Component - Delete
-    - name: /embedded-products
-      cname: Embedded Product - View
-    - name: /embedded-product/add
-      cname: Embedded Product - Add
-    - name: /embedded-product/put
-      cname: Embedded Product - Modify
-    - name: /embedded-product/delete
-      cname: Embedded Product - Delete
+    - name: "/built-in-components"
+      cname: View Built-in Components
+    - name: "/built-in-components/add"
+      cname: Add Built-in Component
+    - name: "/built-in-components/put"
+      cname: Modify Built-in Component
+    - name: "/built-in-components/del"
+      cname: Delete Built-in Component
 
-- name: Organization
-  cname: Organization
+- name: datasource
+  cname: Data Source Management
   ops:
-    - name: /users
-      cname: User - View
-    - name: /users/add
-      cname: User - Add
-    - name: /users/put
-      cname: User - Modify
-    - name: /users/del
-      cname: User - Delete
-    - name: /user-groups
-      cname: Team - View
-    - name: /user-groups/add
-      cname: Team - Add
-    - name: /user-groups/put
-      cname: Team - Modify
-    - name: /user-groups/del
-      cname: Team - Delete
-    - name: /busi-groups
-      cname: Business Group - View
-    - name: /busi-groups/add
-      cname: Business Group - Add
-    - name: /busi-groups/put
-      cname: Business Group - Modify
-    - name: /busi-groups/del
-      cname: Business Group - Delete
-    - name: /roles
-      cname: Role - View
-    - name: /roles/add
-      cname: Role - Add
-    - name: /roles/put
-      cname: Role - Modify
-    - name: /roles/del
-      cname: Role - Delete
+    - name: "/help/source"
+      cname: View Data Source Configuration
 
-- name: System Settings
-  cname: System Settings
+- name: system
+  cname: System Information
   ops:
-    - name: /system/site-settings # 仅用于控制能否展示菜单，只有 Admin 才能修改、删除
+    - name: "/help/variable-configs"
+      cname: View Variable Configuration
+    - name: "/help/version"
+      cname: View Version Information
+    - name: "/help/servers"
+      cname: View Server Information
+    - name: "/help/sso"
+      cname: View SSO Configuration
+    - name: "/site-settings"
       cname: View Site Settings
-    - name: /system/variable-settings
-      cname: View Variable Settings
-    - name: /system/sso-settings
-      cname: View SSO Settings
-    - name: /system/alerting-engines
-      cname: View Alerting Engines
-    - name: /system/version
-      cname: View Product Version
 
+- name: message-templates
+  cname: Message Templates
+  ops:
+    - name: "/notification-templates"
+      cname: View Message Templates
+    - name: "/notification-templates/add"
+      cname: Add Message Templates
+    - name: "/notification-templates/put"
+      cname: Modify Message Templates
+    - name: "/notification-templates/del"
+      cname: Delete Message Templates
+
+- name: notify-rules
+  cname: Notify Rules
+  ops:
+    - name: "/notification-rules"
+      cname: View Notify Rules
+    - name: "/notification-rules/add"
+      cname: Add Notify Rules
+    - name: "/notification-rules/put"
+      cname: Modify Notify Rules
+    - name: "/notification-rules/del"
+      cname: Delete Notify Rules
+
+- name: event-pipelines
+  cname: Event Pipelines
+  ops:
+    - name: "/event-pipelines"
+      cname: View Event Pipelines
+    - name: "/event-pipelines/add"
+      cname: Add Event Pipeline
+    - name: "/event-pipelines/put"
+      cname: Modify Event Pipeline
+    - name: "/event-pipelines/del"
+      cname: Delete Event Pipeline
+
+- name: notify-channels
+  cname: Notify Channels
+  ops:
+    - name: "/notification-channels"
+      cname: View Notify Channels
+    - name: "/notification-channels/add"
+      cname: Add Notify Channels
+    - name: "/notification-channels/put"
+      cname: Modify Notify Channels
+    - name: "/notification-channels/del"
+      cname: Delete Notify Channels
 `
 )

center/cconf/plugin.go

@@ -25,34 +25,4 @@ var Plugins = []Plugin{
 		Type:     "tdengine",
 		TypeName: "TDengine",
 	},
-	{
-		Id:       5,
-		Category: "logging",
-		Type:     "ck",
-		TypeName: "ClickHouse",
-	},
-	{
-		Id:       6,
-		Category: "timeseries",
-		Type:     "mysql",
-		TypeName: "MySQL",
-	},
-	{
-		Id:       7,
-		Category: "timeseries",
-		Type:     "pgsql",
-		TypeName: "PostgreSQL",
-	},
-	{
-		Id:       8,
-		Category: "logging",
-		Type:     "doris",
-		TypeName: "Doris",
-	},
-	{
-		Id:       9,
-		Category: "logging",
-		Type:     "opensearch",
-		TypeName: "OpenSearch",
-	},
 }

center/center.go

@@ -13,6 +13,7 @@ import (
 	alertrt "github.com/ccfos/nightingale/v6/alert/router"
 	"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/integration"
 	"github.com/ccfos/nightingale/v6/center/metas"
 	centerrt "github.com/ccfos/nightingale/v6/center/router"
@@ -59,6 +60,7 @@ func Initialize(configDir string, cryptoKey string) (func(), error) {
 	}
 
 	i18nx.Init(configDir)
+	cstats.Init()
 	flashduty.Init(config.Center.FlashDuty)
 
 	db, err := storage.New(config.DB)
@@ -84,7 +86,7 @@ func Initialize(configDir string, cryptoKey string) (func(), error) {
 	}
 
 	metas := metas.New(redis)
-	idents := idents.New(ctx, redis, config.Pushgw)
+	idents := idents.New(ctx, redis)
 
 	syncStats := memsto.NewSyncStats()
 	alertStats := astats.NewSyncStats()
@@ -92,9 +94,6 @@ func Initialize(configDir string, cryptoKey string) (func(), error) {
 	if config.Center.MigrateBusiGroupLabel || models.CanMigrateBg(ctx) {
 		models.MigrateBg(ctx, config.Pushgw.BusiGroupLabelKey)
 	}
-	if models.CanMigrateEP(ctx) {
-		models.MigrateEP(ctx)
-	}
 
 	configCache := memsto.NewConfigCache(ctx, syncStats, config.HTTP.RSA.RSAPrivateKey, config.HTTP.RSA.RSAPassWord)
 	busiGroupCache := memsto.NewBusiGroupCache(ctx, syncStats)

center/cstats/stats.go

@@ -6,49 +6,40 @@ import (
 	"github.com/prometheus/client_golang/prometheus"
 )
 
-const (
-	namespace = "n9e"
-	subsystem = "center"
-)
+const Service = "n9e-center"
 
 var (
-	uptime = prometheus.NewCounter(
+	labels = []string{"service", "code", "path", "method"}
+
+	uptime = prometheus.NewCounterVec(
 		prometheus.CounterOpts{
-			Namespace: namespace,
-			Subsystem: subsystem,
-			Name:      "uptime",
-			Help:      "HTTP service uptime.",
-		},
+			Name: "uptime",
+			Help: "HTTP service uptime.",
+		}, []string{"service"},
+	)
+
+	RequestCounter = prometheus.NewCounterVec(
+		prometheus.CounterOpts{
+			Name: "http_request_count_total",
+			Help: "Total number of HTTP requests made.",
+		}, labels,
 	)
 
 	RequestDuration = prometheus.NewHistogramVec(
 		prometheus.HistogramOpts{
-			Namespace: namespace,
-			Subsystem: subsystem,
-			Buckets:   prometheus.DefBuckets,
-			Name:      "http_request_duration_seconds",
-			Help:      "HTTP request latencies in seconds.",
-		}, []string{"code", "path", "method"},
-	)
-
-	RedisOperationLatency = prometheus.NewHistogramVec(
-		prometheus.HistogramOpts{
-			Namespace: namespace,
-			Subsystem: subsystem,
-			Name:      "redis_operation_latency_seconds",
-			Help:      "Histogram of latencies for Redis operations",
-			Buckets:   []float64{.005, .01, .025, .05, .1, .25, .5, 1, 2.5, 5},
-		},
-		[]string{"operation", "status"},
+			Buckets: []float64{.01, .1, 1, 10},
+			Name:    "http_request_duration_seconds",
+			Help:    "HTTP request latencies in seconds.",
+		}, labels,
 	)
 )
 
-func init() {
+func Init() {
 	// Register the summary and the histogram with Prometheus's default registry.
 	prometheus.MustRegister(
 		uptime,
+		RequestCounter,
 		RequestDuration,
-		RedisOperationLatency,
 	)
 
 	go recordUptime()
@@ -57,6 +48,6 @@ func init() {
 // recordUptime increases service uptime per second.
 func recordUptime() {
 	for range time.Tick(time.Second) {
-		uptime.Inc()
+		uptime.WithLabelValues(Service).Inc()
 	}
 }

center/integration/init.go

@@ -3,15 +3,11 @@ package integration
 import (
 	"encoding/json"
 	"path"
-	"sort"
 	"strings"
 	"time"
 
 	"github.com/ccfos/nightingale/v6/models"
 	"github.com/ccfos/nightingale/v6/pkg/ctx"
-
-	"github.com/pkg/errors"
-	"github.com/toolkits/pkg/container/set"
 	"github.com/toolkits/pkg/file"
 	"github.com/toolkits/pkg/logger"
 	"github.com/toolkits/pkg/runner"
@@ -19,18 +15,7 @@ import (
 
 const SYSTEM = "system"
 
-var BuiltinPayloadInFile *BuiltinPayloadInFileType
-
-type BuiltinPayloadInFileType struct {
-	Data      map[uint64]map[string]map[string][]*models.BuiltinPayload // map[componet_id]map[type]map[cate][]*models.BuiltinPayload
-	IndexData map[int64]*models.BuiltinPayload                          // map[uuid]payload
-
-	BuiltinMetrics map[string]*models.BuiltinMetric
-}
-
 func Init(ctx *ctx.Context, builtinIntegrationsDir string) {
-	BuiltinPayloadInFile = NewBuiltinPayloadInFileType()
-
 	err := models.InitBuiltinPayloads(ctx)
 	if err != nil {
 		logger.Warning("init old builtinPayloads fail ", err)
@@ -161,10 +146,11 @@ func Init(ctx *ctx.Context, builtinIntegrationsDir string) {
 				}
 
 				newAlerts := []models.AlertRule{}
+				writeAlertFileFlag := false
 				for _, alert := range alerts {
 					if alert.UUID == 0 {
-						time.Sleep(time.Microsecond)
-						alert.UUID = time.Now().UnixMicro()
+						writeAlertFileFlag = true
+						alert.UUID = time.Now().UnixNano()
 					}
 
 					newAlerts = append(newAlerts, alert)
@@ -183,13 +169,47 @@ func Init(ctx *ctx.Context, builtinIntegrationsDir string) {
 						Tags:        alert.AppendTags,
 						Content:     string(content),
 						UUID:        alert.UUID,
-						ID:          alert.UUID,
-						CreatedBy:   SYSTEM,
-						UpdatedBy:   SYSTEM,
 					}
-					BuiltinPayloadInFile.AddBuiltinPayload(&builtinAlert)
 
+					old, err := models.BuiltinPayloadGet(ctx, "uuid = ?", alert.UUID)
+					if err != nil {
+						logger.Warning("get builtin alert fail ", builtinAlert, err)
+						continue
+					}
+
+					if old == nil {
+						err := builtinAlert.Add(ctx, SYSTEM)
+						if err != nil {
+							logger.Warning("add builtin alert fail ", builtinAlert, err)
+						}
+						continue
+					}
+
+					if old.UpdatedBy == SYSTEM {
+						old.ComponentID = component.ID
+						old.Content = string(content)
+						old.Name = alert.Name
+						old.Tags = alert.AppendTags
+						err = models.DB(ctx).Model(old).Select("*").Updates(old).Error
+						if err != nil {
+							logger.Warningf("update builtin alert:%+v fail %v", builtinAlert, err)
+						}
+					}
 				}
+
+				if writeAlertFileFlag {
+					bs, err = json.MarshalIndent(newAlerts, "", "    ")
+					if err != nil {
+						logger.Warning("marshal builtin alerts fail ", newAlerts, err)
+						continue
+					}
+
+					_, err = file.WriteBytes(fp, bs)
+					if err != nil {
+						logger.Warning("write builtin alerts file fail ", f, err)
+					}
+				}
+
 			}
 		}
 
@@ -241,11 +261,32 @@ func Init(ctx *ctx.Context, builtinIntegrationsDir string) {
 					Tags:        dashboard.Tags,
 					Content:     string(content),
 					UUID:        dashboard.UUID,
-					ID:          dashboard.UUID,
-					CreatedBy:   SYSTEM,
-					UpdatedBy:   SYSTEM,
 				}
-				BuiltinPayloadInFile.AddBuiltinPayload(&builtinDashboard)
+
+				old, err := models.BuiltinPayloadGet(ctx, "uuid = ?", dashboard.UUID)
+				if err != nil {
+					logger.Warning("get builtin alert fail ", builtinDashboard, err)
+					continue
+				}
+
+				if old == nil {
+					err := builtinDashboard.Add(ctx, SYSTEM)
+					if err != nil {
+						logger.Warning("add builtin alert fail ", builtinDashboard, err)
+					}
+					continue
+				}
+
+				if old.UpdatedBy == SYSTEM {
+					old.ComponentID = component.ID
+					old.Content = string(content)
+					old.Name = dashboard.Name
+					old.Tags = dashboard.Tags
+					err = models.DB(ctx).Model(old).Select("*").Updates(old).Error
+					if err != nil {
+						logger.Warningf("update builtin alert:%+v fail %v", builtinDashboard, err)
+					}
+				}
 			}
 		} else if err != nil {
 			logger.Warningf("read builtin component dash dir fail %s %v", component.Ident, err)
@@ -263,23 +304,64 @@ func Init(ctx *ctx.Context, builtinIntegrationsDir string) {
 				}
 
 				metrics := []models.BuiltinMetric{}
+				newMetrics := []models.BuiltinMetric{}
 				err = json.Unmarshal(bs, &metrics)
 				if err != nil {
 					logger.Warning("parse builtin component metrics file fail", f, err)
 					continue
 				}
 
+				writeMetricFileFlag := false
 				for _, metric := range metrics {
 					if metric.UUID == 0 {
-						time.Sleep(time.Microsecond)
-						metric.UUID = time.Now().UnixMicro()
+						writeMetricFileFlag = true
+						metric.UUID = time.Now().UnixNano()
 					}
-					metric.ID = metric.UUID
-					metric.CreatedBy = SYSTEM
-					metric.UpdatedBy = SYSTEM
+					newMetrics = append(newMetrics, metric)
 
-					BuiltinPayloadInFile.BuiltinMetrics[metric.Expression] = &metric
+					old, err := models.BuiltinMetricGet(ctx, "uuid = ?", metric.UUID)
+					if err != nil {
+						logger.Warning("get builtin metrics fail ", metric, err)
+						continue
+					}
+
+					if old == nil {
+						err := metric.Add(ctx, SYSTEM)
+						if err != nil {
+							logger.Warning("add builtin metrics fail ", metric, err)
+						}
+						continue
+					}
+
+					if old.UpdatedBy == SYSTEM {
+						old.Collector = metric.Collector
+						old.Typ = metric.Typ
+						old.Name = metric.Name
+						old.Unit = metric.Unit
+						old.Note = metric.Note
+						old.Lang = metric.Lang
+						old.Expression = metric.Expression
+
+						err = models.DB(ctx).Model(old).Select("*").Updates(old).Error
+						if err != nil {
+							logger.Warningf("update builtin metric:%+v fail %v", metric, err)
+						}
+					}
 				}
+
+				if writeMetricFileFlag {
+					bs, err = json.MarshalIndent(newMetrics, "", "    ")
+					if err != nil {
+						logger.Warning("marshal builtin metrics fail ", newMetrics, err)
+						continue
+					}
+
+					_, err = file.WriteBytes(fp, bs)
+					if err != nil {
+						logger.Warning("write builtin metrics file fail ", f, err)
+					}
+				}
+
 			}
 		} else if err != nil {
 			logger.Warningf("read builtin component metrics dir fail %s %v", component.Ident, err)
@@ -305,322 +387,3 @@ type BuiltinBoard struct {
 	Hide       int         `json:"hide"`     // 0: false, 1: true
 	UUID       int64       `json:"uuid"`
 }
-
-func NewBuiltinPayloadInFileType() *BuiltinPayloadInFileType {
-	return &BuiltinPayloadInFileType{
-		Data:           make(map[uint64]map[string]map[string][]*models.BuiltinPayload),
-		IndexData:      make(map[int64]*models.BuiltinPayload),
-		BuiltinMetrics: make(map[string]*models.BuiltinMetric),
-	}
-}
-
-func (b *BuiltinPayloadInFileType) AddBuiltinPayload(bp *models.BuiltinPayload) {
-	if _, exists := b.Data[bp.ComponentID]; !exists {
-		b.Data[bp.ComponentID] = make(map[string]map[string][]*models.BuiltinPayload)
-	}
-	bpInType := b.Data[bp.ComponentID]
-	if _, exists := bpInType[bp.Type]; !exists {
-		bpInType[bp.Type] = make(map[string][]*models.BuiltinPayload)
-	}
-	bpInCate := bpInType[bp.Type]
-	if _, exists := bpInCate[bp.Cate]; !exists {
-		bpInCate[bp.Cate] = make([]*models.BuiltinPayload, 0)
-	}
-	bpInCate[bp.Cate] = append(bpInCate[bp.Cate], bp)
-
-	b.IndexData[bp.UUID] = bp
-}
-
-func (b *BuiltinPayloadInFileType) GetBuiltinPayload(typ, cate, query string, componentId uint64) ([]*models.BuiltinPayload, error) {
-
-	var result []*models.BuiltinPayload
-	source := b.Data[componentId]
-
-	if source == nil {
-		return nil, nil
-	}
-
-	typeMap, exists := source[typ]
-	if !exists {
-		return nil, nil
-	}
-
-	if cate != "" {
-		payloads, exists := typeMap[cate]
-		if !exists {
-			return nil, nil
-		}
-		result = append(result, filterByQuery(payloads, query)...)
-	} else {
-		for _, payloads := range typeMap {
-			result = append(result, filterByQuery(payloads, query)...)
-		}
-	}
-
-	if len(result) > 0 {
-		sort.Slice(result, func(i, j int) bool {
-			return result[i].Name < result[j].Name
-		})
-	}
-
-	return result, nil
-}
-
-func (b *BuiltinPayloadInFileType) GetBuiltinPayloadCates(typ string, componentId uint64) ([]string, error) {
-	var result []string
-	source := b.Data[componentId]
-	if source == nil {
-		return result, nil
-	}
-
-	typeData := source[typ]
-	if typeData == nil {
-		return result, nil
-	}
-	for cate := range typeData {
-		result = append(result, cate)
-	}
-
-	sort.Strings(result)
-	return result, nil
-}
-
-func filterByQuery(payloads []*models.BuiltinPayload, query string) []*models.BuiltinPayload {
-	if query == "" {
-		return payloads
-	}
-
-	queryLower := strings.ToLower(query)
-	var filtered []*models.BuiltinPayload
-	for _, p := range payloads {
-		if strings.Contains(strings.ToLower(p.Name), queryLower) || strings.Contains(strings.ToLower(p.Tags), queryLower) {
-			filtered = append(filtered, p)
-		}
-	}
-	return filtered
-}
-
-func (b *BuiltinPayloadInFileType) BuiltinMetricGets(metricsInDB []*models.BuiltinMetric, lang, collector, typ, query, unit string, limit, offset int) ([]*models.BuiltinMetric, int, error) {
-	var filteredMetrics []*models.BuiltinMetric
-	expressionSet := set.NewStringSet()
-	builtinMetricsByDB := convertBuiltinMetricByDB(metricsInDB)
-	builtinMetricsMap := make(map[string]*models.BuiltinMetric)
-
-	for expression, metric := range builtinMetricsByDB {
-		builtinMetricsMap[expression] = metric
-	}
-
-	for expression, metric := range b.BuiltinMetrics {
-		builtinMetricsMap[expression] = metric
-	}
-
-	for _, metric := range builtinMetricsMap {
-		if !applyFilter(metric, collector, typ, query, unit) {
-			continue
-		}
-
-		// Skip if expression is already in db cache
-		// NOTE: 忽略重复的expression，特别的，在旧版本中，用户可能已经创建了重复的metrics，需要覆盖掉ByFile中相同的Metrics
-		// NOTE: Ignore duplicate expressions, especially in the old version, users may have created duplicate metrics,
-		if expressionSet.Exists(metric.Expression) {
-			continue
-		}
-
-		// Add db expression in set.
-		expressionSet.Add(metric.Expression)
-
-		// Apply language
-		trans, err := getTranslationWithLanguage(metric, lang)
-		if err != nil {
-			logger.Errorf("Error getting translation for metric %s: %v", metric.Name, err)
-			continue // Skip if translation not found
-		}
-		metric.Name = trans.Name
-		metric.Note = trans.Note
-
-		filteredMetrics = append(filteredMetrics, metric)
-	}
-
-	// Sort metrics
-	sort.Slice(filteredMetrics, func(i, j int) bool {
-		if filteredMetrics[i].Collector != filteredMetrics[j].Collector {
-			return filteredMetrics[i].Collector < filteredMetrics[j].Collector
-		}
-		if filteredMetrics[i].Typ != filteredMetrics[j].Typ {
-			return filteredMetrics[i].Typ < filteredMetrics[j].Typ
-		}
-		return filteredMetrics[i].Expression < filteredMetrics[j].Expression
-	})
-
-	totalCount := len(filteredMetrics)
-
-	// Validate parameters
-	if offset < 0 {
-		offset = 0
-	}
-	if limit < 0 {
-		limit = 0
-	}
-
-	// Handle edge cases
-	if offset >= totalCount || limit == 0 {
-		return []*models.BuiltinMetric{}, totalCount, nil
-	}
-
-	// Apply pagination
-	end := offset + limit
-	if end > totalCount {
-		end = totalCount
-	}
-
-	return filteredMetrics[offset:end], totalCount, nil
-}
-
-func (b *BuiltinPayloadInFileType) BuiltinMetricTypes(lang, collector, query string) []string {
-	typeSet := set.NewStringSet()
-	for _, metric := range b.BuiltinMetrics {
-		if !applyFilter(metric, collector, "", query, "") {
-			continue
-		}
-
-		typeSet.Add(metric.Typ)
-	}
-
-	return typeSet.ToSlice()
-}
-
-func (b *BuiltinPayloadInFileType) BuiltinMetricCollectors(lang, typ, query string) []string {
-	collectorSet := set.NewStringSet()
-	for _, metric := range b.BuiltinMetrics {
-		if !applyFilter(metric, "", typ, query, "") {
-			continue
-		}
-
-		collectorSet.Add(metric.Collector)
-	}
-	return collectorSet.ToSlice()
-}
-
-func applyFilter(metric *models.BuiltinMetric, collector, typ, query, unit string) bool {
-	if collector != "" && collector != metric.Collector {
-		return false
-	}
-
-	if typ != "" && typ != metric.Typ {
-		return false
-	}
-
-	if unit != "" && !containsUnit(unit, metric.Unit) {
-		return false
-	}
-
-	if query != "" && !applyQueryFilter(metric, query) {
-		return false
-	}
-
-	return true
-}
-
-func containsUnit(unit, metricUnit string) bool {
-	us := strings.Split(unit, ",")
-	for _, u := range us {
-		if u == metricUnit {
-			return true
-		}
-	}
-	return false
-}
-
-func applyQueryFilter(metric *models.BuiltinMetric, query string) bool {
-	qs := strings.Split(query, " ")
-	for _, q := range qs {
-		if strings.HasPrefix(q, "-") {
-			q = strings.TrimPrefix(q, "-")
-			if strings.Contains(metric.Name, q) || strings.Contains(metric.Note, q) || strings.Contains(metric.Expression, q) {
-				return false
-			}
-		} else {
-			if !strings.Contains(metric.Name, q) && !strings.Contains(metric.Note, q) && !strings.Contains(metric.Expression, q) {
-				return false
-			}
-		}
-	}
-	return true
-}
-
-func getTranslationWithLanguage(bm *models.BuiltinMetric, lang string) (*models.Translation, error) {
-	var defaultTranslation *models.Translation
-	for _, t := range bm.Translation {
-		if t.Lang == lang {
-			return &t, nil
-		}
-
-		if t.Lang == "en_US" {
-			defaultTranslation = &t
-		}
-	}
-
-	if defaultTranslation != nil {
-		return defaultTranslation, nil
-	}
-
-	return nil, errors.Errorf("translation not found for metric %s", bm.Name)
-}
-
-func convertBuiltinMetricByDB(metricsInDB []*models.BuiltinMetric) map[string]*models.BuiltinMetric {
-	builtinMetricsByDB := make(map[string]*models.BuiltinMetric)
-	builtinMetricsByDBList := make(map[string][]*models.BuiltinMetric)
-
-	for _, metric := range metricsInDB {
-		builtinMetrics, ok := builtinMetricsByDBList[metric.Expression]
-		if !ok {
-			builtinMetrics = []*models.BuiltinMetric{}
-		}
-
-		builtinMetrics = append(builtinMetrics, metric)
-		builtinMetricsByDBList[metric.Expression] = builtinMetrics
-	}
-
-	for expression, builtinMetrics := range builtinMetricsByDBList {
-		if len(builtinMetrics) == 0 {
-			continue
-		}
-
-		// NOTE: 为兼容旧版本用户已经创建的 metrics，同时将修改 metrics 收敛到同一个记录上，
-		// 我们选择使用 expression 相同但是 id 最小的 metric 记录作为主要的 Metric。
-		sort.Slice(builtinMetrics, func(i, j int) bool {
-			return builtinMetrics[i].ID < builtinMetrics[j].ID
-		})
-
-		currentBuiltinMetric := builtinMetrics[0]
-		// User have no customed translation, so we can merge it
-		if len(currentBuiltinMetric.Translation) == 0 {
-			translationMap := make(map[string]models.Translation)
-			for _, bm := range builtinMetrics {
-				for _, t := range getDefaultTranslation(bm) {
-					translationMap[t.Lang] = t
-				}
-			}
-			currentBuiltinMetric.Translation = make([]models.Translation, 0, len(translationMap))
-			for _, t := range translationMap {
-				currentBuiltinMetric.Translation = append(currentBuiltinMetric.Translation, t)
-			}
-		}
-
-		builtinMetricsByDB[expression] = currentBuiltinMetric
-	}
-
-	return builtinMetricsByDB
-}
-
-func getDefaultTranslation(bm *models.BuiltinMetric) []models.Translation {
-	if len(bm.Translation) != 0 {
-		return bm.Translation
-	}
-
-	return []models.Translation{{
-		Lang: bm.Lang,
-		Name: bm.Name,
-		Note: bm.Note,
-	}}
-}

center/metas/metas.go

@@ -6,7 +6,6 @@ import (
 	"sync"
 	"time"
 
-	"github.com/ccfos/nightingale/v6/center/cstats"
 	"github.com/ccfos/nightingale/v6/models"
 	"github.com/ccfos/nightingale/v6/storage"
 
@@ -116,23 +115,15 @@ func (s *Set) updateTargets(m map[string]models.HostMeta) error {
 		}
 		newMap[models.WrapIdent(ident)] = meta
 	}
-
-	start := time.Now()
 	err := storage.MSet(context.Background(), s.redis, newMap)
 	if err != nil {
-		cstats.RedisOperationLatency.WithLabelValues("mset_target_meta", "fail").Observe(time.Since(start).Seconds())
 		return err
-	} else {
-		cstats.RedisOperationLatency.WithLabelValues("mset_target_meta", "success").Observe(time.Since(start).Seconds())
 	}
 
 	if len(extendMap) > 0 {
 		err = storage.MSet(context.Background(), s.redis, extendMap)
 		if err != nil {
-			cstats.RedisOperationLatency.WithLabelValues("mset_target_extend", "fail").Observe(time.Since(start).Seconds())
 			return err
-		} else {
-			cstats.RedisOperationLatency.WithLabelValues("mset_target_extend", "success").Observe(time.Since(start).Seconds())
 		}
 	}
 

center/router/router.go

@@ -93,9 +93,10 @@ func stat() gin.HandlerFunc {
 
 		code := fmt.Sprintf("%d", c.Writer.Status())
 		method := c.Request.Method
-		labels := []string{code, c.FullPath(), method}
+		labels := []string{cstats.Service, code, c.FullPath(), method}
 
-		cstats.RequestDuration.WithLabelValues(labels...).Observe(time.Since(start).Seconds())
+		cstats.RequestCounter.WithLabelValues(labels...).Inc()
+		cstats.RequestDuration.WithLabelValues(labels...).Observe(float64(time.Since(start).Seconds()))
 	}
 }
 
@@ -177,7 +178,6 @@ func (rt *Router) Config(r *gin.Engine) {
 	pages := r.Group(pagesPrefix)
 	{
 
-		pages.DELETE("/datasource/series", rt.auth(), rt.admin(), rt.deleteDatasourceSeries)
 		if rt.Center.AnonymousAccess.PromQuerier {
 			pages.Any("/proxy/:id/*url", rt.dsProxy)
 			pages.POST("/query-range-batch", rt.promBatchQueryRange)
@@ -232,11 +232,6 @@ func (rt *Router) Config(r *gin.Engine) {
 			pages.POST("/log-query", rt.QueryLog)
 		}
 
-		// OpenSearch 专用接口
-		pages.POST("/os-indices", rt.QueryOSIndices)
-		pages.POST("/os-variable", rt.QueryOSVariable)
-		pages.POST("/os-fields", rt.QueryOSFields)
-
 		pages.GET("/sql-template", rt.QuerySqlTemplate)
 		pages.POST("/auth/login", rt.jwtMock(), rt.loginPost)
 		pages.POST("/auth/logout", rt.jwtMock(), rt.auth(), rt.user(), rt.logoutPost)
@@ -260,7 +255,6 @@ func (rt *Router) Config(r *gin.Engine) {
 
 		pages.GET("/notify-channels", rt.notifyChannelsGets)
 		pages.GET("/contact-keys", rt.contactKeysGets)
-		pages.GET("/install-date", rt.installDateGet)
 
 		pages.GET("/self/perms", rt.auth(), rt.user(), rt.permsGets)
 		pages.GET("/self/profile", rt.auth(), rt.user(), rt.selfProfileGet)
@@ -271,11 +265,11 @@ func (rt *Router) Config(r *gin.Engine) {
 		pages.DELETE("/self/token/:id", rt.auth(), rt.user(), rt.deleteToken)
 
 		pages.GET("/users", rt.auth(), rt.user(), rt.perm("/users"), rt.userGets)
-		pages.POST("/users", rt.auth(), rt.user(), rt.perm("/users/add"), rt.userAddPost)
+		pages.POST("/users", rt.auth(), rt.admin(), rt.userAddPost)
 		pages.GET("/user/:id/profile", rt.auth(), rt.userProfileGet)
-		pages.PUT("/user/:id/profile", rt.auth(), rt.user(), rt.perm("/users/put"), rt.userProfilePut)
-		pages.PUT("/user/:id/password", rt.auth(), rt.user(), rt.perm("/users/put"), rt.userPasswordPut)
-		pages.DELETE("/user/:id", rt.auth(), rt.user(), rt.perm("/users/del"), rt.userDel)
+		pages.PUT("/user/:id/profile", rt.auth(), rt.admin(), rt.userProfilePut)
+		pages.PUT("/user/:id/password", rt.auth(), rt.admin(), rt.userPasswordPut)
+		pages.DELETE("/user/:id", rt.auth(), rt.admin(), rt.userDel)
 
 		pages.GET("/metric-views", rt.auth(), rt.metricViewGets)
 		pages.DELETE("/metric-views", rt.auth(), rt.user(), rt.metricViewDel)
@@ -316,7 +310,6 @@ func (rt *Router) Config(r *gin.Engine) {
 		pages.GET("/busi-groups/tags", rt.auth(), rt.user(), rt.busiGroupsGetTags)
 
 		pages.GET("/targets", rt.auth(), rt.user(), rt.targetGets)
-		pages.POST("/target-update", rt.auth(), rt.targetUpdate)
 		pages.GET("/target/extra-meta", rt.auth(), rt.user(), rt.targetExtendInfoByIdent)
 		pages.POST("/target/list", rt.auth(), rt.user(), rt.targetGetsByHostFilter)
 		pages.DELETE("/targets", rt.auth(), rt.user(), rt.perm("/targets/del"), rt.targetDel)
@@ -380,8 +373,6 @@ func (rt *Router) Config(r *gin.Engine) {
 		pages.POST("/relabel-test", rt.auth(), rt.user(), rt.relabelTest)
 		pages.POST("/busi-group/:id/alert-rules/clone", rt.auth(), rt.user(), rt.perm("/alert-rules/add"), rt.bgrw(), rt.cloneToMachine)
 		pages.POST("/busi-groups/alert-rules/clones", rt.auth(), rt.user(), rt.perm("/alert-rules/add"), rt.batchAlertRuleClone)
-		pages.POST("/busi-group/alert-rules/notify-tryrun", rt.auth(), rt.user(), rt.perm("/alert-rules/add"), rt.alertRuleNotifyTryRun)
-		pages.POST("/busi-group/alert-rules/enable-tryrun", rt.auth(), rt.user(), rt.perm("/alert-rules/add"), rt.alertRuleEnableTryRun)
 
 		pages.GET("/busi-groups/recording-rules", rt.auth(), rt.user(), rt.perm("/recording-rules"), rt.recordingRuleGetsByGids)
 		pages.GET("/busi-group/:id/recording-rules", rt.auth(), rt.user(), rt.perm("/recording-rules"), rt.recordingRuleGets)
@@ -399,7 +390,6 @@ func (rt *Router) Config(r *gin.Engine) {
 		pages.PUT("/busi-group/:id/alert-mute/:amid", rt.auth(), rt.user(), rt.perm("/alert-mutes/put"), rt.alertMutePutByFE)
 		pages.GET("/busi-group/:id/alert-mute/:amid", rt.auth(), rt.user(), rt.perm("/alert-mutes"), rt.alertMuteGet)
 		pages.PUT("/busi-group/:id/alert-mutes/fields", rt.auth(), rt.user(), rt.perm("/alert-mutes/put"), rt.bgrw(), rt.alertMutePutFields)
-		pages.POST("/alert-mute-tryrun", rt.auth(), rt.user(), rt.perm("/alert-mutes/add"), rt.alertMuteTryRun)
 
 		pages.GET("/busi-groups/alert-subscribes", rt.auth(), rt.user(), rt.perm("/alert-subscribes"), rt.alertSubscribeGetsByGids)
 		pages.GET("/busi-group/:id/alert-subscribes", rt.auth(), rt.user(), rt.perm("/alert-subscribes"), rt.bgro(), rt.alertSubscribeGets)
@@ -407,18 +397,22 @@ func (rt *Router) Config(r *gin.Engine) {
 		pages.POST("/busi-group/:id/alert-subscribes", rt.auth(), rt.user(), rt.perm("/alert-subscribes/add"), rt.bgrw(), rt.alertSubscribeAdd)
 		pages.PUT("/busi-group/:id/alert-subscribes", rt.auth(), rt.user(), rt.perm("/alert-subscribes/put"), rt.bgrw(), rt.alertSubscribePut)
 		pages.DELETE("/busi-group/:id/alert-subscribes", rt.auth(), rt.user(), rt.perm("/alert-subscribes/del"), rt.bgrw(), rt.alertSubscribeDel)
-		pages.POST("/alert-subscribe/alert-subscribes-tryrun", rt.auth(), rt.user(), rt.perm("/alert-subscribes/add"), rt.alertSubscribeTryRun)
 
-		pages.GET("/alert-cur-event/:eid", rt.alertCurEventGet)
-		pages.GET("/alert-his-event/:eid", rt.alertHisEventGet)
-		pages.GET("/event-notify-records/:eid", rt.notificationRecordList)
+		if rt.Center.AnonymousAccess.AlertDetail {
+			pages.GET("/alert-cur-event/:eid", rt.alertCurEventGet)
+			pages.GET("/alert-his-event/:eid", rt.alertHisEventGet)
+			pages.GET("/event-notify-records/:eid", rt.notificationRecordList)
+		} else {
+			pages.GET("/alert-cur-event/:eid", rt.auth(), rt.user(), rt.alertCurEventGet)
+			pages.GET("/alert-his-event/:eid", rt.auth(), rt.user(), rt.alertHisEventGet)
+			pages.GET("/event-notify-records/:eid", rt.auth(), rt.user(), rt.notificationRecordList)
+		}
 
 		// card logic
 		pages.GET("/alert-cur-events/list", rt.auth(), rt.user(), rt.alertCurEventsList)
 		pages.GET("/alert-cur-events/card", rt.auth(), rt.user(), rt.alertCurEventsCard)
 		pages.POST("/alert-cur-events/card/details", rt.auth(), rt.alertCurEventsCardDetails)
 		pages.GET("/alert-his-events/list", rt.auth(), rt.user(), rt.alertHisEventsList)
-		pages.DELETE("/alert-his-events", rt.auth(), rt.admin(), rt.alertHisEventsDelete)
 		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)
 
@@ -450,13 +444,13 @@ func (rt *Router) Config(r *gin.Engine) {
 		pages.POST("/datasource/status/update", rt.auth(), rt.admin(), rt.datasourceUpdataStatus)
 		pages.DELETE("/datasource/", rt.auth(), rt.admin(), rt.datasourceDel)
 
-		pages.GET("/roles", rt.auth(), rt.user(), rt.roleGets)
-		pages.POST("/roles", rt.auth(), rt.user(), rt.perm("/roles/add"), rt.roleAdd)
-		pages.PUT("/roles", rt.auth(), rt.user(), rt.perm("/roles/put"), rt.rolePut)
-		pages.DELETE("/role/:id", rt.auth(), rt.user(), rt.perm("/roles/del"), rt.roleDel)
+		pages.GET("/roles", rt.auth(), rt.admin(), rt.roleGets)
+		pages.POST("/roles", rt.auth(), rt.admin(), rt.roleAdd)
+		pages.PUT("/roles", rt.auth(), rt.admin(), rt.rolePut)
+		pages.DELETE("/role/:id", rt.auth(), rt.admin(), rt.roleDel)
 
-		pages.GET("/role/:id/ops", rt.auth(), rt.user(), rt.perm("/roles"), rt.operationOfRole)
-		pages.PUT("/role/:id/ops", rt.auth(), rt.user(), rt.perm("/roles/put"), rt.roleBindOperation)
+		pages.GET("/role/:id/ops", rt.auth(), rt.admin(), rt.operationOfRole)
+		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.notifyTplGets)
@@ -478,7 +472,7 @@ func (rt *Router) Config(r *gin.Engine) {
 		pages.GET("/notify-channel", rt.auth(), rt.user(), rt.perm("/help/notification-settings"), rt.notifyChannelGets)
 		pages.PUT("/notify-channel", rt.auth(), rt.admin(), rt.notifyChannelPuts)
 
-		pages.GET("/notify-contact", rt.auth(), rt.user(), rt.notifyContactGets)
+		pages.GET("/notify-contact", rt.auth(), rt.user(), rt.perm("/help/notification-settings"), 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)
@@ -494,13 +488,6 @@ func (rt *Router) Config(r *gin.Engine) {
 		pages.GET("/embedded-dashboards", rt.auth(), rt.user(), rt.perm("/embedded-dashboards"), rt.embeddedDashboardsGet)
 		pages.PUT("/embedded-dashboards", rt.auth(), rt.user(), rt.perm("/embedded-dashboards/put"), rt.embeddedDashboardsPut)
 
-		// 获取 embedded-product 列表
-		pages.GET("/embedded-product", rt.auth(), rt.user(), rt.embeddedProductGets)
-		pages.GET("/embedded-product/:id", rt.auth(), rt.user(), rt.embeddedProductGet)
-		pages.POST("/embedded-product", rt.auth(), rt.user(), rt.perm("/embedded-product/add"), rt.embeddedProductAdd)
-		pages.PUT("/embedded-product/:id", rt.auth(), rt.user(), rt.perm("/embedded-product/put"), rt.embeddedProductPut)
-		pages.DELETE("/embedded-product/:id", rt.auth(), rt.user(), rt.perm("/embedded-product/delete"), rt.embeddedProductDelete)
-
 		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)
@@ -510,23 +497,21 @@ func (rt *Router) Config(r *gin.Engine) {
 		pages.PUT("/config", rt.auth(), rt.admin(), rt.configPutByKey)
 		pages.GET("/site-info", rt.siteInfo)
 
-		// source token 相关路由
-		pages.POST("/source-token", rt.auth(), rt.user(), rt.sourceTokenAdd)
-
 		// for admin api
 		pages.GET("/user/busi-groups", rt.auth(), rt.admin(), rt.userBusiGroupsGets)
 
 		pages.GET("/builtin-components", rt.auth(), rt.user(), rt.builtinComponentsGets)
-		pages.POST("/builtin-components", rt.auth(), rt.user(), rt.perm("/components/add"), rt.builtinComponentsAdd)
-		pages.PUT("/builtin-components", rt.auth(), rt.user(), rt.perm("/components/put"), rt.builtinComponentsPut)
-		pages.DELETE("/builtin-components", rt.auth(), rt.user(), rt.perm("/components/del"), rt.builtinComponentsDel)
+		pages.POST("/builtin-components", rt.auth(), rt.user(), rt.perm("/built-in-components/add"), rt.builtinComponentsAdd)
+		pages.PUT("/builtin-components", rt.auth(), rt.user(), rt.perm("/built-in-components/put"), rt.builtinComponentsPut)
+		pages.DELETE("/builtin-components", rt.auth(), rt.user(), rt.perm("/built-in-components/del"), rt.builtinComponentsDel)
 
 		pages.GET("/builtin-payloads", rt.auth(), rt.user(), rt.builtinPayloadsGets)
 		pages.GET("/builtin-payloads/cates", rt.auth(), rt.user(), rt.builtinPayloadcatesGet)
-		pages.POST("/builtin-payloads", rt.auth(), rt.user(), rt.perm("/components/add"), rt.builtinPayloadsAdd)
-		pages.PUT("/builtin-payloads", rt.auth(), rt.user(), rt.perm("/components/put"), rt.builtinPayloadsPut)
-		pages.DELETE("/builtin-payloads", rt.auth(), rt.user(), rt.perm("/components/del"), rt.builtinPayloadsDel)
-		pages.GET("/builtin-payload", rt.auth(), rt.user(), rt.builtinPayloadsGetByUUID)
+		pages.POST("/builtin-payloads", rt.auth(), rt.user(), rt.perm("/built-in-components/add"), rt.builtinPayloadsAdd)
+		pages.GET("/builtin-payload/:id", rt.auth(), rt.user(), rt.perm("/built-in-components"), rt.builtinPayloadGet)
+		pages.PUT("/builtin-payloads", rt.auth(), rt.user(), rt.perm("/built-in-components/put"), rt.builtinPayloadsPut)
+		pages.DELETE("/builtin-payloads", rt.auth(), rt.user(), rt.perm("/built-in-components/del"), rt.builtinPayloadsDel)
+		pages.GET("/builtin-payload", rt.auth(), rt.user(), rt.builtinPayloadsGetByUUIDOrID)
 
 		pages.POST("/message-templates", rt.auth(), rt.user(), rt.perm("/notification-templates/add"), rt.messageTemplatesAdd)
 		pages.DELETE("/message-templates", rt.auth(), rt.user(), rt.perm("/notification-templates/del"), rt.messageTemplatesDel)
@@ -544,9 +529,6 @@ func (rt *Router) Config(r *gin.Engine) {
 		pages.GET("/notify-rule/custom-params", rt.auth(), rt.user(), rt.perm("/notification-rules"), rt.notifyRuleCustomParamsGet)
 		pages.POST("/notify-rule/event-pipelines-tryrun", rt.auth(), rt.user(), rt.perm("/notification-rules/add"), rt.tryRunEventProcessorByNotifyRule)
 
-		pages.GET("/event-tagkeys", rt.auth(), rt.user(), rt.eventTagKeys)
-		pages.GET("/event-tagvalues", rt.auth(), rt.user(), rt.eventTagValues)
-
 		// 事件Pipeline相关路由
 		pages.GET("/event-pipelines", rt.auth(), rt.user(), rt.perm("/event-pipelines"), rt.eventPipelinesList)
 		pages.POST("/event-pipeline", rt.auth(), rt.user(), rt.perm("/event-pipelines/add"), rt.addEventPipeline)
@@ -676,10 +658,6 @@ func (rt *Router) Config(r *gin.Engine) {
 			service.GET("/message-templates", rt.messageTemplateGets)
 
 			service.GET("/event-pipelines", rt.eventPipelinesListByService)
-
-			// 手机号加密存储配置接口
-			service.POST("/users/phone/encrypt", rt.usersPhoneEncrypt)
-			service.POST("/users/phone/decrypt", rt.usersPhoneDecrypt)
 		}
 	}
 

center/router/router_alert_cur_event.go

@@ -1,55 +1,50 @@
 package router
 
 import (
-	"fmt"
 	"net/http"
 	"sort"
 	"strings"
 	"time"
 
 	"github.com/ccfos/nightingale/v6/models"
-	"github.com/ccfos/nightingale/v6/pkg/ctx"
-	"github.com/ccfos/nightingale/v6/pkg/strx"
 
 	"github.com/gin-gonic/gin"
 	"github.com/toolkits/pkg/ginx"
-	"github.com/toolkits/pkg/logger"
 )
 
-func getUserGroupIds(ctx *gin.Context, rt *Router, myGroups bool) ([]int64, error) {
-	if !myGroups {
-		return nil, nil
+func parseAggrRules(c *gin.Context) []*models.AggrRule {
+	aggrRules := strings.Split(ginx.QueryStr(c, "rule", ""), "::") // e.g. field:group_name::field:severity::tagkey:ident
+
+	if len(aggrRules) == 0 {
+		ginx.Bomb(http.StatusBadRequest, "rule empty")
 	}
-	me := ctx.MustGet("user").(*models.User)
-	return models.MyGroupIds(rt.Ctx, me.Id)
+
+	rules := make([]*models.AggrRule, len(aggrRules))
+	for i := 0; i < len(aggrRules); i++ {
+		pair := strings.Split(aggrRules[i], ":")
+		if len(pair) != 2 {
+			ginx.Bomb(http.StatusBadRequest, "rule invalid")
+		}
+
+		if !(pair[0] == "field" || pair[0] == "tagkey") {
+			ginx.Bomb(http.StatusBadRequest, "rule invalid")
+		}
+
+		rules[i] = &models.AggrRule{
+			Type:  pair[0],
+			Value: pair[1],
+		}
+	}
+
+	return rules
 }
 
 func (rt *Router) alertCurEventsCard(c *gin.Context) {
 	stime, etime := getTimeRange(c)
-	severity := strx.IdsInt64ForAPI(ginx.QueryStr(c, "severity", ""), ",")
+	severity := ginx.QueryInt(c, "severity", -1)
 	query := ginx.QueryStr(c, "query", "")
-	myGroups := ginx.QueryBool(c, "my_groups", false) // 是否只看自己组，默认false
-
-	var gids []int64
-	var err error
-	if myGroups {
-		gids, err = getUserGroupIds(c, rt, myGroups)
-		ginx.Dangerous(err)
-		if len(gids) == 0 {
-			gids = append(gids, -1)
-		}
-	}
-
-	viewId := ginx.QueryInt64(c, "view_id")
-
-	alertView, err := models.GetAlertAggrViewByViewID(rt.Ctx, viewId)
-	ginx.Dangerous(err)
-
-	if alertView == nil {
-		ginx.Bomb(http.StatusNotFound, "alert aggr view not found")
-	}
-
 	dsIds := queryDatasourceIds(c)
+	rules := parseAggrRules(c)
 
 	prod := ginx.QueryStr(c, "prods", "")
 	if prod == "" {
@@ -66,18 +61,17 @@ func (rt *Router) alertCurEventsCard(c *gin.Context) {
 		cates = strings.Split(cate, ",")
 	}
 
-	bgids, err := GetBusinessGroupIds(c, rt.Ctx, rt.Center.EventHistoryGroupView, myGroups)
+	bgids, err := GetBusinessGroupIds(c, rt.Ctx, rt.Center.EventHistoryGroupView)
 	ginx.Dangerous(err)
 
 	// 最多获取50000个，获取太多也没啥意义
 	list, err := models.AlertCurEventsGet(rt.Ctx, prods, bgids, stime, etime, severity, dsIds,
-		cates, 0, query, 50000, 0, []int64{})
+		cates, 0, query, 50000, 0)
 	ginx.Dangerous(err)
 
 	cardmap := make(map[string]*AlertCard)
 	for _, event := range list {
-		title, err := event.GenCardTitle(alertView.Rule)
-		ginx.Dangerous(err)
+		title := event.GenCardTitle(rules)
 		if _, has := cardmap[title]; has {
 			cardmap[title].Total++
 			cardmap[title].EventIds = append(cardmap[title].EventIds, event.Id)
@@ -92,10 +86,6 @@ func (rt *Router) alertCurEventsCard(c *gin.Context) {
 				Severity: event.Severity,
 			}
 		}
-
-		if cardmap[title].Severity < 1 {
-			cardmap[title].Severity = 3
-		}
 	}
 
 	titles := make([]string, 0, len(cardmap))
@@ -152,15 +142,11 @@ func (rt *Router) alertCurEventsGetByRid(c *gin.Context) {
 // 列表方式，拉取活跃告警
 func (rt *Router) alertCurEventsList(c *gin.Context) {
 	stime, etime := getTimeRange(c)
-	severity := strx.IdsInt64ForAPI(ginx.QueryStr(c, "severity", ""), ",")
+	severity := ginx.QueryInt(c, "severity", -1)
 	query := ginx.QueryStr(c, "query", "")
 	limit := ginx.QueryInt(c, "limit", 20)
-	myGroups := ginx.QueryBool(c, "my_groups", false) // 是否只看自己组，默认false
-
 	dsIds := queryDatasourceIds(c)
 
-	eventIds := strx.IdsInt64ForAPI(ginx.QueryStr(c, "event_ids", ""), ",")
-
 	prod := ginx.QueryStr(c, "prods", "")
 	if prod == "" {
 		prod = ginx.QueryStr(c, "rule_prods", "")
@@ -179,19 +165,18 @@ func (rt *Router) alertCurEventsList(c *gin.Context) {
 
 	ruleId := ginx.QueryInt64(c, "rid", 0)
 
-	bgids, err := GetBusinessGroupIds(c, rt.Ctx, rt.Center.EventHistoryGroupView, myGroups)
+	bgids, err := GetBusinessGroupIds(c, rt.Ctx, rt.Center.EventHistoryGroupView)
 	ginx.Dangerous(err)
 
 	total, err := models.AlertCurEventTotal(rt.Ctx, prods, bgids, stime, etime, severity, dsIds,
-		cates, ruleId, query, eventIds)
+		cates, ruleId, query)
 	ginx.Dangerous(err)
 
 	list, err := models.AlertCurEventsGet(rt.Ctx, prods, bgids, stime, etime, severity, dsIds,
-		cates, ruleId, query, limit, ginx.Offset(c, limit), eventIds)
+		cates, ruleId, query, limit, ginx.Offset(c, limit))
 	ginx.Dangerous(err)
 
 	cache := make(map[int64]*models.UserGroup)
-
 	for i := 0; i < len(list); i++ {
 		list[i].FillNotifyGroups(rt.Ctx, cache)
 	}
@@ -233,68 +218,24 @@ func (rt *Router) checkCurEventBusiGroupRWPermission(c *gin.Context, ids []int64
 
 func (rt *Router) alertCurEventGet(c *gin.Context) {
 	eid := ginx.UrlParamInt64(c, "eid")
-	event, err := GetCurEventDetail(rt.Ctx, eid)
+	event, err := models.AlertCurEventGetById(rt.Ctx, eid)
+	ginx.Dangerous(err)
 
-	hasPermission := HasPermission(rt.Ctx, c, "event", fmt.Sprintf("%d", eid), rt.Center.AnonymousAccess.AlertDetail)
-	if !hasPermission {
-		rt.auth()(c)
-		rt.user()(c)
+	if event == nil {
+		ginx.Bomb(404, "No such active event")
+	}
+
+	if !rt.Center.AnonymousAccess.AlertDetail && rt.Center.EventHistoryGroupView {
 		rt.bgroCheck(c, event.GroupId)
 	}
 
-	ginx.NewRender(c).Data(event, err)
-}
-
-func GetCurEventDetail(ctx *ctx.Context, eid int64) (*models.AlertCurEvent, error) {
-	event, err := models.AlertCurEventGetById(ctx, eid)
-	if err != nil {
-		return nil, err
-	}
-
-	if event == nil {
-		return nil, fmt.Errorf("no such active event")
-	}
-
-	ruleConfig, needReset := models.FillRuleConfigTplName(ctx, event.RuleConfig)
+	ruleConfig, needReset := models.FillRuleConfigTplName(rt.Ctx, event.RuleConfig)
 	if needReset {
 		event.RuleConfigJson = ruleConfig
 	}
 
 	event.LastEvalTime = event.TriggerTime
-	event.NotifyVersion, err = GetEventNotifyVersion(ctx, event.RuleId, event.NotifyRuleIds)
-	ginx.Dangerous(err)
-
-	event.NotifyRules, err = GetEventNorifyRuleNames(ctx, event.NotifyRuleIds)
-	return event, err
-}
-
-func GetEventNorifyRuleNames(ctx *ctx.Context, notifyRuleIds []int64) ([]*models.EventNotifyRule, error) {
-	notifyRuleNames := make([]*models.EventNotifyRule, 0)
-	notifyRules, err := models.NotifyRulesGet(ctx, "id in ?", notifyRuleIds)
-	if err != nil {
-		return nil, err
-	}
-
-	for _, notifyRule := range notifyRules {
-		notifyRuleNames = append(notifyRuleNames, &models.EventNotifyRule{
-			Id:   notifyRule.ID,
-			Name: notifyRule.Name,
-		})
-	}
-	return notifyRuleNames, nil
-}
-
-func GetEventNotifyVersion(ctx *ctx.Context, ruleId int64, notifyRuleIds []int64) (int, error) {
-	if len(notifyRuleIds) != 0 {
-		// 如果存在 notify_rule_ids，则认为使用新的告警通知方式
-		return 1, nil
-	}
-
-	rule, err := models.AlertRuleGetById(ctx, ruleId)
-	if err != nil {
-		return 0, err
-	}
-	return rule.NotifyVersion, nil
+	ginx.NewRender(c).Data(event, nil)
 }
 
 func (rt *Router) alertCurEventsStatistics(c *gin.Context) {
@@ -306,123 +247,3 @@ func (rt *Router) alertCurEventDelByHash(c *gin.Context) {
 	hash := ginx.QueryStr(c, "hash")
 	ginx.NewRender(c).Message(models.AlertCurEventDelByHash(rt.Ctx, hash))
 }
-
-func (rt *Router) eventTagKeys(c *gin.Context) {
-	// 获取最近1天的活跃告警事件
-	now := time.Now().Unix()
-	stime := now - 24*3600
-	etime := now
-
-	// 获取用户可见的业务组ID列表
-	bgids, err := GetBusinessGroupIds(c, rt.Ctx, rt.Center.EventHistoryGroupView, false)
-	if err != nil {
-		logger.Warningf("failed to get business group ids: %v", err)
-		ginx.NewRender(c).Data([]string{"ident", "app", "service", "instance"}, nil)
-		return
-	}
-
-	// 查询活跃告警事件，限制数量以提高性能
-	events, err := models.AlertCurEventsGet(rt.Ctx, []string{}, bgids, stime, etime, []int64{}, []int64{}, []string{}, 0, "", 200, 0, []int64{})
-	if err != nil {
-		logger.Warningf("failed to get current alert events: %v", err)
-		ginx.NewRender(c).Data([]string{"ident", "app", "service", "instance"}, nil)
-		return
-	}
-
-	// 如果没有查到事件，返回默认标签
-	if len(events) == 0 {
-		ginx.NewRender(c).Data([]string{"ident", "app", "service", "instance"}, nil)
-		return
-	}
-
-	// 收集所有标签键并去重
-	tagKeys := make(map[string]struct{})
-	for _, event := range events {
-		for key := range event.TagsMap {
-			tagKeys[key] = struct{}{}
-		}
-	}
-
-	// 转换为字符串切片
-	var result []string
-	for key := range tagKeys {
-		result = append(result, key)
-	}
-
-	// 如果没有收集到任何标签键，返回默认值
-	if len(result) == 0 {
-		result = []string{"ident", "app", "service", "instance"}
-	}
-
-	ginx.NewRender(c).Data(result, nil)
-}
-
-func (rt *Router) eventTagValues(c *gin.Context) {
-	// 获取标签key
-	tagKey := ginx.QueryStr(c, "key")
-
-	// 获取最近1天的活跃告警事件
-	now := time.Now().Unix()
-	stime := now - 24*3600
-	etime := now
-
-	// 获取用户可见的业务组ID列表
-	bgids, err := GetBusinessGroupIds(c, rt.Ctx, rt.Center.EventHistoryGroupView, false)
-	if err != nil {
-		logger.Warningf("failed to get business group ids: %v", err)
-		ginx.NewRender(c).Data([]string{}, nil)
-		return
-	}
-
-	// 查询活跃告警事件，获取更多数据以保证统计准确性
-	events, err := models.AlertCurEventsGet(rt.Ctx, []string{}, bgids, stime, etime, []int64{}, []int64{}, []string{}, 0, "", 1000, 0, []int64{})
-	if err != nil {
-		logger.Warningf("failed to get current alert events: %v", err)
-		ginx.NewRender(c).Data([]string{}, nil)
-		return
-	}
-
-	// 如果没有查到事件，返回空数组
-	if len(events) == 0 {
-		ginx.NewRender(c).Data([]string{}, nil)
-		return
-	}
-
-	// 统计标签值出现次数
-	valueCount := make(map[string]int)
-	for _, event := range events {
-		// TagsMap已经在AlertCurEventsGet中处理，直接使用
-		if value, exists := event.TagsMap[tagKey]; exists && value != "" {
-			valueCount[value]++
-		}
-	}
-
-	// 转换为切片并按出现次数降序排序
-	type tagValue struct {
-		value string
-		count int
-	}
-
-	tagValues := make([]tagValue, 0, len(valueCount))
-	for value, count := range valueCount {
-		tagValues = append(tagValues, tagValue{value, count})
-	}
-
-	// 按出现次数降序排序
-	sort.Slice(tagValues, func(i, j int) bool {
-		return tagValues[i].count > tagValues[j].count
-	})
-
-	// 只取Top20并转换为字符串数组
-	limit := 20
-	if len(tagValues) < limit {
-		limit = len(tagValues)
-	}
-
-	result := make([]string, 0, limit)
-	for i := 0; i < limit; i++ {
-		result = append(result, tagValues[i].value)
-	}
-
-	ginx.NewRender(c).Data(result, nil)
-}

center/router/router_alert_his_event.go

@@ -2,7 +2,6 @@ package router
 
 import (
 	"fmt"
-	"net/http"
 	"strings"
 	"time"
 
@@ -11,7 +10,6 @@ import (
 
 	"github.com/gin-gonic/gin"
 	"github.com/toolkits/pkg/ginx"
-	"github.com/toolkits/pkg/logger"
 	"golang.org/x/exp/slices"
 )
 
@@ -58,15 +56,15 @@ func (rt *Router) alertHisEventsList(c *gin.Context) {
 
 	ruleId := ginx.QueryInt64(c, "rid", 0)
 
-	bgids, err := GetBusinessGroupIds(c, rt.Ctx, rt.Center.EventHistoryGroupView, false)
+	bgids, err := GetBusinessGroupIds(c, rt.Ctx, rt.Center.EventHistoryGroupView)
 	ginx.Dangerous(err)
 
 	total, err := models.AlertHisEventTotal(rt.Ctx, prods, bgids, stime, etime, severity,
-		recovered, dsIds, cates, ruleId, query, []int64{})
+		recovered, dsIds, cates, ruleId, query)
 	ginx.Dangerous(err)
 
 	list, err := models.AlertHisEventGets(rt.Ctx, prods, bgids, stime, etime, severity, recovered,
-		dsIds, cates, ruleId, query, limit, ginx.Offset(c, limit), []int64{})
+		dsIds, cates, ruleId, query, limit, ginx.Offset(c, limit))
 	ginx.Dangerous(err)
 
 	cache := make(map[int64]*models.UserGroup)
@@ -80,67 +78,16 @@ func (rt *Router) alertHisEventsList(c *gin.Context) {
 	}, nil)
 }
 
-type alertHisEventsDeleteForm struct {
-	Severities []int `json:"severities"`
-	Timestamp  int64 `json:"timestamp" binding:"required"`
-}
-
-func (rt *Router) alertHisEventsDelete(c *gin.Context) {
-	var f alertHisEventsDeleteForm
-	ginx.BindJSON(c, &f)
-	// 校验
-	if f.Timestamp == 0 {
-		ginx.Bomb(http.StatusBadRequest, "timestamp parameter is required")
-		return
-	}
-
-	user := c.MustGet("user").(*models.User)
-
-	// 启动后台清理任务
-	go func() {
-		limit := 100
-		for {
-			n, err := models.AlertHisEventBatchDelete(rt.Ctx, f.Timestamp, f.Severities, limit)
-			if err != nil {
-				logger.Errorf("Failed to delete alert history events: operator=%s, timestamp=%d, severities=%v, error=%v",
-					user.Username, f.Timestamp, f.Severities, err)
-				break
-			}
-			logger.Debugf("Successfully deleted alert history events: operator=%s, timestamp=%d, severities=%v, deleted=%d",
-				user.Username, f.Timestamp, f.Severities, n)
-			if n < int64(limit) {
-				break // 已经删完
-			}
-
-			time.Sleep(100 * time.Millisecond) // 防止锁表
-		}
-	}()
-	ginx.NewRender(c).Data("Alert history events deletion started", nil)
-}
-
-var TransferEventToCur func(*ctx.Context, *models.AlertHisEvent) *models.AlertCurEvent
-
-func init() {
-	TransferEventToCur = transferEventToCur
-}
-
-func transferEventToCur(ctx *ctx.Context, event *models.AlertHisEvent) *models.AlertCurEvent {
-	cur := event.ToCur()
-	return cur
-}
-
 func (rt *Router) alertHisEventGet(c *gin.Context) {
 	eid := ginx.UrlParamInt64(c, "eid")
 	event, err := models.AlertHisEventGetById(rt.Ctx, eid)
 	ginx.Dangerous(err)
+
 	if event == nil {
 		ginx.Bomb(404, "No such alert event")
 	}
 
-	hasPermission := HasPermission(rt.Ctx, c, "event", fmt.Sprintf("%d", eid), rt.Center.AnonymousAccess.AlertDetail)
-	if !hasPermission {
-		rt.auth()(c)
-		rt.user()(c)
+	if !rt.Center.AnonymousAccess.AlertDetail && rt.Center.EventHistoryGroupView {
 		rt.bgroCheck(c, event.GroupId)
 	}
 
@@ -149,54 +96,46 @@ func (rt *Router) alertHisEventGet(c *gin.Context) {
 		event.RuleConfigJson = ruleConfig
 	}
 
-	event.NotifyVersion, err = GetEventNotifyVersion(rt.Ctx, event.RuleId, event.NotifyRuleIds)
-	ginx.Dangerous(err)
-
-	event.NotifyRules, err = GetEventNorifyRuleNames(rt.Ctx, event.NotifyRuleIds)
-	ginx.NewRender(c).Data(TransferEventToCur(rt.Ctx, event), err)
+	ginx.NewRender(c).Data(event, err)
 }
 
-func GetBusinessGroupIds(c *gin.Context, ctx *ctx.Context, onlySelfGroupView bool, myGroups bool) ([]int64, error) {
+func GetBusinessGroupIds(c *gin.Context, ctx *ctx.Context, eventHistoryGroupView bool) ([]int64, error) {
 	bgid := ginx.QueryInt64(c, "bgid", 0)
 	var bgids []int64
 
-	if strings.HasPrefix(c.Request.URL.Path, "/v1") {
-		// 如果请求路径以 /v1 开头，不查询用户信息
+	if !eventHistoryGroupView || strings.HasPrefix(c.Request.URL.Path, "/v1") {
 		if bgid > 0 {
 			return []int64{bgid}, nil
 		}
-
 		return bgids, nil
 	}
 
 	user := c.MustGet("user").(*models.User)
-	if myGroups || (onlySelfGroupView && !user.IsAdmin()) {
-		// 1. 页面上勾选了我的业务组，需要查询用户所属的业务组
-		// 2. 如果 onlySelfGroupView 为 true，表示只允许查询用户所属的业务组
-		bussGroupIds, err := models.MyBusiGroupIds(ctx, user.Id)
-		if err != nil {
-			return nil, err
-		}
-
-		if len(bussGroupIds) == 0 {
-			// 如果没查到用户属于任何业务组，需要返回一个0，否则会导致查询到全部告警历史
-			return []int64{0}, nil
-		}
-
+	if user.IsAdmin() {
 		if bgid > 0 {
-			if !slices.Contains(bussGroupIds, bgid) && !user.IsAdmin() {
-				return nil, fmt.Errorf("business group ID not allowed")
-			}
-
 			return []int64{bgid}, nil
 		}
+		return bgids, nil
+	}
 
-		return bussGroupIds, nil
+	bussGroupIds, err := models.MyBusiGroupIds(ctx, user.Id)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(bussGroupIds) == 0 {
+		// 如果没查到用户属于任何业务组，需要返回一个0，否则会导致查询到全部告警历史
+		return []int64{0}, nil
+	}
+
+	if bgid > 0 && !slices.Contains(bussGroupIds, bgid) {
+		return nil, fmt.Errorf("business group ID not allowed")
 	}
 
 	if bgid > 0 {
+		// Pass filter parameters, priority to use
 		return []int64{bgid}, nil
 	}
 
-	return bgids, nil
+	return bussGroupIds, nil
 }

center/router/router_alert_rule.go

@@ -11,7 +11,6 @@ import (
 
 	"gopkg.in/yaml.v2"
 
-	"github.com/ccfos/nightingale/v6/alert/mute"
 	"github.com/ccfos/nightingale/v6/models"
 	"github.com/ccfos/nightingale/v6/pkg/strx"
 	"github.com/ccfos/nightingale/v6/pushgw/pconf"
@@ -19,7 +18,6 @@ import (
 
 	"github.com/gin-gonic/gin"
 	"github.com/jinzhu/copier"
-	"github.com/pkg/errors"
 	"github.com/prometheus/prometheus/prompb"
 	"github.com/toolkits/pkg/ginx"
 	"github.com/toolkits/pkg/i18n"
@@ -35,12 +33,13 @@ func (rt *Router) alertRuleGets(c *gin.Context) {
 		cache := make(map[int64]*models.UserGroup)
 		for i := 0; i < len(ars); i++ {
 			ars[i].FillNotifyGroups(rt.Ctx, cache)
+			ars[i].FillSeverities()
 		}
 	}
 	ginx.NewRender(c).Data(ars, err)
 }
 
-func GetAlertCueEventTimeRange(c *gin.Context) (stime, etime int64) {
+func getAlertCueEventTimeRange(c *gin.Context) (stime, etime int64) {
 	stime = ginx.QueryInt64(c, "stime", 0)
 	etime = ginx.QueryInt64(c, "etime", 0)
 	if etime == 0 {
@@ -79,6 +78,7 @@ func (rt *Router) alertRuleGetsByGids(c *gin.Context) {
 		names := make([]string, 0, len(ars))
 		for i := 0; i < len(ars); i++ {
 			ars[i].FillNotifyGroups(rt.Ctx, cache)
+			ars[i].FillSeverities()
 
 			if len(ars[i].DatasourceQueries) != 0 {
 				ars[i].DatasourceIdsJson = rt.DatasourceCache.GetIDsByDsCateAndQueries(ars[i].Cate, ars[i].DatasourceQueries)
@@ -88,7 +88,7 @@ func (rt *Router) alertRuleGetsByGids(c *gin.Context) {
 			names = append(names, ars[i].UpdateBy)
 		}
 
-		stime, etime := GetAlertCueEventTimeRange(c)
+		stime, etime := getAlertCueEventTimeRange(c)
 		cnt := models.AlertCurEventCountByRuleId(rt.Ctx, rids, stime, etime)
 		if cnt != nil {
 			for i := 0; i < len(ars); i++ {
@@ -157,120 +157,6 @@ func (rt *Router) alertRuleAddByFE(c *gin.Context) {
 	ginx.NewRender(c).Data(reterr, nil)
 }
 
-type AlertRuleTryRunForm struct {
-	EventId         int64            `json:"event_id" binding:"required"`
-	AlertRuleConfig models.AlertRule `json:"config" binding:"required"`
-}
-
-func (rt *Router) alertRuleNotifyTryRun(c *gin.Context) {
-	// check notify channels of old version
-	var f AlertRuleTryRunForm
-	ginx.BindJSON(c, &f)
-
-	hisEvent, err := models.AlertHisEventGetById(rt.Ctx, f.EventId)
-	ginx.Dangerous(err)
-
-	if hisEvent == nil {
-		ginx.Bomb(http.StatusNotFound, "event not found")
-	}
-
-	curEvent := *hisEvent.ToCur()
-	curEvent.SetTagsMap()
-
-	if f.AlertRuleConfig.NotifyVersion == 1 {
-		for _, id := range f.AlertRuleConfig.NotifyRuleIds {
-			notifyRule, err := models.GetNotifyRule(rt.Ctx, id)
-			ginx.Dangerous(err)
-			for _, notifyConfig := range notifyRule.NotifyConfigs {
-				_, err = SendNotifyChannelMessage(rt.Ctx, rt.UserCache, rt.UserGroupCache, notifyConfig, []*models.AlertCurEvent{&curEvent})
-				ginx.Dangerous(err)
-			}
-		}
-
-		ginx.NewRender(c).Data("notification test ok", nil)
-		return
-	}
-
-	if len(f.AlertRuleConfig.NotifyChannelsJSON) == 0 {
-		ginx.Bomb(http.StatusOK, "no notify channels selected")
-	}
-
-	if len(f.AlertRuleConfig.NotifyGroupsJSON) == 0 {
-		ginx.Bomb(http.StatusOK, "no notify groups selected")
-	}
-
-	ancs := make([]string, 0, len(curEvent.NotifyChannelsJSON))
-	ugids := f.AlertRuleConfig.NotifyGroupsJSON
-	ngids := make([]int64, 0)
-	for i := 0; i < len(ugids); i++ {
-		if gid, err := strconv.ParseInt(ugids[i], 10, 64); err == nil {
-			ngids = append(ngids, gid)
-		}
-	}
-	userGroups := rt.UserGroupCache.GetByUserGroupIds(ngids)
-	uids := make([]int64, 0)
-	for i := range userGroups {
-		uids = append(uids, userGroups[i].UserIds...)
-	}
-	users := rt.UserCache.GetByUserIds(uids)
-	for _, NotifyChannels := range curEvent.NotifyChannelsJSON {
-		flag := true
-		// ignore non-default channels
-		switch NotifyChannels {
-		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(NotifyChannels); b {
-				flag = false
-				break
-			}
-		}
-		if flag {
-			ancs = append(ancs, NotifyChannels)
-		}
-	}
-	if len(ancs) > 0 {
-		ginx.Dangerous(errors.New(fmt.Sprintf("All users are missing notify channel configurations. Please check for missing tokens (each channel should be configured with at least one user). %v", ancs)))
-	}
-
-	ginx.NewRender(c).Data("notification test ok", nil)
-}
-
-func (rt *Router) alertRuleEnableTryRun(c *gin.Context) {
-	// check notify channels of old version
-	var f AlertRuleTryRunForm
-	ginx.BindJSON(c, &f)
-
-	hisEvent, err := models.AlertHisEventGetById(rt.Ctx, f.EventId)
-	ginx.Dangerous(err)
-
-	if hisEvent == nil {
-		ginx.Bomb(http.StatusNotFound, "event not found")
-	}
-
-	curEvent := *hisEvent.ToCur()
-	curEvent.SetTagsMap()
-
-	if f.AlertRuleConfig.Disabled == 1 {
-		ginx.Bomb(http.StatusOK, "rule is disabled")
-	}
-
-	if mute.TimeSpanMuteStrategy(&f.AlertRuleConfig, &curEvent) {
-		ginx.Bomb(http.StatusOK, "event is not match for period of time")
-	}
-
-	if mute.BgNotMatchMuteStrategy(&f.AlertRuleConfig, &curEvent, rt.TargetCache) {
-		ginx.Bomb(http.StatusOK, "event target busi group not match rule busi group")
-	}
-
-	ginx.NewRender(c).Data("event is effective", nil)
-}
-
 func (rt *Router) alertRuleAddByImport(c *gin.Context) {
 	username := c.MustGet("username").(string)
 
@@ -288,15 +174,6 @@ func (rt *Router) alertRuleAddByImport(c *gin.Context) {
 				models.DataSourceQueryAll,
 			}
 		}
-
-		// 将导入的规则统一转为新版本的通知规则配置
-		lst[i].NotifyVersion = 1
-		lst[i].NotifyChannelsJSON = []string{}
-		lst[i].NotifyGroupsJSON = []string{}
-		lst[i].NotifyChannels = ""
-		lst[i].NotifyGroups = ""
-		lst[i].Callbacks = ""
-		lst[i].CallbacksJSON = []string{}
 	}
 
 	bgid := ginx.UrlParamInt64(c, "id")
@@ -315,52 +192,19 @@ func (rt *Router) alertRuleAddByImportPromRule(c *gin.Context) {
 	var f promRuleForm
 	ginx.Dangerous(c.BindJSON(&f))
 
-	// 首先尝试解析带 groups 的格式
 	var pr struct {
 		Groups []models.PromRuleGroup `yaml:"groups"`
 	}
 	err := yaml.Unmarshal([]byte(f.Payload), &pr)
-
-	var groups []models.PromRuleGroup
-
-	if err != nil || len(pr.Groups) == 0 {
-		// 如果解析失败或没有 groups，尝试解析规则数组格式
-		var rules []models.PromRule
-		err = yaml.Unmarshal([]byte(f.Payload), &rules)
-		if err != nil {
-			// 最后尝试解析单个规则格式
-			var singleRule models.PromRule
-			err = yaml.Unmarshal([]byte(f.Payload), &singleRule)
-			if err != nil {
-				ginx.Bomb(http.StatusBadRequest, "invalid yaml format. err: %v", err)
-			}
-
-			// 验证单个规则是否有效
-			if singleRule.Alert == "" && singleRule.Record == "" {
-				ginx.Bomb(http.StatusBadRequest, "input yaml is empty or invalid")
-			}
-
-			rules = []models.PromRule{singleRule}
-		}
-
-		// 验证规则数组是否为空
-		if len(rules) == 0 {
-			ginx.Bomb(http.StatusBadRequest, "input yaml contains no rules")
-		}
-
-		// 将规则数组包装成 group
-		groups = []models.PromRuleGroup{
-			{
-				Name:  "imported_rules",
-				Rules: rules,
-			},
-		}
-	} else {
-		// 使用已解析的 groups
-		groups = pr.Groups
+	if err != nil {
+		ginx.Bomb(http.StatusBadRequest, "invalid yaml format, please use the example format. err: %v", err)
 	}
 
-	lst := models.DealPromGroup(groups, f.DatasourceQueries, f.Disabled)
+	if len(pr.Groups) == 0 {
+		ginx.Bomb(http.StatusBadRequest, "input yaml is empty")
+	}
+
+	lst := models.DealPromGroup(pr.Groups, f.DatasourceQueries, f.Disabled)
 	username := c.MustGet("username").(string)
 	bgid := ginx.UrlParamInt64(c, "id")
 	ginx.NewRender(c).Data(rt.alertRuleAdd(lst, username, bgid, c.GetHeader("X-Language")), nil)
@@ -505,8 +349,8 @@ func (rt *Router) alertRulePutFields(c *gin.Context) {
 		ginx.Bomb(http.StatusBadRequest, "fields empty")
 	}
 
-	updateBy := c.MustGet("username").(string)
-	updateAt := time.Now().Unix()
+	f.Fields["update_by"] = c.MustGet("username").(string)
+	f.Fields["update_at"] = time.Now().Unix()
 
 	for i := 0; i < len(f.Ids); i++ {
 		ar, err := models.AlertRuleGetById(rt.Ctx, f.Ids[i])
@@ -523,6 +367,7 @@ func (rt *Router) alertRulePutFields(c *gin.Context) {
 				b, err := json.Marshal(originRule)
 				ginx.Dangerous(err)
 				ginx.Dangerous(ar.UpdateFieldsMap(rt.Ctx, map[string]interface{}{"rule_config": string(b)}))
+				continue
 			}
 		}
 
@@ -535,6 +380,7 @@ func (rt *Router) alertRulePutFields(c *gin.Context) {
 				b, err := json.Marshal(ar.AnnotationsJSON)
 				ginx.Dangerous(err)
 				ginx.Dangerous(ar.UpdateFieldsMap(rt.Ctx, map[string]interface{}{"annotations": string(b)}))
+				continue
 			}
 		}
 
@@ -547,6 +393,7 @@ func (rt *Router) alertRulePutFields(c *gin.Context) {
 				b, err := json.Marshal(ar.AnnotationsJSON)
 				ginx.Dangerous(err)
 				ginx.Dangerous(ar.UpdateFieldsMap(rt.Ctx, map[string]interface{}{"annotations": string(b)}))
+				continue
 			}
 		}
 
@@ -556,6 +403,7 @@ func (rt *Router) alertRulePutFields(c *gin.Context) {
 				callback := callbacks.(string)
 				if !strings.Contains(ar.Callbacks, callback) {
 					ginx.Dangerous(ar.UpdateFieldsMap(rt.Ctx, map[string]interface{}{"callbacks": ar.Callbacks + " " + callback}))
+					continue
 				}
 			}
 		}
@@ -565,6 +413,7 @@ func (rt *Router) alertRulePutFields(c *gin.Context) {
 			if callbacks, has := f.Fields["callbacks"]; has {
 				callback := callbacks.(string)
 				ginx.Dangerous(ar.UpdateFieldsMap(rt.Ctx, map[string]interface{}{"callbacks": strings.ReplaceAll(ar.Callbacks, callback, "")}))
+				continue
 			}
 		}
 
@@ -574,6 +423,7 @@ func (rt *Router) alertRulePutFields(c *gin.Context) {
 				bytes, err := json.Marshal(datasourceQueries)
 				ginx.Dangerous(err)
 				ginx.Dangerous(ar.UpdateFieldsMap(rt.Ctx, map[string]interface{}{"datasource_queries": bytes}))
+				continue
 			}
 		}
 
@@ -589,12 +439,6 @@ func (rt *Router) alertRulePutFields(c *gin.Context) {
 				ginx.Dangerous(ar.UpdateColumn(rt.Ctx, k, v))
 			}
 		}
-
-		// 统一更新更新时间和更新人，只有更新时间变了，告警规则才会被引擎拉取
-		ginx.Dangerous(ar.UpdateFieldsMap(rt.Ctx, map[string]interface{}{
-			"update_by": updateBy,
-			"update_at": updateAt,
-		}))
 	}
 
 	ginx.NewRender(c).Message(nil)

center/router/router_alert_subscribe.go

@@ -2,17 +2,13 @@ package router
 
 import (
 	"net/http"
-	"strconv"
-	"strings"
 	"time"
 
-	"github.com/ccfos/nightingale/v6/alert/common"
 	"github.com/ccfos/nightingale/v6/models"
 	"github.com/ccfos/nightingale/v6/pkg/strx"
 
 	"github.com/gin-gonic/gin"
 	"github.com/toolkits/pkg/ginx"
-	"github.com/toolkits/pkg/i18n"
 )
 
 // Return all, front-end search and paging
@@ -108,148 +104,6 @@ func (rt *Router) alertSubscribeAdd(c *gin.Context) {
 	ginx.NewRender(c).Message(f.Add(rt.Ctx))
 }
 
-type SubscribeTryRunForm struct {
-	EventId         int64                 `json:"event_id" binding:"required"`
-	SubscribeConfig models.AlertSubscribe `json:"config" binding:"required"`
-}
-
-func (rt *Router) alertSubscribeTryRun(c *gin.Context) {
-	var f SubscribeTryRunForm
-	ginx.BindJSON(c, &f)
-	ginx.Dangerous(f.SubscribeConfig.Verify())
-
-	hisEvent, err := models.AlertHisEventGetById(rt.Ctx, f.EventId)
-	ginx.Dangerous(err)
-
-	if hisEvent == nil {
-		ginx.Bomb(http.StatusNotFound, "event not found")
-	}
-
-	curEvent := *hisEvent.ToCur()
-	curEvent.SetTagsMap()
-
-	lang := c.GetHeader("X-Language")
-
-	// 先判断匹配条件
-	if !f.SubscribeConfig.MatchCluster(curEvent.DatasourceId) {
-		ginx.Bomb(http.StatusBadRequest, i18n.Sprintf(lang, "event datasource not match"))
-	}
-
-	if len(f.SubscribeConfig.RuleIds) != 0 {
-		match := false
-		for _, rid := range f.SubscribeConfig.RuleIds {
-			if rid == curEvent.RuleId {
-				match = true
-				break
-			}
-		}
-		if !match {
-			ginx.Bomb(http.StatusBadRequest, i18n.Sprintf(lang, "event rule id not match"))
-		}
-	}
-
-	// 匹配 tag
-	f.SubscribeConfig.Parse()
-	if !common.MatchTags(curEvent.TagsMap, f.SubscribeConfig.ITags) {
-		ginx.Bomb(http.StatusBadRequest, i18n.Sprintf(lang, "event tags not match"))
-	}
-
-	// 匹配group name
-	if !common.MatchGroupsName(curEvent.GroupName, f.SubscribeConfig.IBusiGroups) {
-		ginx.Bomb(http.StatusBadRequest, i18n.Sprintf(lang, "event group name not match"))
-	}
-
-	// 检查严重级别（Severity）匹配
-	if len(f.SubscribeConfig.SeveritiesJson) != 0 {
-		match := false
-		for _, s := range f.SubscribeConfig.SeveritiesJson {
-			if s == curEvent.Severity || s == 0 {
-				match = true
-				break
-			}
-		}
-		if !match {
-			ginx.Bomb(http.StatusBadRequest, i18n.Sprintf(lang, "event severity not match"))
-		}
-	}
-
-	// 新版本通知规则
-	if f.SubscribeConfig.NotifyVersion == 1 {
-		if len(f.SubscribeConfig.NotifyRuleIds) == 0 {
-			ginx.Bomb(http.StatusBadRequest, i18n.Sprintf(lang, "no notify rules selected"))
-		}
-
-		for _, id := range f.SubscribeConfig.NotifyRuleIds {
-			notifyRule, err := models.GetNotifyRule(rt.Ctx, id)
-			if err != nil {
-				ginx.Bomb(http.StatusNotFound, i18n.Sprintf(lang, "subscribe notify rule not found: %v", err))
-			}
-
-			for _, notifyConfig := range notifyRule.NotifyConfigs {
-				_, err = SendNotifyChannelMessage(rt.Ctx, rt.UserCache, rt.UserGroupCache, notifyConfig, []*models.AlertCurEvent{&curEvent})
-				if err != nil {
-					ginx.Bomb(http.StatusBadRequest, i18n.Sprintf(lang, "notify rule send error: %v", err))
-				}
-			}
-		}
-
-		ginx.NewRender(c).Data(i18n.Sprintf(lang, "event match subscribe and notification test ok"), nil)
-		return
-	}
-
-	// 旧版通知方式
-	f.SubscribeConfig.ModifyEvent(&curEvent)
-	if len(curEvent.NotifyChannelsJSON) == 0 {
-		ginx.Bomb(http.StatusBadRequest, i18n.Sprintf(lang, "no notify channels selected"))
-	}
-
-	if len(curEvent.NotifyGroupsJSON) == 0 {
-		ginx.Bomb(http.StatusOK, i18n.Sprintf(lang, "no notify groups selected"))
-	}
-
-	ancs := make([]string, 0, len(curEvent.NotifyChannelsJSON))
-	ugids := strings.Fields(f.SubscribeConfig.UserGroupIds)
-	ngids := make([]int64, 0)
-	for i := 0; i < len(ugids); i++ {
-		if gid, err := strconv.ParseInt(ugids[i], 10, 64); err == nil {
-			ngids = append(ngids, gid)
-		}
-	}
-
-	userGroups := rt.UserGroupCache.GetByUserGroupIds(ngids)
-	uids := make([]int64, 0)
-	for i := range userGroups {
-		uids = append(uids, userGroups[i].UserIds...)
-	}
-	users := rt.UserCache.GetByUserIds(uids)
-	for _, NotifyChannels := range curEvent.NotifyChannelsJSON {
-		flag := true
-		// ignore non-default channels
-		switch NotifyChannels {
-		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(NotifyChannels); b {
-				flag = false
-				break
-			}
-		}
-		if flag {
-			ancs = append(ancs, NotifyChannels)
-		}
-	}
-	if len(ancs) > 0 {
-		ginx.Bomb(http.StatusBadRequest, i18n.Sprintf(lang, "all users missing notify channel configurations: %v", ancs))
-	}
-
-	ginx.NewRender(c).Data(i18n.Sprintf(lang, "event match subscribe and notify settings ok"), nil)
-}
-
 func (rt *Router) alertSubscribePut(c *gin.Context) {
 	var fs []models.AlertSubscribe
 	ginx.BindJSON(c, &fs)
@@ -288,7 +142,6 @@ func (rt *Router) alertSubscribePut(c *gin.Context) {
 			"busi_groups",
 			"note",
 			"notify_rule_ids",
-			"notify_version",
 		))
 	}
 

center/router/router_builtin_metric_filter.go

@@ -57,7 +57,7 @@ func (rt *Router) metricFilterDel(c *gin.Context) {
 			ginx.Dangerous(err)
 
 			if !HasPerm(gids, old.GroupsPerm, true) {
-				ginx.NewRender(c).Message("forbidden")
+				ginx.NewRender(c).Message("no permission")
 				return
 			}
 		}
@@ -79,7 +79,7 @@ func (rt *Router) metricFilterPut(c *gin.Context) {
 		ginx.Dangerous(err)
 
 		if !HasPerm(gids, old.GroupsPerm, true) {
-			ginx.NewRender(c).Message("forbidden")
+			ginx.NewRender(c).Message("no permission")
 			return
 		}
 	}

center/router/router_builtin_metrics.go

@@ -2,10 +2,8 @@ package router
 
 import (
 	"net/http"
-	"sort"
 	"time"
 
-	"github.com/ccfos/nightingale/v6/center/integration"
 	"github.com/ccfos/nightingale/v6/models"
 
 	"github.com/gin-gonic/gin"
@@ -31,7 +29,7 @@ func (rt *Router) builtinMetricsAdd(c *gin.Context) {
 	reterr := make(map[string]string)
 	for i := 0; i < count; i++ {
 		lst[i].Lang = lang
-		lst[i].UUID = time.Now().UnixMicro()
+		lst[i].UUID = time.Now().UnixNano()
 		if err := lst[i].Add(rt.Ctx, username); err != nil {
 			reterr[lst[i].Name] = i18n.Sprintf(c.GetHeader("X-Language"), err.Error())
 		}
@@ -50,12 +48,11 @@ func (rt *Router) builtinMetricsGets(c *gin.Context) {
 		lang = "zh_CN"
 	}
 
-	bmInDB, err := models.BuiltinMetricGets(rt.Ctx, "", collector, typ, query, unit, limit, ginx.Offset(c, limit))
+	bm, err := models.BuiltinMetricGets(rt.Ctx, lang, collector, typ, query, unit, limit, ginx.Offset(c, limit))
 	ginx.Dangerous(err)
 
-	bm, total, err := integration.BuiltinPayloadInFile.BuiltinMetricGets(bmInDB, lang, collector, typ, query, unit, limit, ginx.Offset(c, limit))
+	total, err := models.BuiltinMetricCount(rt.Ctx, lang, collector, typ, query, unit)
 	ginx.Dangerous(err)
-
 	ginx.NewRender(c).Data(gin.H{
 		"list":  bm,
 		"total": total,
@@ -89,11 +86,15 @@ func (rt *Router) builtinMetricsDel(c *gin.Context) {
 func (rt *Router) builtinMetricsDefaultTypes(c *gin.Context) {
 	lst := []string{
 		"Linux",
-		"Procstat",
 		"cAdvisor",
 		"Ping",
 		"MySQL",
-		"ClickHouse",
+		"Redis",
+		"Kafka",
+		"Elasticsearch",
+		"PostgreSQL",
+		"MongoDB",
+		"Memcached",
 	}
 	ginx.NewRender(c).Data(lst, nil)
 }
@@ -101,28 +102,29 @@ func (rt *Router) builtinMetricsDefaultTypes(c *gin.Context) {
 func (rt *Router) builtinMetricsTypes(c *gin.Context) {
 	collector := ginx.QueryStr(c, "collector", "")
 	query := ginx.QueryStr(c, "query", "")
+	disabled := ginx.QueryInt(c, "disabled", -1)
 	lang := c.GetHeader("X-Language")
 
-	metricTypeListInDB, err := models.BuiltinMetricTypes(rt.Ctx, lang, collector, query)
+	metricTypeList, err := models.BuiltinMetricTypes(rt.Ctx, lang, collector, query)
 	ginx.Dangerous(err)
 
-	metricTypeListInFile := integration.BuiltinPayloadInFile.BuiltinMetricTypes(lang, collector, query)
+	componentList, err := models.BuiltinComponentGets(rt.Ctx, "", disabled)
+	ginx.Dangerous(err)
 
-	typeMap := make(map[string]struct{})
-	for _, metricType := range metricTypeListInDB {
-		typeMap[metricType] = struct{}{}
-	}
-	for _, metricType := range metricTypeListInFile {
-		typeMap[metricType] = struct{}{}
+	// 创建一个 map 来存储 componentList 中的类型
+	componentTypes := make(map[string]struct{})
+	for _, comp := range componentList {
+		componentTypes[comp.Ident] = struct{}{}
 	}
 
-	metricTypeList := make([]string, 0, len(typeMap))
-	for metricType := range typeMap {
-		metricTypeList = append(metricTypeList, metricType)
+	filteredMetricTypeList := make([]string, 0)
+	for _, metricType := range metricTypeList {
+		if _, exists := componentTypes[metricType]; exists {
+			filteredMetricTypeList = append(filteredMetricTypeList, metricType)
+		}
 	}
-	sort.Strings(metricTypeList)
 
-	ginx.NewRender(c).Data(metricTypeList, nil)
+	ginx.NewRender(c).Data(filteredMetricTypeList, nil)
 }
 
 func (rt *Router) builtinMetricsCollectors(c *gin.Context) {
@@ -130,24 +132,5 @@ func (rt *Router) builtinMetricsCollectors(c *gin.Context) {
 	query := ginx.QueryStr(c, "query", "")
 	lang := c.GetHeader("X-Language")
 
-	collectorListInDB, err := models.BuiltinMetricCollectors(rt.Ctx, lang, typ, query)
-	ginx.Dangerous(err)
-
-	collectorListInFile := integration.BuiltinPayloadInFile.BuiltinMetricCollectors(lang, typ, query)
-
-	collectorMap := make(map[string]struct{})
-	for _, collector := range collectorListInDB {
-		collectorMap[collector] = struct{}{}
-	}
-	for _, collector := range collectorListInFile {
-		collectorMap[collector] = struct{}{}
-	}
-
-	collectorList := make([]string, 0, len(collectorMap))
-	for collector := range collectorMap {
-		collectorList = append(collectorList, collector)
-	}
-	sort.Strings(collectorList)
-
-	ginx.NewRender(c).Data(collectorList, nil)
+	ginx.NewRender(c).Data(models.BuiltinMetricCollectors(rt.Ctx, lang, typ, query))
 }

center/router/router_builtin_payload.go

@@ -7,7 +7,6 @@ import (
 	"time"
 
 	"github.com/BurntSushi/toml"
-	"github.com/ccfos/nightingale/v6/center/integration"
 	"github.com/ccfos/nightingale/v6/models"
 	"github.com/gin-gonic/gin"
 	"github.com/toolkits/pkg/ginx"
@@ -193,26 +192,13 @@ func (rt *Router) builtinPayloadsAdd(c *gin.Context) {
 
 func (rt *Router) builtinPayloadsGets(c *gin.Context) {
 	typ := ginx.QueryStr(c, "type", "")
-	if typ == "" {
-		ginx.Bomb(http.StatusBadRequest, "type is required")
-		return
-	}
 	ComponentID := ginx.QueryInt64(c, "component_id", 0)
 
 	cate := ginx.QueryStr(c, "cate", "")
 	query := ginx.QueryStr(c, "query", "")
 
 	lst, err := models.BuiltinPayloadGets(rt.Ctx, uint64(ComponentID), typ, cate, query)
-	ginx.Dangerous(err)
-
-	lstInFile, err := integration.BuiltinPayloadInFile.GetBuiltinPayload(typ, cate, query, uint64(ComponentID))
-	ginx.Dangerous(err)
-
-	if len(lstInFile) > 0 {
-		lst = append(lst, lstInFile...)
-	}
-
-	ginx.NewRender(c).Data(lst, nil)
+	ginx.NewRender(c).Data(lst, err)
 }
 
 func (rt *Router) builtinPayloadcatesGet(c *gin.Context) {
@@ -220,31 +206,21 @@ func (rt *Router) builtinPayloadcatesGet(c *gin.Context) {
 	ComponentID := ginx.QueryInt64(c, "component_id", 0)
 
 	cates, err := models.BuiltinPayloadCates(rt.Ctx, typ, uint64(ComponentID))
-	ginx.Dangerous(err)
+	ginx.NewRender(c).Data(cates, err)
+}
 
-	catesInFile, err := integration.BuiltinPayloadInFile.GetBuiltinPayloadCates(typ, uint64(ComponentID))
-	ginx.Dangerous(err)
+func (rt *Router) builtinPayloadGet(c *gin.Context) {
+	id := ginx.UrlParamInt64(c, "id")
 
-	// 使用 map 进行去重
-	cateMap := make(map[string]bool)
-
-	// 添加数据库中的分类
-	for _, cate := range cates {
-		cateMap[cate] = true
+	bp, err := models.BuiltinPayloadGet(rt.Ctx, "id = ?", id)
+	if err != nil {
+		ginx.Bomb(http.StatusInternalServerError, err.Error())
+	}
+	if bp == nil {
+		ginx.Bomb(http.StatusNotFound, "builtin payload not found")
 	}
 
-	// 添加文件中的分类
-	for _, cate := range catesInFile {
-		cateMap[cate] = true
-	}
-
-	// 将去重后的结果转换回切片
-	result := make([]string, 0, len(cateMap))
-	for cate := range cateMap {
-		result = append(result, cate)
-	}
-
-	ginx.NewRender(c).Data(result, nil)
+	ginx.NewRender(c).Data(bp, nil)
 }
 
 func (rt *Router) builtinPayloadsPut(c *gin.Context) {
@@ -297,15 +273,14 @@ func (rt *Router) builtinPayloadsDel(c *gin.Context) {
 	ginx.NewRender(c).Message(models.BuiltinPayloadDels(rt.Ctx, req.Ids))
 }
 
-func (rt *Router) builtinPayloadsGetByUUID(c *gin.Context) {
-	uuid := ginx.QueryInt64(c, "uuid")
-
-	bp, err := models.BuiltinPayloadGet(rt.Ctx, "uuid = ?", uuid)
-	ginx.Dangerous(err)
-
-	if bp != nil {
-		ginx.NewRender(c).Data(bp, nil)
-	} else {
-		ginx.NewRender(c).Data(integration.BuiltinPayloadInFile.IndexData[uuid], nil)
+func (rt *Router) builtinPayloadsGetByUUIDOrID(c *gin.Context) {
+	uuid := ginx.QueryInt64(c, "uuid", 0)
+	// 优先以 uuid 为准
+	if uuid != 0 {
+		ginx.NewRender(c).Data(models.BuiltinPayloadGet(rt.Ctx, "uuid = ?", uuid))
+		return
 	}
+
+	id := ginx.QueryInt64(c, "id", 0)
+	ginx.NewRender(c).Data(models.BuiltinPayloadGet(rt.Ctx, "id = ?", id))
 }

center/router/router_datasource.go

@@ -2,19 +2,16 @@ package router
 
 import (
 	"crypto/tls"
-	"encoding/json"
 	"fmt"
 	"io"
 	"net/http"
 	"net/url"
 	"strings"
 
-	"github.com/ccfos/nightingale/v6/datasource/opensearch"
 	"github.com/ccfos/nightingale/v6/models"
 
 	"github.com/gin-gonic/gin"
 	"github.com/toolkits/pkg/ginx"
-	"github.com/toolkits/pkg/i18n"
 	"github.com/toolkits/pkg/logger"
 )
 
@@ -103,7 +100,7 @@ func (rt *Router) datasourceUpsert(c *gin.Context) {
 
 	if !req.ForceSave {
 		if req.PluginType == models.PROMETHEUS || req.PluginType == models.LOKI || req.PluginType == models.TDENGINE {
-			err = DatasourceCheck(c, req)
+			err = DatasourceCheck(req)
 			if err != nil {
 				Dangerous(c, err)
 				return
@@ -111,48 +108,6 @@ func (rt *Router) datasourceUpsert(c *gin.Context) {
 		}
 	}
 
-	for k, v := range req.SettingsJson {
-		if strings.Contains(k, "cluster_name") {
-			req.ClusterName = v.(string)
-			break
-		}
-	}
-
-	if req.PluginType == models.OPENSEARCH {
-		b, err := json.Marshal(req.SettingsJson)
-		if err != nil {
-			logger.Warningf("marshal settings fail: %v", err)
-			return
-		}
-
-		var os opensearch.OpenSearch
-		err = json.Unmarshal(b, &os)
-		if err != nil {
-			logger.Warningf("unmarshal settings fail: %v", err)
-			return
-		}
-
-		if len(os.Nodes) == 0 {
-			logger.Warningf("nodes empty, %+v", req)
-			return
-		}
-
-		req.HTTPJson = models.HTTP{
-			Timeout: os.Timeout,
-			Url:     os.Nodes[0],
-			Headers: os.Headers,
-			TLS: models.TLS{
-				SkipTlsVerify: os.TLS.SkipTlsVerify,
-			},
-		}
-
-		req.AuthJson = models.Auth{
-			BasicAuth:         os.Basic.Enable,
-			BasicAuthUser:     os.Basic.Username,
-			BasicAuthPassword: os.Basic.Password,
-		}
-	}
-
 	if req.Id == 0 {
 		req.CreatedBy = username
 		req.Status = "enabled"
@@ -174,7 +129,7 @@ func (rt *Router) datasourceUpsert(c *gin.Context) {
 	Render(c, nil, err)
 }
 
-func DatasourceCheck(c *gin.Context, ds models.Datasource) error {
+func DatasourceCheck(ds models.Datasource) error {
 	if ds.PluginType == models.PROMETHEUS || ds.PluginType == models.LOKI || ds.PluginType == models.TDENGINE {
 		if ds.HTTPJson.Url == "" {
 			return fmt.Errorf("url is empty")
@@ -193,12 +148,11 @@ func DatasourceCheck(c *gin.Context, ds models.Datasource) error {
 		},
 	}
 
-	ds.HTTPJson.Url = strings.TrimRight(ds.HTTPJson.Url, "/")
 	var fullURL string
 	req, err := ds.HTTPJson.NewReq(&fullURL)
 	if err != nil {
 		logger.Errorf("Error creating request: %v", err)
-		return fmt.Errorf("request urls:%v failed: %v", ds.HTTPJson.GetUrls(), err)
+		return fmt.Errorf("request urls:%v failed", ds.HTTPJson.GetUrls())
 	}
 
 	if ds.PluginType == models.PROMETHEUS {
@@ -214,14 +168,14 @@ func DatasourceCheck(c *gin.Context, ds models.Datasource) error {
 		req, err = http.NewRequest("GET", fullURL, nil)
 		if err != nil {
 			logger.Errorf("Error creating request: %v", err)
-			return fmt.Errorf("request url:%s failed: %v", fullURL, 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: %v", fullURL, err)
+			return fmt.Errorf("request url:%s failed", fullURL)
 		}
 	}
 
@@ -233,11 +187,7 @@ func DatasourceCheck(c *gin.Context, ds models.Datasource) error {
 		req, err = http.NewRequest("GET", fullURL, nil)
 		if err != nil {
 			logger.Errorf("Error creating request: %v", err)
-			if !strings.Contains(ds.HTTPJson.Url, "/loki") {
-				lang := c.GetHeader("X-Language")
-				return fmt.Errorf(i18n.Sprintf(lang, "/loki suffix is miss, please add /loki to the url: %s", ds.HTTPJson.Url+"/loki"))
-			}
-			return fmt.Errorf("request url:%s failed: %v", fullURL, err)
+			return fmt.Errorf("request url:%s failed", fullURL)
 		}
 	}
 
@@ -252,16 +202,12 @@ func DatasourceCheck(c *gin.Context, ds models.Datasource) error {
 	resp, err := client.Do(req)
 	if err != nil {
 		logger.Errorf("Error making request: %v\n", err)
-		return fmt.Errorf("request url:%s failed: %v", fullURL, err)
+		return fmt.Errorf("request url:%s failed", fullURL)
 	}
 	defer resp.Body.Close()
 
 	if resp.StatusCode != 200 {
 		logger.Errorf("Error making request: %v\n", resp.StatusCode)
-		if resp.StatusCode == 404 && ds.PluginType == models.LOKI && !strings.Contains(ds.HTTPJson.Url, "/loki") {
-			lang := c.GetHeader("X-Language")
-			return fmt.Errorf(i18n.Sprintf(lang, "/loki suffix is miss, please add /loki to the url: %s", ds.HTTPJson.Url+"/loki"))
-		}
 		body, _ := io.ReadAll(resp.Body)
 		return fmt.Errorf("request url:%s failed code:%d body:%s", fullURL, resp.StatusCode, string(body))
 	}

center/router/router_embedded.go

@@ -1,141 +0,0 @@
-package router
-
-import (
-	"time"
-
-	"github.com/ccfos/nightingale/v6/models"
-	"github.com/ccfos/nightingale/v6/pkg/ctx"
-
-	"github.com/gin-gonic/gin"
-	"github.com/toolkits/pkg/ginx"
-)
-
-func (rt *Router) embeddedProductGets(c *gin.Context) {
-	products, err := models.EmbeddedProductGets(rt.Ctx)
-	ginx.Dangerous(err)
-	// 获取当前用户可访问的Group ID 列表
-	me := c.MustGet("user").(*models.User)
-
-	if me.IsAdmin() {
-		ginx.NewRender(c).Data(products, err)
-		return
-	}
-
-	gids, err := models.MyGroupIds(rt.Ctx, me.Id)
-	bgSet := make(map[int64]struct{}, len(gids))
-	for _, id := range gids {
-		bgSet[id] = struct{}{}
-	}
-
-	// 过滤出公开或有权限访问的私有 product link
-	var result []*models.EmbeddedProduct
-	for _, product := range products {
-		if !product.IsPrivate {
-			result = append(result, product)
-			continue
-		}
-
-		for _, tid := range product.TeamIDs {
-			if _, ok := bgSet[tid]; ok {
-				result = append(result, product)
-				break
-			}
-		}
-	}
-
-	ginx.NewRender(c).Data(result, err)
-}
-
-func (rt *Router) embeddedProductGet(c *gin.Context) {
-	id := ginx.UrlParamInt64(c, "id")
-	if id <= 0 {
-		ginx.Bomb(400, "invalid id")
-	}
-
-	data, err := models.GetEmbeddedProductByID(rt.Ctx, id)
-	ginx.Dangerous(err)
-
-	me := c.MustGet("user").(*models.User)
-	hashPermission, err := hasEmbeddedProductAccess(rt.Ctx, me, data)
-	ginx.Dangerous(err)
-
-	if !hashPermission {
-		ginx.Bomb(403, "forbidden")
-	}
-
-	ginx.NewRender(c).Data(data, nil)
-}
-
-func (rt *Router) embeddedProductAdd(c *gin.Context) {
-	var eps []models.EmbeddedProduct
-	ginx.BindJSON(c, &eps)
-
-	me := c.MustGet("user").(*models.User)
-
-	for i := range eps {
-		eps[i].CreateBy = me.Nickname
-		eps[i].UpdateBy = me.Nickname
-	}
-
-	err := models.AddEmbeddedProduct(rt.Ctx, eps)
-	ginx.NewRender(c).Message(err)
-}
-
-func (rt *Router) embeddedProductPut(c *gin.Context) {
-	var ep models.EmbeddedProduct
-	id := ginx.UrlParamInt64(c, "id")
-	ginx.BindJSON(c, &ep)
-
-	if id <= 0 {
-		ginx.Bomb(400, "invalid id")
-	}
-
-	oldProduct, err := models.GetEmbeddedProductByID(rt.Ctx, id)
-	ginx.Dangerous(err)
-	me := c.MustGet("user").(*models.User)
-
-	now := time.Now().Unix()
-	oldProduct.Name = ep.Name
-	oldProduct.URL = ep.URL
-	oldProduct.IsPrivate = ep.IsPrivate
-	oldProduct.TeamIDs = ep.TeamIDs
-	oldProduct.UpdateBy = me.Username
-	oldProduct.UpdateAt = now
-
-	err = models.UpdateEmbeddedProduct(rt.Ctx, oldProduct)
-	ginx.NewRender(c).Message(err)
-}
-
-func (rt *Router) embeddedProductDelete(c *gin.Context) {
-	id := ginx.UrlParamInt64(c, "id")
-	if id <= 0 {
-		ginx.Bomb(400, "invalid id")
-	}
-
-	err := models.DeleteEmbeddedProduct(rt.Ctx, id)
-	ginx.NewRender(c).Message(err)
-}
-
-func hasEmbeddedProductAccess(ctx *ctx.Context, user *models.User, ep *models.EmbeddedProduct) (bool, error) {
-	if user.IsAdmin() || !ep.IsPrivate {
-		return true, nil
-	}
-
-	gids, err := models.MyGroupIds(ctx, user.Id)
-	if err != nil {
-		return false, err
-	}
-
-	groupSet := make(map[int64]struct{}, len(gids))
-	for _, gid := range gids {
-		groupSet[gid] = struct{}{}
-	}
-
-	for _, tid := range ep.TeamIDs {
-		if _, ok := groupSet[tid]; ok {
-			return true, nil
-		}
-	}
-
-	return false, nil
-}

center/router/router_event_pipeline.go

@@ -4,11 +4,10 @@ import (
 	"net/http"
 	"time"
 
+	"github.com/ccfos/nightingale/v6/alert/pipeline"
 	"github.com/ccfos/nightingale/v6/models"
-
 	"github.com/gin-gonic/gin"
 	"github.com/toolkits/pkg/ginx"
-	"github.com/toolkits/pkg/i18n"
 )
 
 // 获取事件Pipeline列表
@@ -140,39 +139,22 @@ func (rt *Router) tryRunEventPipeline(c *gin.Context) {
 	}
 	event := hisEvent.ToCur()
 
-	lang := c.GetHeader("X-Language")
-	var result string
-	for _, p := range f.PipelineConfig.ProcessorConfigs {
-		processor, err := models.GetProcessorByType(p.Typ, p.Config)
+	for _, p := range f.PipelineConfig.Processors {
+		processor, err := pipeline.GetProcessorByType(p.Typ, p.Config)
 		if err != nil {
-			ginx.Bomb(http.StatusBadRequest, "get processor: %+v err: %+v", p, err)
-		}
-		event, result, err = processor.Process(rt.Ctx, event)
-		if err != nil {
-			ginx.Bomb(http.StatusBadRequest, "processor: %+v err: %+v", p, err)
-		}
-
-		if event == nil {
-			ginx.NewRender(c).Data(map[string]interface{}{
-				"event":  event,
-				"result": i18n.Sprintf(lang, "event is dropped"),
-			}, nil)
-			return
+			ginx.Bomb(http.StatusBadRequest, "processor %+v type not found, error: %s", p, err.Error())
 		}
+		processor.Process(rt.Ctx, event)
 	}
 
-	m := map[string]interface{}{
-		"event":  event,
-		"result": i18n.Sprintf(lang, result),
-	}
-	ginx.NewRender(c).Data(m, nil)
+	ginx.NewRender(c).Data(event, nil)
 }
 
 // 测试事件处理器
 func (rt *Router) tryRunEventProcessor(c *gin.Context) {
 	var f struct {
-		EventId         int64                  `json:"event_id"`
-		ProcessorConfig models.ProcessorConfig `json:"processor_config"`
+		EventId         int64            `json:"event_id"`
+		ProcessorConfig models.Processor `json:"processor_config"`
 	}
 	ginx.BindJSON(c, &f)
 
@@ -182,20 +164,13 @@ func (rt *Router) tryRunEventProcessor(c *gin.Context) {
 	}
 	event := hisEvent.ToCur()
 
-	processor, err := models.GetProcessorByType(f.ProcessorConfig.Typ, f.ProcessorConfig.Config)
+	processor, err := pipeline.GetProcessorByType(f.ProcessorConfig.Typ, f.ProcessorConfig.Config)
 	if err != nil {
-		ginx.Bomb(200, "get processor err: %+v", err)
-	}
-	event, res, err := processor.Process(rt.Ctx, event)
-	if err != nil {
-		ginx.Bomb(200, "processor err: %+v", err)
+		ginx.Bomb(http.StatusBadRequest, "processor type: %s, error: %s", f.ProcessorConfig.Typ, err.Error())
 	}
+	processor.Process(rt.Ctx, event)
 
-	lang := c.GetHeader("X-Language")
-	ginx.NewRender(c).Data(map[string]interface{}{
-		"event":  event,
-		"result": i18n.Sprintf(lang, res),
-	}, nil)
+	ginx.NewRender(c).Data(event, nil)
 }
 
 func (rt *Router) tryRunEventProcessorByNotifyRule(c *gin.Context) {
@@ -224,24 +199,12 @@ func (rt *Router) tryRunEventProcessorByNotifyRule(c *gin.Context) {
 	}
 
 	for _, pl := range pipelines {
-		for _, p := range pl.ProcessorConfigs {
-			processor, err := models.GetProcessorByType(p.Typ, p.Config)
+		for _, p := range pl.Processors {
+			processor, err := pipeline.GetProcessorByType(p.Typ, p.Config)
 			if err != nil {
-				ginx.Bomb(http.StatusBadRequest, "get processor: %+v err: %+v", p, err)
-			}
-
-			event, _, err := processor.Process(rt.Ctx, event)
-			if err != nil {
-				ginx.Bomb(http.StatusBadRequest, "processor: %+v err: %+v", p, err)
-			}
-			if event == nil {
-				lang := c.GetHeader("X-Language")
-				ginx.NewRender(c).Data(map[string]interface{}{
-					"event":  event,
-					"result": i18n.Sprintf(lang, "event is dropped"),
-				}, nil)
-				return
+				ginx.Bomb(http.StatusBadRequest, "processor %+v type not found", p)
 			}
+			processor.Process(rt.Ctx, event)
 		}
 	}
 

center/router/router_funcs.go

@@ -173,38 +173,3 @@ func Username(c *gin.Context) string {
 	}
 	return username
 }
-
-func HasPermission(ctx *ctx.Context, c *gin.Context, sourceType, sourceId string, isAnonymousAccess bool) bool {
-	if sourceType == "event" && isAnonymousAccess {
-		return true
-	}
-
-	// 尝试从请求中获取 __token 参数
-	token := ginx.QueryStr(c, "__token", "")
-
-	// 如果有 __token 参数，验证其合法性
-	if token != "" {
-		return ValidateSourceToken(ctx, sourceType, sourceId, token)
-	}
-
-	return false
-}
-
-func ValidateSourceToken(ctx *ctx.Context, sourceType, sourceId, token string) bool {
-	if token == "" {
-		return false
-	}
-
-	// 根据源类型、源ID和令牌获取源令牌记录
-	sourceToken, err := models.GetSourceTokenBySource(ctx, sourceType, sourceId, token)
-	if err != nil {
-		return false
-	}
-
-	// 检查令牌是否过期
-	if sourceToken.IsExpired() {
-		return false
-	}
-
-	return true
-}

center/router/router_message_template.go

@@ -12,9 +12,7 @@ import (
 	"github.com/ccfos/nightingale/v6/pkg/slice"
 	"github.com/ccfos/nightingale/v6/pkg/strx"
 	"github.com/ccfos/nightingale/v6/pkg/tplx"
-
 	"github.com/gin-gonic/gin"
-	"github.com/google/uuid"
 	"github.com/toolkits/pkg/ginx"
 )
 
@@ -32,12 +30,9 @@ func (rt *Router) messageTemplatesAdd(c *gin.Context) {
 	ginx.Dangerous(err)
 	now := time.Now().Unix()
 	for _, tpl := range lst {
-		// 生成一个唯一的标识符，以后也不允许修改，前端不需要传这个参数
-		tpl.Ident = uuid.New().String()
-
 		ginx.Dangerous(tpl.Verify())
 		if !isAdmin && !slice.HaveIntersection(gids, tpl.UserGroupIds) {
-			ginx.Bomb(http.StatusForbidden, "forbidden")
+			ginx.Bomb(http.StatusForbidden, "no permission")
 		}
 		idents = append(idents, tpl.Ident)
 
@@ -80,8 +75,8 @@ func (rt *Router) messageTemplatesDel(c *gin.Context) {
 		gids, err := models.MyGroupIds(rt.Ctx, me.Id)
 		ginx.Dangerous(err)
 		for _, t := range lst {
-			if !slice.HaveIntersection(gids, t.UserGroupIds) {
-				ginx.Bomb(http.StatusForbidden, "forbidden")
+			if !slice.HaveIntersection[int64](gids, t.UserGroupIds) {
+				ginx.Bomb(http.StatusForbidden, "no permission")
 			}
 		}
 	}
@@ -110,8 +105,8 @@ func (rt *Router) messageTemplatePut(c *gin.Context) {
 	if !me.IsAdmin() {
 		gids, err := models.MyGroupIds(rt.Ctx, me.Id)
 		ginx.Dangerous(err)
-		if !slice.HaveIntersection(gids, mt.UserGroupIds) {
-			ginx.Bomb(http.StatusForbidden, "forbidden")
+		if !slice.HaveIntersection[int64](gids, mt.UserGroupIds) {
+			ginx.Bomb(http.StatusForbidden, "no permission")
 		}
 	}
 
@@ -130,8 +125,8 @@ func (rt *Router) messageTemplateGet(c *gin.Context) {
 	if mt == nil {
 		ginx.Bomb(http.StatusNotFound, "message template not found")
 	}
-	if mt.Private == 1 && !slice.HaveIntersection(gids, mt.UserGroupIds) {
-		ginx.Bomb(http.StatusForbidden, "forbidden")
+	if mt.Private == 1 && !slice.HaveIntersection[int64](gids, mt.UserGroupIds) {
+		ginx.Bomb(http.StatusForbidden, "no permission")
 	}
 
 	ginx.NewRender(c).Data(mt, nil)
@@ -193,9 +188,10 @@ func (rt *Router) eventsMessage(c *gin.Context) {
 		events[i] = he.ToCur()
 	}
 
-	renderData := make(map[string]interface{})
-	renderData["events"] = events
-	defs := models.GetDefs(renderData)
+	var defs = []string{
+		"{{$events := .}}",
+		"{{$event := index . 0}}",
+	}
 	ret := make(map[string]string, len(req.Tpl.Content))
 	for k, v := range req.Tpl.Content {
 		text := strings.Join(append(defs, v), "")
@@ -206,7 +202,7 @@ func (rt *Router) eventsMessage(c *gin.Context) {
 		}
 
 		var buf bytes.Buffer
-		err = tpl.Execute(&buf, renderData)
+		err = tpl.Execute(&buf, events)
 		if err != nil {
 			ret[k] = err.Error()
 			continue

center/router/router_mute.go

@@ -6,21 +6,17 @@ import (
 	"time"
 
 	"github.com/ccfos/nightingale/v6/alert/common"
-	"github.com/ccfos/nightingale/v6/alert/mute"
 	"github.com/ccfos/nightingale/v6/models"
 	"github.com/ccfos/nightingale/v6/pkg/strx"
 
 	"github.com/gin-gonic/gin"
 	"github.com/toolkits/pkg/ginx"
-	"github.com/toolkits/pkg/i18n"
 )
 
 // Return all, front-end search and paging
 func (rt *Router) alertMuteGetsByBG(c *gin.Context) {
 	bgid := ginx.UrlParamInt64(c, "id")
-	prods := strings.Fields(ginx.QueryStr(c, "prods", ""))
-	query := ginx.QueryStr(c, "query", "")
-	lst, err := models.AlertMuteGets(rt.Ctx, prods, bgid, -1, query)
+	lst, err := models.AlertMuteGetsByBG(rt.Ctx, bgid)
 
 	ginx.NewRender(c).Data(lst, err)
 }
@@ -67,58 +63,10 @@ func (rt *Router) alertMuteAdd(c *gin.Context) {
 
 	username := c.MustGet("username").(string)
 	f.CreateBy = username
-	f.UpdateBy = username
 	f.GroupId = ginx.UrlParamInt64(c, "id")
 	ginx.NewRender(c).Message(f.Add(rt.Ctx))
 }
 
-type MuteTestForm struct {
-	EventId       int64            `json:"event_id" binding:"required"`
-	AlertMute     models.AlertMute `json:"config" binding:"required"`
-	PassTimeCheck bool             `json:"pass_time_check"`
-}
-
-func (rt *Router) alertMuteTryRun(c *gin.Context) {
-	var f MuteTestForm
-	ginx.BindJSON(c, &f)
-	ginx.Dangerous(f.AlertMute.Verify())
-
-	hisEvent, err := models.AlertHisEventGetById(rt.Ctx, f.EventId)
-	ginx.Dangerous(err)
-
-	if hisEvent == nil {
-		ginx.Bomb(http.StatusNotFound, "event not found")
-	}
-
-	curEvent := *hisEvent.ToCur()
-	curEvent.SetTagsMap()
-
-	if f.PassTimeCheck {
-		f.AlertMute.MuteTimeType = models.Periodic
-		f.AlertMute.PeriodicMutesJson = []models.PeriodicMute{
-			{
-				EnableDaysOfWeek: "0 1 2 3 4 5 6",
-				EnableStime:      "00:00",
-				EnableEtime:      "00:00",
-			},
-		}
-	}
-
-	match, err := mute.MatchMute(&curEvent, &f.AlertMute)
-	if err != nil {
-		// 对错误信息进行 i18n 翻译
-		translatedErr := i18n.Sprintf(c.GetHeader("X-Language"), err.Error())
-		ginx.Bomb(http.StatusBadRequest, translatedErr)
-	}
-
-	if !match {
-		ginx.NewRender(c).Data("event not match mute", nil)
-		return
-	}
-
-	ginx.NewRender(c).Data("event match mute", nil)
-}
-
 // 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).

center/router/router_mw.go

@@ -9,7 +9,6 @@ import (
 	"strings"
 	"time"
 
-	"github.com/ccfos/nightingale/v6/center/cstats"
 	"github.com/ccfos/nightingale/v6/models"
 
 	"github.com/gin-gonic/gin"
@@ -388,17 +387,13 @@ func (rt *Router) createAuth(ctx context.Context, userIdentity string, td *Token
 	now := time.Now()
 
 	if err := rt.Redis.Set(ctx, rt.wrapJwtKey(td.AccessUuid), userIdentity, at.Sub(now)).Err(); err != nil {
-		cstats.RedisOperationLatency.WithLabelValues("set_token", "fail").Observe(time.Since(now).Seconds())
 		return err
 	}
 
 	if err := rt.Redis.Set(ctx, rt.wrapJwtKey(td.RefreshUuid), userIdentity, rte.Sub(now)).Err(); err != nil {
-		cstats.RedisOperationLatency.WithLabelValues("set_token", "fail").Observe(time.Since(now).Seconds())
 		return err
 	}
 
-	cstats.RedisOperationLatency.WithLabelValues("set_token", "success").Observe(time.Since(now).Seconds())
-
 	if rt.HTTP.JWTAuth.SingleLogin {
 		if err := rt.Redis.SAdd(ctx, rt.wrapJwtKey(username), rt.wrapJwtKey(td.AccessUuid), rt.wrapJwtKey(td.RefreshUuid)).Err(); err != nil {
 			return err
@@ -409,25 +404,11 @@ func (rt *Router) createAuth(ctx context.Context, userIdentity string, td *Token
 }
 
 func (rt *Router) fetchAuth(ctx context.Context, givenUuid string) (string, error) {
-	now := time.Now()
-	ret, err := rt.Redis.Get(ctx, rt.wrapJwtKey(givenUuid)).Result()
-	if err != nil {
-		cstats.RedisOperationLatency.WithLabelValues("get_token", "fail").Observe(time.Since(now).Seconds())
-	} else {
-		cstats.RedisOperationLatency.WithLabelValues("get_token", "success").Observe(time.Since(now).Seconds())
-	}
-
-	return ret, err
+	return rt.Redis.Get(ctx, rt.wrapJwtKey(givenUuid)).Result()
 }
 
 func (rt *Router) deleteAuth(ctx context.Context, givenUuid string) error {
-	err := rt.Redis.Del(ctx, rt.wrapJwtKey(givenUuid)).Err()
-	if err != nil {
-		cstats.RedisOperationLatency.WithLabelValues("del_token", "fail").Observe(time.Since(time.Now()).Seconds())
-	} else {
-		cstats.RedisOperationLatency.WithLabelValues("del_token", "success").Observe(time.Since(time.Now()).Seconds())
-	}
-	return err
+	return rt.Redis.Del(ctx, rt.wrapJwtKey(givenUuid)).Err()
 }
 
 func (rt *Router) deleteTokens(ctx context.Context, authD *AccessDetails) error {

center/router/router_notify_rule.go

@@ -6,12 +6,11 @@ import (
 	"time"
 
 	"github.com/ccfos/nightingale/v6/alert/dispatch"
-	"github.com/ccfos/nightingale/v6/memsto"
 	"github.com/ccfos/nightingale/v6/models"
-	"github.com/ccfos/nightingale/v6/pkg/ctx"
 	"github.com/ccfos/nightingale/v6/pkg/slice"
 
 	"github.com/gin-gonic/gin"
+	"github.com/pkg/errors"
 	"github.com/toolkits/pkg/ginx"
 	"github.com/toolkits/pkg/logger"
 )
@@ -32,7 +31,7 @@ func (rt *Router) notifyRulesAdd(c *gin.Context) {
 	for _, nr := range lst {
 		ginx.Dangerous(nr.Verify())
 		if !isAdmin && !slice.HaveIntersection(gids, nr.UserGroupIds) {
-			ginx.Bomb(http.StatusForbidden, "forbidden")
+			ginx.Bomb(http.StatusForbidden, "no permission")
 		}
 
 		nr.CreateBy = me.Username
@@ -57,8 +56,8 @@ func (rt *Router) notifyRulesDel(c *gin.Context) {
 		gids, err := models.MyGroupIds(rt.Ctx, me.Id)
 		ginx.Dangerous(err)
 		for _, t := range lst {
-			if !slice.HaveIntersection(gids, t.UserGroupIds) {
-				ginx.Bomb(http.StatusForbidden, "forbidden")
+			if !slice.HaveIntersection[int64](gids, t.UserGroupIds) {
+				ginx.Bomb(http.StatusForbidden, "no permission")
 			}
 		}
 	}
@@ -80,8 +79,8 @@ func (rt *Router) notifyRulePut(c *gin.Context) {
 	me := c.MustGet("user").(*models.User)
 	gids, err := models.MyGroupIds(rt.Ctx, me.Id)
 	ginx.Dangerous(err)
-	if !slice.HaveIntersection(gids, nr.UserGroupIds) && !me.IsAdmin() {
-		ginx.Bomb(http.StatusForbidden, "forbidden")
+	if !slice.HaveIntersection[int64](gids, nr.UserGroupIds) && !me.IsAdmin() {
+		ginx.Bomb(http.StatusForbidden, "no permission")
 	}
 
 	f.UpdateBy = me.Username
@@ -100,8 +99,8 @@ func (rt *Router) notifyRuleGet(c *gin.Context) {
 		ginx.Bomb(http.StatusNotFound, "notify rule not found")
 	}
 
-	if !slice.HaveIntersection(gids, nr.UserGroupIds) && !me.IsAdmin() {
-		ginx.Bomb(http.StatusForbidden, "forbidden")
+	if !slice.HaveIntersection[int64](gids, nr.UserGroupIds) && !me.IsAdmin() {
+		ginx.Bomb(http.StatusForbidden, "no permission")
 	}
 
 	ginx.NewRender(c).Data(nr, nil)
@@ -153,117 +152,100 @@ func (rt *Router) notifyTest(c *gin.Context) {
 	for _, he := range hisEvents {
 		event := he.ToCur()
 		event.SetTagsMap()
-		if err := dispatch.NotifyRuleMatchCheck(&f.NotifyConfig, event); err != nil {
-			ginx.Bomb(http.StatusBadRequest, err.Error())
+		if dispatch.NotifyRuleApplicable(&f.NotifyConfig, event) {
+			events = append(events, event)
 		}
-
-		events = append(events, event)
 	}
 
-	resp, err := SendNotifyChannelMessage(rt.Ctx, rt.UserCache, rt.UserGroupCache, f.NotifyConfig, events)
-	if resp == "" {
-		resp = "success"
-	}
-	ginx.NewRender(c).Data(resp, err)
-}
-
-func SendNotifyChannelMessage(ctx *ctx.Context, userCache *memsto.UserCacheType, userGroup *memsto.UserGroupCacheType, notifyConfig models.NotifyConfig, events []*models.AlertCurEvent) (string, error) {
-	notifyChannels, err := models.NotifyChannelGets(ctx, notifyConfig.ChannelID, "", "", -1)
-	if err != nil {
-		return "", fmt.Errorf("failed to get notify channels: %v", err)
+	if len(events) == 0 {
+		ginx.Bomb(http.StatusBadRequest, "not events applicable")
 	}
 
+	notifyChannels, err := models.NotifyChannelGets(rt.Ctx, f.NotifyConfig.ChannelID, "", "", -1)
+	ginx.Dangerous(err)
 	if len(notifyChannels) == 0 {
-		return "", fmt.Errorf("notify channel not found")
+		ginx.Bomb(http.StatusBadRequest, "notify channel not found")
 	}
 
 	notifyChannel := notifyChannels[0]
-	if !notifyChannel.Enable {
-		return "", fmt.Errorf("notify channel not enabled, please enable it first")
-	}
-	tplContent := make(map[string]interface{})
-	if notifyChannel.RequestType != "flashduty" {
-		messageTemplates, err := models.MessageTemplateGets(ctx, notifyConfig.TemplateID, "", "")
-		if err != nil {
-			return "", fmt.Errorf("failed to get message templates: %v", err)
-		}
 
+	if !notifyChannel.Enable {
+		ginx.Bomb(http.StatusBadRequest, "notify channel not enabled, please enable it first")
+	}
+
+	tplContent := make(map[string]interface{})
+	if notifyChannel.RequestType != "flashtudy" {
+		messageTemplates, err := models.MessageTemplateGets(rt.Ctx, f.NotifyConfig.TemplateID, "", "")
+		ginx.Dangerous(err)
 		if len(messageTemplates) == 0 {
-			return "", fmt.Errorf("message template not found")
+			ginx.Bomb(http.StatusBadRequest, "message template not found")
 		}
 		tplContent = messageTemplates[0].RenderEvent(events)
 	}
+
 	var contactKey string
 	if notifyChannel.ParamConfig != nil && notifyChannel.ParamConfig.UserInfo != nil {
 		contactKey = notifyChannel.ParamConfig.UserInfo.ContactKey
 	}
 
-	sendtos, flashDutyChannelIDs, customParams := dispatch.GetNotifyConfigParams(&notifyConfig, contactKey, userCache, userGroup)
+	sendtos, flashDutyChannelIDs, customParams := dispatch.GetNotifyConfigParams(&f.NotifyConfig, contactKey, rt.UserCache, rt.UserGroupCache)
 
 	var resp string
 	switch notifyChannel.RequestType {
 	case "flashduty":
 		client, err := models.GetHTTPClient(notifyChannel)
-		if err != nil {
-			return "", fmt.Errorf("failed to get http client: %v", err)
-		}
+		ginx.Dangerous(err)
 
 		for i := range flashDutyChannelIDs {
 			resp, err = notifyChannel.SendFlashDuty(events, flashDutyChannelIDs[i], client)
 			if err != nil {
-				return "", fmt.Errorf("failed to send flashduty notify: %v", err)
+				break
 			}
 		}
 		logger.Infof("channel_name: %v, event:%+v, tplContent:%s, customParams:%v, respBody: %v, err: %v", notifyChannel.Name, events[0], tplContent, customParams, resp, err)
-		return resp, nil
+		ginx.NewRender(c).Data(resp, err)
 	case "http":
 		client, err := models.GetHTTPClient(notifyChannel)
-		if err != nil {
-			return "", fmt.Errorf("failed to get http client: %v", err)
-		}
+		ginx.Dangerous(err)
 
 		if notifyChannel.RequestConfig == nil {
-			return "", fmt.Errorf("request config is nil")
+			ginx.Bomb(http.StatusBadRequest, "request config not found")
 		}
 
 		if notifyChannel.RequestConfig.HTTPRequestConfig == nil {
-			return "", fmt.Errorf("http request config is nil")
+			ginx.Bomb(http.StatusBadRequest, "http request config not found")
 		}
 
 		if dispatch.NeedBatchContacts(notifyChannel.RequestConfig.HTTPRequestConfig) || len(sendtos) == 0 {
 			resp, err = notifyChannel.SendHTTP(events, tplContent, customParams, sendtos, client)
 			logger.Infof("channel_name: %v, event:%+v, sendtos:%+v, tplContent:%s, customParams:%v, respBody: %v, err: %v", notifyChannel.Name, events[0], sendtos, tplContent, customParams, resp, err)
 			if err != nil {
-				return "", fmt.Errorf("failed to send http notify: %v", err)
+				logger.Errorf("failed to send http notify: %v", err)
 			}
-			return resp, nil
+			ginx.NewRender(c).Data(resp, err)
 		} else {
 			for i := range sendtos {
 				resp, err = notifyChannel.SendHTTP(events, tplContent, customParams, []string{sendtos[i]}, client)
 				logger.Infof("channel_name: %v, event:%+v,  tplContent:%s, customParams:%v, sendto:%+v, respBody: %v, err: %v", notifyChannel.Name, events[0], tplContent, customParams, sendtos[i], resp, err)
 				if err != nil {
-					return "", fmt.Errorf("failed to send http notify: %v", err)
+					logger.Errorf("failed to send http notify: %v", err)
+					ginx.NewRender(c).Message(err)
+					return
 				}
 			}
-			return resp, nil
+			ginx.NewRender(c).Message(err)
 		}
 
 	case "smtp":
-		if len(sendtos) == 0 {
-			return "", fmt.Errorf("no valid email address in the user and team")
-		}
 		err := notifyChannel.SendEmailNow(events, tplContent, sendtos)
-		if err != nil {
-			return "", fmt.Errorf("failed to send email notify: %v", err)
-		}
-		return resp, nil
+		ginx.NewRender(c).Message(err)
 	case "script":
 		resp, _, err := notifyChannel.SendScript(events, tplContent, customParams, sendtos)
 		logger.Infof("channel_name: %v, event:%+v, tplContent:%s, customParams:%v, respBody: %v, err: %v", notifyChannel.Name, events[0], tplContent, customParams, resp, err)
-		return resp, err
+		ginx.NewRender(c).Data(resp, err)
 	default:
 		logger.Errorf("unsupported request type: %v", notifyChannel.RequestType)
-		return "", fmt.Errorf("unsupported request type")
+		ginx.NewRender(c).Message(errors.New("unsupported request type"))
 	}
 }
 

center/router/router_notify_tpl.go

@@ -45,7 +45,7 @@ func (rt *Router) notifyTplUpdateContent(c *gin.Context) {
 	ginx.Dangerous(err)
 
 	if notifyTpl.CreateBy != user.Username && !user.IsAdmin() {
-		ginx.Bomb(403, "forbidden")
+		ginx.Bomb(403, "no permission")
 	}
 
 	f.UpdateAt = time.Now().Unix()
@@ -64,7 +64,7 @@ func (rt *Router) notifyTplUpdate(c *gin.Context) {
 	ginx.Dangerous(err)
 
 	if notifyTpl.CreateBy != user.Username && !user.IsAdmin() {
-		ginx.Bomb(403, "forbidden")
+		ginx.Bomb(403, "no permission")
 	}
 
 	// get the count of the same channel and name but different id
@@ -188,7 +188,7 @@ func (rt *Router) notifyTplDel(c *gin.Context) {
 	ginx.Dangerous(err)
 
 	if notifyTpl.CreateBy != user.Username && !user.IsAdmin() {
-		ginx.Bomb(403, "forbidden")
+		ginx.Bomb(403, "no permission")
 	}
 
 	ginx.NewRender(c).Message(f.NotifyTplDelete(rt.Ctx, id))

center/router/router_opensearch.go

@@ -1,58 +0,0 @@
-package router
-
-import (
-	"github.com/ccfos/nightingale/v6/datasource/opensearch"
-	"github.com/ccfos/nightingale/v6/dscache"
-
-	"github.com/gin-gonic/gin"
-	"github.com/toolkits/pkg/ginx"
-	"github.com/toolkits/pkg/logger"
-)
-
-func (rt *Router) QueryOSIndices(c *gin.Context) {
-	var f IndexReq
-	ginx.BindJSON(c, &f)
-
-	plug, exists := dscache.DsCache.Get(f.Cate, f.DatasourceId)
-	if !exists {
-		logger.Warningf("cluster:%d not exists", f.DatasourceId)
-		ginx.Bomb(200, "cluster not exists")
-	}
-
-	indices, err := plug.(*opensearch.OpenSearch).QueryIndices()
-	ginx.Dangerous(err)
-
-	ginx.NewRender(c).Data(indices, nil)
-}
-
-func (rt *Router) QueryOSFields(c *gin.Context) {
-	var f IndexReq
-	ginx.BindJSON(c, &f)
-
-	plug, exists := dscache.DsCache.Get(f.Cate, f.DatasourceId)
-	if !exists {
-		logger.Warningf("cluster:%d not exists", f.DatasourceId)
-		ginx.Bomb(200, "cluster not exists")
-	}
-
-	fields, err := plug.(*opensearch.OpenSearch).QueryFields([]string{f.Index})
-	ginx.Dangerous(err)
-
-	ginx.NewRender(c).Data(fields, nil)
-}
-
-func (rt *Router) QueryOSVariable(c *gin.Context) {
-	var f FieldValueReq
-	ginx.BindJSON(c, &f)
-
-	plug, exists := dscache.DsCache.Get(f.Cate, f.DatasourceId)
-	if !exists {
-		logger.Warningf("cluster:%d not exists", f.DatasourceId)
-		ginx.Bomb(200, "cluster not exists")
-	}
-
-	fields, err := plug.(*opensearch.OpenSearch).QueryFieldValue([]string{f.Index}, f.Query.Field, f.Query.Query)
-	ginx.Dangerous(err)
-
-	ginx.NewRender(c).Data(fields, nil)
-}

center/router/router_proxy.go

@@ -7,20 +7,16 @@ import (
 	"net"
 	"net/http"
 	"net/http/httputil"
-	"regexp"
-	"strconv"
 	"strings"
 	"sync"
 	"time"
 
-	"github.com/ccfos/nightingale/v6/pkg/poster"
 	pkgprom "github.com/ccfos/nightingale/v6/pkg/prom"
 	"github.com/ccfos/nightingale/v6/prom"
 	"github.com/gin-gonic/gin"
 	"github.com/prometheus/common/model"
 	"github.com/toolkits/pkg/ginx"
 	"github.com/toolkits/pkg/logger"
-	"github.com/toolkits/pkg/net/httplib"
 )
 
 type QueryFormItem struct {
@@ -148,8 +144,6 @@ func (rt *Router) dsProxy(c *gin.Context) {
 
 		if ds.AuthJson.BasicAuthUser != "" {
 			req.SetBasicAuth(ds.AuthJson.BasicAuthUser, ds.AuthJson.BasicAuthPassword)
-		} else {
-			req.Header.Del("Authorization")
 		}
 
 		headerCount := len(ds.HTTPJson.Headers)
@@ -241,94 +235,3 @@ func transportPut(dsid, updatedat int64, tran http.RoundTripper) {
 	updatedAts[dsid] = updatedat
 	transportsLock.Unlock()
 }
-
-const (
-	DatasourceTypePrometheus      = "Prometheus"
-	DatasourceTypeVictoriaMetrics = "VictoriaMetrics"
-)
-
-type deleteDatasourceSeriesForm struct {
-	DatasourceID int64    `json:"datasource_id"`
-	Match        []string `json:"match"`
-	Start        string   `json:"start"`
-	End          string   `json:"end"`
-}
-
-func (rt *Router) deleteDatasourceSeries(c *gin.Context) {
-	var ddsf deleteDatasourceSeriesForm
-	ginx.BindJSON(c, &ddsf)
-	ds := rt.DatasourceCache.GetById(ddsf.DatasourceID)
-
-	if ds == nil {
-		ginx.Bomb(http.StatusBadRequest, "no such datasource")
-		return
-	}
-
-	// Get datasource type, now only support prometheus and victoriametrics
-	datasourceType, ok := ds.SettingsJson["prometheus.tsdb_type"]
-	if !ok {
-		ginx.Bomb(http.StatusBadRequest, "datasource type not found, please check your datasource settings")
-		return
-	}
-
-	target, err := ds.HTTPJson.ParseUrl()
-	if err != nil {
-		ginx.Bomb(http.StatusInternalServerError, "invalid urls: %s", ds.HTTPJson.GetUrls())
-		return
-	}
-
-	timeout := time.Duration(ds.HTTPJson.DialTimeout) * time.Millisecond
-	matchQuerys := make([]string, 0)
-	for _, match := range ddsf.Match {
-		matchQuerys = append(matchQuerys, fmt.Sprintf("match[]=%s", match))
-	}
-	matchQuery := strings.Join(matchQuerys, "&")
-
-	switch datasourceType {
-	case DatasourceTypePrometheus:
-		// Prometheus delete api need POST method
-		// https://prometheus.io/docs/prometheus/latest/querying/api/#delete-series
-		url := fmt.Sprintf("http://%s/api/v1/admin/tsdb/delete_series?%s&start=%s&end=%s", target.Host, matchQuery, ddsf.Start, ddsf.End)
-		go func() {
-			resp, _, err := poster.PostJSON(url, timeout, nil)
-			if err != nil {
-				logger.Errorf("delete series error datasource_id: %d, datasource_name: %s, match: %s, start: %s, end: %s, err: %v",
-					ddsf.DatasourceID, ds.Name, ddsf.Match, ddsf.Start, ddsf.End, err)
-				return
-			}
-			logger.Infof("delete datasource series datasource_id: %d, datasource_name: %s, match: %s, start: %s, end: %s, respBody: %s",
-				ddsf.DatasourceID, ds.Name, ddsf.Match, ddsf.Start, ddsf.End, string(resp))
-		}()
-	case DatasourceTypeVictoriaMetrics:
-		// Delete API doesn’t support the deletion of specific time ranges.
-		// Refer: https://docs.victoriametrics.com/victoriametrics/single-server-victoriametrics/#how-to-delete-time-series
-		var url string
-		// Check VictoriaMetrics is single node or cluster
-		// Cluster will have /select/<accountID>/prometheus pattern
-		re := regexp.MustCompile(`/select/(\d+)/prometheus`)
-		matches := re.FindStringSubmatch(ds.HTTPJson.Url)
-		if len(matches) > 0 && matches[1] != "" {
-			accountID, err := strconv.Atoi(matches[1])
-			if err != nil {
-				ginx.Bomb(http.StatusInternalServerError, "invalid accountID: %s", matches[1])
-			}
-			url = fmt.Sprintf("http://%s/delete/%d/prometheus/api/v1/admin/tsdb/delete_series?%s", target.Host, accountID, matchQuery)
-		} else {
-			url = fmt.Sprintf("http://%s/api/v1/admin/tsdb/delete_series?%s", target.Host, matchQuery)
-		}
-		go func() {
-			resp, err := httplib.Get(url).SetTimeout(timeout).Response()
-			if err != nil {
-				logger.Errorf("delete series failed | datasource_id: %d, datasource_name: %s, match: %s, start: %s, end: %s, err: %v",
-					ddsf.DatasourceID, ds.Name, ddsf.Match, ddsf.Start, ddsf.End, err)
-				return
-			}
-			logger.Infof("sending delete series request | datasource_id: %d, datasource_name: %s, match: %s, start: %s, end: %s, respBody: %s",
-				ddsf.DatasourceID, ds.Name, ddsf.Match, ddsf.Start, ddsf.End, resp.Body)
-		}()
-	default:
-		ginx.Bomb(http.StatusBadRequest, "not support delete series yet")
-	}
-
-	ginx.NewRender(c).Data(nil, nil)
-}

center/router/router_query.go

@@ -47,7 +47,7 @@ func QueryLogBatchConcurrently(anonymousAccess bool, ctx *gin.Context, f QueryFr
 
 	for _, q := range f.Queries {
 		if !anonymousAccess && !CheckDsPerm(ctx, q.Did, q.DsCate, q) {
-			return LogResp{}, fmt.Errorf("forbidden")
+			return LogResp{}, fmt.Errorf("no permission")
 		}
 
 		plug, exists := dscache.DsCache.Get(q.DsCate, q.Did)
@@ -114,7 +114,7 @@ func QueryDataConcurrently(anonymousAccess bool, ctx *gin.Context, f models.Quer
 
 	for _, q := range f.Querys {
 		if !anonymousAccess && !CheckDsPerm(ctx, f.DatasourceId, f.Cate, q) {
-			return nil, fmt.Errorf("forbidden")
+			return nil, fmt.Errorf("no permission")
 		}
 
 		plug, exists := dscache.DsCache.Get(f.Cate, f.DatasourceId)
@@ -185,7 +185,7 @@ func QueryLogConcurrently(anonymousAccess bool, ctx *gin.Context, f models.Query
 
 	for _, q := range f.Querys {
 		if !anonymousAccess && !CheckDsPerm(ctx, f.DatasourceId, f.Cate, q) {
-			return LogResp{}, fmt.Errorf("forbidden")
+			return LogResp{}, fmt.Errorf("no permission")
 		}
 
 		plug, exists := dscache.DsCache.Get(f.Cate, f.DatasourceId)
@@ -244,7 +244,7 @@ func (rt *Router) QueryLog(c *gin.Context) {
 	var resp []interface{}
 	for _, q := range f.Querys {
 		if !rt.Center.AnonymousAccess.PromQuerier && !CheckDsPerm(c, f.DatasourceId, f.Cate, q) {
-			ginx.Bomb(200, "forbidden")
+			ginx.Bomb(200, "no permission")
 		}
 
 		plug, exists := dscache.DsCache.Get("elasticsearch", f.DatasourceId)

center/router/router_recording_rule.go

@@ -149,12 +149,6 @@ func (rt *Router) recordingRulePutFields(c *gin.Context) {
 		f.Fields["datasource_queries"] = string(bytes)
 	}
 
-	if datasourceIds, ok := f.Fields["datasource_ids"]; ok {
-		bytes, err := json.Marshal(datasourceIds)
-		ginx.Dangerous(err)
-		f.Fields["datasource_ids"] = string(bytes)
-	}
-
 	for i := 0; i < len(f.Ids); i++ {
 		ar, err := models.RecordingRuleGetById(rt.Ctx, f.Ids[i])
 		ginx.Dangerous(err)

center/router/router_source_token.go

@@ -1,36 +0,0 @@
-package router
-
-import (
-	"net/http"
-	"time"
-
-	"github.com/ccfos/nightingale/v6/models"
-	"github.com/google/uuid"
-
-	"github.com/gin-gonic/gin"
-	"github.com/toolkits/pkg/ginx"
-)
-
-// sourceTokenAdd 生成新的源令牌
-func (rt *Router) sourceTokenAdd(c *gin.Context) {
-	var f models.SourceToken
-	ginx.BindJSON(c, &f)
-
-	if f.ExpireAt > 0 && f.ExpireAt <= time.Now().Unix() {
-		ginx.Bomb(http.StatusBadRequest, "expire time must be in the future")
-	}
-
-	token := uuid.New().String()
-
-	username := c.MustGet("username").(string)
-
-	f.Token = token
-	f.CreateBy = username
-	f.CreateAt = time.Now().Unix()
-
-	err := f.Add(rt.Ctx)
-	ginx.Dangerous(err)
-
-	go models.CleanupExpiredTokens(rt.Ctx)
-	ginx.NewRender(c).Data(token, nil)
-}

center/router/router_target.go

@@ -11,7 +11,6 @@ import (
 	"github.com/ccfos/nightingale/v6/models"
 	"github.com/ccfos/nightingale/v6/pkg/ctx"
 	"github.com/ccfos/nightingale/v6/pkg/strx"
-	"github.com/ccfos/nightingale/v6/pushgw/idents"
 	"github.com/ccfos/nightingale/v6/storage"
 
 	"github.com/gin-gonic/gin"
@@ -58,11 +57,8 @@ func (rt *Router) targetGets(c *gin.Context) {
 
 	var err error
 	if len(bgids) > 0 {
-		// 如果用户当前查看的是未归组机器，会传入 bgids = [0]，此时是不需要校验的，故而排除这种情况
-		if !(len(bgids) == 1 && bgids[0] == 0) {
-			for _, gid := range bgids {
-				rt.bgroCheck(c, gid)
-			}
+		for _, gid := range bgids {
+			rt.bgroCheck(c, gid)
 		}
 	} else {
 		user := c.MustGet("user").(*models.User)
@@ -462,7 +458,7 @@ func (rt *Router) targetBindBgids(c *gin.Context) {
 			ginx.Dangerous(err)
 
 			if !can {
-				ginx.Bomb(http.StatusForbidden, "forbidden")
+				ginx.Bomb(http.StatusForbidden, "No permission. You are not admin of BG(%s)", bg.Name)
 			}
 		}
 		isNeverGrouped, checkErr := haveNeverGroupedIdent(rt.Ctx, f.Idents)
@@ -472,7 +468,7 @@ func (rt *Router) targetBindBgids(c *gin.Context) {
 			can, err := user.CheckPerm(rt.Ctx, "/targets/bind")
 			ginx.Dangerous(err)
 			if !can {
-				ginx.Bomb(http.StatusForbidden, "forbidden")
+				ginx.Bomb(http.StatusForbidden, "No permission. Only admin can assign BG")
 			}
 		}
 	}
@@ -557,7 +553,7 @@ func (rt *Router) checkTargetPerm(c *gin.Context, idents []string) {
 	ginx.Dangerous(err)
 
 	if len(nopri) > 0 {
-		ginx.Bomb(http.StatusForbidden, "forbidden")
+		ginx.Bomb(http.StatusForbidden, "No permission to operate the targets: %s", strings.Join(nopri, ", "))
 	}
 }
 
@@ -580,11 +576,11 @@ func (rt *Router) targetsOfAlertRule(c *gin.Context) {
 }
 
 func (rt *Router) checkTargetsExistByIndent(idents []string) {
-	notExists, err := models.TargetNoExistIdents(rt.Ctx, idents)
+	existingIdents, err := models.TargetNoExistIdents(rt.Ctx, idents)
 	ginx.Dangerous(err)
 
-	if len(notExists) > 0 {
-		ginx.Bomb(http.StatusBadRequest, "targets not exist: %s", strings.Join(notExists, ", "))
+	if len(existingIdents) > 0 {
+		ginx.Bomb(http.StatusBadRequest, "targets not exist: %s", strings.Join(existingIdents, ","))
 	}
 }
 
@@ -602,10 +598,3 @@ func (rt *Router) targetsOfHostQuery(c *gin.Context) {
 
 	ginx.NewRender(c).Data(lst, nil)
 }
-
-func (rt *Router) targetUpdate(c *gin.Context) {
-	var f idents.TargetUpdate
-	ginx.BindJSON(c, &f)
-
-	ginx.NewRender(c).Message(rt.IdentSet.UpdateTargets(f.Lst, f.Now))
-}

center/router/router_task.go

@@ -1,7 +1,6 @@
 package router
 
 import (
-	"strings"
 	"time"
 
 	"github.com/ccfos/nightingale/v6/alert/sender"
@@ -85,6 +84,20 @@ func (rt *Router) taskGetsByGids(c *gin.Context) {
 	}, nil)
 }
 
+type taskForm struct {
+	Title     string   `json:"title" binding:"required"`
+	Account   string   `json:"account" binding:"required"`
+	Batch     int      `json:"batch"`
+	Tolerance int      `json:"tolerance"`
+	Timeout   int      `json:"timeout"`
+	Pause     string   `json:"pause"`
+	Script    string   `json:"script" binding:"required"`
+	Args      string   `json:"args"`
+	Action    string   `json:"action" binding:"required"`
+	Creator   string   `json:"creator"`
+	Hosts     []string `json:"hosts" binding:"required"`
+}
+
 func (rt *Router) taskRecordAdd(c *gin.Context) {
 	var f *models.TaskRecord
 	ginx.BindJSON(c, &f)
@@ -99,14 +112,6 @@ func (rt *Router) taskAdd(c *gin.Context) {
 
 	var f models.TaskForm
 	ginx.BindJSON(c, &f)
-	// 把 f.Hosts 中的空字符串过滤掉
-	hosts := make([]string, 0, len(f.Hosts))
-	for i := range f.Hosts {
-		if strings.TrimSpace(f.Hosts[i]) != "" {
-			hosts = append(hosts, strings.TrimSpace(f.Hosts[i]))
-		}
-	}
-	f.Hosts = hosts
 
 	bgid := ginx.UrlParamInt64(c, "id")
 	user := c.MustGet("user").(*models.User)

center/router/router_task_tpl.go

@@ -119,18 +119,6 @@ type taskTplForm struct {
 	Hosts     []string `json:"hosts"`
 }
 
-func (f *taskTplForm) Verify() {
-	// 传入的 f.Hosts 可能是 []string{"", "a", "b"}，需要过滤掉空字符串
-	args := make([]string, 0, len(f.Hosts))
-	for _, ident := range f.Hosts {
-		if strings.TrimSpace(ident) != "" {
-			args = append(args, strings.TrimSpace(ident))
-		}
-	}
-
-	f.Hosts = args
-}
-
 func (rt *Router) taskTplAdd(c *gin.Context) {
 	if !rt.Ibex.Enable {
 		ginx.Bomb(400, i18n.Sprintf(c.GetHeader("X-Language"), "This functionality has not been enabled. Please contact the system administrator to activate it."))
@@ -139,7 +127,6 @@ func (rt *Router) taskTplAdd(c *gin.Context) {
 
 	var f taskTplForm
 	ginx.BindJSON(c, &f)
-	f.Verify()
 
 	user := c.MustGet("user").(*models.User)
 	now := time.Now().Unix()
@@ -183,7 +170,6 @@ func (rt *Router) taskTplPut(c *gin.Context) {
 
 	var f taskTplForm
 	ginx.BindJSON(c, &f)
-	f.Verify()
 
 	rt.checkTargetsExistByIndent(f.Hosts)
 

center/router/router_user.go

@@ -1,7 +1,6 @@
 package router
 
 import (
-	"fmt"
 	"net/http"
 	"strings"
 
@@ -13,7 +12,6 @@ import (
 	"github.com/gin-gonic/gin"
 	"github.com/toolkits/pkg/ginx"
 	"github.com/toolkits/pkg/logger"
-	"gorm.io/gorm"
 )
 
 func (rt *Router) userBusiGroupsGets(c *gin.Context) {
@@ -237,217 +235,3 @@ func (rt *Router) userDel(c *gin.Context) {
 
 	ginx.NewRender(c).Message(target.Del(rt.Ctx))
 }
-
-func (rt *Router) installDateGet(c *gin.Context) {
-	rootUser, err := models.UserGetByUsername(rt.Ctx, "root")
-	if err != nil {
-		logger.Errorf("get root user failed: %v", err)
-		ginx.NewRender(c).Data(0, nil)
-		return
-	}
-
-	if rootUser == nil {
-		logger.Errorf("root user not found")
-		ginx.NewRender(c).Data(0, nil)
-		return
-	}
-
-	ginx.NewRender(c).Data(rootUser.CreateAt, nil)
-}
-
-// usersPhoneEncrypt 统一手机号加密
-func (rt *Router) usersPhoneEncrypt(c *gin.Context) {
-	users, err := models.UserGetAll(rt.Ctx)
-	if err != nil {
-		ginx.NewRender(c).Message(fmt.Errorf("get users failed: %v", err))
-		return
-	}
-
-	// 获取RSA密钥
-	_, publicKey, _, err := models.GetRSAKeys(rt.Ctx)
-	if err != nil {
-		ginx.NewRender(c).Message(fmt.Errorf("get RSA keys failed: %v", err))
-		return
-	}
-
-	// 先启用手机号加密功能
-	err = models.SetPhoneEncryptionEnabled(rt.Ctx, true)
-	if err != nil {
-		ginx.NewRender(c).Message(fmt.Errorf("enable phone encryption failed: %v", err))
-		return
-	}
-
-	// 刷新配置缓存
-	err = models.RefreshPhoneEncryptionCache(rt.Ctx)
-	if err != nil {
-		logger.Errorf("Failed to refresh phone encryption cache: %v", err)
-		// 回滚配置
-		models.SetPhoneEncryptionEnabled(rt.Ctx, false)
-		ginx.NewRender(c).Message(fmt.Errorf("refresh cache failed: %v", err))
-		return
-	}
-
-	successCount := 0
-	failCount := 0
-	var failedUsers []string
-
-	// 使用事务处理所有用户的手机号加密
-	err = models.DB(rt.Ctx).Transaction(func(tx *gorm.DB) error {
-		// 对每个用户的手机号进行加密
-		for _, user := range users {
-			if user.Phone == "" {
-				continue
-			}
-
-			if isPhoneEncrypted(user.Phone) {
-				continue
-			}
-
-			encryptedPhone, err := secu.EncryptValue(user.Phone, publicKey)
-			if err != nil {
-				logger.Errorf("Failed to encrypt phone for user %s: %v", user.Username, err)
-				failCount++
-				failedUsers = append(failedUsers, user.Username)
-				continue
-			}
-
-			err = tx.Model(&models.User{}).Where("id = ?", user.Id).Update("phone", encryptedPhone).Error
-			if err != nil {
-				logger.Errorf("Failed to update phone for user %s: %v", user.Username, err)
-				failCount++
-				failedUsers = append(failedUsers, user.Username)
-				continue
-			}
-
-			successCount++
-			logger.Debugf("Successfully encrypted phone for user %s", user.Username)
-		}
-
-		// 如果有失败的用户，回滚事务
-		if failCount > 0 {
-			return fmt.Errorf("encrypt failed users: %d, failed users: %v", failCount, failedUsers)
-		}
-
-		return nil
-	})
-
-	if err != nil {
-		// 加密失败，回滚配置
-		models.SetPhoneEncryptionEnabled(rt.Ctx, false)
-		models.RefreshPhoneEncryptionCache(rt.Ctx)
-		ginx.NewRender(c).Message(fmt.Errorf("encrypt phone failed: %v", err))
-		return
-	}
-
-	ginx.NewRender(c).Data(gin.H{
-		"success_count": successCount,
-		"fail_count":    failCount,
-	}, nil)
-}
-
-// usersPhoneDecrypt 统一手机号解密
-func (rt *Router) usersPhoneDecrypt(c *gin.Context) {
-	// 先关闭手机号加密功能
-	err := models.SetPhoneEncryptionEnabled(rt.Ctx, false)
-	if err != nil {
-		ginx.NewRender(c).Message(fmt.Errorf("disable phone encryption failed: %v", err))
-		return
-	}
-
-	// 刷新配置缓存
-	err = models.RefreshPhoneEncryptionCache(rt.Ctx)
-	if err != nil {
-		logger.Errorf("Failed to refresh phone encryption cache: %v", err)
-		// 回滚配置
-		models.SetPhoneEncryptionEnabled(rt.Ctx, true)
-		ginx.NewRender(c).Message(fmt.Errorf("refresh cache failed: %v", err))
-		return
-	}
-
-	// 获取所有用户（此时加密开关已关闭，直接读取数据库原始数据）
-	var users []*models.User
-	err = models.DB(rt.Ctx).Find(&users).Error
-	if err != nil {
-		// 回滚配置
-		models.SetPhoneEncryptionEnabled(rt.Ctx, true)
-		models.RefreshPhoneEncryptionCache(rt.Ctx)
-		ginx.NewRender(c).Message(fmt.Errorf("get users failed: %v", err))
-		return
-	}
-
-	// 获取RSA密钥
-	privateKey, _, password, err := models.GetRSAKeys(rt.Ctx)
-	if err != nil {
-		// 回滚配置
-		models.SetPhoneEncryptionEnabled(rt.Ctx, true)
-		models.RefreshPhoneEncryptionCache(rt.Ctx)
-		ginx.NewRender(c).Message(fmt.Errorf("get RSA keys failed: %v", err))
-		return
-	}
-
-	successCount := 0
-	failCount := 0
-	var failedUsers []string
-
-	// 使用事务处理所有用户的手机号解密
-	err = models.DB(rt.Ctx).Transaction(func(tx *gorm.DB) error {
-		// 对每个用户的手机号进行解密
-		for _, user := range users {
-			if user.Phone == "" {
-				continue
-			}
-
-			// 检查是否是加密的手机号
-			if !isPhoneEncrypted(user.Phone) {
-				continue
-			}
-
-			// 对手机号进行解密
-			decryptedPhone, err := secu.Decrypt(user.Phone, privateKey, password)
-			if err != nil {
-				logger.Errorf("Failed to decrypt phone for user %s: %v", user.Username, err)
-				failCount++
-				failedUsers = append(failedUsers, user.Username)
-				continue
-			}
-
-			// 直接更新数据库中的手机号字段（绕过GORM钩子）
-			err = tx.Model(&models.User{}).Where("id = ?", user.Id).Update("phone", decryptedPhone).Error
-			if err != nil {
-				logger.Errorf("Failed to update phone for user %s: %v", user.Username, err)
-				failCount++
-				failedUsers = append(failedUsers, user.Username)
-				continue
-			}
-
-			successCount++
-			logger.Debugf("Successfully decrypted phone for user %s", user.Username)
-		}
-
-		// 如果有失败的用户，回滚事务
-		if failCount > 0 {
-			return fmt.Errorf("decrypt failed users: %d, failed users: %v", failCount, failedUsers)
-		}
-
-		return nil
-	})
-
-	if err != nil {
-		// 解密失败，回滚配置
-		models.SetPhoneEncryptionEnabled(rt.Ctx, true)
-		models.RefreshPhoneEncryptionCache(rt.Ctx)
-		ginx.NewRender(c).Message(fmt.Errorf("decrypt phone failed: %v", err))
-		return
-	}
-
-	ginx.NewRender(c).Data(gin.H{
-		"success_count": successCount,
-		"fail_count":    failCount,
-	}, nil)
-}
-
-// isPhoneEncrypted 检查手机号是否已经加密
-func isPhoneEncrypted(phone string) bool {
-	// 检查是否有 "enc:" 前缀标记
-	return len(phone) > 4 && phone[:4] == "enc:"
-}

center/router/router_user_variable_config.go

@@ -40,7 +40,7 @@ func (rt *Router) userVariableConfigPut(context *gin.Context) {
 	user := context.MustGet("user").(*models.User)
 	if !user.IsAdmin() && f.CreateBy != user.Username {
 		// only admin or creator can update
-		ginx.Bomb(403, "forbidden")
+		ginx.Bomb(403, "no permission")
 	}
 
 	ginx.NewRender(context).Message(models.ConfigsUserVariableUpdate(rt.Ctx, f))
@@ -54,7 +54,7 @@ func (rt *Router) userVariableConfigDel(context *gin.Context) {
 	user := context.MustGet("user").(*models.User)
 	if !user.IsAdmin() && configs.CreateBy != user.Username {
 		// only admin or creator can delete
-		ginx.Bomb(403, "forbidden")
+		ginx.Bomb(403, "no permission")
 	}
 
 	if configs != nil && configs.External == models.ConfigExternal {

cmd/edge/edge.go

@@ -54,7 +54,7 @@ func Initialize(configDir string, cryptoKey string) (func(), error) {
 	targetCache := memsto.NewTargetCache(ctx, syncStats, redis)
 	busiGroupCache := memsto.NewBusiGroupCache(ctx, syncStats)
 	configCvalCache := memsto.NewCvalCache(ctx, syncStats)
-	idents := idents.New(ctx, redis, config.Pushgw)
+	idents := idents.New(ctx, redis)
 	metas := metas.New(redis)
 	writers := writer.NewWriters(config.Pushgw)
 	pushgwRouter := pushgwrt.New(config.HTTP, config.Pushgw, config.Alert, targetCache, busiGroupCache, idents, metas, writers, ctx)

conf/crypto.go

@@ -14,13 +14,6 @@ func decryptConfig(config *ConfigType, cryptoKey string) error {
 
 	config.DB.DSN = decryptDsn
 
-	decryptRedisPwd, err := secu.DealWithDecrypt(config.Redis.Password, cryptoKey)
-	if err != nil {
-		return fmt.Errorf("failed to decrypt the redis password: %s", err)
-	}
-
-	config.Redis.Password = decryptRedisPwd
-
 	for k := range config.HTTP.APIForService.BasicAuth {
 		decryptPwd, err := secu.DealWithDecrypt(config.HTTP.APIForService.BasicAuth[k], cryptoKey)
 		if err != nil {

datasource/commons/eslike/eslike.go

@@ -10,20 +10,12 @@ import (
 
 	"github.com/araddon/dateparse"
 	"github.com/bitly/go-simplejson"
+	"github.com/ccfos/nightingale/v6/memsto"
+	"github.com/ccfos/nightingale/v6/models"
 	"github.com/mitchellh/mapstructure"
 	"github.com/olivere/elastic/v7"
 	"github.com/prometheus/common/model"
 	"github.com/toolkits/pkg/logger"
-
-	"github.com/ccfos/nightingale/v6/memsto"
-	"github.com/ccfos/nightingale/v6/models"
-)
-
-type FixedField string
-
-const (
-	FieldIndex FixedField = "_index"
-	FieldId    FixedField = "_id"
 )
 
 type Query struct {
@@ -45,18 +37,6 @@ type Query struct {
 
 	Timeout  int `json:"timeout" mapstructure:"timeout"`
 	MaxShard int `json:"max_shard" mapstructure:"max_shard"`
-
-	SearchAfter *SearchAfter `json:"search_after" mapstructure:"search_after"`
-}
-
-type SortField struct {
-	Field     string `json:"field" mapstructure:"field"`
-	Ascending bool   `json:"ascending" mapstructure:"ascending"`
-}
-
-type SearchAfter struct {
-	SortFields  []SortField   `json:"sort_fields" mapstructure:"sort_fields"`   // 指定排序字段, 一般是timestamp:desc, _index:asc, _id:asc 三者组合，构成唯一的排序字段
-	SearchAfter []interface{} `json:"search_after" mapstructure:"search_after"` // 指定排序字段的搜索值，搜索值必须和sort_fields的顺序一致，为上一次查询的最后一条日志的值
 }
 
 type MetricAggr struct {
@@ -291,10 +271,7 @@ func MakeLogQuery(ctx context.Context, query interface{}, eventTags []string, st
 	}
 
 	for i := 0; i < len(eventTags); i++ {
-		arr := strings.SplitN(eventTags[i], "=", 2)
-		if len(arr) == 2 {
-			eventTags[i] = fmt.Sprintf("%s:%s", arr[0], strconv.Quote(arr[1]))
-		}
+		eventTags[i] = strings.Replace(eventTags[i], "=", ":", 1)
 	}
 
 	if len(eventTags) > 0 {
@@ -318,10 +295,7 @@ func MakeTSQuery(ctx context.Context, query interface{}, eventTags []string, sta
 	}
 
 	for i := 0; i < len(eventTags); i++ {
-		arr := strings.SplitN(eventTags[i], "=", 2)
-		if len(arr) == 2 {
-			eventTags[i] = fmt.Sprintf("%s:%s", arr[0], strconv.Quote(arr[1]))
-		}
+		eventTags[i] = strings.Replace(eventTags[i], "=", ":", 1)
 	}
 
 	if len(eventTags) > 0 {
@@ -442,9 +416,7 @@ func QueryData(ctx context.Context, queryParam interface{}, cliTimeout int64, ve
 		MinDocCount(1)
 
 	if strings.HasPrefix(version, "7") {
-		// 添加偏移量，使第一个分桶bucket的左边界对齐为 start 时间
-		offset := (start % param.Interval) - param.Interval
-		tsAggr.FixedInterval(fmt.Sprintf("%ds", param.Interval)).Offset(fmt.Sprintf("%ds", offset))
+		tsAggr.FixedInterval(fmt.Sprintf("%ds", param.Interval))
 	} else {
 		// 兼容 7.0 以下的版本
 		// OpenSearch 也使用这个字段
@@ -631,27 +603,14 @@ func QueryLog(ctx context.Context, queryParam interface{}, timeout int64, versio
 	if param.MaxShard < 1 {
 		param.MaxShard = maxShard
 	}
-	// from+size 分页方式获取日志，受es 的max_result_window参数限制，默认最多返回1w条日志, 可以使用search_after方式获取更多日志
+
 	source := elastic.NewSearchSource().
 		TrackTotalHits(true).
 		Query(queryString).
-		Size(param.Limit)
-	// 是否使用search_after方式
-	if param.SearchAfter != nil {
-		// 设置默认排序字段
-		if len(param.SearchAfter.SortFields) == 0 {
-			source = source.Sort(param.DateField, param.Ascending).Sort(string(FieldIndex), true).Sort(string(FieldId), true)
-		} else {
-			for _, field := range param.SearchAfter.SortFields {
-				source = source.Sort(field.Field, field.Ascending)
-			}
-		}
-		if len(param.SearchAfter.SearchAfter) > 0 {
-			source = source.SearchAfter(param.SearchAfter.SearchAfter...)
-		}
-	} else {
-		source = source.From(param.P).Sort(param.DateField, param.Ascending)
-	}
+		From(param.P).
+		Size(param.Limit).
+		Sort(param.DateField, param.Ascending)
+
 	result, err := search(ctx, indexArr, source, param.Timeout, param.MaxShard)
 	if err != nil {
 		logger.Warningf("query data error:%v", err)

datasource/datasource.go

@@ -53,20 +53,6 @@ func init() {
 		PluginType:     "ck",
 		PluginTypeName: "ClickHouse",
 	}
-
-	DatasourceTypes[5] = DatasourceType{
-		Id:             5,
-		Category:       "timeseries",
-		PluginType:     "mysql",
-		PluginTypeName: "MySQL",
-	}
-
-	DatasourceTypes[6] = DatasourceType{
-		Id:             6,
-		Category:       "timeseries",
-		PluginType:     "pgsql",
-		PluginTypeName: "PostgreSQL",
-	}
 }
 
 type NewDatasrouceFn func(settings map[string]interface{}) (Datasource, error)

datasource/doris/doris.go

@@ -1,213 +0,0 @@
-package doris
-
-import (
-	"context"
-	"fmt"
-	"strings"
-
-	"github.com/ccfos/nightingale/v6/datasource"
-	"github.com/ccfos/nightingale/v6/dskit/doris"
-	"github.com/ccfos/nightingale/v6/dskit/types"
-	"github.com/ccfos/nightingale/v6/pkg/macros"
-	"github.com/ccfos/nightingale/v6/models"
-
-	"github.com/mitchellh/mapstructure"
-	"github.com/toolkits/pkg/logger"
-)
-
-const (
-	DorisType = "doris"
-)
-
-func init() {
-	datasource.RegisterDatasource(DorisType, new(Doris))
-}
-
-type Doris struct {
-	doris.Doris `json:",inline" mapstructure:",squash"`
-}
-
-type QueryParam struct {
-	Ref        string          `json:"ref" mapstructure:"ref"`
-	Database   string          `json:"database" mapstructure:"database"`
-	Table      string          `json:"table" mapstructure:"table"`
-	SQL        string          `json:"sql" mapstructure:"sql"`
-	Keys       datasource.Keys `json:"keys" mapstructure:"keys"`
-	Limit      int             `json:"limit" mapstructure:"limit"`
-	From       int64           `json:"from" mapstructure:"from"`
-	To         int64           `json:"to" mapstructure:"to"`
-	TimeField  string          `json:"time_field" mapstructure:"time_field"`
-	TimeFormat string          `json:"time_format" mapstructure:"time_format"`
-}
-
-func (d *Doris) InitClient() error {
-	if len(d.Addr) == 0 {
-		return fmt.Errorf("not found doris addr, please check datasource config")
-	}
-	if _, err := d.NewConn(context.TODO(), ""); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (d *Doris) Init(settings map[string]interface{}) (datasource.Datasource, error) {
-	newest := new(Doris)
-	err := mapstructure.Decode(settings, newest)
-	return newest, err
-}
-
-func (d *Doris) Validate(ctx context.Context) error {
-	if len(d.Addr) == 0 || len(strings.TrimSpace(d.Addr)) == 0 {
-		return fmt.Errorf("doris addr is invalid, please check datasource setting")
-	}
-
-	if len(strings.TrimSpace(d.User)) == 0 {
-		return fmt.Errorf("doris user is invalid, please check datasource setting")
-	}
-
-	return nil
-}
-
-// Equal compares whether two objects are the same, used for caching
-func (d *Doris) Equal(p datasource.Datasource) bool {
-	newest, ok := p.(*Doris)
-	if !ok {
-		logger.Errorf("unexpected plugin type, expected is doris")
-		return false
-	}
-
-	// only compare first shard
-	if d.Addr != newest.Addr {
-		return false
-	}
-
-	if d.User != newest.User {
-		return false
-	}
-
-	if d.Password != newest.Password {
-		return false
-	}
-
-	if d.EnableWrite != newest.EnableWrite {
-		return false
-	}
-
-	if d.FeAddr != newest.FeAddr {
-		return false
-	}
-
-	if d.MaxQueryRows != newest.MaxQueryRows {
-		return false
-	}
-
-	if d.Timeout != newest.Timeout {
-		return false
-	}
-
-	if d.MaxIdleConns != newest.MaxIdleConns {
-		return false
-	}
-
-	if d.MaxOpenConns != newest.MaxOpenConns {
-		return false
-	}
-
-	if d.ConnMaxLifetime != newest.ConnMaxLifetime {
-		return false
-	}
-
-	if d.ClusterName != newest.ClusterName {
-		return false
-	}
-
-	return true
-}
-
-func (d *Doris) MakeLogQuery(ctx context.Context, query interface{}, eventTags []string, start, end int64) (interface{}, error) {
-	return nil, nil
-}
-
-func (d *Doris) MakeTSQuery(ctx context.Context, query interface{}, eventTags []string, start, end int64) (interface{}, error) {
-	return nil, nil
-}
-
-func (d *Doris) QueryMapData(ctx context.Context, query interface{}) ([]map[string]string, error) {
-	return nil, nil
-}
-
-func (d *Doris) QueryData(ctx context.Context, query interface{}) ([]models.DataResp, error) {
-	dorisQueryParam := new(QueryParam)
-	if err := mapstructure.Decode(query, dorisQueryParam); err != nil {
-		return nil, err
-	}
-
-	if dorisQueryParam.Keys.ValueKey == "" {
-		return nil, fmt.Errorf("valueKey is required")
-	}
-
-	items, err := d.QueryTimeseries(context.TODO(), &doris.QueryParam{
-		Database: dorisQueryParam.Database,
-		Sql:      dorisQueryParam.SQL,
-		Keys: types.Keys{
-			ValueKey: dorisQueryParam.Keys.ValueKey,
-			LabelKey: dorisQueryParam.Keys.LabelKey,
-			TimeKey:  dorisQueryParam.Keys.TimeKey,
-		},
-	})
-	if err != nil {
-		logger.Warningf("query:%+v get data err:%v", dorisQueryParam, err)
-		return []models.DataResp{}, err
-	}
-	data := make([]models.DataResp, 0)
-	for i := range items {
-		data = append(data, models.DataResp{
-			Ref:    dorisQueryParam.Ref,
-			Metric: items[i].Metric,
-			Values: items[i].Values,
-		})
-	}
-
-	// parse resp to time series data
-	logger.Infof("req:%+v keys:%+v \n data:%v", dorisQueryParam, dorisQueryParam.Keys, data)
-
-	return data, nil
-}
-
-func (d *Doris) QueryLog(ctx context.Context, query interface{}) ([]interface{}, int64, error) {
-	dorisQueryParam := new(QueryParam)
-	if err := mapstructure.Decode(query, dorisQueryParam); err != nil {
-		return nil, 0, err
-	}
-
-	if strings.Contains(dorisQueryParam.SQL, "$__") {
-		var err error
-		dorisQueryParam.SQL, err = macros.Macro(dorisQueryParam.SQL, dorisQueryParam.From, dorisQueryParam.To)
-		if err != nil {
-			return nil, 0, err
-		}
-	}
-
-	items, err := d.QueryLogs(ctx, &doris.QueryParam{
-		Database: dorisQueryParam.Database,
-		Sql:      dorisQueryParam.SQL,
-	})
-	if err != nil {
-		logger.Warningf("query:%+v get data err:%v", dorisQueryParam, err)
-		return []interface{}{}, 0, err
-	}
-	logs := make([]interface{}, 0)
-	for i := range items {
-		logs = append(logs, items[i])
-	}
-
-	return logs, int64(len(logs)), nil
-}
-
-func (d *Doris) DescribeTable(ctx context.Context, query interface{}) ([]*types.ColumnProperty, error) {
-	dorisQueryParam := new(QueryParam)
-	if err := mapstructure.Decode(query, dorisQueryParam); err != nil {
-		return nil, err
-	}
-	return d.DescTable(ctx, dorisQueryParam.Database, dorisQueryParam.Table)
-}

datasource/mysql/mysql.go

@@ -1,227 +0,0 @@
-package mysql
-
-import (
-	"context"
-	"fmt"
-	"strings"
-	"time"
-
-	"github.com/ccfos/nightingale/v6/datasource"
-	"github.com/ccfos/nightingale/v6/dskit/mysql"
-	"github.com/ccfos/nightingale/v6/dskit/sqlbase"
-	"github.com/ccfos/nightingale/v6/dskit/types"
-	"github.com/ccfos/nightingale/v6/models"
-	"github.com/ccfos/nightingale/v6/pkg/macros"
-
-	"github.com/mitchellh/mapstructure"
-	"github.com/toolkits/pkg/logger"
-)
-
-const (
-	MySQLType = "mysql"
-)
-
-func init() {
-	datasource.RegisterDatasource(MySQLType, new(MySQL))
-}
-
-type MySQL struct {
-	mysql.MySQL `json:",inline" mapstructure:",squash"`
-}
-
-type QueryParam struct {
-	Ref      string          `json:"ref" mapstructure:"ref"`
-	Database string          `json:"database" mapstructure:"database"`
-	Table    string          `json:"table" mapstructure:"table"`
-	SQL      string          `json:"sql" mapstructure:"sql"`
-	Keys     datasource.Keys `json:"keys" mapstructure:"keys"`
-	From     int64           `json:"from" mapstructure:"from"`
-	To       int64           `json:"to" mapstructure:"to"`
-}
-
-func (m *MySQL) InitClient() error {
-	if len(m.Shards) == 0 {
-		return fmt.Errorf("not found mysql addr, please check datasource config")
-	}
-	if _, err := m.NewConn(context.TODO(), ""); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (m *MySQL) Init(settings map[string]interface{}) (datasource.Datasource, error) {
-	newest := new(MySQL)
-	err := mapstructure.Decode(settings, newest)
-	return newest, err
-}
-
-func (m *MySQL) Validate(ctx context.Context) error {
-	if len(m.Shards) == 0 || len(strings.TrimSpace(m.Shards[0].Addr)) == 0 {
-		return fmt.Errorf("mysql addr is invalid, please check datasource setting")
-	}
-
-	if len(strings.TrimSpace(m.Shards[0].User)) == 0 {
-		return fmt.Errorf("mysql user is invalid, please check datasource setting")
-	}
-
-	return nil
-}
-
-// Equal compares whether two objects are the same, used for caching
-func (m *MySQL) Equal(p datasource.Datasource) bool {
-	newest, ok := p.(*MySQL)
-	if !ok {
-		logger.Errorf("unexpected plugin type, expected is mysql")
-		return false
-	}
-
-	if len(m.Shards) == 0 || len(newest.Shards) == 0 {
-		return false
-	}
-
-	oldShard := m.Shards[0]
-	newShard := newest.Shards[0]
-
-	if oldShard.Addr != newShard.Addr {
-		return false
-	}
-
-	if oldShard.User != newShard.User {
-		return false
-	}
-
-	if oldShard.Password != newShard.Password {
-		return false
-	}
-
-	if oldShard.MaxQueryRows != newShard.MaxQueryRows {
-		return false
-	}
-
-	if oldShard.Timeout != newShard.Timeout {
-		return false
-	}
-
-	if oldShard.MaxIdleConns != newShard.MaxIdleConns {
-		return false
-	}
-
-	if oldShard.MaxOpenConns != newShard.MaxOpenConns {
-		return false
-	}
-
-	if oldShard.ConnMaxLifetime != newShard.ConnMaxLifetime {
-		return false
-	}
-
-	return true
-}
-
-func (m *MySQL) MakeLogQuery(ctx context.Context, query interface{}, eventTags []string, start, end int64) (interface{}, error) {
-	return nil, nil
-}
-
-func (m *MySQL) MakeTSQuery(ctx context.Context, query interface{}, eventTags []string, start, end int64) (interface{}, error) {
-	return nil, nil
-}
-
-func (m *MySQL) QueryMapData(ctx context.Context, query interface{}) ([]map[string]string, error) {
-	return nil, nil
-}
-
-func (m *MySQL) QueryData(ctx context.Context, query interface{}) ([]models.DataResp, error) {
-	mysqlQueryParam := new(QueryParam)
-	if err := mapstructure.Decode(query, mysqlQueryParam); err != nil {
-		return nil, err
-	}
-
-	if strings.Contains(mysqlQueryParam.SQL, "$__") {
-		var err error
-		mysqlQueryParam.SQL, err = macros.Macro(mysqlQueryParam.SQL, mysqlQueryParam.From, mysqlQueryParam.To)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	if mysqlQueryParam.Keys.ValueKey == "" {
-		return nil, fmt.Errorf("valueKey is required")
-	}
-
-	timeout := m.Shards[0].Timeout
-	if timeout == 0 {
-		timeout = 60
-	}
-
-	timeoutCtx, cancel := context.WithTimeout(ctx, time.Duration(timeout)*time.Second)
-	defer cancel()
-
-	items, err := m.QueryTimeseries(timeoutCtx, &sqlbase.QueryParam{
-		Sql: mysqlQueryParam.SQL,
-		Keys: types.Keys{
-			ValueKey: mysqlQueryParam.Keys.ValueKey,
-			LabelKey: mysqlQueryParam.Keys.LabelKey,
-			TimeKey:  mysqlQueryParam.Keys.TimeKey,
-		},
-	})
-
-	if err != nil {
-		logger.Warningf("query:%+v get data err:%v", mysqlQueryParam, err)
-		return []models.DataResp{}, err
-	}
-	data := make([]models.DataResp, 0)
-	for i := range items {
-		data = append(data, models.DataResp{
-			Ref:    mysqlQueryParam.Ref,
-			Metric: items[i].Metric,
-			Values: items[i].Values,
-		})
-	}
-
-	return data, nil
-}
-
-func (m *MySQL) QueryLog(ctx context.Context, query interface{}) ([]interface{}, int64, error) {
-	mysqlQueryParam := new(QueryParam)
-	if err := mapstructure.Decode(query, mysqlQueryParam); err != nil {
-		return nil, 0, err
-	}
-
-	if strings.Contains(mysqlQueryParam.SQL, "$__") {
-		var err error
-		mysqlQueryParam.SQL, err = macros.Macro(mysqlQueryParam.SQL, mysqlQueryParam.From, mysqlQueryParam.To)
-		if err != nil {
-			return nil, 0, err
-		}
-	}
-
-	timeout := m.Shards[0].Timeout
-	if timeout == 0 {
-		timeout = 60
-	}
-
-	timeoutCtx, cancel := context.WithTimeout(ctx, time.Duration(timeout)*time.Second)
-	defer cancel()
-
-	items, err := m.Query(timeoutCtx, &sqlbase.QueryParam{
-		Sql: mysqlQueryParam.SQL,
-	})
-
-	if err != nil {
-		logger.Warningf("query:%+v get data err:%v", mysqlQueryParam, err)
-		return []interface{}{}, 0, err
-	}
-	logs := make([]interface{}, 0)
-	for i := range items {
-		logs = append(logs, items[i])
-	}
-
-	return logs, 0, nil
-}
-
-func (m *MySQL) DescribeTable(ctx context.Context, query interface{}) ([]*types.ColumnProperty, error) {
-	mysqlQueryParam := new(QueryParam)
-	if err := mapstructure.Decode(query, mysqlQueryParam); err != nil {
-		return nil, err
-	}
-	return m.DescTable(ctx, mysqlQueryParam.Database, mysqlQueryParam.Table)
-}

datasource/opensearch/opensearch.go

@@ -1,401 +0,0 @@
-package opensearch
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net"
-	"net/http"
-	"net/url"
-	"reflect"
-	"regexp"
-	"sort"
-	"strings"
-	"time"
-
-	"github.com/ccfos/nightingale/v6/datasource"
-	"github.com/ccfos/nightingale/v6/datasource/commons/eslike"
-	"github.com/ccfos/nightingale/v6/models"
-	"github.com/ccfos/nightingale/v6/pkg/tlsx"
-
-	"github.com/mitchellh/mapstructure"
-	"github.com/olivere/elastic/v7"
-	oscliv2 "github.com/opensearch-project/opensearch-go/v2"
-	osapiv2 "github.com/opensearch-project/opensearch-go/v2/opensearchapi"
-)
-
-const (
-	OpenSearchType = "opensearch"
-)
-
-type OpenSearch struct {
-	Addr        string            `json:"os.addr" mapstructure:"os.addr"`
-	Nodes       []string          `json:"os.nodes" mapstructure:"os.nodes"`
-	Timeout     int64             `json:"os.timeout" mapstructure:"os.timeout"` // millis
-	Basic       BasicAuth         `json:"os.basic" mapstructure:"os.basic"`
-	TLS         TLS               `json:"os.tls" mapstructure:"os.tls"`
-	Version     string            `json:"os.version" mapstructure:"os.version"`
-	Headers     map[string]string `json:"os.headers" mapstructure:"os.headers"`
-	MinInterval int               `json:"os.min_interval" mapstructure:"os.min_interval"` // seconds
-	MaxShard    int               `json:"os.max_shard" mapstructure:"os.max_shard"`
-	ClusterName string            `json:"os.cluster_name" mapstructure:"os.cluster_name"`
-	Client      *oscliv2.Client   `json:"os.client" mapstructure:"os.client"`
-}
-
-type TLS struct {
-	SkipTlsVerify bool `json:"os.tls.skip_tls_verify" mapstructure:"os.tls.skip_tls_verify"`
-}
-
-type BasicAuth struct {
-	Enable   bool   `json:"os.auth.enable" mapstructure:"os.auth.enable"`
-	Username string `json:"os.user" mapstructure:"os.user"`
-	Password string `json:"os.password" mapstructure:"os.password"`
-}
-
-func init() {
-	datasource.RegisterDatasource(OpenSearchType, new(OpenSearch))
-}
-
-func (os *OpenSearch) Init(settings map[string]interface{}) (datasource.Datasource, error) {
-	newest := new(OpenSearch)
-	err := mapstructure.Decode(settings, newest)
-	return newest, err
-}
-
-func (os *OpenSearch) InitClient() error {
-	transport := &http.Transport{
-		Proxy: http.ProxyFromEnvironment,
-		DialContext: (&net.Dialer{
-			Timeout: time.Duration(os.Timeout) * time.Millisecond,
-		}).DialContext,
-		ResponseHeaderTimeout: time.Duration(os.Timeout) * time.Millisecond,
-	}
-
-	if len(os.Nodes) > 0 {
-		os.Addr = os.Nodes[0]
-	}
-
-	if strings.Contains(os.Addr, "https") {
-		tlsConfig := tlsx.ClientConfig{
-			InsecureSkipVerify: os.TLS.SkipTlsVerify,
-			UseTLS:             true,
-		}
-		cfg, err := tlsConfig.TLSConfig()
-		if err != nil {
-			return err
-		}
-		transport.TLSClientConfig = cfg
-	}
-
-	headers := http.Header{}
-	for k, v := range os.Headers {
-		headers[k] = []string{v}
-	}
-
-	options := oscliv2.Config{
-		Addresses: os.Nodes,
-		Transport: transport,
-		Header:    headers,
-	}
-
-	// 只要有用户名就添加认证，不依赖 Enable 字段
-	if os.Basic.Username != "" {
-		options.Username = os.Basic.Username
-		options.Password = os.Basic.Password
-	}
-
-	var err = error(nil)
-	os.Client, err = oscliv2.NewClient(options)
-
-	return err
-}
-
-func (os *OpenSearch) Equal(other datasource.Datasource) bool {
-	sort.Strings(os.Nodes)
-	sort.Strings(other.(*OpenSearch).Nodes)
-
-	if strings.Join(os.Nodes, ",") != strings.Join(other.(*OpenSearch).Nodes, ",") {
-		return false
-	}
-
-	if os.Basic.Username != other.(*OpenSearch).Basic.Username {
-		return false
-	}
-
-	if os.Basic.Password != other.(*OpenSearch).Basic.Password {
-		return false
-	}
-
-	if os.TLS.SkipTlsVerify != other.(*OpenSearch).TLS.SkipTlsVerify {
-		return false
-	}
-
-	if os.Timeout != other.(*OpenSearch).Timeout {
-		return false
-	}
-
-	if !reflect.DeepEqual(os.Headers, other.(*OpenSearch).Headers) {
-		return false
-	}
-
-	return true
-}
-
-func (os *OpenSearch) Validate(ctx context.Context) (err error) {
-	if len(os.Nodes) == 0 {
-		return fmt.Errorf("need a valid addr")
-	}
-
-	for _, addr := range os.Nodes {
-		_, err = url.Parse(addr)
-		if err != nil {
-			return fmt.Errorf("parse addr error: %v", err)
-		}
-	}
-
-	// 如果提供了用户名，必须同时提供密码
-	if len(os.Basic.Username) > 0 && len(os.Basic.Password) == 0 {
-		return fmt.Errorf("password is required when username is provided")
-	}
-
-	if os.MaxShard == 0 {
-		os.MaxShard = 5
-	}
-
-	if os.MinInterval < 10 {
-		os.MinInterval = 10
-	}
-
-	if os.Timeout == 0 {
-		os.Timeout = 6000
-	}
-
-	if !strings.HasPrefix(os.Version, "2") {
-		return fmt.Errorf("version must be 2.0+")
-	}
-
-	return nil
-}
-
-func (os *OpenSearch) MakeLogQuery(ctx context.Context, query interface{}, eventTags []string, start, end int64) (interface{}, error) {
-	return eslike.MakeLogQuery(ctx, query, eventTags, start, end)
-}
-
-func (os *OpenSearch) MakeTSQuery(ctx context.Context, query interface{}, eventTags []string, start, end int64) (interface{}, error) {
-	return eslike.MakeTSQuery(ctx, query, eventTags, start, end)
-}
-
-func search(ctx context.Context, indices []string, source interface{}, timeout int, cli *oscliv2.Client) (*elastic.SearchResult, error) {
-	var body *bytes.Buffer = nil
-	if source != nil {
-		body = new(bytes.Buffer)
-		err := json.NewEncoder(body).Encode(source)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	req := osapiv2.SearchRequest{
-		Index: indices,
-		Body:  body,
-	}
-
-	if timeout > 0 {
-		req.Timeout = time.Second * time.Duration(timeout)
-	}
-
-	resp, err := req.Do(ctx, cli)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		return nil, fmt.Errorf("opensearch response not 2xx, resp is %v", resp)
-	}
-
-	bs, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return nil, err
-	}
-
-	result := new(elastic.SearchResult)
-	err = json.Unmarshal(bs, &result)
-	if err != nil {
-		return nil, err
-	}
-
-	return result, nil
-}
-
-func (os *OpenSearch) QueryData(ctx context.Context, queryParam interface{}) ([]models.DataResp, error) {
-
-	search := func(ctx context.Context, indices []string, source interface{}, timeout int, maxShard int) (*elastic.SearchResult, error) {
-		return search(ctx, indices, source, timeout, os.Client)
-	}
-
-	return eslike.QueryData(ctx, queryParam, os.Timeout, os.Version, search)
-}
-
-func (os *OpenSearch) QueryIndices() ([]string, error) {
-
-	cir := osapiv2.CatIndicesRequest{
-		Format: "json",
-	}
-
-	rsp, err := cir.Do(context.Background(), os.Client)
-	if err != nil {
-		return nil, err
-	}
-	defer rsp.Body.Close()
-
-	bs, err := io.ReadAll(rsp.Body)
-	if err != nil {
-		return nil, err
-	}
-
-	resp := make([]struct {
-		Index string `json:"index"`
-	}, 0)
-
-	err = json.Unmarshal(bs, &resp)
-	if err != nil {
-		return nil, err
-	}
-
-	var ret []string
-	for _, k := range resp {
-		ret = append(ret, k.Index)
-	}
-
-	return ret, nil
-}
-
-func (os *OpenSearch) QueryFields(indices []string) ([]string, error) {
-
-	var fields []string
-	mappingRequest := osapiv2.IndicesGetMappingRequest{
-		Index: indices,
-	}
-
-	resp, err := mappingRequest.Do(context.Background(), os.Client)
-	if err != nil {
-		return fields, err
-	}
-	defer resp.Body.Close()
-	bs, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return fields, err
-	}
-
-	result := map[string]interface{}{}
-
-	err = json.Unmarshal(bs, &result)
-	if err != nil {
-		return fields, err
-	}
-
-	idx := ""
-	if len(indices) > 0 {
-		idx = indices[0]
-	}
-
-	mappingIndex := ""
-	indexReg, _ := regexp.Compile(idx)
-	for key, value := range result {
-		mappings, ok := value.(map[string]interface{})
-		if !ok {
-			continue
-		}
-		if len(mappings) == 0 {
-			continue
-		}
-		if key == idx || strings.Contains(key, idx) ||
-			(indexReg != nil && indexReg.MatchString(key)) {
-			mappingIndex = key
-			break
-		}
-	}
-
-	if len(mappingIndex) == 0 {
-		return fields, nil
-	}
-
-	fields = propertyMappingRange(result[mappingIndex], 1)
-
-	sort.Strings(fields)
-	return fields, nil
-}
-
-func propertyMappingRange(v interface{}, depth int) (fields []string) {
-	mapping, ok := v.(map[string]interface{})
-	if !ok {
-		return
-	}
-	if len(mapping) == 0 {
-		return
-	}
-	for key, value := range mapping {
-		if reflect.TypeOf(value).Kind() == reflect.Map {
-			valueMap := value.(map[string]interface{})
-			if prop, found := valueMap["properties"]; found {
-				subFields := propertyMappingRange(prop, depth+1)
-				for i := range subFields {
-					if depth == 1 {
-						fields = append(fields, subFields[i])
-					} else {
-						fields = append(fields, key+"."+subFields[i])
-					}
-				}
-			} else if typ, found := valueMap["type"]; found {
-				if eslike.HitFilter(typ.(string)) {
-					continue
-				}
-				fields = append(fields, key)
-			}
-		}
-	}
-	return
-}
-
-func (os *OpenSearch) QueryLog(ctx context.Context, queryParam interface{}) ([]interface{}, int64, error) {
-
-	search := func(ctx context.Context, indices []string, source interface{}, timeout int, maxShard int) (*elastic.SearchResult, error) {
-		return search(ctx, indices, source, timeout, os.Client)
-	}
-
-	return eslike.QueryLog(ctx, queryParam, os.Timeout, os.Version, 0, search)
-}
-
-func (os *OpenSearch) QueryFieldValue(indexs []string, field string, query string) ([]string, error) {
-	var values []string
-	source := elastic.NewSearchSource().
-		Size(0)
-
-	if query != "" {
-		source = source.Query(elastic.NewBoolQuery().Must(elastic.NewQueryStringQuery(query)))
-	}
-	source = source.Aggregation("distinct", elastic.NewTermsAggregation().Field(field).Size(10000))
-
-	result, err := search(context.Background(), indexs, source, 0, os.Client)
-	if err != nil {
-		return values, err
-	}
-
-	agg, found := result.Aggregations.Terms("distinct")
-	if !found {
-		return values, nil
-	}
-
-	for _, bucket := range agg.Buckets {
-		values = append(values, bucket.Key.(string))
-	}
-
-	return values, nil
-}
-
-func (os *OpenSearch) QueryMapData(ctx context.Context, query interface{}) ([]map[string]string, error) {
-	return nil, nil
-}

datasource/postgresql/postgresql.go

@@ -1,358 +0,0 @@
-package postgresql
-
-import (
-	"context"
-	"fmt"
-	"regexp"
-	"strings"
-	"time"
-
-	"github.com/ccfos/nightingale/v6/datasource"
-	"github.com/ccfos/nightingale/v6/pkg/macros"
-
-	"github.com/ccfos/nightingale/v6/dskit/postgres"
-	"github.com/ccfos/nightingale/v6/dskit/sqlbase"
-	"github.com/ccfos/nightingale/v6/dskit/types"
-	"github.com/ccfos/nightingale/v6/models"
-	"github.com/mitchellh/mapstructure"
-	"github.com/toolkits/pkg/logger"
-)
-
-const (
-	PostgreSQLType = "pgsql"
-)
-
-var (
-	regx = `(?i)from\s+((?:"[^"]+"|[a-zA-Z0-9_]+))\.((?:"[^"]+"|[a-zA-Z0-9_]+))\.((?:"[^"]+"|[a-zA-Z0-9_]+))`
-)
-
-func init() {
-	datasource.RegisterDatasource(PostgreSQLType, new(PostgreSQL))
-}
-
-type PostgreSQL struct {
-	Shards []*postgres.PostgreSQL `json:"pgsql.shards" mapstructure:"pgsql.shards"`
-}
-
-type QueryParam struct {
-	Ref      string          `json:"ref" mapstructure:"ref"`
-	Database string          `json:"database" mapstructure:"database"`
-	Table    string          `json:"table" mapstructure:"table"`
-	SQL      string          `json:"sql" mapstructure:"sql"`
-	Keys     datasource.Keys `json:"keys" mapstructure:"keys"`
-	From     int64           `json:"from" mapstructure:"from"`
-	To       int64           `json:"to" mapstructure:"to"`
-}
-
-func (p *PostgreSQL) InitClient() error {
-	if len(p.Shards) == 0 {
-		return fmt.Errorf("not found postgresql addr, please check datasource config")
-	}
-	for _, shard := range p.Shards {
-		if db, err := shard.NewConn(context.TODO(), "postgres"); err != nil {
-			defer sqlbase.CloseDB(db)
-			return err
-		}
-	}
-	return nil
-}
-
-func (p *PostgreSQL) Init(settings map[string]interface{}) (datasource.Datasource, error) {
-	newest := new(PostgreSQL)
-	err := mapstructure.Decode(settings, newest)
-	return newest, err
-}
-
-func (p *PostgreSQL) Validate(ctx context.Context) error {
-	if len(p.Shards) == 0 || len(strings.TrimSpace(p.Shards[0].Addr)) == 0 {
-		return fmt.Errorf("postgresql addr is invalid, please check datasource setting")
-	}
-
-	if len(strings.TrimSpace(p.Shards[0].User)) == 0 {
-		return fmt.Errorf("postgresql user is invalid, please check datasource setting")
-	}
-
-	return nil
-}
-
-// Equal compares whether two objects are the same, used for caching
-func (p *PostgreSQL) Equal(d datasource.Datasource) bool {
-	newest, ok := d.(*PostgreSQL)
-	if !ok {
-		logger.Errorf("unexpected plugin type, expected is postgresql")
-		return false
-	}
-
-	if len(p.Shards) == 0 || len(newest.Shards) == 0 {
-		return false
-	}
-
-	oldShard := p.Shards[0]
-	newShard := newest.Shards[0]
-
-	if oldShard.Addr != newShard.Addr {
-		return false
-	}
-
-	if oldShard.User != newShard.User {
-		return false
-	}
-
-	if oldShard.Password != newShard.Password {
-		return false
-	}
-
-	if oldShard.MaxQueryRows != newShard.MaxQueryRows {
-		return false
-	}
-
-	if oldShard.Timeout != newShard.Timeout {
-		return false
-	}
-
-	if oldShard.MaxIdleConns != newShard.MaxIdleConns {
-		return false
-	}
-
-	if oldShard.MaxOpenConns != newShard.MaxOpenConns {
-		return false
-	}
-
-	if oldShard.ConnMaxLifetime != newShard.ConnMaxLifetime {
-		return false
-	}
-
-	return true
-}
-
-func (p *PostgreSQL) ShowDatabases(ctx context.Context) ([]string, error) {
-	return p.Shards[0].ShowDatabases(ctx, "")
-}
-
-func (p *PostgreSQL) ShowTables(ctx context.Context, database string) ([]string, error) {
-	p.Shards[0].DB = database
-	rets, err := p.Shards[0].ShowTables(ctx, "")
-	if err != nil {
-		return nil, err
-	}
-	tables := make([]string, 0, len(rets))
-	for scheme, tabs := range rets {
-		for _, tab := range tabs {
-			tables = append(tables, scheme+"."+tab)
-		}
-	}
-	return tables, nil
-}
-
-func (p *PostgreSQL) MakeLogQuery(ctx context.Context, query interface{}, eventTags []string, start, end int64) (interface{}, error) {
-	return nil, nil
-}
-
-func (p *PostgreSQL) MakeTSQuery(ctx context.Context, query interface{}, eventTags []string, start, end int64) (interface{}, error) {
-	return nil, nil
-}
-
-func (p *PostgreSQL) QueryMapData(ctx context.Context, query interface{}) ([]map[string]string, error) {
-	return nil, nil
-}
-
-func (p *PostgreSQL) QueryData(ctx context.Context, query interface{}) ([]models.DataResp, error) {
-	postgresqlQueryParam := new(QueryParam)
-	if err := mapstructure.Decode(query, postgresqlQueryParam); err != nil {
-		return nil, err
-	}
-
-	postgresqlQueryParam.SQL = formatSQLDatabaseNameWithRegex(postgresqlQueryParam.SQL)
-	if strings.Contains(postgresqlQueryParam.SQL, "$__") {
-		var err error
-		postgresqlQueryParam.SQL, err = macros.Macro(postgresqlQueryParam.SQL, postgresqlQueryParam.From, postgresqlQueryParam.To)
-		if err != nil {
-			return nil, err
-		}
-	}
-	if postgresqlQueryParam.Database != "" {
-		p.Shards[0].DB = postgresqlQueryParam.Database
-	} else {
-		db, err := parseDBName(postgresqlQueryParam.SQL)
-		if err != nil {
-			return nil, err
-		}
-		p.Shards[0].DB = db
-	}
-
-	timeout := p.Shards[0].Timeout
-	if timeout == 0 {
-		timeout = 60
-	}
-	timeoutCtx, cancel := context.WithTimeout(ctx, time.Duration(timeout)*time.Second)
-	defer cancel()
-
-	items, err := p.Shards[0].QueryTimeseries(timeoutCtx, &sqlbase.QueryParam{
-		Sql: postgresqlQueryParam.SQL,
-		Keys: types.Keys{
-			ValueKey: postgresqlQueryParam.Keys.ValueKey,
-			LabelKey: postgresqlQueryParam.Keys.LabelKey,
-			TimeKey:  postgresqlQueryParam.Keys.TimeKey,
-		},
-	})
-
-	if err != nil {
-		logger.Warningf("query:%+v get data err:%v", postgresqlQueryParam, err)
-		return []models.DataResp{}, err
-	}
-	data := make([]models.DataResp, 0)
-	for i := range items {
-		data = append(data, models.DataResp{
-			Ref:    postgresqlQueryParam.Ref,
-			Metric: items[i].Metric,
-			Values: items[i].Values,
-		})
-	}
-
-	// parse resp to time series data
-	logger.Infof("req:%+v keys:%+v \n data:%v", postgresqlQueryParam, postgresqlQueryParam.Keys, data)
-
-	return data, nil
-}
-
-func (p *PostgreSQL) QueryLog(ctx context.Context, query interface{}) ([]interface{}, int64, error) {
-	postgresqlQueryParam := new(QueryParam)
-	if err := mapstructure.Decode(query, postgresqlQueryParam); err != nil {
-		return nil, 0, err
-	}
-	if postgresqlQueryParam.Database != "" {
-		p.Shards[0].DB = postgresqlQueryParam.Database
-	} else {
-		db, err := parseDBName(postgresqlQueryParam.SQL)
-		if err != nil {
-			return nil, 0, err
-		}
-		p.Shards[0].DB = db
-	}
-
-	postgresqlQueryParam.SQL = formatSQLDatabaseNameWithRegex(postgresqlQueryParam.SQL)
-	if strings.Contains(postgresqlQueryParam.SQL, "$__") {
-		var err error
-		postgresqlQueryParam.SQL, err = macros.Macro(postgresqlQueryParam.SQL, postgresqlQueryParam.From, postgresqlQueryParam.To)
-		if err != nil {
-			return nil, 0, err
-		}
-	}
-
-	timeout := p.Shards[0].Timeout
-	if timeout == 0 {
-		timeout = 60
-	}
-	timeoutCtx, cancel := context.WithTimeout(ctx, time.Duration(timeout)*time.Second)
-	defer cancel()
-	items, err := p.Shards[0].Query(timeoutCtx, &sqlbase.QueryParam{
-		Sql: postgresqlQueryParam.SQL,
-	})
-	if err != nil {
-		logger.Warningf("query:%+v get data err:%v", postgresqlQueryParam, err)
-		return []interface{}{}, 0, err
-	}
-	logs := make([]interface{}, 0)
-	for i := range items {
-		logs = append(logs, items[i])
-	}
-
-	return logs, 0, nil
-}
-
-func (p *PostgreSQL) DescribeTable(ctx context.Context, query interface{}) ([]*types.ColumnProperty, error) {
-	postgresqlQueryParam := new(QueryParam)
-	if err := mapstructure.Decode(query, postgresqlQueryParam); err != nil {
-		return nil, err
-	}
-	p.Shards[0].DB = postgresqlQueryParam.Database
-	pairs := strings.Split(postgresqlQueryParam.Table, ".") // format: scheme.table_name
-	scheme := ""
-	table := postgresqlQueryParam.Table
-	if len(pairs) == 2 {
-		scheme = pairs[0]
-		table = pairs[1]
-	}
-	return p.Shards[0].DescTable(ctx, scheme, table)
-}
-
-func parseDBName(sql string) (db string, err error) {
-	re := regexp.MustCompile(regx)
-	matches := re.FindStringSubmatch(sql)
-	if len(matches) != 4 {
-		return "", fmt.Errorf("no valid table name in format database.schema.table found")
-	}
-	return strings.Trim(matches[1], `"`), nil
-}
-
-// formatSQLDatabaseNameWithRegex 只对 dbname.scheme.tabname 格式进行数据库名称格式化，转为 "dbname".scheme.tabname
-// 在pgsql中，大小写是通过"" 双引号括起来区分的,默认pg都是转为小写的，所以这里转为 "dbname".scheme."tabname"
-func formatSQLDatabaseNameWithRegex(sql string) string {
-	// 匹配 from dbname.scheme.table_name 的模式
-	// 使用捕获组来精确匹配数据库名称，确保后面跟着scheme和table
-	re := regexp.MustCompile(`(?i)\bfrom\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*\.\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\.\s*([a-zA-Z_][a-zA-Z0-9_]*)`)
-
-	return re.ReplaceAllString(sql, `from "$1"."$2"."$3"`)
-}
-
-func extractColumns(sql string) ([]string, error) {
-	// 将 SQL 转换为小写以简化匹配
-	sql = strings.ToLower(sql)
-
-	// 匹配 SELECT 和 FROM 之间的内容
-	re := regexp.MustCompile(`select\s+(.*?)\s+from`)
-	matches := re.FindStringSubmatch(sql)
-
-	if len(matches) < 2 {
-		return nil, fmt.Errorf("no columns found or invalid SQL syntax")
-	}
-
-	// 提取列部分
-	columnsString := matches[1]
-
-	// 分割列
-	columns := splitColumns(columnsString)
-
-	// 清理每个列名
-	for i, col := range columns {
-		columns[i] = strings.TrimSpace(col)
-	}
-
-	return columns, nil
-}
-
-func splitColumns(columnsString string) []string {
-	var columns []string
-	var currentColumn strings.Builder
-	parenthesesCount := 0
-	inQuotes := false
-
-	for _, char := range columnsString {
-		switch char {
-		case '(':
-			parenthesesCount++
-			currentColumn.WriteRune(char)
-		case ')':
-			parenthesesCount--
-			currentColumn.WriteRune(char)
-		case '\'', '"':
-			inQuotes = !inQuotes
-			currentColumn.WriteRune(char)
-		case ',':
-			if parenthesesCount == 0 && !inQuotes {
-				columns = append(columns, currentColumn.String())
-				currentColumn.Reset()
-			} else {
-				currentColumn.WriteRune(char)
-			}
-		default:
-			currentColumn.WriteRune(char)
-		}
-	}
-
-	if currentColumn.Len() > 0 {
-		columns = append(columns, currentColumn.String())
-	}
-
-	return columns
-}

docker/compose-postgres/initsql_for_postgres/a-n9e-for-Postgres.sql

@@ -204,7 +204,6 @@ CREATE TABLE board (
     public smallint not null default 0 ,
     built_in smallint not null default 0 ,
     hide smallint not null default 0 ,
-    public_cate bigint NOT NULL DEFAULT 0,
     create_at bigint not null default 0,
     create_by varchar(64) not null default '',
     update_at bigint not null default 0,
@@ -218,7 +217,6 @@ COMMENT ON COLUMN board.tags IS 'split by space';
 COMMENT ON COLUMN board.public IS '0:false 1:true';
 COMMENT ON COLUMN board.built_in IS '0:false 1:true';
 COMMENT ON COLUMN board.hide IS '0:false 1:true';
-COMMENT ON COLUMN board.public_cate IS '0 anonymous 1 login 2 busi';
 
 
 -- for dashboard new version
@@ -431,31 +429,43 @@ CREATE TABLE target (
     ident varchar(191) not null,
     note varchar(255) not null default '',
     tags varchar(512) not null default '',
-    host_tags text,
     host_ip varchar(15) default '',
     agent_version varchar(255) default '',
     engine_name varchar(255) default '',
-    os varchar(31) default '',
     update_at bigint not null default 0,
     PRIMARY KEY (id),
     UNIQUE (ident)
 );
 
 CREATE INDEX ON target (group_id);
-CREATE INDEX idx_host_ip ON target (host_ip);
-CREATE INDEX idx_agent_version ON target (agent_version);
-CREATE INDEX idx_engine_name ON target (engine_name);
-CREATE INDEX idx_os ON target (os);
 
 COMMENT ON COLUMN target.group_id IS 'busi group id';
 COMMENT ON COLUMN target.ident IS 'target id';
 COMMENT ON COLUMN target.note IS 'append to alert event as field';
 COMMENT ON COLUMN target.tags IS 'append to series data as tags, split by space, append external space at suffix';
-COMMENT ON COLUMN target.host_tags IS 'global labels set in conf file';
 COMMENT ON COLUMN target.host_ip IS 'IPv4 string';
 COMMENT ON COLUMN target.agent_version IS 'agent version';
 COMMENT ON COLUMN target.engine_name IS 'engine_name';
-COMMENT ON COLUMN target.os IS 'os type';
+-- case1: target_idents; case2: target_tags
+-- CREATE TABLE collect_rule (
+--     id bigserial,
+--     group_id bigint not null default 0 comment 'busi group id',
+--     cluster varchar(128) not null,
+--     target_idents varchar(512) not null default '' comment 'ident list, split by space',
+--     target_tags varchar(512) not null default '' comment 'filter targets by tags, split by space',
+--     name varchar(191) not null default '',
+--     note varchar(255) not null default '',
+--     step int not null,
+--     type varchar(64) not null comment 'e.g. port proc log plugin',
+--     data text not null,
+--     append_tags varchar(255) not null default '' comment 'split by space: e.g. mod=n9e dept=cloud',
+--     create_at bigint not null default 0,
+--     create_by varchar(64) not null default '',
+--     update_at bigint not null default 0,
+--     update_by varchar(64) not null default '',
+--     PRIMARY KEY (id),
+--     KEY (group_id, type, name)
+-- ) ;
 
 CREATE TABLE metric_view (
     id bigserial,
@@ -724,7 +734,6 @@ CREATE TABLE datasource
 (
     id serial,
     name varchar(191) not null default '',
-    identifier varchar(255) not null default '',
     description varchar(255) not null default '',
     category varchar(255) not null default '',
     plugin_id int  not null default 0,
@@ -742,8 +751,8 @@ CREATE TABLE datasource
     updated_by varchar(64) not null default '',
     UNIQUE (name),
     PRIMARY KEY (id)
-) ;
-
+) ; 
+  
 CREATE TABLE builtin_cate (
     id bigserial,
     name varchar(191) not null,
@@ -786,12 +795,10 @@ CREATE TABLE es_index_pattern (
     create_by varchar(64) default '',
     update_at bigint default '0',
     update_by varchar(64) default '',
-    note varchar(4096) not null default '',
     PRIMARY KEY (id),
     UNIQUE (datasource_id, name)
 ) ;
 COMMENT ON COLUMN es_index_pattern.datasource_id IS 'datasource id';
-COMMENT ON COLUMN es_index_pattern.note IS 'description of metric in Chinese';
 
 CREATE TABLE builtin_metrics (
   id bigserial,
@@ -806,7 +813,6 @@ CREATE TABLE builtin_metrics (
   created_by varchar(191) NOT NULL DEFAULT '',
   updated_at bigint NOT NULL DEFAULT 0,
   updated_by varchar(191) NOT NULL DEFAULT '',
-  uuid BIGINT NOT NULL DEFAULT 0,
   PRIMARY KEY (id),
   UNIQUE (lang, collector, typ, name)
 );
@@ -828,7 +834,6 @@ COMMENT ON COLUMN builtin_metrics.created_at IS 'create time';
 COMMENT ON COLUMN builtin_metrics.created_by IS 'creator';
 COMMENT ON COLUMN builtin_metrics.updated_at IS 'update time';
 COMMENT ON COLUMN builtin_metrics.updated_by IS 'updater';
-COMMENT ON COLUMN builtin_metrics.uuid IS 'unique identifier';
 
 CREATE TABLE metric_filter (
   id BIGSERIAL PRIMARY KEY,
@@ -898,128 +903,4 @@ CREATE TABLE dash_annotation (
     create_by varchar(64) not null default '',
     update_at bigint not null default 0,
     update_by varchar(64) not null default ''
-);
-
-CREATE TABLE source_token (
-    id bigserial PRIMARY KEY,
-    source_type varchar(64) NOT NULL DEFAULT '',
-    source_id varchar(255) NOT NULL DEFAULT '',
-    token varchar(255) NOT NULL DEFAULT '',
-    expire_at bigint NOT NULL DEFAULT 0,
-    create_at bigint NOT NULL DEFAULT 0,
-    create_by varchar(64) NOT NULL DEFAULT ''
-);
-
-CREATE INDEX idx_source_token_type_id_token ON source_token (source_type, source_id, token);
-
-CREATE TABLE notification_record (
-    id BIGSERIAL PRIMARY KEY,
-    notify_rule_id BIGINT NOT NULL DEFAULT 0,
-    event_id bigint NOT NULL,
-    sub_id bigint DEFAULT NULL,
-    channel varchar(255) NOT NULL,
-    status bigint DEFAULT NULL,
-    target varchar(1024) NOT NULL,
-    details varchar(2048) DEFAULT '',
-    created_at bigint NOT NULL
-);
-
-CREATE INDEX idx_evt ON notification_record (event_id);
-
-COMMENT ON COLUMN notification_record.event_id IS 'event history id';
-COMMENT ON COLUMN notification_record.sub_id IS 'subscribed rule id';
-COMMENT ON COLUMN notification_record.channel IS 'notification channel name';
-COMMENT ON COLUMN notification_record.status IS 'notification status';
-COMMENT ON COLUMN notification_record.target IS 'notification target';
-COMMENT ON COLUMN notification_record.details IS 'notification other info';
-COMMENT ON COLUMN notification_record.created_at IS 'create time';
-
-CREATE TABLE target_busi_group (
-    id BIGSERIAL PRIMARY KEY,
-    target_ident varchar(191) NOT NULL,
-    group_id bigint NOT NULL,
-    update_at bigint NOT NULL
-);
-
-CREATE UNIQUE INDEX idx_target_group ON target_busi_group (target_ident, group_id);
-
-CREATE TABLE user_token (
-    id BIGSERIAL PRIMARY KEY,
-    username varchar(255) NOT NULL DEFAULT '',
-    token_name varchar(255) NOT NULL DEFAULT '',
-    token varchar(255) NOT NULL DEFAULT '',
-    create_at bigint NOT NULL DEFAULT 0,
-    last_used bigint NOT NULL DEFAULT 0
-);
-
-CREATE TABLE notify_rule (
-    id bigserial PRIMARY KEY,
-    name varchar(255) NOT NULL,
-    description text,
-    enable boolean DEFAULT false,
-    user_group_ids varchar(255) NOT NULL DEFAULT '',
-    notify_configs text,
-    pipeline_configs text,
-    create_at bigint NOT NULL DEFAULT 0,
-    create_by varchar(64) NOT NULL DEFAULT '',
-    update_at bigint NOT NULL DEFAULT 0,
-    update_by varchar(64) NOT NULL DEFAULT ''
-);
-
-CREATE TABLE notify_channel (
-    id bigserial PRIMARY KEY,
-    name varchar(255) NOT NULL,
-    ident varchar(255) NOT NULL,
-    description text,
-    enable boolean DEFAULT false,
-    param_config text,
-    request_type varchar(50) NOT NULL,
-    request_config text,
-    weight int NOT NULL DEFAULT 0,
-    create_at bigint NOT NULL DEFAULT 0,
-    create_by varchar(64) NOT NULL DEFAULT '',
-    update_at bigint NOT NULL DEFAULT 0,
-    update_by varchar(64) NOT NULL DEFAULT ''
-);
-
-CREATE TABLE message_template (
-    id bigserial PRIMARY KEY,
-    name varchar(64) NOT NULL,
-    ident varchar(64) NOT NULL,
-    content text,
-    user_group_ids varchar(64),
-    notify_channel_ident varchar(64) NOT NULL DEFAULT '',
-    private int NOT NULL DEFAULT 0,
-    weight int NOT NULL DEFAULT 0,
-    create_at bigint NOT NULL DEFAULT 0,
-    create_by varchar(64) NOT NULL DEFAULT '',
-    update_at bigint NOT NULL DEFAULT 0,
-    update_by varchar(64) NOT NULL DEFAULT ''
-);
-
-CREATE TABLE event_pipeline (
-    id bigserial PRIMARY KEY,
-    name varchar(128) NOT NULL,
-    team_ids text,
-    description varchar(255) NOT NULL DEFAULT '',
-    filter_enable smallint NOT NULL DEFAULT 0,
-    label_filters text,
-    attribute_filters text,
-    processors text,
-    create_at bigint NOT NULL DEFAULT 0,
-    create_by varchar(64) NOT NULL DEFAULT '',
-    update_at bigint NOT NULL DEFAULT 0,
-    update_by varchar(64) NOT NULL DEFAULT ''
-);
-
-CREATE TABLE embedded_product (
-    id bigserial PRIMARY KEY,
-    name varchar(255) DEFAULT NULL,
-    url varchar(255) DEFAULT NULL,
-    is_private boolean DEFAULT NULL,
-    team_ids varchar(255),
-    create_at bigint NOT NULL DEFAULT 0,
-    create_by varchar(64) NOT NULL DEFAULT '',
-    update_at bigint NOT NULL DEFAULT 0,
-    update_by varchar(64) NOT NULL DEFAULT ''
 );

docker/initsql/a-n9e.sql

@@ -107,6 +107,12 @@ insert into `role_operation`(role_name, operation) values('Standard', '/help/mig
 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('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');
+
 insert into `role_operation`(role_name, operation) values('Standard', '/users');
 insert into `role_operation`(role_name, operation) values('Standard', '/user-groups');
 insert into `role_operation`(role_name, operation) values('Standard', '/user-groups/add');
@@ -465,7 +471,6 @@ CREATE TABLE `alert_cur_event` (
     `rule_config` text not null comment 'annotations',
     `tags` varchar(1024) not null default '' comment 'merge data_tags rule_tags, split by ,,',
     `original_tags` text comment 'labels key=val,,k2=v2',
-    `notify_rule_ids` text COMMENT 'notify rule ids',
     PRIMARY KEY (`id`),
     KEY (`hash`),
     KEY (`rule_id`),
@@ -508,7 +513,6 @@ CREATE TABLE `alert_his_event` (
     `original_tags` text comment 'labels key=val,,k2=v2',
     `annotations` text not null comment 'annotations',
     `rule_config` text not null comment 'annotations',
-    `notify_rule_ids` text COMMENT 'notify rule ids',
     PRIMARY KEY (`id`),
     INDEX `idx_last_eval_time` (`last_eval_time`),
     KEY (`hash`),
@@ -723,6 +727,7 @@ CREATE TABLE `builtin_metrics` (
     `updated_by` varchar(191) NOT NULL DEFAULT '' COMMENT '''updater''',
     `uuid` bigint NOT NULL DEFAULT 0 COMMENT '''uuid''',
     PRIMARY KEY (`id`),
+    UNIQUE KEY `idx_collector_typ_name` (`lang`,`collector`, `typ`, `name`),
     INDEX `idx_uuid` (`uuid`),
     INDEX `idx_collector` (`collector`),
     INDEX `idx_typ` (`typ`),
@@ -836,8 +841,8 @@ CREATE TABLE `event_pipeline` (
     `description` varchar(255) not null default '',
     `filter_enable` tinyint(1) not null default 0,
     `label_filters` text,
-    `attr_filters` text,
-    `processor_configs` text,
+    `attribute_filters` text,
+    `processors` text,
     `create_at` bigint not null default 0,
     `create_by` varchar(64) not null default '',
     `update_at` bigint not null default 0,
@@ -845,19 +850,6 @@ CREATE TABLE `event_pipeline` (
     PRIMARY KEY (`id`)
 ) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4;
 
-CREATE TABLE `embedded_product` (
-    `id` bigint unsigned NOT NULL AUTO_INCREMENT,
-    `name` varchar(255) DEFAULT NULL,
-    `url` varchar(255) DEFAULT NULL,
-    `is_private` boolean DEFAULT NULL,
-    `team_ids` varchar(255),
-    `create_at` bigint not null default 0,
-    `create_by` varchar(64) not null default '',
-    `update_at` bigint not null default 0,
-    `update_by` varchar(64) not null default '',
-    PRIMARY KEY (`id`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
-
 CREATE TABLE `task_meta`
 (
     `id`          bigint unsigned NOT NULL AUTO_INCREMENT,
@@ -2215,15 +2207,3 @@ CREATE TABLE task_host_99
     PRIMARY KEY (`ii`)
 ) ENGINE = InnoDB
   DEFAULT CHARSET = utf8mb4;
-
-CREATE TABLE `source_token` (
-    `id` bigint unsigned NOT NULL AUTO_INCREMENT,
-    `source_type` varchar(64) NOT NULL DEFAULT '' COMMENT 'source type',
-    `source_id` varchar(255) NOT NULL DEFAULT '' COMMENT 'source identifier',
-    `token` varchar(255) NOT NULL DEFAULT '' COMMENT 'access token',
-    `expire_at` bigint NOT NULL DEFAULT 0 COMMENT 'expire timestamp',
-    `create_at` bigint NOT NULL DEFAULT 0 COMMENT 'create timestamp',
-    `create_by` varchar(64) NOT NULL DEFAULT '' COMMENT 'creator',
-    PRIMARY KEY (`id`),
-    KEY `idx_source_type_id_token` (`source_type`, `source_id`, `token`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

docker/migratesql/migrate.sql

@@ -13,6 +13,7 @@ CREATE TABLE `builtin_metrics` (
     `updated_at` bigint NOT NULL DEFAULT 0 COMMENT 'update time',
     `updated_by` varchar(191) NOT NULL DEFAULT '' COMMENT 'updater',
     PRIMARY KEY (`id`),
+    UNIQUE KEY `idx_collector_typ_name` (`lang`,`collector`, `typ`, `name`),
     INDEX `idx_collector` (`collector`),
     INDEX `idx_typ` (`typ`),
     INDEX `idx_name` (`name`),
@@ -235,51 +236,12 @@ CREATE TABLE `event_pipeline` (
     `team_ids` text,
     `description` varchar(255) not null default '',
     `filter_enable` tinyint(1) not null default 0,
-    `attr_filters` text,
-    `processor_configs` text,
+    `label_filters` text,
+    `attribute_filters` text,
+    `processors` text,
     `create_at` bigint not null default 0,
     `create_by` varchar(64) not null default '',
     `update_at` bigint not null default 0,
     `update_by` varchar(64) not null default '',
     PRIMARY KEY (`id`)
-) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4;
-
-/* v8.0.0 2025-05-15 */
-CREATE TABLE `embedded_product` (
-    `id` bigint unsigned NOT NULL AUTO_INCREMENT,
-    `name` varchar(255) DEFAULT NULL,
-    `url` varchar(255) DEFAULT NULL,
-    `is_private` boolean DEFAULT NULL,
-    `team_ids` varchar(255),
-    `create_at` bigint not null default 0,
-    `create_by` varchar(64) not null default '',
-    `update_at` bigint not null default 0,
-    `update_by` varchar(64) not null default '',
-    PRIMARY KEY (`id`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
-
-/* v8.0.0 2025-05-29 */
-CREATE TABLE `source_token` (
-    `id` bigint unsigned NOT NULL AUTO_INCREMENT,
-    `source_type` varchar(64) NOT NULL DEFAULT '' COMMENT 'source type',
-    `source_id` varchar(255) NOT NULL DEFAULT '' COMMENT 'source identifier',
-    `token` varchar(255) NOT NULL DEFAULT '' COMMENT 'access token',
-    `expire_at` bigint NOT NULL DEFAULT 0 COMMENT 'expire timestamp',
-    `create_at` bigint NOT NULL DEFAULT 0 COMMENT 'create timestamp',
-    `create_by` varchar(64) NOT NULL DEFAULT '' COMMENT 'creator',
-    PRIMARY KEY (`id`),
-    KEY `idx_source_type_id_token` (`source_type`, `source_id`, `token`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
-
-
-/* Add translation column for builtin metrics */
-ALTER TABLE `builtin_metrics` ADD COLUMN `translation` TEXT COMMENT 'translation of metric' AFTER `lang`;
-
-/* v8.0.0-beta.12 2025-06-03 */
-ALTER TABLE `alert_his_event` ADD COLUMN `notify_rule_ids` text COMMENT 'notify rule ids';
-ALTER TABLE `alert_cur_event` ADD COLUMN `notify_rule_ids` text COMMENT 'notify rule ids';
-
-/* v8.0.0-beta.13 */
--- 删除 builtin_metrics 表的 idx_collector_typ_name 唯一索引
-DROP INDEX IF EXISTS `idx_collector_typ_name` ON `builtin_metrics`;
-
+) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4;

docker/sqlite.sql

@@ -656,6 +656,7 @@ CREATE TABLE `builtin_metrics` (
     `uuid integer` not null default 0
 );
 
+CREATE UNIQUE INDEX idx_collector_typ_name ON builtin_metrics (lang, collector, typ, name);
 CREATE INDEX idx_collector ON builtin_metrics (collector);
 CREATE INDEX idx_typ ON builtin_metrics (typ);
 CREATE INDEX idx_builtinmetric_name ON builtin_metrics (name);

dscache/sync.go

@@ -8,11 +8,7 @@ import (
 
 	"github.com/ccfos/nightingale/v6/datasource"
 	_ "github.com/ccfos/nightingale/v6/datasource/ck"
-	_ "github.com/ccfos/nightingale/v6/datasource/doris"
 	"github.com/ccfos/nightingale/v6/datasource/es"
-	_ "github.com/ccfos/nightingale/v6/datasource/mysql"
-	_ "github.com/ccfos/nightingale/v6/datasource/opensearch"
-	_ "github.com/ccfos/nightingale/v6/datasource/postgresql"
 	"github.com/ccfos/nightingale/v6/dskit/tdengine"
 	"github.com/ccfos/nightingale/v6/models"
 	"github.com/ccfos/nightingale/v6/pkg/ctx"
@@ -22,8 +18,6 @@ import (
 
 var FromAPIHook func()
 
-var DatasourceProcessHook func(items []datasource.DatasourceInfo) []datasource.DatasourceInfo
-
 func Init(ctx *ctx.Context, fromAPI bool) {
 	go getDatasourcesFromDBLoop(ctx, fromAPI)
 }
@@ -86,6 +80,8 @@ func getDatasourcesFromDBLoop(ctx *ctx.Context, fromAPI bool) {
 
 				if item.PluginType == "elasticsearch" {
 					esN9eToDatasourceInfo(&ds, item)
+				} else if item.PluginType == "opensearch" {
+					osN9eToDatasourceInfo(&ds, item)
 				} else if item.PluginType == "tdengine" {
 					tdN9eToDatasourceInfo(&ds, item)
 				} else {
@@ -102,10 +98,6 @@ func getDatasourcesFromDBLoop(ctx *ctx.Context, fromAPI bool) {
 				atomic.StoreInt64(&PromDefaultDatasourceId, 0)
 			}
 
-			if DatasourceProcessHook != nil {
-				dss = DatasourceProcessHook(dss)
-			}
-
 			PutDatasources(dss)
 		} else {
 			FromAPIHook()
@@ -150,6 +142,24 @@ func esN9eToDatasourceInfo(ds *datasource.DatasourceInfo, item models.Datasource
 	ds.Settings["es.enable_write"] = item.SettingsJson["enable_write"]
 }
 
+// for opensearch
+func osN9eToDatasourceInfo(ds *datasource.DatasourceInfo, item models.Datasource) {
+	ds.Settings = make(map[string]interface{})
+	ds.Settings["os.nodes"] = []string{item.HTTPJson.Url}
+	ds.Settings["os.timeout"] = item.HTTPJson.Timeout
+	ds.Settings["os.basic"] = es.BasicAuth{
+		Username: item.AuthJson.BasicAuthUser,
+		Password: item.AuthJson.BasicAuthPassword,
+	}
+	ds.Settings["os.tls"] = es.TLS{
+		SkipTlsVerify: item.HTTPJson.TLS.SkipTlsVerify,
+	}
+	ds.Settings["os.version"] = item.SettingsJson["version"]
+	ds.Settings["os.headers"] = item.HTTPJson.Headers
+	ds.Settings["os.min_interval"] = item.SettingsJson["min_interval"]
+	ds.Settings["os.max_shard"] = item.SettingsJson["max_shard"]
+}
+
 func PutDatasources(items []datasource.DatasourceInfo) {
 	ids := make([]int64, 0)
 	for _, item := range items {
@@ -169,7 +179,7 @@ func PutDatasources(items []datasource.DatasourceInfo) {
 
 		ds, err := datasource.GetDatasourceByType(typ, item.Settings)
 		if err != nil {
-			logger.Debugf("get plugin:%+v fail: %v", item, err)
+			logger.Warningf("get plugin:%+v fail: %v", item, err)
 			continue
 		}
 

dskit/clickhouse/clickhouse.go

@@ -129,7 +129,9 @@ func (c *Clickhouse) QueryRows(ctx context.Context, query string) (*sql.Rows, er
 
 // ShowDatabases lists all databases in Clickhouse
 func (c *Clickhouse) ShowDatabases(ctx context.Context) ([]string, error) {
-	res := make([]string, 0)
+	var (
+		res []string
+	)
 
 	rows, err := c.QueryRows(ctx, ShowDatabases)
 	if err != nil {
@@ -149,7 +151,9 @@ func (c *Clickhouse) ShowDatabases(ctx context.Context) ([]string, error) {
 
 // ShowTables lists all tables in a given database
 func (c *Clickhouse) ShowTables(ctx context.Context, database string) ([]string, error) {
-	res := make([]string, 0)
+	var (
+		res []string
+	)
 
 	showTables := fmt.Sprintf(ShowTables, database)
 	rows, err := c.QueryRows(ctx, showTables)

dskit/doris/doris.go

@@ -1,543 +0,0 @@
-package doris
-
-import (
-	"context"
-	"database/sql"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"reflect"
-	"strings"
-	"time"
-	"unicode"
-
-	"github.com/ccfos/nightingale/v6/dskit/pool"
-	"github.com/ccfos/nightingale/v6/dskit/types"
-
-	_ "github.com/go-sql-driver/mysql" // MySQL driver
-	"github.com/mitchellh/mapstructure"
-)
-
-// Doris struct to hold connection details and the connection object
-type Doris struct {
-	Addr            string `json:"doris.addr" mapstructure:"doris.addr"`         // fe mysql endpoint
-	FeAddr          string `json:"doris.fe_addr" mapstructure:"doris.fe_addr"`   // fe http endpoint
-	User            string `json:"doris.user" mapstructure:"doris.user"`         //
-	Password        string `json:"doris.password" mapstructure:"doris.password"` //
-	Timeout         int    `json:"doris.timeout" mapstructure:"doris.timeout"`
-	MaxIdleConns    int    `json:"doris.max_idle_conns" mapstructure:"doris.max_idle_conns"`
-	MaxOpenConns    int    `json:"doris.max_open_conns" mapstructure:"doris.max_open_conns"`
-	ConnMaxLifetime int    `json:"doris.conn_max_lifetime" mapstructure:"doris.conn_max_lifetime"`
-	MaxQueryRows    int    `json:"doris.max_query_rows" mapstructure:"doris.max_query_rows"`
-	ClusterName     string `json:"doris.cluster_name" mapstructure:"doris.cluster_name"`
-	EnableWrite     bool   `json:"doris.enable_write" mapstructure:"doris.enable_write"`
-}
-
-// NewDorisWithSettings initializes a new Doris instance with the given settings
-func NewDorisWithSettings(ctx context.Context, settings interface{}) (*Doris, error) {
-	newest := new(Doris)
-	settingsMap := map[string]interface{}{}
-	if reflect.TypeOf(settings).Kind() == reflect.String {
-		if err := json.Unmarshal([]byte(settings.(string)), &settingsMap); err != nil {
-			return nil, err
-		}
-	} else {
-		var assert bool
-		settingsMap, assert = settings.(map[string]interface{})
-		if !assert {
-			return nil, errors.New("settings type invalid")
-		}
-	}
-	if err := mapstructure.Decode(settingsMap, newest); err != nil {
-		return nil, err
-	}
-
-	return newest, nil
-}
-
-// NewConn establishes a new connection to Doris
-func (d *Doris) NewConn(ctx context.Context, database string) (*sql.DB, error) {
-	if len(d.Addr) == 0 {
-		return nil, errors.New("empty fe-node addr")
-	}
-
-	// Set default values similar to postgres implementation
-	if d.Timeout == 0 {
-		d.Timeout = 60
-	}
-	if d.MaxIdleConns == 0 {
-		d.MaxIdleConns = 10
-	}
-	if d.MaxOpenConns == 0 {
-		d.MaxOpenConns = 100
-	}
-	if d.ConnMaxLifetime == 0 {
-		d.ConnMaxLifetime = 14400
-	}
-	if d.MaxQueryRows == 0 {
-		d.MaxQueryRows = 500
-	}
-
-	var keys []string
-	keys = append(keys, d.Addr)
-	keys = append(keys, d.Password, d.User)
-	if len(database) > 0 {
-		keys = append(keys, database)
-	}
-	cachedkey := strings.Join(keys, ":")
-	// cache conn with database
-	conn, ok := pool.PoolClient.Load(cachedkey)
-	if ok {
-		return conn.(*sql.DB), nil
-	}
-	var db *sql.DB
-	var err error
-	defer func() {
-		if db != nil && err == nil {
-			pool.PoolClient.Store(cachedkey, db)
-		}
-	}()
-
-	// Simplified connection logic for Doris using MySQL driver
-	dsn := fmt.Sprintf("%s:%s@tcp(%s)/%s?charset=utf8", d.User, d.Password, d.Addr, database)
-	db, err = sql.Open("mysql", dsn)
-	if err != nil {
-		return nil, err
-	}
-
-	// Set connection pool configuration
-	db.SetMaxIdleConns(d.MaxIdleConns)
-	db.SetMaxOpenConns(d.MaxOpenConns)
-	db.SetConnMaxLifetime(time.Duration(d.ConnMaxLifetime) * time.Second)
-
-	return db, nil
-}
-
-// createTimeoutContext creates a context with timeout based on Doris configuration
-func (d *Doris) createTimeoutContext(ctx context.Context) (context.Context, context.CancelFunc) {
-	timeout := d.Timeout
-	if timeout == 0 {
-		timeout = 60
-	}
-	return context.WithTimeout(ctx, time.Duration(timeout)*time.Second)
-}
-
-// ShowDatabases lists all databases in Doris
-func (d *Doris) ShowDatabases(ctx context.Context) ([]string, error) {
-	timeoutCtx, cancel := d.createTimeoutContext(ctx)
-	defer cancel()
-
-	db, err := d.NewConn(timeoutCtx, "")
-	if err != nil {
-		return []string{}, err
-	}
-
-	rows, err := db.QueryContext(timeoutCtx, "SHOW DATABASES")
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-
-	databases := make([]string, 0)
-	for rows.Next() {
-		var dbName string
-		if err := rows.Scan(&dbName); err != nil {
-			continue
-		}
-		databases = append(databases, dbName)
-	}
-	return databases, nil
-}
-
-// ShowResources lists all resources with type resourceType in Doris
-func (d *Doris) ShowResources(ctx context.Context, resourceType string) ([]string, error) {
-	timeoutCtx, cancel := d.createTimeoutContext(ctx)
-	defer cancel()
-
-	db, err := d.NewConn(timeoutCtx, "")
-	if err != nil {
-		return []string{}, err
-	}
-
-	// 使用 SHOW RESOURCES 命令
-	query := fmt.Sprintf("SHOW RESOURCES WHERE RESOURCETYPE = '%s'", resourceType)
-	rows, err := db.QueryContext(timeoutCtx, query)
-	if err != nil {
-		return nil, fmt.Errorf("failed to execute query: %w", err)
-	}
-	defer rows.Close()
-
-	distinctName := make(map[string]struct{})
-
-	// 获取列信息
-	columns, err := rows.Columns()
-	if err != nil {
-		return nil, fmt.Errorf("failed to get columns: %w", err)
-	}
-
-	// 准备接收数据的变量
-	values := make([]interface{}, len(columns))
-	valuePtrs := make([]interface{}, len(columns))
-	for i := range values {
-		valuePtrs[i] = &values[i]
-	}
-
-	// 遍历结果集
-	for rows.Next() {
-		err := rows.Scan(valuePtrs...)
-		if err != nil {
-			return nil, fmt.Errorf("error scanning row: %w", err)
-		}
-		// 提取资源名称并添加到 map 中（自动去重）
-		if name, ok := values[0].([]byte); ok {
-			distinctName[string(name)] = struct{}{}
-		} else if nameStr, ok := values[0].(string); ok {
-			distinctName[nameStr] = struct{}{}
-		}
-	}
-
-	if err := rows.Err(); err != nil {
-		return nil, fmt.Errorf("error iterating rows: %w", err)
-	}
-
-	// 将 map 转换为切片
-	resources := make([]string, 0)
-	for name := range distinctName {
-		resources = append(resources, name)
-	}
-
-	return resources, nil
-}
-
-// ShowTables lists all tables in a given database
-func (d *Doris) ShowTables(ctx context.Context, database string) ([]string, error) {
-	timeoutCtx, cancel := d.createTimeoutContext(ctx)
-	defer cancel()
-
-	db, err := d.NewConn(timeoutCtx, database)
-	if err != nil {
-		return nil, err
-	}
-
-	query := fmt.Sprintf("SHOW TABLES IN %s", database)
-	rows, err := db.QueryContext(timeoutCtx, query)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-
-	tables := make([]string, 0)
-	for rows.Next() {
-		var tableName string
-		if err := rows.Scan(&tableName); err != nil {
-			continue
-		}
-		tables = append(tables, tableName)
-	}
-	return tables, nil
-}
-
-// DescTable describes the schema of a specified table in Doris
-func (d *Doris) DescTable(ctx context.Context, database, table string) ([]*types.ColumnProperty, error) {
-	timeoutCtx, cancel := d.createTimeoutContext(ctx)
-	defer cancel()
-
-	db, err := d.NewConn(timeoutCtx, database)
-	if err != nil {
-		return nil, err
-	}
-
-	query := fmt.Sprintf("DESCRIBE %s.%s", database, table)
-	rows, err := db.QueryContext(timeoutCtx, query)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-
-	// 日志报表中需要把 .type 转化成内部类型
-	// TODO: 是否有复合类型, Array/JSON/Tuple/Nested, 是否有更多的类型
-	convertDorisType := func(origin string) (string, bool) {
-		lower := strings.ToLower(origin)
-		switch lower {
-		case "double":
-			return types.LogExtractValueTypeFloat, true
-
-		case "datetime", "date":
-			return types.LogExtractValueTypeDate, false
-
-		case "text":
-			return types.LogExtractValueTypeText, true
-
-		default:
-			if strings.Contains(lower, "int") {
-				return types.LogExtractValueTypeLong, true
-			}
-			// 日期类型统一按照.date处理
-			if strings.HasPrefix(lower, "date") {
-				return types.LogExtractValueTypeDate, false
-			}
-			if strings.HasPrefix(lower, "varchar") || strings.HasPrefix(lower, "char") {
-				return types.LogExtractValueTypeText, true
-			}
-			if strings.HasPrefix(lower, "decimal") {
-				return types.LogExtractValueTypeFloat, true
-			}
-		}
-
-		return origin, false
-	}
-
-	var columns []*types.ColumnProperty
-	for rows.Next() {
-		var (
-			field        string
-			typ          string
-			null         string
-			key          string
-			defaultValue sql.NullString
-			extra        string
-		)
-		if err := rows.Scan(&field, &typ, &null, &key, &defaultValue, &extra); err != nil {
-			continue
-		}
-		type2, indexable := convertDorisType(typ)
-		columns = append(columns, &types.ColumnProperty{
-			Field: field,
-			Type:  typ, // You might want to convert MySQL types to your custom types
-
-			Type2:     type2,
-			Indexable: indexable,
-		})
-	}
-	return columns, nil
-}
-
-// SelectRows selects rows from a specified table in Doris based on a given query with MaxQueryRows check
-func (d *Doris) SelectRows(ctx context.Context, database, table, query string) ([]map[string]interface{}, error) {
-	sql := fmt.Sprintf("SELECT * FROM %s.%s", database, table)
-	if query != "" {
-		sql += " " + query
-	}
-
-	// 检查查询结果行数
-	err := d.CheckMaxQueryRows(ctx, database, sql)
-	if err != nil {
-		return nil, err
-	}
-
-	return d.ExecQuery(ctx, database, sql)
-}
-
-// ExecQuery executes a given SQL query in Doris and returns the results
-func (d *Doris) ExecQuery(ctx context.Context, database string, sql string) ([]map[string]interface{}, error) {
-	timeoutCtx, cancel := d.createTimeoutContext(ctx)
-	defer cancel()
-
-	db, err := d.NewConn(timeoutCtx, database)
-	if err != nil {
-		return nil, err
-	}
-
-	rows, err := db.QueryContext(timeoutCtx, sql)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-
-	columns, err := rows.Columns()
-	if err != nil {
-		return nil, err
-	}
-
-	var results []map[string]interface{}
-
-	for rows.Next() {
-		columnValues := make([]interface{}, len(columns))
-		columnPointers := make([]interface{}, len(columns))
-		for i := range columnValues {
-			columnPointers[i] = &columnValues[i]
-		}
-
-		if err := rows.Scan(columnPointers...); err != nil {
-			continue
-		}
-
-		rowMap := make(map[string]interface{})
-		for i, colName := range columns {
-			val := columnValues[i]
-			bytes, ok := val.([]byte)
-			if ok {
-				rowMap[colName] = string(bytes)
-			} else {
-				rowMap[colName] = val
-			}
-		}
-		results = append(results, rowMap)
-	}
-	return results, nil
-}
-
-// ExecContext executes a given SQL query in Doris and returns the results
-func (d *Doris) ExecContext(ctx context.Context, database string, sql string) error {
-	timeoutCtx, cancel := d.createTimeoutContext(ctx)
-	defer cancel()
-
-	db, err := d.NewConn(timeoutCtx, database)
-	if err != nil {
-		return err
-	}
-
-	_, err = db.ExecContext(timeoutCtx, sql)
-	return err
-}
-
-// ExecBatchSQL 执行多条 SQL 语句
-func (d *Doris) ExecBatchSQL(ctx context.Context, database string, sqlBatch string) error {
-	// 分割 SQL 语句
-	sqlStatements := SplitSQLStatements(sqlBatch)
-
-	// 逐条执行 SQL 语句
-	for _, ql := range sqlStatements {
-		// 跳过空语句
-		ql = strings.TrimSpace(ql)
-		if ql == "" {
-			continue
-		}
-
-		// 检查是否是 CREATE DATABASE 语句
-		isCreateDB := strings.HasPrefix(strings.ToUpper(ql), "CREATE DATABASE")
-		// strings.HasPrefix(strings.ToUpper(sql), "CREATE SCHEMA") // 暂时不支持CREATE SCHEMA
-
-		// 对于 CREATE DATABASE 语句，使用空数据库名连接
-		currentDB := database
-		if isCreateDB {
-			currentDB = ""
-		}
-
-		// 执行单条 SQL，ExecContext 内部已经包含超时处理
-		err := d.ExecContext(ctx, currentDB, ql)
-		if err != nil {
-			return fmt.Errorf("exec sql failed, sql:%s, err:%w", sqlBatch, err)
-		}
-	}
-
-	return nil
-}
-
-// SplitSQLStatements 将多条 SQL 语句分割成单独的语句
-func SplitSQLStatements(sqlBatch string) []string {
-	var statements []string
-	var currentStatement strings.Builder
-
-	// 状态标记
-	var (
-		inString           bool // 是否在字符串内
-		inComment          bool // 是否在单行注释内
-		inMultilineComment bool // 是否在多行注释内
-		escaped            bool // 前一个字符是否为转义字符
-	)
-
-	for i := 0; i < len(sqlBatch); i++ {
-		char := sqlBatch[i]
-		currentStatement.WriteByte(char)
-
-		// 处理转义字符
-		if inString && char == '\\' {
-			escaped = !escaped
-			continue
-		}
-
-		// 处理字符串
-		if char == '\'' && !inComment && !inMultilineComment {
-			if !escaped {
-				inString = !inString
-			}
-			escaped = false
-			continue
-		}
-
-		// 处理单行注释
-		if !inString && !inMultilineComment && !inComment && char == '-' && i+1 < len(sqlBatch) && sqlBatch[i+1] == '-' {
-			inComment = true
-			currentStatement.WriteByte(sqlBatch[i+1]) // 写入第二个'-'
-			i++
-			continue
-		}
-
-		// 处理多行注释开始
-		if !inString && !inComment && char == '/' && i+1 < len(sqlBatch) && sqlBatch[i+1] == '*' {
-			inMultilineComment = true
-			currentStatement.WriteByte(sqlBatch[i+1]) // 写入'*'
-			i++
-			continue
-		}
-
-		// 处理多行注释结束
-		if inMultilineComment && char == '*' && i+1 < len(sqlBatch) && sqlBatch[i+1] == '/' {
-			inMultilineComment = false
-			currentStatement.WriteByte(sqlBatch[i+1]) // 写入'/'
-			i++
-			continue
-		}
-
-		// 处理换行符，结束单行注释
-		if inComment && (char == '\n' || char == '\r') {
-			inComment = false
-		}
-
-		// 分割SQL语句
-		if char == ';' && !inString && !inMultilineComment && !inComment {
-			// 收集到分号后面的单行注释（如果有）
-			for j := i + 1; j < len(sqlBatch); j++ {
-				nextChar := sqlBatch[j]
-
-				// 检查是否是注释开始
-				if nextChar == '-' && j+1 < len(sqlBatch) && sqlBatch[j+1] == '-' {
-					// 找到了注释，添加到当前语句
-					currentStatement.WriteByte(nextChar)      // 添加'-'
-					currentStatement.WriteByte(sqlBatch[j+1]) // 添加第二个'-'
-					j++
-
-					// 读取直到行尾
-					for k := j + 1; k < len(sqlBatch); k++ {
-						commentChar := sqlBatch[k]
-						currentStatement.WriteByte(commentChar)
-						j = k
-
-						if commentChar == '\n' || commentChar == '\r' {
-							break
-						}
-					}
-					i = j
-					break
-				} else if !isWhitespace(nextChar) {
-					// 非注释且非空白字符，停止收集
-					break
-				} else {
-					// 是空白字符，添加到当前语句
-					currentStatement.WriteByte(nextChar)
-					i = j
-				}
-			}
-
-			statements = append(statements, strings.TrimSpace(currentStatement.String()))
-			currentStatement.Reset()
-			continue
-		}
-
-		escaped = false
-	}
-
-	// 处理最后一条可能没有分号的语句
-	lastStatement := strings.TrimSpace(currentStatement.String())
-	if lastStatement != "" {
-		statements = append(statements, lastStatement)
-	}
-
-	return statements
-}
-
-// 判断字符是否为空白字符
-func isWhitespace(c byte) bool {
-	return unicode.IsSpace(rune(c))
-}

dskit/doris/logs.go

@@ -1,36 +0,0 @@
-package doris
-
-import (
-	"context"
-	"sort"
-)
-
-// 日志相关的操作
-const (
-	TimeseriesAggregationTimestamp = "__ts__"
-)
-
-// TODO: 待测试, MAP/ARRAY/STRUCT/JSON 等类型能否处理
-func (d *Doris) QueryLogs(ctx context.Context, query *QueryParam) ([]map[string]interface{}, error) {
-	// 等同于 Query()
-	return d.Query(ctx, query)
-}
-
-// 本质是查询时序数据, 取第一组, SQL由上层封装, 不再做复杂的解析和截断
-func (d *Doris) QueryHistogram(ctx context.Context, query *QueryParam) ([][]float64, error) {
-	values, err := d.QueryTimeseries(ctx, query)
-	if err != nil {
-		return [][]float64{}, nil
-	}
-	if len(values) > 0 && len(values[0].Values) > 0 {
-		items := values[0].Values
-		sort.Slice(items, func(i, j int) bool {
-			if len(items[i]) > 0 && len(items[j]) > 0 {
-				return items[i][0] < items[j][0]
-			}
-			return false
-		})
-		return items, nil
-	}
-	return [][]float64{}, nil
-}

dskit/doris/template.md

@@ -1,126 +0,0 @@
-## SQL变量
-
-| 字段名 | 含义  | 使用场景 |
-| ----  | ---- |  ----  | 
-|database|数据库|无|
-|table|表名||
-|time_field|时间戳的字段||
-|query|查询条件|日志原文|
-|from|开始时间||
-|to|结束时间||
-|aggregation|聚合算法|时序图|
-|field|聚合的字段|时序图|
-|limit|分页参数|日志原文|
-|offset|分页参数|日志原文|
-|interval|直方图的时间粒度|直方图|
-
-## 日志原文
-### 直方图
-
-```
-# 如何计算interval的值
-max := 60 // 最多60个柱子
-interval := ($to-$from) / max
-interval = interval - interval%10
-if interval <= 0 {
-	interval = 60
-}
-```
-
-```
-SELECT count() as cnt,
-	FLOOR(UNIX_TIMESTAMP($time_field) / $interval) * $interval AS __ts__ 
-		FROM $table
-	WHERE $time_field BETWEEN FROM_UNIXTIME($from) AND FROM_UNIXTIME($to)
-	GROUP BY __ts__;
-```
-
-```
-{
-	"database":"$database",
-	"sql":"$sql",
-	"keys:": {
-		"valueKey":"cnt",
-		"timeKey":"__ts__"
-	}
-}
-```
-
-### 日志原文
-
-```
-SELECT * from $table
-	WHERE $time_field BETWEEN FROM_UNIXTIME($from) AND FROM_UNIXTIME($to)
-	ORDER by $time_filed
-	LIMIT $limit OFFSET $offset;
-```
-
-```
-{
-	"database":"$database",
-	"sql":"$sql"
-}
-```
-
-## 时序图
-
-### 日志行数
-
-```
-SELECT COUNT() AS cnt, DATE_FORMAT(date, '%Y-%m-%d %H:%i:00') AS __ts__ 
-	FROM nginx_access_log
-	WHERE $time_field BETWEEN FROM_UNIXTIME($from) AND FROM_UNIXTIME($to)
-	GROUP BY __ts__
-```
-
-```
-{
-	"database":"$database",
-	"sql":"$sql",
-	"keys:": {
-		"valueKey":"cnt",
-		"timeKey":"__ts__"
-	}
-}
-```
-
-### max/min/avg/sum
-
-```
-SELECT $aggregation($field) AS series, DATE_FORMAT(date, '%Y-%m-%d %H:%i:00') AS __ts__ 
-	FROM nginx_access_log
-	WHERE $time_field BETWEEN FROM_UNIXTIME($from) AND FROM_UNIXTIME($to)
-	GROUP BY __ts__
-```
-
-```
-{
-	"database":"$database",
-	"sql":"$sql",
-	"keys:": {
-		"valueKey":"series",
-		"timeKey":"__ts__"
-	}
-}
-```
-
-
-### 分位值
-
-```
-SELECT percentile($field, 0.95) AS series, DATE_FORMAT(date, '%Y-%m-%d %H:%i:00') AS __ts__ 
-	FROM nginx_access_log
-	WHERE $time_field BETWEEN FROM_UNIXTIME($from) AND FROM_UNIXTIME($to)
-	GROUP BY __ts__
-```
-
-```
-{
-	"database":"$database",
-	"sql":"$sql",
-	"keys:": {
-		"valueKey":"series",
-		"timeKey":"__ts__"
-	}
-}
-```

dskit/doris/timeseries.go

@@ -1,108 +0,0 @@
-package doris
-
-import (
-	"context"
-	"fmt"
-	"strings"
-
-	"github.com/ccfos/nightingale/v6/dskit/sqlbase"
-	"github.com/ccfos/nightingale/v6/dskit/types"
-)
-
-const (
-	TimeFieldFormatEpochMilli  = "epoch_millis"
-	TimeFieldFormatEpochSecond = "epoch_second"
-	TimeFieldFormatDateTime    = "datetime"
-)
-
-// 不再拼接SQL, 完全信赖用户的输入
-type QueryParam struct {
-	Database string     `json:"database"`
-	Sql      string     `json:"sql"`
-	Keys     types.Keys `json:"keys" mapstructure:"keys"`
-}
-
-var (
-	DorisBannedOp = map[string]struct{}{
-		"CREATE":   {},
-		"INSERT":   {},
-		"ALTER":    {},
-		"REVOKE":   {},
-		"DROP":     {},
-		"RENAME":   {},
-		"ATTACH":   {},
-		"DETACH":   {},
-		"OPTIMIZE": {},
-		"TRUNCATE": {},
-		"SET":      {},
-	}
-)
-
-// Query executes a given SQL query in Doris and returns the results with MaxQueryRows check
-func (d *Doris) Query(ctx context.Context, query *QueryParam) ([]map[string]interface{}, error) {
-	// 校验SQL的合法性, 过滤掉 write请求
-	sqlItem := strings.Split(strings.ToUpper(query.Sql), " ")
-	for _, item := range sqlItem {
-		if _, ok := DorisBannedOp[item]; ok {
-			return nil, fmt.Errorf("operation %s is forbid, only read db, please check your sql", item)
-		}
-	}
-
-	// 检查查询结果行数
-	err := d.CheckMaxQueryRows(ctx, query.Database, query.Sql)
-	if err != nil {
-		return nil, err
-	}
-
-	rows, err := d.ExecQuery(ctx, query.Database, query.Sql)
-	if err != nil {
-		return nil, err
-	}
-	return rows, nil
-}
-
-// QueryTimeseries executes a time series data query using the given parameters with MaxQueryRows check
-func (d *Doris) QueryTimeseries(ctx context.Context, query *QueryParam) ([]types.MetricValues, error) {
-	// 使用 Query 方法执行查询，Query方法内部已包含MaxQueryRows检查
-	rows, err := d.Query(ctx, query)
-	if err != nil {
-		return nil, err
-	}
-
-	return sqlbase.FormatMetricValues(query.Keys, rows), nil
-}
-
-// CheckMaxQueryRows checks if the query result exceeds the maximum allowed rows
-func (d *Doris) CheckMaxQueryRows(ctx context.Context, database, sql string) error {
-	timeoutCtx, cancel := d.createTimeoutContext(ctx)
-	defer cancel()
-
-	cleanedSQL := strings.ReplaceAll(sql, ";", "")
-	checkQuery := fmt.Sprintf("SELECT COUNT(*) as count FROM (%s) AS subquery;", cleanedSQL)
-
-	// 执行计数查询
-	results, err := d.ExecQuery(timeoutCtx, database, checkQuery)
-	if err != nil {
-		return err
-	}
-
-	if len(results) > 0 {
-		if count, exists := results[0]["count"]; exists {
-			v, err := sqlbase.ParseFloat64Value(count)
-			if err != nil {
-				return err
-			}
-
-			maxQueryRows := d.MaxQueryRows
-			if maxQueryRows == 0 {
-				maxQueryRows = 500
-			}
-
-			if v > float64(maxQueryRows) {
-				return fmt.Errorf("query result rows count %d exceeds the maximum limit %d", int(v), maxQueryRows)
-			}
-		}
-	}
-
-	return nil
-}

dskit/mysql/mysql.go

@@ -1,172 +0,0 @@
-// @Author: Ciusyan 5/10/24
-
-package mysql
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"strings"
-	"time"
-
-	"github.com/ccfos/nightingale/v6/dskit/pool"
-	"github.com/ccfos/nightingale/v6/dskit/sqlbase"
-	"github.com/ccfos/nightingale/v6/dskit/types"
-
-	_ "github.com/go-sql-driver/mysql" // MySQL driver
-	"github.com/mitchellh/mapstructure"
-	"gorm.io/driver/mysql"
-	"gorm.io/gorm"
-)
-
-type MySQL struct {
-	Shards []Shard `json:"mysql.shards" mapstructure:"mysql.shards"`
-}
-
-type Shard struct {
-	Addr            string `json:"mysql.addr" mapstructure:"mysql.addr"`
-	DB              string `json:"mysql.db" mapstructure:"mysql.db"`
-	User            string `json:"mysql.user" mapstructure:"mysql.user"`
-	Password        string `json:"mysql.password" mapstructure:"mysql.password"`
-	Timeout         int    `json:"mysql.timeout" mapstructure:"mysql.timeout"`
-	MaxIdleConns    int    `json:"mysql.max_idle_conns" mapstructure:"mysql.max_idle_conns"`
-	MaxOpenConns    int    `json:"mysql.max_open_conns" mapstructure:"mysql.max_open_conns"`
-	ConnMaxLifetime int    `json:"mysql.conn_max_lifetime" mapstructure:"mysql.conn_max_lifetime"`
-	MaxQueryRows    int    `json:"mysql.max_query_rows" mapstructure:"mysql.max_query_rows"`
-}
-
-func NewMySQLWithSettings(ctx context.Context, settings interface{}) (*MySQL, error) {
-	newest := new(MySQL)
-	settingsMap := map[string]interface{}{}
-
-	switch s := settings.(type) {
-	case string:
-		if err := json.Unmarshal([]byte(s), &settingsMap); err != nil {
-			return nil, err
-		}
-	case map[string]interface{}:
-		settingsMap = s
-	default:
-		return nil, errors.New("unsupported settings type")
-	}
-
-	if err := mapstructure.Decode(settingsMap, newest); err != nil {
-		return nil, err
-	}
-
-	return newest, nil
-}
-
-// NewConn establishes a new connection to MySQL
-func (m *MySQL) NewConn(ctx context.Context, database string) (*gorm.DB, error) {
-	if len(m.Shards) == 0 {
-		return nil, errors.New("empty pgsql shards")
-	}
-
-	shard := m.Shards[0]
-
-	if shard.Timeout == 0 {
-		shard.Timeout = 300
-	}
-
-	if shard.MaxIdleConns == 0 {
-		shard.MaxIdleConns = 10
-	}
-
-	if shard.MaxOpenConns == 0 {
-		shard.MaxOpenConns = 100
-	}
-
-	if shard.ConnMaxLifetime == 0 {
-		shard.ConnMaxLifetime = 300
-	}
-
-	if shard.MaxQueryRows == 0 {
-		shard.MaxQueryRows = 100
-	}
-
-	if len(shard.Addr) == 0 {
-		return nil, errors.New("empty addr")
-	}
-
-	if len(shard.Addr) == 0 {
-		return nil, errors.New("empty addr")
-	}
-	var keys []string
-	var err error
-	keys = append(keys, shard.Addr)
-
-	keys = append(keys, shard.Password, shard.User)
-	if len(database) > 0 {
-		keys = append(keys, database)
-	}
-	cachedKey := strings.Join(keys, ":")
-	// cache conn with database
-	conn, ok := pool.PoolClient.Load(cachedKey)
-	if ok {
-		return conn.(*gorm.DB), nil
-	}
-	var db *gorm.DB
-	defer func() {
-		if db != nil && err == nil {
-			pool.PoolClient.Store(cachedKey, db)
-		}
-	}()
-
-	dsn := fmt.Sprintf("%s:%s@tcp(%s)/%s?charset=utf8&parseTime=True", shard.User, shard.Password, shard.Addr, database)
-	db, err = sqlbase.NewDB(
-		ctx,
-		mysql.Open(dsn),
-		shard.MaxIdleConns,
-		shard.MaxOpenConns,
-		time.Duration(shard.ConnMaxLifetime)*time.Second,
-	)
-	return db, err
-}
-
-func (m *MySQL) ShowDatabases(ctx context.Context) ([]string, error) {
-	db, err := m.NewConn(ctx, "")
-	if err != nil {
-		return nil, err
-	}
-
-	return sqlbase.ShowDatabases(ctx, db, "SHOW DATABASES")
-}
-
-func (m *MySQL) ShowTables(ctx context.Context, database string) ([]string, error) {
-	db, err := m.NewConn(ctx, database)
-	if err != nil {
-		return nil, err
-	}
-
-	return sqlbase.ShowTables(ctx, db, "SHOW TABLES")
-}
-
-func (m *MySQL) DescTable(ctx context.Context, database, table string) ([]*types.ColumnProperty, error) {
-	db, err := m.NewConn(ctx, database)
-	if err != nil {
-		return nil, err
-	}
-
-	query := fmt.Sprintf("DESCRIBE %s", table)
-	return sqlbase.DescTable(ctx, db, query)
-}
-
-func (m *MySQL) SelectRows(ctx context.Context, database, table, query string) ([]map[string]interface{}, error) {
-	db, err := m.NewConn(ctx, database)
-	if err != nil {
-		return nil, err
-	}
-
-	return sqlbase.SelectRows(ctx, db, table, query)
-}
-
-func (m *MySQL) ExecQuery(ctx context.Context, database string, sql string) ([]map[string]interface{}, error) {
-	db, err := m.NewConn(ctx, database)
-	if err != nil {
-		return nil, err
-	}
-
-	return sqlbase.ExecQuery(ctx, db, sql)
-}

dskit/mysql/mysql_test.go

@@ -1,129 +0,0 @@
-// @Author: Ciusyan 5/11/24
-
-package mysql
-
-import (
-	"context"
-	"testing"
-
-	"github.com/stretchr/testify/require"
-)
-
-func TestNewMySQLWithSettings(t *testing.T) {
-	tests := []struct {
-		name     string
-		settings interface{}
-		wantErr  bool
-	}{
-		{
-			name:     "valid string settings",
-			settings: `{"mysql.addr":"localhost:3306","mysql.user":"root","mysql.password":"root","mysql.maxIdleConns":5,"mysql.maxOpenConns":10,"mysql.connMaxLifetime":30}`,
-			wantErr:  false,
-		},
-		{
-			name:     "invalid settings type",
-			settings: 12345,
-			wantErr:  true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got, err := NewMySQLWithSettings(context.Background(), tt.settings)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("NewMySQLWithSettings() error = %v, wantErr %v", err, tt.wantErr)
-			}
-			t.Log(got)
-		})
-	}
-}
-
-func TestNewConn(t *testing.T) {
-	ctx := context.Background()
-	settings := `{"mysql.addr":"localhost:3306","mysql.user":"root","mysql.password":"root","mysql.maxIdleConns":5,"mysql.maxOpenConns":10,"mysql.connMaxLifetime":30}`
-	mysql, err := NewMySQLWithSettings(ctx, settings)
-	require.NoError(t, err)
-
-	tests := []struct {
-		name     string
-		database string
-		wantErr  bool
-	}{
-		{
-			name:     "valid connection",
-			database: "db1",
-			wantErr:  false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			_, err := mysql.NewConn(ctx, tt.database)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("NewConn() error = %v, wantErr %v", err, tt.wantErr)
-				return
-			}
-		})
-	}
-}
-
-func TestShowDatabases(t *testing.T) {
-	ctx := context.Background()
-	settings := `{"mysql.addr":"localhost:3306","mysql.user":"root","mysql.password":"root","mysql.maxIdleConns":5,"mysql.maxOpenConns":10,"mysql.connMaxLifetime":30}`
-	mysql, err := NewMySQLWithSettings(ctx, settings)
-	require.NoError(t, err)
-
-	databases, err := mysql.ShowDatabases(ctx)
-	require.NoError(t, err)
-	t.Log(databases)
-}
-
-func TestShowTables(t *testing.T) {
-	ctx := context.Background()
-	settings := `{"mysql.addr":"localhost:3306","mysql.user":"root","mysql.password":"root","mysql.maxIdleConns":5,"mysql.maxOpenConns":10,"mysql.connMaxLifetime":30}`
-	mysql, err := NewMySQLWithSettings(ctx, settings)
-	require.NoError(t, err)
-
-	tables, err := mysql.ShowTables(ctx, "db1")
-	require.NoError(t, err)
-	t.Log(tables)
-}
-
-func TestDescTable(t *testing.T) {
-	ctx := context.Background()
-	settings := `{"mysql.addr":"localhost:3306","mysql.user":"root","mysql.password":"root","mysql.maxIdleConns":5,"mysql.maxOpenConns":10,"mysql.connMaxLifetime":30}`
-	mysql, err := NewMySQLWithSettings(ctx, settings)
-	require.NoError(t, err)
-
-	descTable, err := mysql.DescTable(ctx, "db1", "students")
-	require.NoError(t, err)
-	for _, desc := range descTable {
-		t.Logf("%+v", *desc)
-	}
-}
-
-func TestExecQuery(t *testing.T) {
-	ctx := context.Background()
-	settings := `{"mysql.addr":"localhost:3306","mysql.user":"root","mysql.password":"root","mysql.maxIdleConns":5,"mysql.maxOpenConns":10,"mysql.connMaxLifetime":30}`
-	mysql, err := NewMySQLWithSettings(ctx, settings)
-	require.NoError(t, err)
-
-	rows, err := mysql.ExecQuery(ctx, "db1", "SELECT * FROM students WHERE id = 10008")
-	require.NoError(t, err)
-	for _, row := range rows {
-		t.Log(row)
-	}
-}
-
-func TestSelectRows(t *testing.T) {
-	ctx := context.Background()
-	settings := `{"mysql.addr":"localhost:3306","mysql.user":"root","mysql.password":"root","mysql.maxIdleConns":5,"mysql.maxOpenConns":10,"mysql.connMaxLifetime":30}`
-	mysql, err := NewMySQLWithSettings(ctx, settings)
-	require.NoError(t, err)
-
-	rows, err := mysql.SelectRows(ctx, "db1", "students", "id > 10008")
-	require.NoError(t, err)
-	for _, row := range rows {
-		t.Log(row)
-	}
-}

dskit/mysql/timeseries.go

@@ -1,74 +0,0 @@
-package mysql
-
-import (
-	"context"
-	"fmt"
-	"strings"
-
-	"github.com/ccfos/nightingale/v6/dskit/sqlbase"
-	"github.com/ccfos/nightingale/v6/dskit/types"
-
-	"gorm.io/gorm"
-)
-
-// Query executes a given SQL query in MySQL and returns the results
-func (m *MySQL) Query(ctx context.Context, query *sqlbase.QueryParam) ([]map[string]interface{}, error) {
-	db, err := m.NewConn(ctx, "")
-	if err != nil {
-		return nil, err
-	}
-
-	err = m.CheckMaxQueryRows(db, ctx, query)
-	if err != nil {
-		return nil, err
-	}
-
-	return sqlbase.Query(ctx, db, query)
-}
-
-// QueryTimeseries executes a time series data query using the given parameters
-func (m *MySQL) QueryTimeseries(ctx context.Context, query *sqlbase.QueryParam) ([]types.MetricValues, error) {
-	db, err := m.NewConn(ctx, "")
-	if err != nil {
-		return nil, err
-	}
-
-	err = m.CheckMaxQueryRows(db, ctx, query)
-	if err != nil {
-		return nil, err
-	}
-
-	return sqlbase.QueryTimeseries(ctx, db, query)
-}
-
-func (m *MySQL) CheckMaxQueryRows(db *gorm.DB, ctx context.Context, query *sqlbase.QueryParam) error {
-	sql := strings.ReplaceAll(query.Sql, ";", "")
-	checkQuery := &sqlbase.QueryParam{
-		Sql: fmt.Sprintf("SELECT COUNT(*) as count FROM (%s) AS subquery;", sql),
-	}
-
-	res, err := sqlbase.Query(ctx, db, checkQuery)
-	if err != nil {
-		return err
-	}
-
-	if len(res) > 0 {
-		if count, exists := res[0]["count"]; exists {
-			v, err := sqlbase.ParseFloat64Value(count)
-			if err != nil {
-				return err
-			}
-
-			maxQueryRows := m.Shards[0].MaxQueryRows
-			if maxQueryRows == 0 {
-				maxQueryRows = 500
-			}
-
-			if v > float64(maxQueryRows) {
-				return fmt.Errorf("query result rows count %d exceeds the maximum limit %d", int(v), maxQueryRows)
-			}
-		}
-	}
-
-	return nil
-}

dskit/mysql/timeseries_test.go

@@ -1,62 +0,0 @@
-// @Author: Ciusyan 5/11/24
-
-package mysql
-
-import (
-	"context"
-	"testing"
-
-	"github.com/ccfos/nightingale/v6/dskit/sqlbase"
-	"github.com/ccfos/nightingale/v6/dskit/types"
-
-	"github.com/stretchr/testify/require"
-)
-
-func TestQuery(t *testing.T) {
-	ctx := context.Background()
-	settings := `{"mysql.addr":"localhost:3306","mysql.user":"root","mysql.password":"root","mysql.maxIdleConns":5,"mysql.maxOpenConns":10,"mysql.connMaxLifetime":30}`
-	mysql, err := NewMySQLWithSettings(ctx, settings)
-	require.NoError(t, err)
-
-	param := &sqlbase.QueryParam{
-		Sql: "SELECT * FROM students WHERE id > 10900",
-		Keys: types.Keys{
-			ValueKey:   "",
-			LabelKey:   "",
-			TimeKey:    "",
-			TimeFormat: "",
-		},
-	}
-
-	rows, err := mysql.Query(ctx, param)
-	require.NoError(t, err)
-	for _, row := range rows {
-		t.Log(row)
-	}
-}
-
-func TestQueryTimeseries(t *testing.T) {
-	ctx := context.Background()
-	settings := `{"mysql.addr":"localhost:3306","mysql.user":"root","mysql.password":"root","mysql.maxIdleConns":5,"mysql.maxOpenConns":10,"mysql.connMaxLifetime":30}`
-	mysql, err := NewMySQLWithSettings(ctx, settings)
-	require.NoError(t, err)
-
-	// Prepare a test query parameter
-	param := &sqlbase.QueryParam{
-		Sql: "SELECT id, grade, student_name, a_grade, update_time FROM students WHERE grade > 20000", // Modify SQL query to select specific columns
-		Keys: types.Keys{
-			ValueKey:   "grade a_grade",                 // Set the value key to the column name containing the metric value
-			LabelKey:   "id student_name",               // Set the label key to the column name containing the metric label
-			TimeKey:    "update_time",                   // Set the time key to the column name containing the timestamp
-			TimeFormat: "2006-01-02 15:04:05 +0000 UTC", // Provide the time format according to the timestamp column's format
-		},
-	}
-
-	// Execute the query and retrieve the time series data
-	metricValues, err := mysql.QueryTimeseries(ctx, param)
-	require.NoError(t, err)
-
-	for _, metric := range metricValues {
-		t.Log(metric)
-	}
-}

dskit/pool/pool.go

@@ -1,37 +0,0 @@
-package pool
-
-import (
-	"bytes"
-	"sync"
-	"time"
-
-	gc "github.com/patrickmn/go-cache"
-)
-
-var (
-	PoolClient = new(sync.Map)
-)
-
-var (
-	// default cache instance, do not use this if you want to specify the defaultExpiration
-	DefaultCache = gc.New(time.Hour*24, time.Hour)
-)
-
-var (
-	bytesPool = sync.Pool{
-		New: func() interface{} { return new(bytes.Buffer) },
-	}
-)
-
-func PoolGetBytesBuffer() *bytes.Buffer {
-	buf := bytesPool.Get().(*bytes.Buffer)
-	buf.Reset()
-	return buf
-}
-
-func PoolPutBytesBuffer(buf *bytes.Buffer) {
-	if buf == nil {
-		return
-	}
-	bytesPool.Put(buf)
-}

dskit/postgres/postgres.go

@@ -1,207 +0,0 @@
-// @Author: Ciusyan 5/20/24
-
-package postgres
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"strings"
-	"time"
-
-	"github.com/ccfos/nightingale/v6/dskit/pool"
-	"github.com/ccfos/nightingale/v6/dskit/sqlbase"
-	"github.com/ccfos/nightingale/v6/dskit/types"
-
-	_ "github.com/lib/pq" // PostgreSQL driver
-	"github.com/mitchellh/mapstructure"
-	"gorm.io/driver/postgres"
-	"gorm.io/gorm"
-)
-
-type PostgreSQL struct {
-	Shard `json:",inline"  mapstructure:",squash"`
-}
-
-type Shard struct {
-	Addr            string `json:"pgsql.addr" mapstructure:"pgsql.addr"`
-	DB              string `json:"pgsql.db" mapstructure:"pgsql.db"`
-	User            string `json:"pgsql.user" mapstructure:"pgsql.user"`
-	Password        string `json:"pgsql.password" mapstructure:"pgsql.password" `
-	Timeout         int    `json:"pgsql.timeout" mapstructure:"pgsql.timeout"`
-	MaxIdleConns    int    `json:"pgsql.max_idle_conns" mapstructure:"pgsql.max_idle_conns"`
-	MaxOpenConns    int    `json:"pgsql.max_open_conns" mapstructure:"pgsql.max_open_conns"`
-	ConnMaxLifetime int    `json:"pgsql.conn_max_lifetime" mapstructure:"pgsql.conn_max_lifetime"`
-	MaxQueryRows    int    `json:"pgsql.max_query_rows" mapstructure:"pgsql.max_query_rows"`
-}
-
-// NewPostgreSQLWithSettings initializes a new PostgreSQL instance with the given settings
-func NewPostgreSQLWithSettings(ctx context.Context, settings interface{}) (*PostgreSQL, error) {
-	newest := new(PostgreSQL)
-	settingsMap := map[string]interface{}{}
-
-	switch s := settings.(type) {
-	case string:
-		if err := json.Unmarshal([]byte(s), &settingsMap); err != nil {
-			return nil, err
-		}
-	case map[string]interface{}:
-		settingsMap = s
-	case *PostgreSQL:
-		return s, nil
-	case PostgreSQL:
-		return &s, nil
-	case Shard:
-		newest.Shard = s
-		return newest, nil
-	case *Shard:
-		newest.Shard = *s
-		return newest, nil
-	default:
-		return nil, errors.New("unsupported settings type")
-	}
-
-	if err := mapstructure.Decode(settingsMap, newest); err != nil {
-		return nil, err
-	}
-
-	return newest, nil
-}
-
-// NewConn establishes a new connection to PostgreSQL
-func (p *PostgreSQL) NewConn(ctx context.Context, database string) (*gorm.DB, error) {
-	if len(p.DB) == 0 && len(database) == 0 {
-		return nil, errors.New("empty pgsql database") // 兼容阿里实时数仓Holgres, 连接时必须指定db名字
-	}
-
-	if p.Shard.Timeout == 0 {
-		p.Shard.Timeout = 60
-	}
-
-	if p.Shard.MaxIdleConns == 0 {
-		p.Shard.MaxIdleConns = 10
-	}
-
-	if p.Shard.MaxOpenConns == 0 {
-		p.Shard.MaxOpenConns = 100
-	}
-
-	if p.Shard.ConnMaxLifetime == 0 {
-		p.Shard.ConnMaxLifetime = 14400
-	}
-
-	if len(p.Shard.Addr) == 0 {
-		return nil, errors.New("empty fe-node addr")
-	}
-	var keys []string
-	var err error
-	keys = append(keys, p.Shard.Addr)
-
-	keys = append(keys, p.Shard.Password, p.Shard.User)
-	if len(database) > 0 {
-		keys = append(keys, database)
-	}
-	cachedKey := strings.Join(keys, ":")
-	// cache conn with database
-	conn, ok := pool.PoolClient.Load(cachedKey)
-	if ok {
-		return conn.(*gorm.DB), nil
-	}
-
-	var db *gorm.DB
-	defer func() {
-		if db != nil && err == nil {
-			pool.PoolClient.Store(cachedKey, db)
-		}
-	}()
-
-	// Simplified connection logic for PostgreSQL
-	dsn := fmt.Sprintf("postgres://%s:%s@%s/%s?sslmode=disable&TimeZone=Asia/Shanghai", p.Shard.User, p.Shard.Password, p.Shard.Addr, database)
-	db, err = sqlbase.NewDB(
-		ctx,
-		postgres.Open(dsn),
-		p.Shard.MaxIdleConns,
-		p.Shard.MaxOpenConns,
-		time.Duration(p.Shard.ConnMaxLifetime)*time.Second,
-	)
-
-	if err != nil {
-		if db != nil {
-			sqlDB, _ := db.DB()
-			if sqlDB != nil {
-				sqlDB.Close()
-			}
-		}
-		return nil, err
-	}
-
-	return db, nil
-}
-
-// ShowDatabases lists all databases in PostgreSQL
-func (p *PostgreSQL) ShowDatabases(ctx context.Context, searchKeyword string) ([]string, error) {
-	db, err := p.NewConn(ctx, "postgres")
-	if err != nil {
-		return nil, err
-	}
-	sql := fmt.Sprintf("SELECT datname FROM pg_database WHERE datistemplate = false AND datname LIKE %s",
-		"'%"+searchKeyword+"%'")
-	return sqlbase.ShowDatabases(ctx, db, sql)
-}
-
-// ShowTables lists all tables in a given database
-func (p *PostgreSQL) ShowTables(ctx context.Context, searchKeyword string) (map[string][]string, error) {
-	db, err := p.NewConn(ctx, p.DB)
-	if err != nil {
-		return nil, err
-	}
-	sql := fmt.Sprintf("SELECT schemaname, tablename FROM pg_tables WHERE schemaname !='information_schema' and schemaname !='pg_catalog'  and  tablename LIKE %s",
-		"'%"+searchKeyword+"%'")
-	rets, err := sqlbase.ExecQuery(ctx, db, sql)
-	if err != nil {
-		return nil, err
-	}
-	tabs := make(map[string][]string, 3)
-	for _, row := range rets {
-		if val, ok := row["schemaname"].(string); ok {
-			tabs[val] = append(tabs[val], row["tablename"].(string))
-		}
-	}
-	return tabs, nil
-}
-
-// DescTable describes the schema of a specified table in PostgreSQL
-// scheme default: public if not specified
-func (p *PostgreSQL) DescTable(ctx context.Context, scheme, table string) ([]*types.ColumnProperty, error) {
-	db, err := p.NewConn(ctx, p.DB)
-	if err != nil {
-		return nil, err
-	}
-	if scheme == "" {
-		scheme = "public"
-	}
-
-	query := fmt.Sprintf("SELECT column_name, data_type, is_nullable, column_default FROM information_schema.columns WHERE table_name = '%s' AND table_schema = '%s'", table, scheme)
-	return sqlbase.DescTable(ctx, db, query)
-}
-
-// SelectRows selects rows from a specified table in PostgreSQL based on a given query
-func (p *PostgreSQL) SelectRows(ctx context.Context, table, where string) ([]map[string]interface{}, error) {
-	db, err := p.NewConn(ctx, p.DB)
-	if err != nil {
-		return nil, err
-	}
-
-	return sqlbase.SelectRows(ctx, db, table, where)
-}
-
-// ExecQuery executes a SQL query in PostgreSQL
-func (p *PostgreSQL) ExecQuery(ctx context.Context, sql string) ([]map[string]interface{}, error) {
-	db, err := p.NewConn(ctx, p.DB)
-	if err != nil {
-		return nil, err
-	}
-
-	return sqlbase.ExecQuery(ctx, db, sql)
-}

dskit/postgres/timeseries.go

@@ -1,73 +0,0 @@
-package postgres
-
-import (
-	"context"
-	"fmt"
-	"strings"
-
-	"github.com/ccfos/nightingale/v6/dskit/sqlbase"
-	"github.com/ccfos/nightingale/v6/dskit/types"
-	"gorm.io/gorm"
-)
-
-// Query executes a given SQL query in PostgreSQL and returns the results
-func (p *PostgreSQL) Query(ctx context.Context, query *sqlbase.QueryParam) ([]map[string]interface{}, error) {
-	db, err := p.NewConn(ctx, p.Shard.DB)
-	if err != nil {
-		return nil, err
-	}
-
-	err = p.CheckMaxQueryRows(db, ctx, query)
-	if err != nil {
-		return nil, err
-	}
-
-	return sqlbase.Query(ctx, db, query)
-}
-
-// QueryTimeseries executes a time series data query using the given parameters
-func (p *PostgreSQL) QueryTimeseries(ctx context.Context, query *sqlbase.QueryParam) ([]types.MetricValues, error) {
-	db, err := p.NewConn(ctx, p.Shard.DB)
-	if err != nil {
-		return nil, err
-	}
-
-	err = p.CheckMaxQueryRows(db, ctx, query)
-	if err != nil {
-		return nil, err
-	}
-
-	return sqlbase.QueryTimeseries(ctx, db, query, true)
-}
-
-func (p *PostgreSQL) CheckMaxQueryRows(db *gorm.DB, ctx context.Context, query *sqlbase.QueryParam) error {
-	sql := strings.ReplaceAll(query.Sql, ";", "")
-	checkQuery := &sqlbase.QueryParam{
-		Sql: fmt.Sprintf("SELECT COUNT(*) as count FROM (%s) AS subquery;", sql),
-	}
-
-	res, err := sqlbase.Query(ctx, db, checkQuery)
-	if err != nil {
-		return err
-	}
-
-	if len(res) > 0 {
-		if count, exists := res[0]["count"]; exists {
-			v, err := sqlbase.ParseFloat64Value(count)
-			if err != nil {
-				return err
-			}
-
-			maxQueryRows := p.Shard.MaxQueryRows
-			if maxQueryRows == 0 {
-				maxQueryRows = 500
-			}
-
-			if v > float64(maxQueryRows) {
-				return fmt.Errorf("query result rows count %d exceeds the maximum limit %d", int(v), maxQueryRows)
-			}
-		}
-	}
-
-	return nil
-}

dskit/sqlbase/base.go

@@ -9,9 +9,9 @@ import (
 	"strings"
 	"time"
 
-	"gorm.io/gorm"
-
 	"github.com/ccfos/nightingale/v6/dskit/types"
+
+	"gorm.io/gorm"
 )
 
 // NewDB creates a new Gorm DB instance based on the provided gorm.Dialector and configures the connection pool
@@ -19,7 +19,7 @@ func NewDB(ctx context.Context, dialector gorm.Dialector, maxIdleConns, maxOpenC
 	// Create a new Gorm DB instance
 	db, err := gorm.Open(dialector, &gorm.Config{})
 	if err != nil {
-		return db, err
+		return nil, err
 	}
 
 	// Configure the connection pool
@@ -35,20 +35,9 @@ func NewDB(ctx context.Context, dialector gorm.Dialector, maxIdleConns, maxOpenC
 	return db.WithContext(ctx), sqlDB.Ping()
 }
 
-func CloseDB(db *gorm.DB) error {
-	if db != nil {
-		sqlDb, err := db.DB()
-		if err != nil {
-			return err
-		}
-		return sqlDb.Close()
-	}
-	return nil
-}
-
 // ShowTables retrieves a list of all tables in the specified database
 func ShowTables(ctx context.Context, db *gorm.DB, query string) ([]string, error) {
-	tables := make([]string, 0)
+	var tables []string
 
 	rows, err := db.WithContext(ctx).Raw(query).Rows()
 	if err != nil {
@@ -123,7 +112,7 @@ func DescTable(ctx context.Context, db *gorm.DB, query string) ([]*types.ColumnP
 		}
 
 		// Convert the database-specific type to internal type
-		type2, indexable := ConvertDBType(db.Dialector.Name(), typ)
+		type2, indexable := convertDBType(db.Dialector.Name(), typ)
 		columns = append(columns, &types.ColumnProperty{
 			Field:     field,
 			Type:      typ,
@@ -186,7 +175,7 @@ func SelectRows(ctx context.Context, db *gorm.DB, table, query string) ([]map[st
 }
 
 // convertDBType converts MySQL or PostgreSQL data types to custom internal types and determines if they are indexable
-func ConvertDBType(dialect, dbType string) (string, bool) {
+func convertDBType(dialect, dbType string) (string, bool) {
 	typ := strings.ToLower(dbType)
 
 	// Common type conversions
@@ -201,7 +190,7 @@ func ConvertDBType(dialect, dbType string) (string, bool) {
 		strings.HasPrefix(typ, "char"), strings.HasPrefix(typ, "tinytext"),
 		strings.HasPrefix(typ, "mediumtext"), strings.HasPrefix(typ, "longtext"),
 		strings.HasPrefix(typ, "character varying"), strings.HasPrefix(typ, "nvarchar"),
-		strings.HasPrefix(typ, "nchar"), strings.HasPrefix(typ, "bpchar"):
+		strings.HasPrefix(typ, "nchar"):
 		return types.LogExtractValueTypeText, true
 
 	case strings.HasPrefix(typ, "float"), strings.HasPrefix(typ, "double"),
@@ -214,7 +203,7 @@ func ConvertDBType(dialect, dbType string) (string, bool) {
 		strings.HasPrefix(typ, "time"), strings.HasPrefix(typ, "smalldatetime"):
 		return types.LogExtractValueTypeDate, false
 
-	case strings.HasPrefix(typ, "boolean"), strings.HasPrefix(typ, "bit"), strings.HasPrefix(typ, "bool"):
+	case strings.HasPrefix(typ, "boolean"), strings.HasPrefix(typ, "bit"):
 		return types.LogExtractValueTypeBool, false
 	}
 

dskit/sqlbase/timeseries.go

@@ -7,7 +7,6 @@ import (
 	"crypto/md5"
 	"encoding/json"
 	"fmt"
-	"math"
 	"reflect"
 	"sort"
 	"strconv"
@@ -113,8 +112,7 @@ func FormatMetricValues(keys types.Keys, rows []map[string]interface{}, ignoreDe
 				metricTs[k] = float64(ts.Unix())
 			default:
 				// Default to labels for any unrecognized columns
-				if !ignore && keys.LabelKey == "" {
-					// 只有当 labelKey 为空时，才将剩余的列作为 label
+				if !ignore {
 					labels[k] = fmt.Sprintf("%v", v)
 				}
 			}
@@ -122,11 +120,6 @@ func FormatMetricValues(keys types.Keys, rows []map[string]interface{}, ignoreDe
 
 		// Compile and store the metric values
 		for metricName, value := range metricValue {
-			// NaN 无法执行json.Marshal(), 接口会报错
-			if math.IsNaN(value) {
-				continue
-			}
-
 			metrics := make(model.Metric)
 			var labelsStr []string
 

dskit/tdengine/tdengine.go

@@ -122,7 +122,7 @@ func (tc *Tdengine) QueryTable(query string) (APIResponse, error) {
 }
 
 func (tc *Tdengine) ShowDatabases(context.Context) ([]string, error) {
-	databases := make([]string, 0)
+	var databases []string
 	data, err := tc.QueryTable("show databases")
 	if err != nil {
 		return databases, err
@@ -135,7 +135,7 @@ func (tc *Tdengine) ShowDatabases(context.Context) ([]string, error) {
 }
 
 func (tc *Tdengine) ShowTables(ctx context.Context, database string) ([]string, error) {
-	tables := make([]string, 0)
+	var tables []string
 	sql := fmt.Sprintf("show %s", database)
 	data, err := tc.QueryTable(sql)
 	if err != nil {

etc/config.toml

@@ -68,9 +68,6 @@ Enable = false
 HeaderUserNameKey = "X-User-Name"
 DefaultRoles = ["Standard"]
 
-[HTTP.TokenAuth]
-Enable = true
-
 [HTTP.RSA]
 # open RSA
 OpenRSA = false

go.mod

@@ -1,6 +1,6 @@
 module github.com/ccfos/nightingale/v6
 
-go 1.23.0
+go 1.22
 
 require (
 	github.com/BurntSushi/toml v1.4.0
@@ -13,7 +13,7 @@ require (
 	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc
 	github.com/dgrijalva/jwt-go v3.2.0+incompatible
 	github.com/expr-lang/expr v1.16.1
-	github.com/flashcatcloud/ibex v1.3.6
+	github.com/flashcatcloud/ibex v1.3.5
 	github.com/gin-contrib/pprof v1.4.0
 	github.com/gin-gonic/gin v1.9.1
 	github.com/glebarez/sqlite v1.11.0
@@ -27,14 +27,11 @@ require (
 	github.com/jinzhu/copier v0.4.0
 	github.com/json-iterator/go v1.1.12
 	github.com/koding/multiconfig v0.0.0-20171124222453-69c27309b2d7
-	github.com/lib/pq v1.10.9
 	github.com/mailru/easyjson v0.7.7
 	github.com/mattn/go-isatty v0.0.19
 	github.com/mitchellh/mapstructure v1.5.0
 	github.com/mojocn/base64Captcha v1.3.6
 	github.com/olivere/elastic/v7 v7.0.32
-	github.com/opensearch-project/opensearch-go/v2 v2.3.0
-	github.com/patrickmn/go-cache v2.1.0+incompatible
 	github.com/pelletier/go-toml/v2 v2.0.8
 	github.com/pkg/errors v0.9.1
 	github.com/prometheus/client_golang v1.20.5
@@ -47,7 +44,7 @@ require (
 	github.com/tidwall/gjson v1.14.2
 	github.com/toolkits/pkg v1.3.8
 	golang.org/x/exp v0.0.0-20231006140011-7918f672742d
-	golang.org/x/oauth2 v0.27.0
+	golang.org/x/oauth2 v0.23.0
 	gopkg.in/gomail.v2 v2.0.0-20160411212932-81ebce5c23df
 	gopkg.in/yaml.v2 v2.4.0
 	gorm.io/driver/clickhouse v0.6.1
@@ -123,7 +120,7 @@ require (
 	github.com/go-playground/locales v0.14.1 // indirect
 	github.com/go-playground/universal-translator v0.18.1 // indirect
 	github.com/go-playground/validator/v10 v10.14.0 // indirect
-	github.com/go-sql-driver/mysql v1.6.0
+	github.com/go-sql-driver/mysql v1.6.0 // indirect
 	github.com/goccy/go-json v0.10.2 // indirect
 	github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0 // indirect
 	github.com/grafana/regexp v0.0.0-20221122212121-6b5c0a4cb7fd // indirect
@@ -160,5 +157,3 @@ require (
 )
 
 replace golang.org/x/exp v0.0.0-20231006140011-7918f672742d => golang.org/x/exp v0.0.0-20230713183714-613f0c0eb8a1
-
-// replace github.com/flashcatcloud/ibex => ../github.com/flashcatcloud/ibex

go.sum

@@ -31,21 +31,8 @@ github.com/andybalholm/brotli v1.1.0 h1:eLKJA0d02Lf0mVpIDgYnqXcUn0GqVmEFny3VuID1
 github.com/andybalholm/brotli v1.1.0/go.mod h1:sms7XGricyQI9K10gOSf56VKKWS4oLer58Q+mhRPtnY=
 github.com/araddon/dateparse v0.0.0-20210429162001-6b43995a97de h1:FxWPpzIjnTlhPwqqXc4/vE0f7GvRjuAsbW+HOIe8KnA=
 github.com/araddon/dateparse v0.0.0-20210429162001-6b43995a97de/go.mod h1:DCaWoUhZrYW9p1lxo/cm8EmUOOzAPSEZNGF2DK1dJgw=
-github.com/aws/aws-sdk-go v1.44.263/go.mod h1:aVsgQcEevwlmQ7qHE9I3h+dtQgpqhFB+i8Phjh7fkwI=
 github.com/aws/aws-sdk-go v1.44.302 h1:ST3ko6GrJKn3Xi+nAvxjG3uk/V1pW8KC52WLeIxqqNk=
 github.com/aws/aws-sdk-go v1.44.302/go.mod h1:aVsgQcEevwlmQ7qHE9I3h+dtQgpqhFB+i8Phjh7fkwI=
-github.com/aws/aws-sdk-go-v2 v1.18.0/go.mod h1:uzbQtefpm44goOPmdKyAlXSNcwlRgF3ePWVW6EtJvvw=
-github.com/aws/aws-sdk-go-v2/config v1.18.25/go.mod h1:dZnYpD5wTW/dQF0rRNLVypB396zWCcPiBIvdvSWHEg4=
-github.com/aws/aws-sdk-go-v2/credentials v1.13.24/go.mod h1:jYPYi99wUOPIFi0rhiOvXeSEReVOzBqFNOX5bXYoG2o=
-github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.13.3/go.mod h1:4Q0UFP0YJf0NrsEuEYHpM9fTSEVnD16Z3uyEF7J9JGM=
-github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.33/go.mod h1:7i0PF1ME/2eUPFcjkVIwq+DOygHEoK92t5cDqNgYbIw=
-github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.4.27/go.mod h1:UrHnn3QV/d0pBZ6QBAEQcqFLf8FAzLmoUfPVIueOvoM=
-github.com/aws/aws-sdk-go-v2/internal/ini v1.3.34/go.mod h1:Etz2dj6UHYuw+Xw830KfzCfWGMzqvUTCjUj5b76GVDc=
-github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.9.27/go.mod h1:EOwBD4J4S5qYszS5/3DpkejfuK+Z5/1uzICfPaZLtqw=
-github.com/aws/aws-sdk-go-v2/service/sso v1.12.10/go.mod h1:ouy2P4z6sJN70fR3ka3wD3Ro3KezSxU6eKGQI2+2fjI=
-github.com/aws/aws-sdk-go-v2/service/ssooidc v1.14.10/go.mod h1:AFvkxc8xfBe8XA+5St5XIHHrQQtkxqrRincx4hmMHOk=
-github.com/aws/aws-sdk-go-v2/service/sts v1.19.0/go.mod h1:BgQOMsg8av8jset59jelyPW7NoZcZXLVpDsXunGDrk8=
-github.com/aws/smithy-go v1.13.5/go.mod h1:Tg+OJXh4MB2R/uN61Ko2f6hTZwB/ZYGOtib8J3gBHzA=
 github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
 github.com/bitly/go-simplejson v0.5.1 h1:xgwPbetQScXt1gh9BmoJ6j9JMr3TElvuIyjR8pgdoow=
@@ -89,8 +76,8 @@ github.com/fatih/camelcase v1.0.0 h1:hxNvNX/xYBp0ovncs8WyWZrOrpBNub/JfaMvbURyft8
 github.com/fatih/camelcase v1.0.0/go.mod h1:yN2Sb0lFhZJUdVvtELVWefmrXpuZESvPmqwoZc+/fpc=
 github.com/fatih/structs v1.1.0 h1:Q7juDM0QtcnhCpeyLGQKyg4TOIghuNXrkL32pHAUMxo=
 github.com/fatih/structs v1.1.0/go.mod h1:9NiDSp5zOcgEDl+j00MP/WkGVPOlPRLejGD8Ga6PJ7M=
-github.com/flashcatcloud/ibex v1.3.6 h1:lJShPFxcZksmkB0w99a3uROGB+Fie1NsqOlkAdar12A=
-github.com/flashcatcloud/ibex v1.3.6/go.mod h1:iTU1dKT9TnDNllRPRHUOjXe+HDTQkPH2TeaucHtSuh4=
+github.com/flashcatcloud/ibex v1.3.5 h1:8GOOf5+aJT0TP/MC6izz7CO5JKJSdKVFBwL0vQp93Nc=
+github.com/flashcatcloud/ibex v1.3.5/go.mod h1:T8hbMUySK2q6cXUaYp0AUVeKkU9Od2LjzwmB5lmTRBM=
 github.com/fortytw2/leaktest v1.3.0 h1:u8491cBMTQ8ft8aeV+adlcytMZylmA5nnwwkRZjI8vw=
 github.com/fortytw2/leaktest v1.3.0/go.mod h1:jDsjWgpAGjm2CA7WthBh/CdZYEPF31XHquHwclZch5g=
 github.com/gabriel-vasile/mimetype v1.4.2 h1:w5qFW6JKBz9Y393Y4q372O9A7cUSequkh1Q7OhCmWKU=
@@ -152,7 +139,6 @@ github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM=
 github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.8/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
 github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
@@ -203,7 +189,6 @@ github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ=
 github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8=
 github.com/jmespath/go-jmespath v0.4.0 h1:BEgLn5cpjn8UN1mAw4NjwDrS35OdebyEtFe+9YPoQUg=
 github.com/jmespath/go-jmespath v0.4.0/go.mod h1:T8mJZnbsbmF+m6zOOFylbeCJqk5+pHWvzYPziyZiYoo=
-github.com/jmespath/go-jmespath/internal/testify v1.5.1/go.mod h1:L3OGu8Wl2/fWfCI6z80xFu9LTZmf1ZRjMHUOPmWr69U=
 github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY=
 github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y=
 github.com/jpillora/backoff v1.0.0 h1:uvFg412JmmHBHw7iwprIxkPMI+sGQ4kzOWsMeHnm2EA=
@@ -235,8 +220,6 @@ github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+
 github.com/leodido/go-urn v1.2.1/go.mod h1:zt4jvISO2HfUBqxjfIshjdMTYS56ZS/qv49ictyFfxY=
 github.com/leodido/go-urn v1.2.4 h1:XlAE/cm/ms7TE/VMVoduSpNBoyc2dOxHs5MZSwAN63Q=
 github.com/leodido/go-urn v1.2.4/go.mod h1:7ZrI8mTSeBSHl/UaRyKQW1qZeMgak41ANeCNaVckg+4=
-github.com/lib/pq v1.10.9 h1:YXG7RB+JIjhP29X+OtkiDnYaXQwpS4JEWq7dtCCRUEw=
-github.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
 github.com/mailru/easyjson v0.7.7 h1:UGYAvKxe3sBsEDzO8ZeWOSlIQfWFlxbzLZe7hwFURr0=
 github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc=
 github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94=
@@ -263,10 +246,6 @@ github.com/oklog/ulid v1.3.1 h1:EGfNDEx6MqHz8B3uNV6QAib1UR2Lm97sHi3ocA6ESJ4=
 github.com/oklog/ulid v1.3.1/go.mod h1:CirwcVhetQ6Lv90oh/F+FBtV6XMibvdAFo93nm5qn4U=
 github.com/olivere/elastic/v7 v7.0.32 h1:R7CXvbu8Eq+WlsLgxmKVKPox0oOwAE/2T9Si5BnvK6E=
 github.com/olivere/elastic/v7 v7.0.32/go.mod h1:c7PVmLe3Fxq77PIfY/bZmxY/TAamBhCzZ8xDOE09a9k=
-github.com/opensearch-project/opensearch-go/v2 v2.3.0 h1:nQIEMr+A92CkhHrZgUhcfsrZjibvB3APXf2a1VwCmMQ=
-github.com/opensearch-project/opensearch-go/v2 v2.3.0/go.mod h1:8LDr9FCgUTVoT+5ESjc2+iaZuldqE+23Iq0r1XeNue8=
-github.com/patrickmn/go-cache v2.1.0+incompatible h1:HRMgzkcYKYpi3C8ajMPV8OFXaaRUnok+kx1WdO15EQc=
-github.com/patrickmn/go-cache v2.1.0+incompatible/go.mod h1:3Qf8kWWT7OJRJbdiICTKqZju1ZixQ/KpMGzzAfe6+WQ=
 github.com/paulmach/orb v0.11.1 h1:3koVegMC4X/WeiXYz9iswopaTwMem53NzTJuTF20JzU=
 github.com/paulmach/orb v0.11.1/go.mod h1:5mULz1xQfs3bmQm63QEJA6lNGujuRafwA5S/EnuLaLU=
 github.com/paulmach/protoscan v0.2.1/go.mod h1:SpcSwydNLrxUGSDvXvO0P7g7AuhJ7lcKfDlhJCDw2gY=
@@ -409,15 +388,14 @@ golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwY
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
-golang.org/x/net v0.1.0/go.mod h1:Cx3nUiGt4eDBEyega/BKRp+/AlGL8hYe7U9odMt2Cco=
 golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
 golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
 golang.org/x/net v0.8.0/go.mod h1:QVkue5JL9kW//ek3r6jTKnTFis1tRmNAW2P1shuFdJc=
 golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
 golang.org/x/net v0.34.0 h1:Mb7Mrk043xzHgnRM88suvJFwzVrRfHEHJEl5/71CKw0=
 golang.org/x/net v0.34.0/go.mod h1:di0qlW3YNM5oh6GqDGQr92MyTozJPmybPK4Ev/Gm31k=
-golang.org/x/oauth2 v0.27.0 h1:da9Vo7/tDv5RH/7nZDz1eMGS/q1Vv1N/7FCrBhI9I3M=
-golang.org/x/oauth2 v0.27.0/go.mod h1:onh5ek6nERTohokkhCD/y2cV4Do3fxFHFuAejCkRWT8=
+golang.org/x/oauth2 v0.23.0 h1:PbgcYx2W7i4LvjJWEbf0ngHV6qJYr86PkAV3bXdLEbs=
+golang.org/x/oauth2 v0.23.0/go.mod h1:XYTD2NtWslqkgxebSiOHnXEap4TF09sJSc7H1sXbhtI=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
@@ -437,7 +415,6 @@ golang.org/x/sys v0.0.0-20210806184541-e5e7981a1069/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220704084225-05e143d24a9e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
@@ -447,7 +424,6 @@ golang.org/x/sys v0.29.0 h1:TPYlXGxvx1MGTn2GiZDhnjPA9wZzZeGKHHmKhHYvgaU=
 golang.org/x/sys v0.29.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
-golang.org/x/term v0.1.0/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
 golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
 golang.org/x/term v0.6.0/go.mod h1:m6U89DPEgQRMq3DNkDClhWw02AUbt2daBVO4cn4Hv9U=
 golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo=
@@ -456,7 +432,6 @@ golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
 golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ=
-golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
 golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
 golang.org/x/text v0.8.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
 golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
@@ -491,7 +466,6 @@ gopkg.in/gomail.v2 v2.0.0-20160411212932-81ebce5c23df/go.mod h1:LRQQ+SO6ZHR7tOkp
 gopkg.in/square/go-jose.v2 v2.6.0 h1:NGk74WTnPKBNUhNzQX7PYcTLUjoq7mzKk2OKbvwk2iI=
 gopkg.in/square/go-jose.v2 v2.6.0/go.mod h1:M9dMgbHiYLoDGQrXy7OpJDJWiKiU//h+vD76mk0e1AI=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
 gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

integrations/ClickHouse/metrics/clickhouse_by_categraf.json

@@ -12,19 +12,7 @@
         "created_at": 0,
         "created_by": "",
         "updated_at": 0,
-        "updated_by": "",
-        "translation": [
-            {
-                "lang": "zh_CN",
-                "name": "ClickHouse HTTP 连接数",
-                "note": "通过HTTP协议连接到ClickHouse服务器的客户端数量。"
-            },
-            {
-                "lang": "en_US",
-                "name": "ClickHouse HTTP Connections",
-                "note": "The number of clients connected to the ClickHouse server via the HTTP protocol."
-            }
-        ]
+        "updated_by": ""
     },
     {
         "id": 0,
@@ -39,19 +27,7 @@
         "created_at": 0,
         "created_by": "",
         "updated_at": 0,
-        "updated_by": "",
-        "translation": [
-            {
-                "lang": "zh_CN",
-                "name": "ClickHouse INSERT查询平均时间",
-                "note": "插入查询执行的平均时间（微秒）。"
-            },
-            {
-                "lang": "en_US",
-                "name": "ClickHouse INSERT query average time",
-                "note": "The average time in microseconds for the insertion query to execute."
-            }
-        ]
+        "updated_by": ""
     },
     {
         "id": 0,
@@ -66,19 +42,7 @@
         "created_at": 0,
         "created_by": "",
         "updated_at": 0,
-        "updated_by": "",
-        "translation": [
-            {
-                "lang": "zh_CN",
-                "name": "ClickHouse SELECT 查询数",
-                "note": "执行的选择（SELECT）查询的数量"
-            },
-            {
-                "lang": "en_US",
-                "name": "ClickHouse SELECT Query Number",
-                "note": "Number of SELECT queries executed"
-            }
-        ]
+        "updated_by": ""
     },
     {
         "id": 0,
@@ -93,19 +57,7 @@
         "created_at": 0,
         "created_by": "",
         "updated_at": 0,
-        "updated_by": "",
-        "translation": [
-            {
-                "lang": "zh_CN",
-                "name": "ClickHouse SELECT查询平均时间",
-                "note": "选择查询执行的平均时间（微秒）。"
-            },
-            {
-                "lang": "en_US",
-                "name": "ClickHouse SELECT query average time",
-                "note": "Select the average time (microseconds) for query execution."
-            }
-        ]
+        "updated_by": ""
     },
     {
         "id": 0,
@@ -120,19 +72,7 @@
         "created_at": 0,
         "created_by": "",
         "updated_at": 0,
-        "updated_by": "",
-        "translation": [
-            {
-                "lang": "zh_CN",
-                "name": "ClickHouse TCP 连接数",
-                "note": "通过TCP协议连接到ClickHouse服务器的客户端数量。"
-            },
-            {
-                "lang": "en_US",
-                "name": "ClickHouse TCP Connections",
-                "note": "The number of clients connected to the ClickHouse server via the TCP protocol."
-            }
-        ]
+        "updated_by": ""
     },
     {
         "id": 0,
@@ -147,19 +87,7 @@
         "created_at": 0,
         "created_by": "",
         "updated_at": 0,
-        "updated_by": "",
-        "translation": [
-            {
-                "lang": "zh_CN",
-                "name": "ClickHouse 临时数据量",
-                "note": "临时数据部分的数量，这些部分当前正在生成。"
-            },
-            {
-                "lang": "en_US",
-                "name": "ClickHouse Temporary Data Volume",
-                "note": "The number of temporary data sections that are currently being generated."
-            }
-        ]
+        "updated_by": ""
     },
     {
         "id": 0,
@@ -174,19 +102,7 @@
         "created_at": 0,
         "created_by": "",
         "updated_at": 0,
-        "updated_by": "",
-        "translation": [
-            {
-                "lang": "zh_CN",
-                "name": "ClickHouse 分布式表连接数",
-                "note": "发送到分布式表的远程服务器的数据连接数。"
-            },
-            {
-                "lang": "en_US",
-                "name": "ClickHouse Distributed Table Joins",
-                "note": "The number of data connections sent to the remote server of the distributed table."
-            }
-        ]
+        "updated_by": ""
     },
     {
         "id": 0,
@@ -201,19 +117,7 @@
         "created_at": 0,
         "created_by": "",
         "updated_at": 0,
-        "updated_by": "",
-        "translation": [
-            {
-                "lang": "zh_CN",
-                "name": "ClickHouse 宽数据量",
-                "note": "宽数据部分的数量。"
-            },
-            {
-                "lang": "en_US",
-                "name": "ClickHouse wide data volume",
-                "note": "Number of wide data sections."
-            }
-        ]
+        "updated_by": ""
     },
     {
         "id": 0,
@@ -228,19 +132,7 @@
         "created_at": 0,
         "created_by": "",
         "updated_at": 0,
-        "updated_by": "",
-        "translation": [
-            {
-                "lang": "zh_CN",
-                "name": "ClickHouse 待插入分布式表文件数",
-                "note": "等待异步插入到分布式表的文件数量。"
-            },
-            {
-                "lang": "en_US",
-                "name": "ClickHouse Number of distributed table files to be inserted",
-                "note": "The number of files waiting to be inserted asynchronously into the distributed table."
-            }
-        ]
+        "updated_by": ""
     },
     {
         "id": 0,
@@ -255,19 +147,7 @@
         "created_at": 0,
         "created_by": "",
         "updated_at": 0,
-        "updated_by": "",
-        "translation": [
-            {
-                "lang": "zh_CN",
-                "name": "ClickHouse 提交前数据量",
-                "note": "提交前的数据部分数量，这些部分在data_parts列表中，但不用于SELECT查询。"
-            },
-            {
-                "lang": "en_US",
-                "name": "Data volume before ClickHouse submission",
-                "note": "The number of data parts before submission, which are in the data _ parts list, but are not used for SELECT queries."
-            }
-        ]
+        "updated_by": ""
     },
     {
         "id": 0,
@@ -282,19 +162,7 @@
         "created_at": 0,
         "created_by": "",
         "updated_at": 0,
-        "updated_by": "",
-        "translation": [
-            {
-                "lang": "zh_CN",
-                "name": "ClickHouse 提交后数据量",
-                "note": "提交后的数据部分数量，这些部分在data_parts列表中，并且用于SELECT查询。"
-            },
-            {
-                "lang": "en_US",
-                "name": "Data volume after ClickHouse submission",
-                "note": "The number of submitted data parts, which are in the data _ parts list and used for SELECT queries."
-            }
-        ]
+        "updated_by": ""
     },
     {
         "id": 0,
@@ -309,19 +177,7 @@
         "created_at": 0,
         "created_by": "",
         "updated_at": 0,
-        "updated_by": "",
-        "translation": [
-            {
-                "lang": "zh_CN",
-                "name": "ClickHouse 插入未压缩",
-                "note": " 插入操作写入的未压缩字节数。"
-            },
-            {
-                "lang": "en_US",
-                "name": "ClickHouse Insert Uncompressed",
-                "note": "The number of uncompressed bytes written by the insert operation."
-            }
-        ]
+        "updated_by": ""
     },
     {
         "id": 0,
@@ -336,19 +192,7 @@
         "created_at": 0,
         "created_by": "",
         "updated_at": 0,
-        "updated_by": "",
-        "translation": [
-            {
-                "lang": "zh_CN",
-                "name": "ClickHouse 插入行数",
-                "note": ""
-            },
-            {
-                "lang": "en_US",
-                "name": "Number of ClickHouse inserted rows",
-                "note": ""
-            }
-        ]
+        "updated_by": ""
     },
     {
         "id": 0,
@@ -363,19 +207,7 @@
         "created_at": 0,
         "created_by": "",
         "updated_at": 0,
-        "updated_by": "",
-        "translation": [
-            {
-                "lang": "zh_CN",
-                "name": "ClickHouse 查询优先级",
-                "note": "由于优先级设置，被停止并等待的查询数量。\n"
-            },
-            {
-                "lang": "en_US",
-                "name": "ClickHouse Query Priority",
-                "note": "The number of queries that were stopped and waiting due to the priority setting. \n"
-            }
-        ]
+        "updated_by": ""
     },
     {
         "id": 0,
@@ -390,19 +222,7 @@
         "created_at": 0,
         "created_by": "",
         "updated_at": 0,
-        "updated_by": "",
-        "translation": [
-            {
-                "lang": "zh_CN",
-                "name": "ClickHouse 查询总数",
-                "note": "ClickHouse执行的查询总数。"
-            },
-            {
-                "lang": "en_US",
-                "name": "Total ClickHouse Queries",
-                "note": "The total number of queries executed by ClickHouse."
-            }
-        ]
+        "updated_by": ""
     },
     {
         "id": 0,
@@ -417,19 +237,7 @@
         "created_at": 0,
         "created_by": "",
         "updated_at": 0,
-        "updated_by": "",
-        "translation": [
-            {
-                "lang": "zh_CN",
-                "name": "ClickHouse 查询总时间",
-                "note": "查询执行的总时间（微秒）。"
-            },
-            {
-                "lang": "en_US",
-                "name": "Total ClickHouse query time",
-                "note": "The total time in microseconds for the query to execute."
-            }
-        ]
+        "updated_by": ""
     },
     {
         "id": 0,
@@ -444,19 +252,7 @@
         "created_at": 0,
         "created_by": "",
         "updated_at": 0,
-        "updated_by": "",
-        "translation": [
-            {
-                "lang": "zh_CN",
-                "name": "ClickHouse 正被删除数据量",
-                "note": "正在被删除的数据部分数量。"
-            },
-            {
-                "lang": "en_US",
-                "name": "ClickHouse Amount of Data being Deleted",
-                "note": "The number of data parts being deleted."
-            }
-        ]
+        "updated_by": ""
     },
     {
         "id": 0,
@@ -471,19 +267,7 @@
         "created_at": 0,
         "created_by": "",
         "updated_at": 0,
-        "updated_by": "",
-        "translation": [
-            {
-                "lang": "zh_CN",
-                "name": "ClickHouse 移动池活动任务数",
-                "note": "后台移动池中的活动任务数，用于处理数据移动。"
-            },
-            {
-                "lang": "en_US",
-                "name": "Number of active tasks in ClickHouse mobile pool",
-                "note": "The number of active tasks in the background move pool, used to handle data moves."
-            }
-        ]
+        "updated_by": ""
     },
     {
         "id": 0,
@@ -498,19 +282,7 @@
         "created_at": 0,
         "created_by": "",
         "updated_at": 0,
-        "updated_by": "",
-        "translation": [
-            {
-                "lang": "zh_CN",
-                "name": "ClickHouse 紧凑数据量",
-                "note": "紧凑数据部分的数量。"
-            },
-            {
-                "lang": "en_US",
-                "name": "ClickHouse Compact Data Volume",
-                "note": "Number of compact data sections."
-            }
-        ]
+        "updated_by": ""
     },
     {
         "id": 0,
@@ -525,19 +297,7 @@
         "created_at": 0,
         "created_by": "",
         "updated_at": 0,
-        "updated_by": "",
-        "translation": [
-            {
-                "lang": "zh_CN",
-                "name": "ClickHouse 缓冲区活动任务数",
-                "note": "后台缓冲区冲洗调度池中的活动任务数，用于定期缓冲区冲洗。"
-            },
-            {
-                "lang": "en_US",
-                "name": "Number of active tasks in ClickHouse buffer",
-                "note": "The number of active tasks in the background buffer flushing scheduling pool for periodic buffer flushing."
-            }
-        ]
+        "updated_by": ""
     },
     {
         "id": 0,
@@ -552,19 +312,7 @@
         "created_at": 0,
         "created_by": "",
         "updated_at": 0,
-        "updated_by": "",
-        "translation": [
-            {
-                "lang": "zh_CN",
-                "name": "ClickHouse 跨磁盘量",
-                "note": "移动到另一个磁盘并应在析构函数中删除的数据部分数量。"
-            },
-            {
-                "lang": "en_US",
-                "name": "ClickHouse cross-disk volume",
-                "note": "The number of portions of data that are moved to another disk and should be deleted in the destructor."
-            }
-        ]
+        "updated_by": ""
     },
     {
         "id": 0,
@@ -579,19 +327,7 @@
         "created_at": 0,
         "created_by": "",
         "updated_at": 0,
-        "updated_by": "",
-        "translation": [
-            {
-                "lang": "zh_CN",
-                "name": "ClickHouse 过时数据量",
-                "note": " 过时的数据部分数量，这些部分不是活动数据部分，但当前SELECT查询可能使用它们。"
-            },
-            {
-                "lang": "en_US",
-                "name": "ClickHouse Obsolete Data Volume",
-                "note": "The number of obsolete data parts that are not active data parts, but may be used by the current SELECT query."
-            }
-        ]
+        "updated_by": ""
     },
     {
         "id": 0,
@@ -606,19 +342,7 @@
         "created_at": 0,
         "created_by": "",
         "updated_at": 0,
-        "updated_by": "",
-        "translation": [
-            {
-                "lang": "zh_CN",
-                "name": "ClickHouse中内存使用情况",
-                "note": "ClickHouse服务器使用的总内存量。"
-            },
-            {
-                "lang": "en_US",
-                "name": "Memory usage in ClickHouse",
-                "note": "The total amount of memory used by the ClickHouse server."
-            }
-        ]
+        "updated_by": ""
     },
     {
         "id": 0,
@@ -633,19 +357,7 @@
         "created_at": 0,
         "created_by": "",
         "updated_at": 0,
-        "updated_by": "",
-        "translation": [
-            {
-                "lang": "zh_CN",
-                "name": "ClickHouse中数据库数量",
-                "note": "ClickHouse数据库数量"
-            },
-            {
-                "lang": "en_US",
-                "name": "Number of databases in ClickHouse",
-                "note": "Number of ClickHouse databases"
-            }
-        ]
+        "updated_by": ""
     },
     {
         "id": 0,
@@ -660,19 +372,7 @@
         "created_at": 0,
         "created_by": "",
         "updated_at": 0,
-        "updated_by": "",
-        "translation": [
-            {
-                "lang": "zh_CN",
-                "name": "ClickHouse中表的数量",
-                "note": "ClickHouse表数量"
-            },
-            {
-                "lang": "en_US",
-                "name": "Number of tables in ClickHouse",
-                "note": "Number of ClickHouse tables"
-            }
-        ]
+        "updated_by": ""
     },
     {
         "id": 0,
@@ -687,19 +387,7 @@
         "created_at": 0,
         "created_by": "",
         "updated_at": 0,
-        "updated_by": "",
-        "translation": [
-            {
-                "lang": "zh_CN",
-                "name": "ClickHouse修订",
-                "note": "ClickHouse服务器的修订号，通常是一个用于标识特定构建的数字。"
-            },
-            {
-                "lang": "en_US",
-                "name": "ClickHouse Revision",
-                "note": "The revision number of the ClickHouse server, usually a number used to identify a specific build."
-            }
-        ]
+        "updated_by": ""
     },
     {
         "id": 0,
@@ -714,19 +402,7 @@
         "created_at": 0,
         "created_by": "",
         "updated_at": 0,
-        "updated_by": "",
-        "translation": [
-            {
-                "lang": "zh_CN",
-                "name": "ClickHouse服务器运行时间",
-                "note": "ClickHouse服务器自启动以来的运行时间。"
-            },
-            {
-                "lang": "en_US",
-                "name": "ClickHouse server runtime",
-                "note": "The running time of the ClickHouse server since it started."
-            }
-        ]
+        "updated_by": ""
     },
     {
         "id": 0,
@@ -741,18 +417,6 @@
         "created_at": 0,
         "created_by": "",
         "updated_at": 0,
-        "updated_by": "",
-        "translation": [
-            {
-                "lang": "zh_CN",
-                "name": "ClickHouse版本号",
-                "note": "ClickHouse服务器的版本号，以整数形式表示。"
-            },
-            {
-                "lang": "en_US",
-                "name": "ClickHouse version number",
-                "note": "Version number of the ClickHouse server, expressed as an integer."
-            }
-        ]
+        "updated_by": ""
     }
 ]