Adding upstream version 1.34.4.

Signed-off-by: Daniel Baumann <daniel@debian.org>

plugins/inputs/rethinkdb/README.md

@@ -0,0 +1,70 @@
+# RethinkDB Input Plugin
+
+Collect metrics from [RethinkDB](https://www.rethinkdb.com/).
+
+## Global configuration options <!-- @/docs/includes/plugin_config.md -->
+
+In addition to the plugin-specific configuration settings, plugins support
+additional global and plugin configuration settings. These settings are used to
+modify metrics, tags, and field or create aliases and configure ordering, etc.
+See the [CONFIGURATION.md][CONFIGURATION.md] for more details.
+
+[CONFIGURATION.md]: ../../../docs/CONFIGURATION.md#plugins
+
+## Configuration
+
+```toml @sample.conf
+# Read metrics from one or many RethinkDB servers
+[[inputs.rethinkdb]]
+  ## An array of URI to gather stats about. Specify an ip or hostname
+  ## with optional port add password. ie,
+  ##   rethinkdb://user:auth_key@10.10.3.30:28105,
+  ##   rethinkdb://10.10.3.33:18832,
+  ##   10.0.0.1:10000, etc.
+  servers = ["127.0.0.1:28015"]
+
+  ## If you use actual rethinkdb of > 2.3.0 with username/password authorization,
+  ## protocol have to be named "rethinkdb2" - it will use 1_0 H.
+  # servers = ["rethinkdb2://username:password@127.0.0.1:28015"]
+
+  ## If you use older versions of rethinkdb (<2.2) with auth_key, protocol
+  ## have to be named "rethinkdb".
+  # servers = ["rethinkdb://username:auth_key@127.0.0.1:28015"]
+```
+
+## Metrics
+
+- rethinkdb
+  - tags:
+    - type
+    - ns
+    - rethinkdb_host
+    - rethinkdb_hostname
+  - fields:
+    - cache_bytes_in_use (integer, bytes)
+    - disk_read_bytes_per_sec (integer, reads)
+    - disk_read_bytes_total (integer, bytes)
+    - disk_written_bytes_per_sec (integer, bytes)
+    - disk_written_bytes_total (integer, bytes)
+    - disk_usage_data_bytes (integer, bytes)
+    - disk_usage_garbage_bytes (integer, bytes)
+    - disk_usage_metadata_bytes (integer, bytes)
+    - disk_usage_preallocated_bytes (integer, bytes)
+
+- rethinkdb_engine
+  - tags:
+    - type
+    - ns
+    - rethinkdb_host
+    - rethinkdb_hostname
+  - fields:
+    - active_clients (integer, clients)
+    - clients (integer, clients)
+    - queries_per_sec (integer, queries)
+    - total_queries (integer, queries)
+    - read_docs_per_sec (integer, reads)
+    - total_reads (integer, reads)
+    - written_docs_per_sec (integer, writes)
+    - total_writes (integer, writes)
+
+## Example Output

plugins/inputs/rethinkdb/rethinkdb.go

@@ -0,0 +1,92 @@
+//go:generate ../../../tools/readme_config_includer/generator
+package rethinkdb
+
+import (
+	_ "embed"
+	"fmt"
+	"net/url"
+	"sync"
+
+	"gopkg.in/gorethink/gorethink.v3"
+
+	"github.com/influxdata/telegraf"
+	"github.com/influxdata/telegraf/plugins/inputs"
+)
+
+//go:embed sample.conf
+var sampleConfig string
+
+var localhost = &server{url: &url.URL{Host: "127.0.0.1:28015"}}
+
+type RethinkDB struct {
+	Servers []string `toml:"servers"`
+}
+
+func (*RethinkDB) SampleConfig() string {
+	return sampleConfig
+}
+
+func (r *RethinkDB) Gather(acc telegraf.Accumulator) error {
+	if len(r.Servers) == 0 {
+		return gatherServer(localhost, acc)
+	}
+
+	var wg sync.WaitGroup
+
+	for _, serv := range r.Servers {
+		u, err := url.Parse(serv)
+		if err != nil {
+			acc.AddError(fmt.Errorf("unable to parse to address %q: %w", serv, err))
+			continue
+		} else if u.Scheme == "" {
+			// fallback to simple string based address (i.e. "10.0.0.1:10000")
+			u.Host = serv
+		}
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			acc.AddError(gatherServer(&server{url: u}, acc))
+		}()
+	}
+
+	wg.Wait()
+
+	return nil
+}
+
+func gatherServer(server *server, acc telegraf.Accumulator) error {
+	var err error
+	connectOpts := gorethink.ConnectOpts{
+		Address:       server.url.Host,
+		DiscoverHosts: false,
+	}
+	if server.url.User != nil {
+		pwd, set := server.url.User.Password()
+		if set && pwd != "" {
+			connectOpts.AuthKey = pwd
+			connectOpts.HandshakeVersion = gorethink.HandshakeV0_4
+		}
+	}
+	if server.url.Scheme == "rethinkdb2" && server.url.User != nil {
+		pwd, set := server.url.User.Password()
+		if set && pwd != "" {
+			connectOpts.Username = server.url.User.Username()
+			connectOpts.Password = pwd
+			connectOpts.HandshakeVersion = gorethink.HandshakeV1_0
+		}
+	}
+
+	server.session, err = gorethink.Connect(connectOpts)
+	if err != nil {
+		return fmt.Errorf("unable to connect to RethinkDB: %w", err)
+	}
+	defer server.session.Close()
+
+	return server.gatherData(acc)
+}
+
+func init() {
+	inputs.Add("rethinkdb", func() telegraf.Input {
+		return &RethinkDB{}
+	})
+}

