xugudb_exporter/collector/collector.go

package collector

import (
	"bytes"
	"context"
	"crypto/sha256"
	"database/sql"
	"errors"
	"fmt"
	"net/url"

	"strconv"
	"strings"
	"sync"
	"time"

	"github.com/BurntSushi/toml"
	"github.com/go-kit/log"
	"github.com/go-kit/log/level"
	"github.com/prometheus/client_golang/prometheus"
)

// Exporter 收集 xugu 数据库的指标信息。它实现了 prometheus.Collector 接口。
type Exporter struct {
	config          *Config                // 配置项
	mu              *sync.Mutex            // 互斥锁，用于保护并发访问
	metricsToScrape Metrics                // 需要抓取的指标
	scrapeInterval  *time.Duration         // 抓取间隔
	dsn             string                 // 数据库连接字符串
	duration, error prometheus.Gauge       // prometheus Gauge，用于记录抓取持续时间和错误状态
	totalScrapes    prometheus.Counter     // prometheus Counter，记录总抓取次数
	scrapeErrors    *prometheus.CounterVec // prometheus CounterVec，记录抓取错误的详细信息
	scrapeResults   []prometheus.Metric    // 抓取结果存储
	up              prometheus.Gauge       // prometheus Gauge，表示数据库是否可用
	db              *sql.DB                // 数据库连接对象
	logger          log.Logger             // 日志记录器
}

// Config 定义 Exporter 的配置
type Config struct {
	DSN                string // 数据库连接字符串
	MaxIdleConns       int    // 最大空闲连接数
	MaxOpenConns       int    // 最大打开连接数
	CustomMetrics      string // 自定义指标配置
	QueryTimeout       int    // 查询超时时间（秒）
	DefaultMetricsFile string // 默认指标文件路径
}

// CreateDefaultConfig 返回 Exporter 的默认配置
// 注意：返回的配置中 DSN 是空的
func CreateDefaultConfig() *Config {
	return &Config{
		MaxIdleConns:       0,  // 默认最大空闲连接数为 0
		MaxOpenConns:       10, // 默认最大打开连接数为 10
		CustomMetrics:      "", // 默认没有自定义指标
		QueryTimeout:       5,  // 默认查询超时时间为 5 秒
		DefaultMetricsFile: "", // 默认没有指定指标文件
	}
}

// Metric 描述一个指标对象
type Metric struct {
	Context          string                       // 指标上下文（例如查询的数据库信息）
	Labels           []string                     // 指标标签
	MetricsDesc      map[string]string            // 指标描述
	MetricsType      map[string]string            // 指标类型（如 Gauge 或 Counter）
	MetricsBuckets   map[string]map[string]string // 指标的直方图桶信息
	FieldToAppend    string                       // 需要附加的字段
	Request          string                       // 指标抓取的 SQL 查询
	IgnoreZeroResult bool                         // 是否忽略结果为零的情况
}

// Metrics 是 prometheus 指标的容器结构
type Metrics struct {
	Metric []Metric `json:"metrics"` // 包含多个指标对象
}

var (
	additionalMetrics Metrics                // 附加的指标
	hashMap           = make(map[int][]byte) // 用于存储额外信息的哈希表
	namespace         = "xugudb"             // 指标命名空间
	exporterName      = "exporter"           // 导出器名称
)

// maskDsn 用于屏蔽数据库连接字符串中的敏感信息
func maskDsn(dsn string) string {
	parts := strings.Split(dsn, "@") // 将连接字符串按 "@" 分割
	if len(parts) > 1 {
		maskedURL := "***@" + parts[1] // 将用户名部分替换为 "***"
		return maskedURL
	}
	return dsn
}

