Add all bool/integer/real runtime variables

Use the `pg_settings` view to retrieve runtime variables:
https://www.postgresql.org/docs/current/static/view-pg-settings.html

This replaces the use of `SHOW` to retrieve runtime variables.

In PostgreSQL 9.6, this adds 189 metrics, which use the `short_desc`
field as a description.

Only runtime variables with a `vartype` of `bool`, `real`, or `integer`
are currently supported.

Example metrics:

    # HELP pg_settings_allow_system_table_mods Allows modifications of the structure of system tables.
    # TYPE pg_settings_allow_system_table_mods gauge
    pg_settings_allow_system_table_mods 0
    # HELP pg_settings_archive_timeout_seconds Forces a switch to the next xlog file if a new file has not been started within N seconds. [Converted to seconds.]
    # TYPE pg_settings_archive_timeout_seconds gauge
    pg_settings_archive_timeout_seconds 0
    # HELP pg_settings_array_nulls Enable input of NULL elements in arrays.
    # TYPE pg_settings_array_nulls gauge
    pg_settings_array_nulls 1
    # HELP pg_settings_authentication_timeout_seconds Sets the maximum allowed time to complete client authentication. [Converted to seconds.]
    # TYPE pg_settings_authentication_timeout_seconds gauge
    pg_settings_authentication_timeout_seconds 60
    # HELP pg_settings_autovacuum Starts the autovacuum subprocess.
    # TYPE pg_settings_autovacuum gauge
    pg_settings_autovacuum 1
    # HELP pg_settings_autovacuum_analyze_scale_factor Number of tuple inserts, updates, or deletes prior to analyze as a fraction of reltuples.
    # TYPE pg_settings_autovacuum_analyze_scale_factor gauge
    pg_settings_autovacuum_analyze_scale_factor 0.1

Author: mattbostock

postgres_exporter.go

@@ -94,12 +94,6 @@ const (
 	DURATION     ColumnUsage = iota // This column should be interpreted as a text duration (and converted to milliseconds)
 )
 
-// Special case matric mappings
-const (
-	// Which metric mapping should be acquired using "SHOW" queries
-	SHOW_METRIC = "pg_runtime_variables"
-)
-
 // Regex used to get the "short-version" from the postgres version field.
 var versionRegex = regexp.MustCompile(`^\w+ (\d+\.\d+\.\d+)`)
 var lowestSupportedVersion = semver.MustParse("9.1.0")
@@ -146,24 +140,6 @@ type MetricMap struct {
 	conversion func(interface{}) (float64, bool) // Conversion function to turn PG result into float64
 }
 
-// Metric descriptors for dynamically created metrics.
-var variableMaps = map[string]map[string]ColumnMapping{
-	"pg_runtime_variable": {
-		"max_connections":                {GAUGE, "Sets the maximum number of concurrent connections.", nil, nil},
-		"max_files_per_process":          {GAUGE, "Sets the maximum number of simultaneously open files for each server process.", nil, nil},
-		"max_function_args":              {GAUGE, "Shows the maximum number of function arguments.", nil, nil},
-		"max_identifier_length":          {GAUGE, "Shows the maximum identifier length.", nil, nil},
-		"max_index_keys":                 {GAUGE, "Shows the maximum number of index keys.", nil, nil},
-		"max_locks_per_transaction":      {GAUGE, "Sets the maximum number of locks per transaction.", nil, nil},
-		"max_pred_locks_per_transaction": {GAUGE, "Sets the maximum number of predicate locks per transaction.", nil, nil},
-		"max_prepared_transactions":      {GAUGE, "Sets the maximum number of simultaneously prepared transactions.", nil, nil},
-		//"max_stack_depth" : { GAUGE, "Sets the maximum number of concurrent connections.", nil }, // No dehumanize support yet
-		"max_standby_archive_delay":   {DURATION, "Sets the maximum delay before canceling queries when a hot standby server is processing archived WAL data.", nil, nil},
-		"max_standby_streaming_delay": {DURATION, "Sets the maximum delay before canceling queries when a hot standby server is processing streamed WAL data.", nil, nil},
-		"max_wal_senders":             {GAUGE, "Sets the maximum number of simultaneously running WAL sender processes.", nil, nil},
-	},
-}
-
 // TODO: revisit this with the semver system
 func dumpMaps() {
 	for name, cmap := range metricMaps {
@@ -693,8 +669,6 @@ type Exporter struct {
 	// Last version used to calculate metric map. If mismatch on scrape,
 	// then maps are recalculated.
 	lastMapVersion semver.Version
-	// Currently active variable map
-	variableMap map[string]MetricMapNamespace
 	// Currently active metric map
 	metricMap map[string]MetricMapNamespace
 	// Currently active query overrides
@@ -725,7 +699,6 @@ func NewExporter(dsn string, userQueriesPath string) *Exporter {
 			Name:      "last_scrape_error",
 			Help:      "Whether the last scrape of metrics from PostgreSQL resulted in an error (1 for error, 0 for success).",
 		}),
-		variableMap:    nil,
 		metricMap:      nil,
 		queryOverrides: nil,
 	}
@@ -775,40 +748,124 @@ func newDesc(subsystem, name, help string) *prometheus.Desc {
 	)
 }
 