plugins/inputs/rethinkdb/rethinkdb_data.go

@@ -0,0 +1,111 @@
+package rethinkdb
+
+import (
+	"reflect"
+	"time"
+
+	"github.com/influxdata/telegraf"
+)
+
+type serverStatus struct {
+	ID      string `gorethink:"id"`
+	Network struct {
+		Addresses  []address `gorethink:"canonical_addresses"`
+		Hostname   string    `gorethink:"hostname"`
+		DriverPort int       `gorethink:"reql_port"`
+	} `gorethink:"network"`
+	Process struct {
+		Version      string    `gorethink:"version"`
+		RunningSince time.Time `gorethink:"time_started"`
+	} `gorethink:"process"`
+}
+
+type address struct {
+	Host string `gorethink:"host"`
+	Port int    `gorethink:"port"`
+}
+
+type stats struct {
+	Engine engine `gorethink:"query_engine"`
+}
+
+type engine struct {
+	ClientConns   int64 `gorethink:"client_connections,omitempty"`
+	ClientActive  int64 `gorethink:"clients_active,omitempty"`
+	QueriesPerSec int64 `gorethink:"queries_per_sec,omitempty"`
+	TotalQueries  int64 `gorethink:"queries_total,omitempty"`
+	ReadsPerSec   int64 `gorethink:"read_docs_per_sec,omitempty"`
+	TotalReads    int64 `gorethink:"read_docs_total,omitempty"`
+	WritesPerSec  int64 `gorethink:"written_docs_per_sec,omitempty"`
+	TotalWrites   int64 `gorethink:"written_docs_total,omitempty"`
+}
+
+type tableStatus struct {
+	ID   string `gorethink:"id"`
+	DB   string `gorethink:"db"`
+	Name string `gorethink:"name"`
+}
+
+type tableStats struct {
+	Engine  engine  `gorethink:"query_engine"`
+	Storage storage `gorethink:"storage_engine"`
+}
+
+type storage struct {
+	Cache cache `gorethink:"cache"`
+	Disk  disk  `gorethink:"disk"`
+}
+
+type cache struct {
+	BytesInUse int64 `gorethink:"in_use_bytes"`
+}
+
+type disk struct {
+	ReadBytesPerSec  int64      `gorethink:"read_bytes_per_sec"`
+	ReadBytesTotal   int64      `gorethink:"read_bytes_total"`
+	WriteBytesPerSec int64      `gorethik:"written_bytes_per_sec"`
+	WriteBytesTotal  int64      `gorethink:"written_bytes_total"`
+	SpaceUsage       spaceUsage `gorethink:"space_usage"`
+}
+
+type spaceUsage struct {
+	Data     int64 `gorethink:"data_bytes"`
+	Garbage  int64 `gorethink:"garbage_bytes"`
+	Metadata int64 `gorethink:"metadata_bytes"`
+	Prealloc int64 `gorethink:"preallocated_bytes"`
+}
+
+var engineStats = map[string]string{
+	"active_clients":       "ClientActive",
+	"clients":              "ClientConns",
+	"queries_per_sec":      "QueriesPerSec",
+	"total_queries":        "TotalQueries",
+	"read_docs_per_sec":    "ReadsPerSec",
+	"total_reads":          "TotalReads",
+	"written_docs_per_sec": "WritesPerSec",
+	"total_writes":         "TotalWrites",
+}
+
+func (e *engine) addEngineStats(keys []string, acc telegraf.Accumulator, tags map[string]string) {
+	engine := reflect.ValueOf(e).Elem()
+	fields := make(map[string]interface{})
+	for _, key := range keys {
+		fields[key] = engine.FieldByName(engineStats[key]).Interface()
+	}
+	acc.AddFields("rethinkdb_engine", fields, tags)
+}
+
+func (s *storage) addStats(acc telegraf.Accumulator, tags map[string]string) {
+	fields := map[string]interface{}{
+		"cache_bytes_in_use":            s.Cache.BytesInUse,
+		"disk_read_bytes_per_sec":       s.Disk.ReadBytesPerSec,
+		"disk_read_bytes_total":         s.Disk.ReadBytesTotal,
+		"disk_written_bytes_per_sec":    s.Disk.WriteBytesPerSec,
+		"disk_written_bytes_total":      s.Disk.WriteBytesTotal,
+		"disk_usage_data_bytes":         s.Disk.SpaceUsage.Data,
+		"disk_usage_garbage_bytes":      s.Disk.SpaceUsage.Garbage,
+		"disk_usage_metadata_bytes":     s.Disk.SpaceUsage.Metadata,
+		"disk_usage_preallocated_bytes": s.Disk.SpaceUsage.Prealloc,
+	}
+	acc.AddFields("rethinkdb", fields, tags)
+}