// NewExporter 创建一个新的 Exporter 实例
func NewExporter(logger log.Logger, cfg *Config) (*Exporter, error) {
	e := &Exporter{
		mu:  &sync.Mutex{}, // 初始化互斥锁
		dsn: cfg.DSN,       // 数据库连接字符串

		// 定义指标：上次抓取持续时间
		duration: prometheus.NewGauge(prometheus.GaugeOpts{
			Namespace: namespace,
			Subsystem: exporterName,
			Name:      "last_scrape_duration_seconds",
			Help:      "上次从 xugu 数据库抓取指标的持续时间（秒）。",
		}),
		// 定义指标：抓取总次数
		totalScrapes: prometheus.NewCounter(prometheus.CounterOpts{
			Namespace: namespace,
			Subsystem: exporterName,
			Name:      "scrapes_total",
			Help:      "从 xugu 数据库抓取指标的总次数。",
		}),
		// 定义指标：抓取错误总数（分 collector 分类）
		scrapeErrors: prometheus.NewCounterVec(prometheus.CounterOpts{
			Namespace: namespace,
			Subsystem: exporterName,
			Name:      "scrape_errors_total",
			Help:      "从 xugu 数据库抓取指标时发生错误的总次数。",
		}, []string{"collector"}),
		// 定义指标：上次抓取是否出错（1 表示出错，0 表示成功）
		error: prometheus.NewGauge(prometheus.GaugeOpts{
			Namespace: namespace,
			Subsystem: exporterName,
			Name:      "last_scrape_error",
			Help:      "上次从 xugu 数据库抓取指标是否出错（1 表示出错，0 表示成功）。",
		}),
		// 定义指标：数据库是否可用
		up: prometheus.NewGauge(prometheus.GaugeOpts{
			Namespace: namespace,
			Name:      "up",
			Help:      "xugu 数据库服务器是否可用。",
		}),
		logger: logger, // 日志记录器
		config: cfg,    // 配置信息
	}

	// 设置要抓取的默认指标
	e.metricsToScrape = e.DefaultMetrics()
	// 尝试连接数据库
	err := e.connect()
	return e, err
}

// connect 方法用于建立与 xugu 数据库的连接并进行配置。
// 它将 DSN（Data Source Name）解析、连接数据库、配置连接池等。
// 返回:
// 如果连接成功，返回 nil。
// 如果连接失败，返回相应的错误。
func (e *Exporter) connect() error {
	// 解析 DSN (数据源名称)，检查格式是否正确
	_, err := url.Parse(e.dsn)
	if err != nil {
		// 如果 DSN 格式错误，记录日志并返回错误
		level.Error(e.logger).Log("malformed DSN: ", maskDsn(e.dsn))
		return err
	}

	// 记录连接日志，使用 maskDsn 函数隐藏 DSN 的敏感信息
	level.Debug(e.logger).Log("launching connection: ", maskDsn(e.dsn))

	// 使用 sql.Open 打开与 xugu 数据库的连接
	fmt.Println("连接的虚谷数据库为： ", e.dsn)
	db, err := sql.Open("xugu", e.dsn)
	if err != nil {
		// 如果连接失败，记录日志并返回错误
		level.Error(e.logger).Log("error while connecting to", e.dsn)
		return err
	}

	// 设置最大空闲连接数，并记录日志
	level.Debug(e.logger).Log("set max idle connections to ", e.config.MaxIdleConns)
	db.SetMaxIdleConns(e.config.MaxIdleConns)

	// 设置最大打开连接数，并记录日志
	level.Debug(e.logger).Log("set max open connections to ", e.config.MaxOpenConns)
	db.SetMaxOpenConns(e.config.MaxOpenConns)

	// 连接成功，记录日志并将数据库连接对象赋值给 e.db
	level.Debug(e.logger).Log("successfully connected to: ", maskDsn(e.dsn))
	e.db = db

	// 返回 nil 表示连接成功
	return nil
}

// RunScheduledScrapes 是为想要设置定时抓取而非每次 Collect 调用时抓取的用户准备的。
// 它会根据给定的时间间隔 (si) 定期从数据库抓取指标
func (e *Exporter) RunScheduledScrapes(ctx context.Context, si time.Duration) {
	// 设置抓取的时间间隔
	e.scrapeInterval = &si

	// 创建一个定时器，每隔指定的时间间隔(si)触发一次
	ticker := time.NewTicker(si)

	// 确保函数退出时定时器能够停止
	defer ticker.Stop()

	// 启动一个无限循环来定期抓取指标
	for {
		select {
		// 每当定时器到达时间间隔时执行抓取操作
		case <-ticker.C:
			e.mu.Lock()         // 获取锁，确保不会发生并发的抓取操作
			e.scheduledScrape() // 调用实际的抓取函数
			e.mu.Unlock()       // 释放锁

		// 如果上下文被取消（通常是服务器关闭或者停止信号），退出循环
		case <-ctx.Done():
			return
		}
	}
}