-// Query the SHOW variables from the query map
-// TODO: make this more functional
-func queryShowVariables(ch chan<- prometheus.Metric, db *sql.DB, variableMap map[string]MetricMapNamespace) []error {
-	log.Debugln("Querying SHOW variables")
-	nonFatalErrors := []error{}
-
-	for _, mapping := range variableMap {
-		for columnName, columnMapping := range mapping.columnMappings {
-			// Check for a discard request on this value
-			if columnMapping.discard {
-				continue
-			}
+// Query the pg_settings view containing runtime variables
+func querySettings(ch chan<- prometheus.Metric, db *sql.DB) error {
+	log.Debugln("Querying pg_setting view")
+	subsystem := "settings"
 
-			// Use SHOW to get the value
-			row := db.QueryRow(fmt.Sprintf("SHOW %s;", columnName))
+	// pg_settings docs: https://www.postgresql.org/docs/current/static/view-pg-settings.html
+	query := "SELECT name, setting, COALESCE(unit, ''), short_desc, vartype FROM pg_settings WHERE vartype IN ('bool', 'integer', 'real');"
 
-			var val interface{}
-			err := row.Scan(&val)
-			if err != nil {
-				nonFatalErrors = append(nonFatalErrors, errors.New(fmt.Sprintln("Error scanning runtime variable:", columnName, err)))
-				continue
+	rows, err := db.Query(query)
+	if err != nil {
+		return errors.New(fmt.Sprintln("Error running query on database: ", namespace, err))
+	}
+	defer rows.Close()
+
+	var name, setting, unit, shortDesc, vartype string
+	for rows.Next() {
+		err = rows.Scan(&name, &setting, &unit, &shortDesc, &vartype)
+		if err != nil {
+			return errors.New(fmt.Sprintln("Error retrieving rows:", namespace, err))
+		}
+
+		if vartype == "bool" {
+			var val float64
+			if setting == "on" {
+				val = 1
 			}
 
-			fval, ok := columnMapping.conversion(val)
-			if !ok {
-				nonFatalErrors = append(nonFatalErrors, errors.New(fmt.Sprintln("Unexpected error parsing column: ", namespace, columnName, val)))
-				continue
+			desc := newDesc(subsystem, name, shortDesc)
+			ch <- prometheus.MustNewConstMetric(desc, prometheus.GaugeValue, val)
+			continue
+		}
+
+		val, err := strconv.ParseFloat(setting, 64)
+		if err != nil {
+			return errors.New(fmt.Sprintf("Error converting setting %q value %q to float: %s", name, setting, err))
+		}
+
+		var suffix string
+		// Units defined in: https://www.postgresql.org/docs/current/static/config-setting.html
+		switch unit {
+		case "":
+			// Do nothing, no conversion required
+		case "ms":
+			suffix = "seconds"
+			// -1 is special
+			if val > 0 {
+				val /= 1000
+			}
+		case "s":
+			suffix = "seconds"
+		case "min":
+			suffix = "seconds"
+			// -1 is special
+			if val > 0 {
+				val *= 60
+			}
+		case "h":
+			suffix = "seconds"
+			// -1 is special
+			if val > 0 {
+				val *= 60 * 60
+			}
+		case "d":
+			suffix = "seconds"
+			// -1 is special
+			if val > 0 {
+				val *= 60 * 60 * 24
+			}
+		case "kB":
+			suffix = "bytes"
+			// -1 is special
+			if val > 0 {
+				val *= math.Pow(2, 10)
 			}
+		case "MB":
+			suffix = "bytes"
+			// -1 is special
+			if val > 0 {
+				val *= math.Pow(2, 20)
+			}
+		case "GB":
+			suffix = "bytes"
+			// -1 is special
+			if val > 0 {
+				val *= math.Pow(2, 30)
+			}
+		case "TB":
+			suffix = "bytes"
+			// -1 is special
+			if val > 0 {
+				val *= math.Pow(2, 40)
+			}
+		case "8kB":
+			suffix = "bytes"
+			// -1 is special
+			if val > 0 {
+				val *= math.Pow(2, 13)
+			}
+		case "16MB":
+			suffix = "bytes"
+			// -1 is special
+			if val > 0 {
+				val *= math.Pow(2, 24)
+			}
+		default:
+			return errors.New(fmt.Sprintf("Unknown unit %q for runtime variable %q", val, name))
+		}
 
-			ch <- prometheus.MustNewConstMetric(columnMapping.desc, columnMapping.vtype, fval)
+		if len(suffix) > 0 {
+			name = fmt.Sprintf("%s_%s", name, suffix)
+			shortDesc = fmt.Sprintf("%s [Converted to %s.]", shortDesc, suffix)
 		}
+
+		desc := newDesc(subsystem, name, shortDesc)
+		ch <- prometheus.MustNewConstMetric(desc, prometheus.GaugeValue, val)
 	}
 
-	return nonFatalErrors
+	return nil
 }
 
 // Query within a namespace mapping and emit metrics. Returns fatal errors if
@@ -941,11 +998,10 @@ func (e *Exporter) checkMapVersions(ch chan<- prometheus.Metric, db *sql.DB) err
 	semanticVersion, err := parseVersion(versionString)
 
 	// Check if semantic version changed and recalculate maps if needed.
-	if semanticVersion.NE(e.lastMapVersion) || e.variableMap == nil || e.metricMap == nil {
+	if semanticVersion.NE(e.lastMapVersion) || e.metricMap == nil {
 		log.Infoln("Semantic Version Changed:", e.lastMapVersion.String(), "->", semanticVersion.String())
 		e.mappingMtx.Lock()
 
-		e.variableMap = makeDescMap(semanticVersion, variableMaps)
 		e.metricMap = makeDescMap(semanticVersion, metricMaps)
 		e.queryOverrides = makeQueryOverrideMap(semanticVersion, queryOverrides)
 		e.lastMapVersion = semanticVersion
@@ -1010,9 +1066,8 @@ func (e *Exporter) scrape(ch chan<- prometheus.Metric) {
 	// Lock the exporter maps
 	e.mappingMtx.RLock()
 	defer e.mappingMtx.RUnlock()
-	// Handle querying the show variables
-	nonFatalErrors := queryShowVariables(ch, db, e.variableMap)
-	if len(nonFatalErrors) > 0 {
+	if err := querySettings(ch, db); err != nil {
+		log.Infof("Error retrieving settings: %s", err)
 		e.error.Set(1)
 	}
 

postgres_exporter_integration_test.go

@@ -13,6 +13,7 @@ import (
 
 	"database/sql"
 	"fmt"
+
 	_ "github.com/lib/pq"
 	"github.com/prometheus/client_golang/prometheus"
 )
@@ -57,13 +58,10 @@ func (s *IntegrationSuite) TestAllNamespacesReturnResults(c *C) {
 	err = s.e.checkMapVersions(ch, db)
 	c.Assert(err, IsNil)
 
-	// Check the show variables work
-	nonFatalErrors := queryShowVariables(ch, db, s.e.variableMap)
-	if !c.Check(len(nonFatalErrors), Equals, 0) {
-		fmt.Println("## NONFATAL ERRORS FOUND")
-		for _, err := range nonFatalErrors {
-			fmt.Println(err)
-		}
+	err = querySettings(ch, db)
+	if !c.Check(err, Equals, nil) {
+		fmt.Println("## ERRORS FOUND")
+		fmt.Println(err)
 	}
 
 	// This should never happen in our test cases.