Merge pull request #28 from ContaAzul/pg10

Add support to PostgreSQL 10

Author: diogonicoleti

.travis.yml

@@ -1,7 +1,7 @@
 dist: trusty
 sudo: required
 language: go
-go: 1.9
+go: "1.10"
 services:
   - docker
   - postgresql

Makefile

@@ -8,7 +8,7 @@ build:
 	CGO_ENABLED=0 go build -ldflags="-s -w"
 
 test:
-	go test -v ./...
+	GOCACHE=off go test -v ./...
 
 lint:
 	gometalinter.v2 --vendor --deadline=60s ./...

gauges/backends.go

@@ -3,6 +3,7 @@ package gauges
 import (
 	"time"
 
+	"github.com/ContaAzul/postgresql_exporter/postgres"
 	"github.com/apex/log"
 	"github.com/prometheus/client_golang/prometheus"
 )
@@ -85,7 +86,7 @@ func (g *Gauges) BackendsStatus() *prometheus.GaugeVec {
 }
 
 func (g *Gauges) waitingBackendsQuery() string {
-	if isPG96(g.version()) {
+	if postgres.Version(g.version()).Is96Or10() {
 		return `
 			SELECT COUNT(*) as count, 'waiting' as state, usename
 			FROM pg_stat_activity

gauges/gauge.go

@@ -3,7 +3,6 @@ package gauges
 import (
 	"context"
 	"database/sql"
-	"regexp"
 	"strings"
 	"time"
 
@@ -171,17 +170,11 @@ func (g *Gauges) queryWithTimeout(
 	return err
 }
 
-var versionRE = regexp.MustCompile(`^PostgreSQL (\d\.\d\.\d).*`)
-
 func (g *Gauges) version() string {
 	var version string
-	if err := g.db.QueryRow("select version()").Scan(&version); err != nil {
+	if err := g.db.QueryRow("show server_version").Scan(&version); err != nil {
 		log.WithError(err).Error("failed to get postgresql version, assuming 9.6.0")
 		return "9.6.0"
 	}
-	return versionRE.FindStringSubmatch(version)[1]
-}
-
-func isPG96(version string) bool {
-	return strings.HasPrefix(version, "9.6.")
+	return version
 }

gauges/gauge_test.go

@@ -83,3 +83,11 @@ func connect(t *testing.T) *sql.DB {
 	db.SetMaxOpenConns(1)
 	return db
 }
+
+func TestVersion(t *testing.T) {
+	var assert = assert.New(t)
+	_, gauges, close := prepare(t)
+	defer close()
+	assert.NotEmpty(gauges.version())
+	assertNoErrs(t, gauges)
+}

gauges/replication.go

@@ -1,31 +1,41 @@
 package gauges
 
-import "github.com/prometheus/client_golang/prometheus"
+import (
+	"fmt"
 
+	"github.com/ContaAzul/postgresql_exporter/postgres"
+	"github.com/prometheus/client_golang/prometheus"
+)
+
+// ReplicationStatus returns a prometheus gauge for the PostgreSQL
+// replication status
 func (g *Gauges) ReplicationStatus() prometheus.Gauge {
 	return g.new(
 		prometheus.GaugeOpts{
 			Name:        "postgresql_replication_status",
 			Help:        "Returns 1 if in recovery and replay is paused, 0 if OK and -1 if not in recovery",
 			ConstLabels: g.labels,
 		},
-		`
+		fmt.Sprintf(`
 			SELECT
 			CASE
 				WHEN pg_is_in_recovery() is true
 				THEN
 					CASE
-						WHEN pg_is_xlog_replay_paused() is true
+						WHEN %s() is true
 						THEN 1
 						ELSE 0
 					END
 			ELSE
 				-1
-			END
-		`,
+			END`,
+			postgres.Version(g.version()).IsWalReplayPausedFunctionName(),
+		),
 	)
 }
 
+// StreamingWALs returns a prometheus gauge for the count of WALs
+// in streaming state
 func (g *Gauges) StreamingWALs() prometheus.Gauge {
 	return g.new(
 		prometheus.GaugeOpts{
@@ -41,26 +51,32 @@ func (g *Gauges) StreamingWALs() prometheus.Gauge {
 	)
 }
 
+// ReplicationLag returns a prometheus gauge for the database replication
+// lag in milliseconds
 func (g *Gauges) ReplicationLag() prometheus.Gauge {
+	version := postgres.Version(g.version())
+
 	return g.new(
 		prometheus.GaugeOpts{
 			Name:        "postgresql_replication_lag",
 			Help:        "Dabatase replication lag",
 			ConstLabels: g.labels,
 		},
-		`
+		fmt.Sprintf(`
 			SELECT COALESCE(
 				CASE
 					WHEN pg_is_in_recovery() is true
 					THEN
 					CASE
-						WHEN pg_last_xlog_receive_location() = pg_last_xlog_replay_location()
+						WHEN %s() = %s()
 						THEN 0
 					ELSE
 						EXTRACT (EPOCH FROM now() - pg_last_xact_replay_timestamp())
 					END
 				END
-			, 0)
-		`,
+			, 0)`,
+			version.LastWalReceivedLsnFunctionName(),
+			version.LastWalReplayedLsnFunctionName(),
+		),
 	)
 }

postgres/version.go

@@ -0,0 +1,47 @@
+package postgres
+
+import "strings"
+
+// Version for a postgres server
+type Version string
+
+// IsWalReplayPausedFunctionName returns the name of the function to verify whether the replication
+// log is paused according to the postgres version
+func (v Version) IsWalReplayPausedFunctionName() string {
+	if v.is10() {
+		return "pg_is_wal_replay_paused"
+	}
+	return "pg_is_xlog_replay_paused"
+}
+
+// LastWalReceivedLsnFunctionName returns the name of the function that returns the last write-ahead
+// log location received and synced to disk by replication according to the postgres version
+func (v Version) LastWalReceivedLsnFunctionName() string {
+	if v.is10() {
+		return "pg_last_wal_receive_lsn"
+	}
+	return "pg_last_xlog_receive_location"
+}
+
+// LastWalReplayedLsnFunctionName returns the name of the function that returns the last write-ahead
+// log location replayed during recovery according to the postgres version
+func (v Version) LastWalReplayedLsnFunctionName() string {
+	if v.is10() {
+		return "pg_last_wal_replay_lsn"
+	}
+	return "pg_last_xlog_replay_location"
+
+}
+
+func (v Version) is96() bool {
+	return strings.HasPrefix(string(v), "9.6.")
+}
+
+func (v Version) is10() bool {
+	return strings.HasPrefix(string(v), "10.")
+}
+
+// Is96Or10 returns whether this is version 9.6.x, 10.x or not
+func (v Version) Is96Or10() bool {
+	return v.is96() || v.is10()
+}

postgres/version_test.go

@@ -0,0 +1,36 @@
+package postgres
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestFunctionVersions(t *testing.T) {
+	is96 := Version.is96
+	is10 := Version.is10
+	is96Or10 := Version.Is96Or10
+
+	tt := []struct {
+		str      string
+		fn       func(Version) bool
+		expected bool
+	}{
+		{"9.6.6", is96, true},
+		{"9.5.4", is96, false},
+		{"10.3", is10, true},
+		{"9.6.6", is10, false},
+		{"9.6.6", is96Or10, true},
+		{"9.5.4", is96Or10, false},
+		{"10.4", is96Or10, true},
+		{"11.0", is96Or10, false},
+	}
+
+	for _, tc := range tt {
+		testName := fmt.Sprintf("expecting %p(\"%v\") to be %v", tc.fn, tc.str, tc.expected)
+		t.Run(testName, func(t *testing.T) {
+			assert.Equal(t, tc.fn(Version(tc.str)), tc.expected)
+		})
+	}
+}