func (e *Exporter) scheduledScrape() {
	// 创建一个用于传递指标的 channel，缓冲区大小为 5
	metricCh := make(chan prometheus.Metric, 5)

	// 创建一个 WaitGroup，确保所有指标收集完成后再返回
	wg := &sync.WaitGroup{}
	wg.Add(1)

	// 启动一个 goroutine 来处理收集到的指标
	go func() {
		// 当 goroutine 完成时减少 WaitGroup 的计数
		defer wg.Done()

		// 初始化 scrapeResults 列表，用于存储所有抓取到的指标
		e.scrapeResults = []prometheus.Metric{}

		// 不断从 metricCh 获取指标并添加到 scrapeResults
		for {
			scrapeResult, more := <-metricCh
			if more {
				// 将收到的指标添加到 scrapeResults 中
				e.scrapeResults = append(e.scrapeResults, scrapeResult)
				continue
			}
			// 当 channel 被关闭时，退出循环
			return
		}
	}()

	// 调用 scrape 方法抓取数据库指标，将结果发送到 metricCh
	e.scrape(metricCh)

	// 报告元数据指标
	metricCh <- e.duration           // 记录持续时间指标
	metricCh <- e.totalScrapes       // 记录总抓取次数指标
	metricCh <- e.error              // 记录错误指标
	e.scrapeErrors.Collect(metricCh) // 收集并发送错误相关的指标

	// 发送 up 指标，表示抓取是否成功
	metricCh <- e.up

	// 关闭指标 channel，通知 goroutine 停止处理指标
	close(metricCh)

	// 等待 goroutine 完成，确保所有指标都已处理
	wg.Wait()
}

// Describe 描述由  数据库导出器导出的所有指标
func (e *Exporter) Describe(ch chan<- *prometheus.Desc) {
	// 由于无法预先知道导出器会生成哪些指标，
	// 使用一种“简易描述方法”：执行一次 Collect 方法
	// 并将收集到的指标描述符发送到描述通道。
	// 问题在于需要连接  数据库，如果数据库当前不可用，
	// 描述符将是不完整的。然而，由于这是一个独立的导出器，
	// 而非在其他代码中作为库使用，因此最糟糕的情况是无法检测到
	// 导出器本身创建的不一致指标。此外，受监控的  数据库 实例
	// 发生变化可能会在运行时更改导出的指标。

	metricCh := make(chan prometheus.Metric) // 用于接收指标的通道
	doneCh := make(chan struct{})            // 用于通知完成的通道

	// 启动一个 goroutine，将指标描述符发送到描述通道
	go func() {
		for m := range metricCh {
			ch <- m.Desc() // 提取指标的描述符
		}
		close(doneCh) // 完成后关闭 doneCh
	}()

	e.Collect(metricCh) // 调用 Collect 方法收集指标
	close(metricCh)     // 关闭指标通道
	<-doneCh            // 等待完成通知
}

// Collect 实现了 prometheus.Collector 接口，用于收集指标数据
func (e *Exporter) Collect(ch chan<- prometheus.Metric) {
	// 如果有设置抓取间隔（scrapeInterval），且抓取间隔不为 0
	if e.scrapeInterval != nil && *e.scrapeInterval != 0 {
		// 确保线程安全，进行只读访问
		e.mu.Lock()
		for _, r := range e.scrapeResults { // 将之前的抓取结果发送到指标通道
			ch <- r
		}
		e.mu.Unlock()
		return
	}

	// 如果没有抓取间隔，或者间隔为 0，则按请求进行抓取
	e.mu.Lock()         // 加锁以确保没有并发抓取操作
	defer e.mu.Unlock() // 解锁防止资源泄漏

	// 执行抓取操作
	e.scrape(ch)

	// 发送基础指标到通道
	ch <- e.duration           // 上次抓取持续时间
	ch <- e.totalScrapes       // 总抓取次数
	ch <- e.error              // 上次抓取是否出错
	e.scrapeErrors.Collect(ch) // 抓取错误的详细统计
	ch <- e.up                 // 数据库是否可用
}