plugins/inputs/rethinkdb/rethinkdb_data_test.go

@@ -0,0 +1,113 @@
+package rethinkdb
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/influxdata/telegraf/testutil"
+)
+
+var tags = make(map[string]string)
+
+func TestAddEngineStats(t *testing.T) {
+	engine := &engine{
+		ClientConns:   0,
+		ClientActive:  0,
+		QueriesPerSec: 0,
+		TotalQueries:  0,
+		ReadsPerSec:   0,
+		TotalReads:    0,
+		WritesPerSec:  0,
+		TotalWrites:   0,
+	}
+
+	var acc testutil.Accumulator
+
+	keys := []string{
+		"active_clients",
+		"clients",
+		"queries_per_sec",
+		"total_queries",
+		"read_docs_per_sec",
+		"total_reads",
+		"written_docs_per_sec",
+		"total_writes",
+	}
+	engine.addEngineStats(keys, &acc, tags)
+
+	for _, metric := range keys {
+		require.True(t, acc.HasInt64Field("rethinkdb_engine", metric))
+	}
+}
+
+func TestAddEngineStatsPartial(t *testing.T) {
+	engine := &engine{
+		ClientConns:   0,
+		ClientActive:  0,
+		QueriesPerSec: 0,
+		ReadsPerSec:   0,
+		WritesPerSec:  0,
+	}
+
+	var acc testutil.Accumulator
+
+	keys := []string{
+		"active_clients",
+		"clients",
+		"queries_per_sec",
+		"read_docs_per_sec",
+		"written_docs_per_sec",
+	}
+
+	missingKeys := []string{
+		"total_queries",
+		"total_reads",
+		"total_writes",
+	}
+	engine.addEngineStats(keys, &acc, tags)
+
+	for _, metric := range missingKeys {
+		require.False(t, acc.HasInt64Field("rethinkdb", metric))
+	}
+}
+
+func TestAddStorageStats(t *testing.T) {
+	storage := &storage{
+		Cache: cache{
+			BytesInUse: 0,
+		},
+		Disk: disk{
+			ReadBytesPerSec:  0,
+			ReadBytesTotal:   0,
+			WriteBytesPerSec: 0,
+			WriteBytesTotal:  0,
+			SpaceUsage: spaceUsage{
+				Data:     0,
+				Garbage:  0,
+				Metadata: 0,
+				Prealloc: 0,
+			},
+		},
+	}
+
+	var acc testutil.Accumulator
+
+	keys := []string{
+		"cache_bytes_in_use",
+		"disk_read_bytes_per_sec",
+		"disk_read_bytes_total",
+		"disk_written_bytes_per_sec",
+		"disk_written_bytes_total",
+		"disk_usage_data_bytes",
+		"disk_usage_garbage_bytes",
+		"disk_usage_metadata_bytes",
+		"disk_usage_preallocated_bytes",
+	}
+
+	storage.addStats(&acc, tags)
+
+	for _, metric := range keys {
+		require.True(t, acc.HasInt64Field("rethinkdb", metric))
+	}
+}

