InclMetricsForEmptyDatabases (continuation of #988) (#1001)

* add InclMetricsForEmptyDatabases

* add test

---------

Co-authored-by: 寇天龙 <[email protected]>

Author: oliver006

README.md

@@ -210,6 +210,7 @@ scrape_configs:
 | config-command          | REDIS_EXPORTER_CONFIG_COMMAND          | What to use for the CONFIG command, defaults to `CONFIG`, , set to "-" to skip config metrics extraction.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
 | basic-auth-username     | REDIS_EXPORTER_BASIC_AUTH_USERNAME     | Username for Basic Authentication with the redis exporter needs to be set together with basic-auth-password to be effective                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
 | basic-auth-password     | REDIS_EXPORTER_BASIC_AUTH_PASSWORD     | Password for Basic Authentication with the redis exporter needs to be set together with basic-auth-username to be effective                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
+| include-metrics-for-empty-databases | REDIS_EXPORTER_INCL_METRICS_FOR_EMPTY_DATABASES | Whether to emit db metrics (like db_keys) for empty databases 
 
 Redis instance addresses can be tcp addresses: `redis://localhost:6379`, `redis.example.com:6379` or e.g. unix sockets: `unix:///tmp/redis.sock`.\
 SSL is supported by using the `rediss://` schema, for example: `rediss://azure-ssl-enabled-host.redis.cache.windows.net:6380` (note that the port is required when connecting to a non-standard 6379 port, e.g. with Azure Redis instances).\

exporter/exporter.go

@@ -88,6 +88,7 @@ type Options struct {
 	BasicAuthUsername              string
 	BasicAuthPassword              string
 	SkipCheckKeysForRoleMaster     bool
+	InclMetricsForEmptyDatabases   bool
 }
 
 // NewRedisExporter returns a new exporter of Redis metrics.
@@ -714,13 +715,13 @@ func (e *Exporter) scrapeRedisHost(ch chan<- prometheus.Metric) error {
 		if clusterInfo, err := redis.String(doRedisCmd(c, "CLUSTER", "INFO")); err == nil {
 			e.extractClusterInfoMetrics(ch, clusterInfo)
 
-			// in cluster mode Redis only supports one database so no extra DB number padding needed
+			// in cluster mode Redis only supports one database, so no extra DB number padding needed
 			dbCount = 1
 		} else {
 			log.Errorf("Redis CLUSTER INFO err: %s", err)
 		}
 	} else if dbCount == 0 {
-		// in non-cluster mode, if dbCount is zero then "CONFIG" failed to retrieve a valid
+		// in non-cluster mode, if dbCount is zero, then "CONFIG" failed to retrieve a valid
 		// number of databases, and we use the Redis config default which is 16
 
 		dbCount = 16

exporter/info.go

@@ -159,11 +159,13 @@ func (e *Exporter) extractInfoMetrics(ch chan<- prometheus.Metric, info string,
 	// from #Commandstats processing and the percentile info that we get from the #Latencystats processing
 	e.generateCommandLatencySummaries(ch, cmdLatencyMap, cmdCount, cmdSum)
 
-	for dbIndex := 0; dbIndex < dbCount; dbIndex++ {
-		dbName := "db" + strconv.Itoa(dbIndex)
-		if _, exists := handledDBs[dbName]; !exists {
-			e.registerConstMetricGauge(ch, "db_keys", 0, dbName)
-			e.registerConstMetricGauge(ch, "db_keys_expiring", 0, dbName)
+	if e.options.InclMetricsForEmptyDatabases {
+		for dbIndex := 0; dbIndex < dbCount; dbIndex++ {
+			dbName := "db" + strconv.Itoa(dbIndex)
+			if _, exists := handledDBs[dbName]; !exists {
+				e.registerConstMetricGauge(ch, "db_keys", 0, dbName)
+				e.registerConstMetricGauge(ch, "db_keys_expiring", 0, dbName)
+			}
 		}
 	}
 

exporter/info_test.go

@@ -131,6 +131,36 @@ func commandStatsCheck(t *testing.T, e *Exporter, want map[string]bool) {
 	}
 }
 
+func TestInclMetricsForEmptyDatabases(t *testing.T) {
+	addr := os.Getenv("TEST_REDIS_URI")
+	if addr == "" {
+		t.Skipf("TEST_REDIS_URI not set - skipping")
+	}
+
+	for _, inclMetrics := range []bool{true, false} {
+		t.Run(fmt.Sprintf("inclMetrics:%t", inclMetrics), func(t *testing.T) {
+			e, _ := NewRedisExporter(addr,
+				Options{
+					Namespace: "test", Registry: prometheus.NewRegistry(),
+					InclMetricsForEmptyDatabases: inclMetrics,
+				})
+			ts := httptest.NewServer(e)
+			defer ts.Close()
+
+			body := downloadURL(t, ts.URL+"/metrics")
+			if inclMetrics {
+				if !strings.Contains(body, `test_db_keys{db="db10"} 0`) {
+					t.Errorf("Expected to find test_db_keys")
+				}
+			} else {
+				if strings.Contains(body, `test_db_keys{db="db10"} 0`) {
+					t.Errorf("Expected to not find test_db_keys")
+				}
+			}
+		})
+	}
+}
+
 func TestClusterMaster(t *testing.T) {
 	if os.Getenv("TEST_REDIS_CLUSTER_MASTER_URI") == "" {
 		t.Skipf("TEST_REDIS_CLUSTER_MASTER_URI not set - skipping")

exporter/keys.go

@@ -89,7 +89,7 @@ func (e *Exporter) extractCheckKeyMetrics(ch chan<- prometheus.Metric, redisClie
 	if e.options.IsCluster {
 		cc, err := e.connectToRedisCluster()
 		if err != nil {
-			return fmt.Errorf("Couldn't connect to redis cluster, err: %s", err)
+			return fmt.Errorf("couldn't connect to redis cluster, err: %s", err)
 		}
 		defer cc.Close()
 
@@ -98,13 +98,13 @@ func (e *Exporter) extractCheckKeyMetrics(ch chan<- prometheus.Metric, redisClie
 
 	keys, err := parseKeyArg(e.options.CheckKeys)
 	if err != nil {
-		return fmt.Errorf("Couldn't parse check-keys: %w", err)
+		return fmt.Errorf("couldn't parse check-keys: %w", err)
 	}
 	log.Debugf("keys: %#v", keys)
 
 	singleKeys, err := parseKeyArg(e.options.CheckSingleKeys)
 	if err != nil {
-		return fmt.Errorf("Couldn't parse check-single-keys: %w", err)
+		return fmt.Errorf("couldn't parse check-single-keys: %w", err)
 	}
 	log.Debugf("e.singleKeys: %#v", singleKeys)
 
@@ -243,13 +243,13 @@ func (e *Exporter) getKeyInfoPipelined(ch chan<- prometheus.Metric, c redis.Conn
 
 			log.Debugf("c.Send() STRLEN  args: [%v]", keyName)
 			if err := c.Send("STRLEN", keyName); err != nil {
-				log.Errorf("PFCOUNT err: %s", err)
+				log.Errorf("STRLEN err: %s", err)
 				return
 			}
 
 			log.Debugf("c.Send() GET  args: [%v]", keyName)
 			if err := c.Send("GET", keyName); err != nil {
-				log.Errorf("PFCOUNT err: %s", err)
+				log.Errorf("GET err: %s", err)
 				return
 			}
 

main.go

@@ -99,10 +99,11 @@ func main() {
 		excludeLatencyHistogramMetrics = flag.Bool("exclude-latency-histogram-metrics", getEnvBool("REDIS_EXPORTER_EXCLUDE_LATENCY_HISTOGRAM_METRICS", false), "Do not try to collect latency histogram metrics")
 		redactConfigMetrics            = flag.Bool("redact-config-metrics", getEnvBool("REDIS_EXPORTER_REDACT_CONFIG_METRICS", true), "Whether to redact config settings that include potentially sensitive information like passwords")
 		inclSystemMetrics              = flag.Bool("include-system-metrics", getEnvBool("REDIS_EXPORTER_INCL_SYSTEM_METRICS", false), "Whether to include system metrics like e.g. redis_total_system_memory_bytes")
-		skipTLSVerification            = flag.Bool("skip-tls-verification", getEnvBool("REDIS_EXPORTER_SKIP_TLS_VERIFICATION", false), "Whether to skip TLS verification")
+		skipTLSVerification            = flag.Bool("skip-tls-verification", getEnvBool("REDIS_EXPORTER_SKIP_TLS_VERIFICATION", false), "Whether to to skip TLS verification")
 		skipCheckKeysForRoleMaster     = flag.Bool("skip-checkkeys-for-role-master", getEnvBool("REDIS_EXPORTER_SKIP_CHECKKEYS_FOR_ROLE_MASTER", false), "Whether to skip gathering the check-keys metrics (size, val) when the instance is of type master (reduce load on master nodes)")
 		basicAuthUsername              = flag.String("basic-auth-username", getEnv("REDIS_EXPORTER_BASIC_AUTH_USERNAME", ""), "Username for basic authentication")
 		basicAuthPassword              = flag.String("basic-auth-password", getEnv("REDIS_EXPORTER_BASIC_AUTH_PASSWORD", ""), "Password for basic authentication")
+		inclMetricsForEmptyDatabases   = flag.Bool("include-metrics-for-empty-databases", getEnvBool("REDIS_EXPORTER_INCL_METRICS_FOR_EMPTY_DATABASES", true), "Whether to emit db metrics (like db_keys) for empty databases")
 	)
 	flag.Parse()
 
@@ -205,8 +206,9 @@ func main() {
 				CommitSha: BuildCommitSha,
 				Date:      BuildDate,
 			},
-			BasicAuthUsername: *basicAuthUsername,
-			BasicAuthPassword: *basicAuthPassword,
+			BasicAuthUsername:            *basicAuthUsername,
+			BasicAuthPassword:            *basicAuthPassword,
+			InclMetricsForEmptyDatabases: *inclMetricsForEmptyDatabases,
 		},
 	)
 	if err != nil {