func (e *Exporter) scrape(ch chan<- prometheus.Metric) {
	e.totalScrapes.Inc() // 增加总抓取次数计数器
	var err error
	var errmutex sync.Mutex

	// 延迟执行，用于记录抓取持续时间和错误状态
	defer func(begun time.Time) {
		e.duration.Set(time.Since(begun).Seconds()) // 设置持续时间指标
		if err == nil {
			e.error.Set(0) // 如果没有错误，设置错误指标为 0
		} else {
			e.error.Set(1) // 如果有错误，设置错误指标为 1
		}
	}(time.Now())

	// 检查数据库连接是否正常
	if err = e.db.Ping(); err != nil {
		if strings.Contains(err.Error(), "sql: database is closed") {
			level.Info(e.logger).Log("Reconnecting to DB") // 记录重新连接数据库的信息
			err = e.connect()
			if err != nil {
				level.Error(e.logger).Log("error reconnecting to DB", err.Error())
			}
		}
	}

	// 再次检查数据库连接
	if err = e.db.Ping(); err != nil {
		level.Error(e.logger).Log("error pinging xugu:", err.Error())
		e.up.Set(0) // 设置数据库不可用指标为 0
		return
	}

	level.Debug(e.logger).Log("Successfully pinged xugu database: ", maskDsn(e.dsn))
	e.up.Set(1) // 设置数据库可用指标为 1

	// 检查指标配置是否有变化
	if e.checkIfMetricsChanged() {
		e.reloadMetrics() // 重新加载指标配置
	}

	wg := sync.WaitGroup{} // 定义一个 WaitGroup，用于等待所有抓取协程完成

	// 遍历需要抓取的指标
	for _, metric := range e.metricsToScrape.Metric {
		wg.Add(1)
		metric := metric // 为闭包创建新的局部变量（避免闭包捕获循环变量的问题）

		f := func() {
			defer wg.Done() // 在函数结束时，通知 WaitGroup 完成

			// 输出调试信息，记录当前正在抓取的指标信息
			level.Debug(e.logger).Log("About to scrape metric: ")
			level.Debug(e.logger).Log("- Metric MetricsDesc: ", fmt.Sprintf("%+v", metric.MetricsDesc))
			level.Debug(e.logger).Log("- Metric Context: ", metric.Context)
			level.Debug(e.logger).Log("- Metric MetricsType: ", fmt.Sprintf("%+v", metric.MetricsType))
			level.Debug(e.logger).Log("- Metric MetricsBuckets: ", fmt.Sprintf("%+v", metric.MetricsBuckets), "(Ignored unless Histogram type)")
			level.Debug(e.logger).Log("- Metric Labels: ", fmt.Sprintf("%+v", metric.Labels))
			level.Debug(e.logger).Log("- Metric FieldToAppend: ", metric.FieldToAppend)
			level.Debug(e.logger).Log("- Metric IgnoreZeroResult: ", fmt.Sprintf("%+v", metric.IgnoreZeroResult))
			level.Debug(e.logger).Log("- Metric Request: ", metric.Request)

			// 检查请求是否为空
			if len(metric.Request) == 0 {
				level.Error(e.logger).Log("Error scraping for ", metric.MetricsDesc, ". Did you forget to define request in your metrics config file?")
				return
			}

			// 检查指标描述是否为空
			if len(metric.MetricsDesc) == 0 {
				level.Error(e.logger).Log("Error scraping for query", metric.Request, ". Did you forget to define metricsdesc in your metrics config file?")
				return
			}

			// 检查直方图类型的指标是否定义了桶（Buckets）
			for column, metricType := range metric.MetricsType {
				if metricType == "histogram" {
					_, ok := metric.MetricsBuckets[column]
					if !ok {
						level.Error(e.logger).Log("Unable to find MetricsBuckets configuration key for metric. (metric=" + column + ")")
						return
					}
				}
			}

			scrapeStart := time.Now() // 记录抓取开始时间
			// 执行实际的指标抓取操作
			if err1 := e.ScrapeMetric(e.db, ch, metric); err1 != nil {
				// 如果抓取过程中发生错误，记录错误信息并更新错误计数器
				errmutex.Lock()
				{
					err = err1
				}
				errmutex.Unlock()
				level.Error(e.logger).Log("scrapeMetricContext", metric.Context, "ScrapeDuration", time.Since(scrapeStart), "msg", err1.Error())
				e.scrapeErrors.WithLabelValues(metric.Context).Inc()
			} else {
				// 如果抓取成功，记录成功信息
				level.Debug(e.logger).Log("successfully scraped metric: ", metric.Context, metric.MetricsDesc, time.Since(scrapeStart))
			}
		}

		go f() // 启动一个协程执行抓取函数
	}
	wg.Wait() // 等待所有抓取协程完成
}