plugins/inputs/rethinkdb/rethinkdb_server.go

@@ -0,0 +1,209 @@
+package rethinkdb
+
+import (
+	"errors"
+	"fmt"
+	"net"
+	"net/url"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"gopkg.in/gorethink/gorethink.v3"
+
+	"github.com/influxdata/telegraf"
+)
+
+type server struct {
+	url          *url.URL
+	session      *gorethink.Session
+	serverStatus serverStatus
+}
+
+func (s *server) gatherData(acc telegraf.Accumulator) error {
+	if err := s.getServerStatus(); err != nil {
+		return fmt.Errorf("failed to get server_status: %w", err)
+	}
+
+	if err := s.validateVersion(); err != nil {
+		return fmt.Errorf("failed version validation: %w", err)
+	}
+
+	if err := s.addClusterStats(acc); err != nil {
+		return fmt.Errorf("error adding cluster stats: %w", err)
+	}
+
+	if err := s.addMemberStats(acc); err != nil {
+		return fmt.Errorf("error adding member stats: %w", err)
+	}
+
+	if err := s.addTablesStats(acc); err != nil {
+		return fmt.Errorf("error adding table stats: %w", err)
+	}
+
+	return nil
+}
+
+func (s *server) validateVersion() error {
+	if s.serverStatus.Process.Version == "" {
+		return errors.New("could not determine the RethinkDB server version: process.version key missing")
+	}
+
+	versionRegexp := regexp.MustCompile(`\d.\d.\d`)
+	versionString := versionRegexp.FindString(s.serverStatus.Process.Version)
+	if versionString == "" {
+		return fmt.Errorf("could not determine the RethinkDB server version: malformed version string (%v)", s.serverStatus.Process.Version)
+	}
+
+	majorVersion, err := strconv.Atoi(strings.Split(versionString, "")[0])
+	if err != nil || majorVersion < 2 {
+		return fmt.Errorf("unsupported major version %s", versionString)
+	}
+	return nil
+}
+
+func (s *server) getServerStatus() error {
+	cursor, err := gorethink.DB("rethinkdb").Table("server_status").Run(s.session)
+	if err != nil {
+		return err
+	}
+
+	if cursor.IsNil() {
+		return errors.New("could not determine the RethinkDB server version: no rows returned from the server_status table")
+	}
+	defer cursor.Close()
+	var serverStatuses []serverStatus
+	err = cursor.All(&serverStatuses)
+	if err != nil {
+		return errors.New("could not parse server_status results")
+	}
+	host, port, err := net.SplitHostPort(s.url.Host)
+	if err != nil {
+		return fmt.Errorf("unable to determine provided hostname from %s", s.url.Host)
+	}
+	driverPort, err := strconv.Atoi(port)
+	if err != nil {
+		return fmt.Errorf("unable to parse port from %s: %w", port, err)
+	}
+	for _, ss := range serverStatuses {
+		for _, address := range ss.Network.Addresses {
+			if address.Host == host && ss.Network.DriverPort == driverPort {
+				s.serverStatus = ss
+				return nil
+			}
+		}
+	}
+
+	return fmt.Errorf("unable to determine host id from server_status with %s", s.url.Host)
+}
+
+func (s *server) getDefaultTags() map[string]string {
+	tags := make(map[string]string)
+	tags["rethinkdb_host"] = s.url.Host
+	tags["rethinkdb_hostname"] = s.serverStatus.Network.Hostname
+	return tags
+}
+
+var clusterTracking = []string{
+	"active_clients",
+	"clients",
+	"queries_per_sec",
+	"read_docs_per_sec",
+	"written_docs_per_sec",
+}
+
+func (s *server) addClusterStats(acc telegraf.Accumulator) error {
+	cursor, err := gorethink.DB("rethinkdb").Table("stats").Get([]string{"cluster"}).Run(s.session)
+	if err != nil {
+		return fmt.Errorf("cluster stats query error: %w", err)
+	}
+	defer cursor.Close()
+	var clusterStats stats
+	if err := cursor.One(&clusterStats); err != nil {
+		return fmt.Errorf("failure to parse cluster stats: %w", err)
+	}
+
+	tags := s.getDefaultTags()
+	tags["type"] = "cluster"
+	clusterStats.Engine.addEngineStats(clusterTracking, acc, tags)
+	return nil
+}
+
+var memberTracking = []string{
+	"active_clients",
+	"clients",
+	"queries_per_sec",
+	"total_queries",
+	"read_docs_per_sec",
+	"total_reads",
+	"written_docs_per_sec",
+	"total_writes",
+}
+
+func (s *server) addMemberStats(acc telegraf.Accumulator) error {
+	cursor, err := gorethink.DB("rethinkdb").Table("stats").Get([]string{"server", s.serverStatus.ID}).Run(s.session)
+	if err != nil {
+		return fmt.Errorf("member stats query error: %w", err)
+	}
+	defer cursor.Close()
+	var memberStats stats
+	if err := cursor.One(&memberStats); err != nil {
+		return fmt.Errorf("failure to parse member stats: %w", err)
+	}
+
+	tags := s.getDefaultTags()
+	tags["type"] = "member"
+	memberStats.Engine.addEngineStats(memberTracking, acc, tags)
+	return nil
+}
+
+var tableTracking = []string{
+	"read_docs_per_sec",
+	"total_reads",
+	"written_docs_per_sec",
+	"total_writes",
+}
+
+func (s *server) addTablesStats(acc telegraf.Accumulator) error {
+	tablesCursor, err := gorethink.DB("rethinkdb").Table("table_status").Run(s.session)
+	if err != nil {
+		return fmt.Errorf("table stats query error: %w", err)
+	}
+
+	defer tablesCursor.Close()
+	var tables []tableStatus
+	err = tablesCursor.All(&tables)
+	if err != nil {
+		return errors.New("could not parse table_status results")
+	}
+	for _, table := range tables {
+		err = s.addTableStats(acc, table)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (s *server) addTableStats(acc telegraf.Accumulator, table tableStatus) error {
+	cursor, err := gorethink.DB("rethinkdb").Table("stats").
+		Get([]string{"table_server", table.ID, s.serverStatus.ID}).
+		Run(s.session)
+	if err != nil {
+		return fmt.Errorf("table stats query error: %w", err)
+	}
+	defer cursor.Close()
+
+	var ts tableStats
+	if err := cursor.One(&ts); err != nil {
+		return fmt.Errorf("failure to parse table stats: %w", err)
+	}
+
+	tags := s.getDefaultTags()
+	tags["type"] = "data"
+	tags["ns"] = fmt.Sprintf("%s.%s", table.DB, table.Name)
+	ts.Engine.addEngineStats(tableTracking, acc, tags)
+	ts.Storage.addStats(acc, tags)
+
+	return nil
+}

plugins/inputs/rethinkdb/rethinkdb_server_test.go

@@ -0,0 +1,81 @@
+//go:build integration
+
+package rethinkdb
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/influxdata/telegraf/testutil"
+)
+
+func TestValidateVersion(t *testing.T) {
+	err := server.validateVersion()
+	require.NoError(t, err)
+}
+
+func TestGetDefaultTags(t *testing.T) {
+	var tagTests = []struct {
+		in  string
+		out string
+	}{
+		{"rethinkdb_host", server.Url.Host},
+		{"rethinkdb_hostname", server.serverStatus.Network.Hostname},
+	}
+	defaultTags := server.getDefaultTags()
+	for _, tt := range tagTests {
+		if defaultTags[tt.in] != tt.out {
+			t.Errorf("expected %q, got %q", tt.out, defaultTags[tt.in])
+		}
+	}
+}
+
+func TestAddClusterStats(t *testing.T) {
+	var acc testutil.Accumulator
+
+	err := server.addClusterStats(&acc)
+	require.NoError(t, err)
+
+	for _, metric := range clusterTracking {
+		require.True(t, acc.HasIntValue(metric))
+	}
+}
+
+func TestAddMemberStats(t *testing.T) {
+	var acc testutil.Accumulator
+
+	err := server.addMemberStats(&acc)
+	require.NoError(t, err)
+
+	for _, metric := range memberTracking {
+		require.True(t, acc.HasIntValue(metric))
+	}
+}
+
+func TestAddTableStats(t *testing.T) {
+	var acc testutil.Accumulator
+
+	err := server.addTableStats(&acc)
+	require.NoError(t, err)
+
+	for _, metric := range tableTracking {
+		require.True(t, acc.HasIntValue(metric))
+	}
+
+	keys := []string{
+		"cache_bytes_in_use",
+		"disk_read_bytes_per_sec",
+		"disk_read_bytes_total",
+		"disk_written_bytes_per_sec",
+		"disk_written_bytes_total",
+		"disk_usage_data_bytes",
+		"disk_usage_garbage_bytes",
+		"disk_usage_metadata_bytes",
+		"disk_usage_preallocated_bytes",
+	}
+
+	for _, metric := range keys {
+		require.True(t, acc.HasIntValue(metric))
+	}
+}

plugins/inputs/rethinkdb/rethinkdb_test.go

@@ -0,0 +1,73 @@
+//go:build integration
+
+package rethinkdb
+
+import (
+	"log"
+	"math/rand"
+	"net/url"
+	"os"
+	"testing"
+	"time"
+
+	"gopkg.in/gorethink/gorethink.v3"
+)
+
+var connect_url, authKey, username, password string
+var server *server
+
+func init() {
+	connect_url = os.Getenv("RETHINKDB_URL")
+	if connect_url == "" {
+		connect_url = "127.0.0.1:28015"
+	}
+	authKey = os.Getenv("RETHINKDB_AUTHKEY")
+	username = os.Getenv("RETHINKDB_USERNAME")
+	password = os.Getenv("RETHINKDB_PASSWORD")
+}
+
+func testSetup(m *testing.M) {
+	var err error
+	server = &server{url: &url.URL{Host: connect_url}}
+
+	if authKey {
+		server.session, _ = gorethink.Connect(gorethink.ConnectOpts{
+			Address:          server.url.Host,
+			AuthKey:          authKey,
+			HandshakeVersion: gorethink.HandshakeV0_4,
+			DiscoverHosts:    false,
+		})
+	} else {
+		server.session, _ = gorethink.Connect(gorethink.ConnectOpts{
+			Address:          server.url.Host,
+			Username:         username,
+			Password:         password,
+			HandshakeVersion: gorethink.HandshakeV1_0,
+			DiscoverHosts:    false,
+		})
+	}
+
+	if err != nil {
+		log.Fatalln(err.Error())
+	}
+
+	err = server.getServerStatus()
+	if err != nil {
+		log.Fatalln(err.Error())
+	}
+}
+
+func testTeardown(m *testing.M) {
+	server.session.Close()
+}
+
+func TestMain(m *testing.M) {
+	// seed randomness for use with tests
+	rand.Seed(time.Now().UTC().UnixNano())
+
+	testSetup(m)
+	res := m.Run()
+	testTeardown(m)
+
+	os.Exit(res)
+}

plugins/inputs/rethinkdb/sample.conf

@@ -0,0 +1,16 @@
+# Read metrics from one or many RethinkDB servers
+[[inputs.rethinkdb]]
+  ## An array of URI to gather stats about. Specify an ip or hostname
+  ## with optional port add password. ie,
+  ##   rethinkdb://user:auth_key@10.10.3.30:28105,
+  ##   rethinkdb://10.10.3.33:18832,
+  ##   10.0.0.1:10000, etc.
+  servers = ["127.0.0.1:28015"]
+
+  ## If you use actual rethinkdb of > 2.3.0 with username/password authorization,
+  ## protocol have to be named "rethinkdb2" - it will use 1_0 H.
+  # servers = ["rethinkdb2://username:password@127.0.0.1:28015"]
+
+  ## If you use older versions of rethinkdb (<2.2) with auth_key, protocol
+  ## have to be named "rethinkdb".
+  # servers = ["rethinkdb://username:auth_key@127.0.0.1:28015"]