// ScrapeMetric 是接口方法，调用 scrapeGenericValues 使用 Metric 结构体的值来抓取指标
func (e *Exporter) ScrapeMetric(db *sql.DB, ch chan<- prometheus.Metric, metricDefinition Metric) error {
	level.Debug(e.logger).Log("调用函数 ScrapeGenericValues()")
	// 调用 scrapeGenericValues 函数来抓取指标
	return e.scrapeGenericValues(db, ch, metricDefinition.Context, metricDefinition.Labels,
		metricDefinition.MetricsDesc, metricDefinition.MetricsType, metricDefinition.MetricsBuckets,
		metricDefinition.FieldToAppend, metricDefinition.IgnoreZeroResult,
		metricDefinition.Request)
}

// scrapeGenericValues 是一个通用的抓取指标的方法
// 参数：
// - db: 数据库连接对象，用于执行 SQL 查询。
// - ch: 用于发送抓取到的 Prometheus 指标的通道。
// - context: 指标的上下文，用于标识指标的来源或类型。
// - labels: 指标的标签，用于给指标添加上下文信息。
// - metricsDesc: 存储指标名称及其帮助信息的映射。
// - metricsType: 存储指标类型（例如 gauge 或 histogram）的映射。
// - metricsBuckets: 存储直方图类型指标的桶（buckets）配置。
// - fieldToAppend: 用于动态附加到指标名称中的字段。
// - ignoreZeroResult: 如果为 true，则忽略没有结果的指标，否则会返回错误。
// - request: 执行数据库查询的 SQL 请求。
func (e *Exporter) scrapeGenericValues(db *sql.DB, ch chan<- prometheus.Metric, context string, labels []string,
	metricsDesc map[string]string, metricsType map[string]string, metricsBuckets map[string]map[string]string, fieldToAppend string, ignoreZeroResult bool, request string) error {

	metricsCount := 0 // 记录抓取的指标数量

	// 通用解析器，用于处理查询结果行
	genericParser := func(row map[string]string) error {
		labelsValues := []string{} // 存储标签的值
		// 遍历标签数组，将对应标签的值添加到 labelsValues 中
		for _, label := range labels {
			labelsValues = append(labelsValues, row[strings.ToUpper(label)])
		}

		// 遍历所有指标，抓取其对应的值
		for metric, metricHelp := range metricsDesc {
			// 将指标值转换为浮动点数

			value, err := strconv.ParseFloat(strings.TrimSpace(row[strings.ToUpper(metric)]), 64)
			if err != nil {
				// 如果无法转换为浮动点数，跳过该指标
				level.Error(e.logger).Log("msg", "无法将当前值转换为浮动点数", "metric", metric, "metricHelp", metricHelp, "value", row[metric])
				continue
			}

			level.Debug(e.logger).Log("查询结果：", value)

			// 如果指标名称不使用附加字段（fieldToAppend），则使用普通的描述
			if strings.Compare(fieldToAppend, "") == 0 {
				desc := prometheus.NewDesc(
					prometheus.BuildFQName(namespace, context, metric), // 构建 Prometheus 描述符
					metricHelp, // 指标的帮助信息
					labels,     // 指标的标签
					nil,        // 没有附加标签
				)
				// 如果该指标是直方图类型
				if metricsType[strings.ToLower(metric)] == "histogram" {
					// 获取直方图的计数

					count, err := strconv.ParseUint(strings.TrimSpace(row["COUNT"]), 10, 64)

					if err != nil {
						// 如果无法转换计数值为整型，跳过该指标
						level.Error(e.logger).Log("无法将 count 值转换为整型 (metric=" + metric +
							",metricHelp=" + metricHelp + ",value=<" + row["COUNT"] + ">)")
						continue
					}
					// 创建桶（buckets）并填充数据
					buckets := make(map[float64]uint64)
					for field, le := range metricsBuckets[strings.ToUpper(metric)] {
						lelimit, err := strconv.ParseFloat(strings.TrimSpace(le), 64)
						if err != nil {
							// 如果桶的限制值无法转换为浮动点数，跳过
							level.Error(e.logger).Log("无法将桶的限制值转换为浮动点数 (metric=" + metric +
								",metricHelp=" + metricHelp + ",bucketlimit=<" + le + ">)")
							continue
						}
						fmt.Println("row[field]", row[field])
						counter, err := strconv.ParseUint(strings.TrimSpace(row[strings.ToUpper(field)]), 10, 64)
						if err != nil {
							// 如果桶的计数无法转换为整型，跳过
							level.Error(e.logger).Log("无法将桶计数值转换为整型 (metric=" + metric +
								",metricHelp=" + metricHelp + ",value=<" + row[field] + ">)")
							continue
						}
						buckets[lelimit] = counter
					}
					// 将直方图指标发送到 Prometheus 通道
					ch <- prometheus.MustNewConstHistogram(desc, count, value, buckets, labelsValues...)
				} else {
					// 对于非直方图类型指标，直接将其发送到 Prometheus 通道
					ch <- prometheus.MustNewConstMetric(desc, getMetricType(metric, metricsType), value, labelsValues...)
				}
			} else {
				// 如果指标使用附加字段，则使用附加字段值构建描述符
				desc := prometheus.NewDesc(
					prometheus.BuildFQName(namespace, context, cleanName(row[fieldToAppend])),
					metricHelp,
					nil, nil, // 没有标签
				)
				// 处理直方图类型指标
				if metricsType[strings.ToLower(metric)] == "histogram" {
					// 获取直方图的计数
					count, err := strconv.ParseUint(strings.TrimSpace(row["count"]), 10, 64)
					if err != nil {
						// 如果无法转换计数值为整型，跳过该指标
						level.Error(e.logger).Log("无法将 count 值转换为整型 (metric=" + metric +
							",metricHelp=" + metricHelp + ",value=<" + row["count"] + ">)")
						continue
					}
					// 创建桶（buckets）并填充数据
					buckets := make(map[float64]uint64)
					for field, le := range metricsBuckets[strings.ToUpper(metric)] {
						lelimit, err := strconv.ParseFloat(strings.TrimSpace(le), 64)
						if err != nil {
							// 如果桶的限制值无法转换为浮动点数，跳过
							level.Error(e.logger).Log("无法将桶的限制值转换为浮动点数 (metric=" + metric +
								",metricHelp=" + metricHelp + ",bucketlimit=<" + le + ">)")
							continue
						}
						counter, err := strconv.ParseUint(strings.TrimSpace(row[field]), 10, 64)
						if err != nil {
							// 如果桶的计数无法转换为整型，跳过
							level.Error(e.logger).Log("无法将桶计数值转换为整型 (metric=" + metric +
								",metricHelp=" + metricHelp + ",value=<" + row[field] + ">)")
							continue
						}
						buckets[lelimit] = counter
					}
					// 将直方图指标发送到 Prometheus 通道
					ch <- prometheus.MustNewConstHistogram(desc, count, value, buckets)
				} else {
					// 对于非直方图类型指标，直接将其发送到 Prometheus 通道
					ch <- prometheus.MustNewConstMetric(desc, getMetricType(metric, metricsType), value)
				}
			}
			metricsCount++ // 增加抓取的指标计数
		}
		return nil
	}

	level.Debug(e.logger).Log("调用函数 GeneratePrometheusMetrics()")
	// 调用函数生成 Prometheus 指标
	err := e.generatePrometheusMetrics(db, genericParser, request)
	level.Debug(e.logger).Log("ScrapeGenericValues() - metricsCount: ", metricsCount)
	if err != nil {
		return err
	}

	// 如果没有找到任何指标且未忽略零结果，则返回错误
	if !ignoreZeroResult && metricsCount == 0 {
		return errors.New("没有找到任何指标")
	}
	return err
}

// generatePrometheusMetrics 从数据库中执行 SQL 查询，解析查询结果并调用解析函数处理每一行数据。
// 参数:
// db: 需要查询的数据库连接。
// parse: 一个处理每一行结果的函数，它接收一个映射（map）作为输入参数。
// query: 要执行的 SQL 查询。
// 返回:
// 如果查询或处理过程中出现错误，返回错误。
func (e *Exporter) generatePrometheusMetrics(db *sql.DB, parse func(row map[string]string) error, query string) error {
	// 设置查询超时，避免长时间阻塞
	ctx, cancel := context.WithTimeout(context.Background(), time.Duration(e.config.QueryTimeout)*time.Second)
	defer cancel()

	// 执行 SQL 查询
	rows, err := db.QueryContext(ctx, query)

	// 检查是否超时
	if errors.Is(ctx.Err(), context.DeadlineExceeded) {
		return errors.New("xugu query timed out")
	}

	// 检查查询是否出错
	if err != nil {
		return err
	}

	// 获取查询结果的列名
	cols, err := rows.Columns()
	defer rows.Close()

	// 如果查询结果的列名获取失败，返回错误
	if err != nil {
		return err
	}

	// 遍历查询结果的每一行
	for rows.Next() {
		// 创建一个切片，用来表示每一列的值，以及一个切片，用来存储每列的指针
		columns := make([]interface{}, len(cols))
		columnPointers := make([]interface{}, len(cols))
		for i := range columns {
			columnPointers[i] = &columns[i]
		}

		// 将查询结果扫描到 columnPointers 切片中
		if err := rows.Scan(columnPointers...); err != nil {
			return err
		}

		// 创建一个 map，用来存储每列的值，列名作为 key
		m := make(map[string]string)
		for i, colName := range cols {
			// 获取列的值并将其格式化为字符串，存入 map 中
			val := columnPointers[i].(*interface{})
			//m[strings.ToLower(colName)] = fmt.Sprintf("%v", *val)
			m[strings.ToUpper(colName)] = fmt.Sprintf("%v", *val)

		}
		fmt.Println("m:", m)
		// 调用传入的解析函数处理每一行数据
		if err := parse(m); err != nil {
			return err
		}
	}
	// 查询和处理成功后返回 nil
	return nil
}

// getMetricType 函数根据传入的 metricType 和 metricsType 获取相应的 Prometheus 值类型 (prometheus.ValueType)
// 参数:
// metricType: 一个字符串，表示传入的指标类型
// metricsType: 一个字典映射，包含了每个 metricType 对应的字符串类型
// 返回:
// 返回对应的 prometheus.ValueType
func getMetricType(metricType string, metricsType map[string]string) prometheus.ValueType {
	// 定义一个映射，将字符串类型映射到 Prometheus 的 ValueType 类型
	var strToPromType = map[string]prometheus.ValueType{
		"gauge":     prometheus.GaugeValue,   // "gauge" 映射为 Prometheus 的 GaugeValue 类型
		"counter":   prometheus.CounterValue, // "counter" 映射为 Prometheus 的 CounterValue 类型
		"histogram": prometheus.UntypedValue, // "histogram" 映射为 Prometheus 的 UntypedValue 类型
	}

	// 将传入的 metricType 转为小写并在 metricsType 字典中查找其对应的类型
	strType, ok := metricsType[strings.ToLower(metricType)]
	if !ok {
		// 如果在 metricsType 中没有找到对应的类型，则默认返回 prometheus.GaugeValue
		return prometheus.GaugeValue
	}

	// 查找对应的 Prometheus ValueType 类型
	valueType, ok := strToPromType[strings.ToLower(strType)]
	if !ok {
		// 如果在 strToPromType 中没有找到对应的 Prometheus 类型，则抛出 panic
		panic(errors.New("Error while getting prometheus type " + strings.ToLower(strType)))
	}

	// 返回对应的 Prometheus 类型
	return valueType
}

// checkIfMetricsChanged 方法检查配置文件中定义的自定义指标文件是否发生变化。
// 如果文件发生了变化（通过计算哈希值进行比较），则返回 true，表示需要重新加载指标。
// 返回:
// 如果有文件发生变化，则返回 true，否则返回 false。
func (e *Exporter) checkIfMetricsChanged() bool {
	// 遍历自定义指标文件的列表，分隔符为逗号
	for i, _customMetrics := range strings.Split(e.config.CustomMetrics, ",") {
		// 如果自定义指标文件名为空，跳过当前循环
		if len(_customMetrics) == 0 {
			continue
		}

		// 记录正在检查的文件
		level.Debug(e.logger).Log("checking modifications in following metrics definition file:", _customMetrics)

		// 创建一个新的 SHA256 哈希计算器
		h := sha256.New()

		// 使用 hashFile 函数计算文件的哈希值
		if err := hashFile(h, _customMetrics); err != nil {
			// 如果文件哈希计算失败，记录错误并返回 false
			level.Error(e.logger).Log("unable to get file hash", err.Error())
			return false
		}

		// 如果当前文件的哈希值与之前存储的哈希值不同，表示文件已更改
		if !bytes.Equal(hashMap[i], h.Sum(nil)) {
			// 记录文件已更改，触发重新加载指标
			level.Info(e.logger).Log(_customMetrics, "has been changed. Reloading metrics...")
			// 更新存储的哈希值
			hashMap[i] = h.Sum(nil)
			return true
		}
	}

	// 如果所有文件都没有变化，返回 false
	return false
}

// reloadMetrics 方法用于重新加载 Prometheus 指标。
// 它首先清空当前的指标列表，加载默认的指标，然后根据配置加载自定义的指标。
// 如果有自定义指标文件，则加载并解析这些文件，最终将所有指标添加到 e.metricsToScrape 中。
// 返回值:
// 无，直接操作实例的状态（e.metricsToScrape）。
func (e *Exporter) reloadMetrics() {
	// 清空当前的指标列表
	e.metricsToScrape.Metric = []Metric{}

	// 加载默认指标
	defaultMetrics := e.DefaultMetrics()
	e.metricsToScrape.Metric = defaultMetrics.Metric

	// 如果有自定义指标配置，则加载它们
	if strings.Compare(e.config.CustomMetrics, "") != 0 {
		// 遍历自定义指标配置文件列表（由逗号分隔）
		for _, _customMetrics := range strings.Split(e.config.CustomMetrics, ",") {
			// 判断是 TOML 文件还是 YAML 文件，根据文件后缀调用不同的加载函数
			if strings.HasSuffix(_customMetrics, "toml") {
				// 加载 TOML 配置文件
				if err := loadTomlMetricsConfig(_customMetrics, &additionalMetrics); err != nil {
					// 如果加载失败，触发 panic
					panic(err)
				}
			}

			// 记录成功加载自定义指标
			level.Info(e.logger).Log("event", "Successfully loaded custom metrics from "+_customMetrics)
			// 输出调试信息，显示解析后的自定义指标内容
			level.Debug(e.logger).Log("custom metrics parsed content", fmt.Sprintf("%+v", additionalMetrics))

			// 将加载的自定义指标添加到 e.metricsToScrape.Metric 中
			e.metricsToScrape.Metric = append(e.metricsToScrape.Metric, additionalMetrics.Metric...)
		}
	} else {
		// 如果没有定义自定义指标，记录调试日志
		level.Debug(e.logger).Log("No custom metrics defined.")
	}
}

// loadTomlMetricsConfig 函数用于加载并解析 TOML 配置文件。
// 参数:
// _customMetrics: 自定义指标文件的路径。
// metrics: 用于存储解析后的自定义指标的结构体。
// 返回:
// 如果解析成功，返回 nil；如果出现错误，返回相应的错误。
func loadTomlMetricsConfig(_customMetrics string, metrics *Metrics) error {
	// 使用 toml.DecodeFile 解析 TOML 配置文件
	if _, err := toml.DecodeFile(_customMetrics, metrics); err != nil {
		// 如果解析失败，返回格式化的错误消息
		return fmt.Errorf("cannot read the metrics config %s: %w", _customMetrics, err)
	}

	// 解析成功，返回 nil
	return nil
}