From b173af7bd2f00475fe575e11720bf77a57544c5e Mon Sep 17 00:00:00 2001
From: Michael Okoko <10512379+idoqo@users.noreply.github.com>
Date: Wed, 17 Jan 2024 14:20:17 +0100
Subject: [PATCH] PMM-12510 correctly recognize arbiter nodes (#755)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* add networks

* accept exit code

* use replica set status for node states

* drop external links

* fix formatting

* convert to table tests

* fix topology tests

* include hello command for arbiter nodes

* use parallel tests

* add tests for hello metrics

* attempt to satisfy golint

* use single command for replica setup

* improve naming

* reduce external calls

* add method comments

* use isMaster for compatibility

* PMM-12712 Shards collector. (#762)

* PMM-12712 Shard ID and count.

* PMM-12712 Name and count.

* PMM-12712 Sharded collector.

* PMM-12712 Remove missed print.

* PMM-12712 Revert test changes.

* PMM-12712 Revert old not related changes.

* PMM-12712 Another changes.

* PMM-12712 Missed print.

* PMM-12712 Align naming with task description.

* PMM-12712 Add mongos test client.

* PMM-12712 Lint.

* PMM-12712 Lint.

* PMM-12712 Typo.

* PMM-12712 Lint.

* PMM-12712 Test higher sleep.

* Revert "PMM-12712 Test higher sleep."

This reverts commit 88451ba6b8a01d7c9b97daf4ac17a1c19a28f82b.

* PMM-12712 Test of pipeline.

* PMM-12712 Change.

* PMM-12712 Test.

* PMM-12712 Test.

* PMM-12712 Test.

* PMM-12712 Correct aggregation to get chunks info.

* PMM-12712 Another progress.

* PMM-12702 Small refactor.

* PMM-12712 Test.

* PMM-12712 Fix, tests.

* PMM-12712 Temp.

* PMM-12712 Improve sharded test.

* PMM-12712 Change in workflow.

* PMM-12712 Remove print.

* PMM-12712 Init script changes.

* PMM-12712 Remove print.

* PMM-12712 Bigger sleep.

* PMM-12712 Refactor.

* PMM-12712 Small refactor.

* PMM-12712 Another refactor.

* PMM-12712 Fix after refactor.

* PMM-12712 Alias.

* PMM-12712 Alias for shell in older versions.

* PMM-12712 Static test shard.

* PMM-12712 Fix another tests, mongo 4 shell script.

* PMM-12712 Big sleep test.

* PMM-12712 Michael's fix.

* PMM-12712 Sleep.

* PMM-12712 Env.

* PMM-12712 Test.

* PMM-12712 Fix test.

* PMM-12712 Bigger sleep after changes.

* PMM-12712 Remove duplicate lines.

* PMM-12712 Renaming from sharded to shards.

* PMM-12712 Better script to detect proper mongo client.

* PMM-12712 Init script refactor.

* PMM-12712 Fix.

* PMM-12712 Small refactor.

* Update main.go

Co-authored-by: Michael Okoko <10512379+idoqo@users.noreply.github.com>

* Update exporter/shards_collector.go

Co-authored-by: Michael Okoko <10512379+idoqo@users.noreply.github.com>

* PMM-12712 Remove mongo 6 for now, skip test for shards.

* PMM-12712 Revert sleep length.

* PMM-12712 Mongo client based on vendor.

---------

Co-authored-by: Michael Okoko <10512379+idoqo@users.noreply.github.com>

* add wait to docker compose command

* remove wait from docker compose command

---------

Co-authored-by: Jiří Čtvrtka <62988319+JiriCtvrtka@users.noreply.github.com>
---
 Makefile                                   |   2 +-
 docker-compose.yml                         |  91 ++++++----
 docker/scripts/init-shard.sh               |  20 ++-
 docker/scripts/setup.sh                    |  42 +++--
 exporter/diagnostic_data_collector.go      |   6 +-
 exporter/diagnostic_data_collector_test.go | 147 ++++++++++------
 exporter/exporter.go                       |  10 ++
 exporter/shards_collector.go               | 189 +++++++++++++++++++++
 exporter/shards_collector_test.go          |  69 ++++++++
 exporter/topology_info.go                  |   2 +-
 exporter/topology_info_test.go             |  32 ++--
 exporter/v1_compatibility.go               |  65 +++++--
 exporter/v1_compatibility_test.go          |  92 ++++++++--
 internal/proto/replstatus.go               |  20 ++-
 internal/tu/testutils.go                   |  18 +-
 internal/util/util.go                      |  22 ++-
 main.go                                    |   2 +
 17 files changed, 667 insertions(+), 162 deletions(-)
 create mode 100644 exporter/shards_collector.go
 create mode 100644 exporter/shards_collector_test.go

diff --git a/Makefile b/Makefile
index 65d91fcc1..25866ddcd 100644
--- a/Makefile
+++ b/Makefile
@@ -104,7 +104,7 @@ test-race: env              ## Run all tests with race flag.
 	go test -race -v -timeout 30s ./...
 
 test-cluster: env           ## Starts MongoDB test cluster. Use env var TEST_MONGODB_IMAGE to set flavor and version. Example: TEST_MONGODB_IMAGE=mongo:3.6 make test-cluster
-	docker compose up -d --wait
+	docker compose up -d
 
 test-cluster-clean: env     ## Stops MongoDB test cluster.
 	docker compose down --remove-orphans
diff --git a/docker-compose.yml b/docker-compose.yml
index 3fb2743f9..92e51f9ef 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -6,9 +6,12 @@ services:
         ports:
             - "${TEST_MONGODB_S1_PRIMARY_PORT:-17001}:27017"
         command: mongod --replSet rs1 --shardsvr --port 27017  --oplogSize 16
-        links:
-            - mongo-1-2:mongo-1-2
-            - mongo-1-3:mongo-1-3
+        networks:
+            - rs1
+        depends_on:
+          - "mongo-1-2"
+          - "mongo-1-3"
+          - "mongo-1-arbiter"
 
     mongo-1-2:
         container_name: "mongo-1-2"
@@ -16,6 +19,8 @@ services:
         ports:
             - "${TEST_MONGODB_S1_SECONDARY1_PORT:-17002}:27017"
         command: mongod --replSet rs1 --shardsvr --port 27017  --oplogSize 16
+        networks:
+            - rs1
 
     mongo-1-3:
         container_name: "mongo-1-3"
@@ -23,6 +28,8 @@ services:
         ports:
             - "${TEST_MONGODB_S1_SECONDARY2_PORT:-17003}:27017"
         command: mongod --replSet rs1 --shardsvr --port 27017  --oplogSize 16
+        networks:
+            - rs1
 
     mongo-1-arbiter:
         container_name: "mongo-1-arbiter"
@@ -30,6 +37,8 @@ services:
         ports:
             - "${TEST_MONGODB_S1_ARBITER:-17011}:27017"
         command: mongod --replSet rs1 --shardsvr --port 27017  --oplogSize 16
+        networks:
+            - rs1
 
     mongo-rs1-setup:
         container_name: "mongo-rs1-setup"
@@ -39,11 +48,6 @@ services:
             - "mongo-1-2"
             - "mongo-1-3"
             - "mongo-1-arbiter"
-        links:
-            - mongo-1-1:mongo-1-1
-            - mongo-1-2:mongo-1-2
-            - mongo-1-3:mongo-1-3
-            - mongo-1-arbiter:mongo-1-arbiter
         volumes:
             - ./docker/scripts:/scripts
         environment:
@@ -52,7 +56,10 @@ services:
             - MONGO3=mongo-1-3
             - ARBITER=mongo-1-arbiter
             - RS=rs1
+            - VERSION=${TEST_MONGODB_IMAGE}
         entrypoint: [ "/scripts/setup.sh" ]
+        networks:
+            - rs1
 
     mongo-2-2:
         container_name: "mongo-2-2"
@@ -60,6 +67,8 @@ services:
         ports:
             - "${TEST_MONGODB_S2_PRIMARY_PORT:-17004}:27017"
         command: mongod --replSet rs2 --shardsvr --port 27017  --oplogSize 16
+        networks:
+            - rs2
 
     mongo-2-3:
         container_name: "mongo-2-3"
@@ -67,6 +76,8 @@ services:
         ports:
             - "${TEST_MONGODB_S2_SECONDARY1_PORT:-17005}:27017"
         command: mongod --replSet rs2 --shardsvr --port 27017  --oplogSize 16
+        networks:
+            - rs2
 
     mongo-2-1:
         container_name: "mongo-2-1"
@@ -74,9 +85,8 @@ services:
         ports:
             - "${TEST_MONGODB_S2_SECONDARY2_PORT:-17006}:27017"
         command: mongod --replSet rs2 --shardsvr --port 27017  --oplogSize 16
-        links:
-            - mongo-2-2:mongo-2-2
-            - mongo-2-3:mongo-2-3
+        networks:
+            - rs2
 
     mongo-2-arbiter:
         container_name: "mongo-2-arbiter"
@@ -84,6 +94,8 @@ services:
         ports:
             - "${TEST_MONGODB_S2_ARBITER:-17012}:27017"
         command: mongod --replSet rs1 --shardsvr --port 27017  --oplogSize 16
+        networks:
+            - rs2
 
     mongo-rs2-setup:
         container_name: "mongo-rs2-setup"
@@ -93,19 +105,18 @@ services:
             - "mongo-2-2"
             - "mongo-2-3"
             - "mongo-2-arbiter"
-        links:
-            - mongo-2-1:mongo-2-1
-            - mongo-2-2:mongo-2-2
-            - mongo-2-3:mongo-2-3
         volumes:
             - ./docker/scripts:/scripts
         environment:
-            - MONGO1=mongo-2-1
-            - MONGO2=mongo-2-2
+            - MONGO1=mongo-2-2
+            - MONGO2=mongo-2-1
             - MONGO3=mongo-2-3
             - ARBITER=mongo-2-arbiter
             - RS=rs2
+            - VERSION=${TEST_MONGODB_IMAGE}
         entrypoint: [ "/scripts/setup.sh" ]
+        networks:
+            - rs2
 
     # Config servers
     mongo-cnf-2:
@@ -114,6 +125,8 @@ services:
         ports:
             - "${TEST_MONGODB_CONFIGSVR1_PORT:-17007}:27017"
         command: mongod --dbpath /data/db --replSet cnf-serv --configsvr --port 27017 --oplogSize 16
+        networks:
+            - cnf-serv
 
     mongo-cnf-3:
         container_name: "mongo-cnf-3"
@@ -121,6 +134,8 @@ services:
         ports:
             - "${TEST_MONGODB_CONFIGSVR2_PORT:-17008}:27017"
         command: mongod --dbpath /data/db --replSet cnf-serv --configsvr --port 27017 --oplogSize 16
+        networks:
+            - cnf-serv
 
     mongo-cnf-1:
         container_name: "mongo-cnf-1"
@@ -128,9 +143,11 @@ services:
         ports:
             - "${TEST_MONGODB_CONFIGSVR3_PORT:-17009}:27017"
         command: mongod --dbpath /data/db --replSet cnf-serv --configsvr --port 27017 --oplogSize 16
-        links:
-            - mongo-cnf-2:mongo-cnf-2
-            - mongo-cnf-3:mongo-cnf-3
+        networks:
+            - cnf-serv
+        depends_on:
+            - mongo-cnf-2
+            - mongo-cnf-3
 
     mongo-cnf-setup:
         container_name: "mongo-cnf-setup"
@@ -139,10 +156,6 @@ services:
             - "mongo-cnf-1"
             - "mongo-cnf-2"
             - "mongo-cnf-3"
-        links:
-            - mongo-cnf-1:mongo-cnf-1
-            - mongo-cnf-2:mongo-cnf-2
-            - mongo-cnf-3:mongo-cnf-3
         volumes:
             - ./docker/scripts:/scripts
         environment:
@@ -151,27 +164,25 @@ services:
             - MONGO3=mongo-cnf-3
             - RS=cnf-serv
             - PORT=27017
+            - VERSION=${TEST_MONGODB_IMAGE}
         entrypoint: [ "/scripts/setup.sh","cnf_servers" ]
+        networks:
+            - cnf-serv
 
     mongos:
         container_name: "mongos"
         image: ${TEST_MONGODB_IMAGE:-mongo:4.2}
         ports:
             - "${TEST_MONGODB_MONGOS_PORT:-17000}:27017"
+        networks:
+            - mongo-shard
+            - rs1
+            - rs2
+            - cnf-serv
         depends_on:
             - "mongo-rs1-setup"
             - "mongo-rs2-setup"
             - "mongo-cnf-setup"
-        external_links:
-            - mongo-cnf-1:mongo-cnf-1
-            - mongo-cnf-2:mongo-cnf-2
-            - mongo-cnf-3:mongo-cnf-3
-            - mongo-1-1:mongo-1-1
-            - mongo-1-2:mongo-1-2
-            - mongo-1-3:mongo-1-3
-            - mongo-2-1:mongo-2-1
-            - mongo-2-2:mongo-2-2
-            - mongo-2-3:mongo-2-3
         command: mongos --configdb cnf-serv/mongo-cnf-1:27017,mongo-cnf-2:27017,mongo-cnf-3:27017 --port 27017 --bind_ip 0.0.0.0
 
     mongo-shard-setup:
@@ -179,8 +190,8 @@ services:
         image: ${TEST_MONGODB_IMAGE:-mongo:4.2}
         depends_on:
             - "mongos"
-        links:
-            - mongos:mongos
+        networks:
+            - mongo-shard
         volumes:
             - ./docker/scripts:/scripts
         environment:
@@ -197,6 +208,7 @@ services:
             - PORT1=27017
             - PORT2=27017
             - PORT3=27017
+            - VERSION=${TEST_MONGODB_IMAGE}
         entrypoint: [ "/scripts/init-shard.sh" ]
         restart: on-failure:20
 
@@ -208,6 +220,7 @@ services:
         command: mongod --port 27017  --oplogSize 16
 
     standalone-encrypted:
+        user: root
         container_name: "standalone-encrypted"
         image: percona/percona-server-mongodb:5.0.13-11
         ports:
@@ -216,3 +229,9 @@ services:
             - ./docker/secret/mongodb_secrets.txt:/secret/mongodb_secrets.txt
             - ./docker/scripts:/scripts
         command: /scripts/run-mongodb-encrypted.sh
+
+networks:
+    rs1:
+    rs2:
+    cnf-serv:
+    mongo-shard:
diff --git a/docker/scripts/init-shard.sh b/docker/scripts/init-shard.sh
index 8467b74f8..f5de49498 100755
--- a/docker/scripts/init-shard.sh
+++ b/docker/scripts/init-shard.sh
@@ -1,4 +1,16 @@
 #!/bin/bash 
+# `mongosh` is used starting from MongoDB 5.x
+MONGODB_CLIENT="mongosh --quiet"
+PARSED=(${VERSION//:/ })
+MONGODB_VERSION=${PARSED[1]}
+MONGODB_VENDOR=${PARSED[0]}
+if [ "`echo ${MONGODB_VERSION} | cut -c 1`" = "4" ]; then
+  MONGODB_CLIENT="mongo"
+fi
+if [ "`echo ${MONGODB_VERSION} | cut -c 1`" = "5" ] && [ ${MONGODB_VENDOR} == "percona/percona-server-mongodb" ]; then
+  MONGODB_CLIENT="mongo"
+fi
+echo "MongoDB vendor, client and version: ${MONGODB_VENDOR} ${MONGODB_CLIENT} ${MONGODB_VERSION}"
 
 mongodb1=`getent hosts ${MONGOS} | awk '{ print $1 }'`
 
@@ -17,7 +29,7 @@ mongodb33=`getent hosts ${MONGO33} | awk '{ print $1 }'`
 port=${PORT:-27017}
 
 echo "Waiting for startup.."
-until mongo --host ${mongodb1}:${port} --eval 'quit(db.runCommand({ ping: 1 }).ok ? 0 : 2)' &>/dev/null; do
+until ${MONGODB_CLIENT} --host ${mongodb1}:${port} --eval 'quit(db.runCommand({ ping: 1 }).ok ? 0 : 2)' &>/dev/null; do
   printf '.'
   sleep 1
 done
@@ -25,8 +37,12 @@ done
 echo "Started.."
 
 echo init-shard.sh time now: `date +"%T" `
-mongo --host ${mongodb1}:${port} <<EOF
+${MONGODB_CLIENT} --host ${mongodb1}:${port} <<EOF
    sh.addShard( "${RS1}/${mongodb11}:${PORT1},${mongodb12}:${PORT2},${mongodb13}:${PORT3}" );
    sh.addShard( "${RS2}/${mongodb21}:${PORT1},${mongodb22}:${PORT2},${mongodb23}:${PORT3}" );
+   use test;
+   db.createCollection("shard");
+   sh.enableSharding("test");
+   sh.shardCollection( "test.shard", { id: "hashed" }, false, { numInitialChunks: 500, collation: { locale: "simple" }} );
    sh.status();
 EOF
diff --git a/docker/scripts/setup.sh b/docker/scripts/setup.sh
index e663230f4..c432bdcbe 100755
--- a/docker/scripts/setup.sh
+++ b/docker/scripts/setup.sh
@@ -1,4 +1,16 @@
 #!/bin/bash 
+# `mongosh` is used starting from MongoDB 5.x
+MONGODB_CLIENT="mongosh --quiet"
+PARSED=(${VERSION//:/ })
+MONGODB_VERSION=${PARSED[1]}
+MONGODB_VENDOR=${PARSED[0]}
+if [ "`echo ${MONGODB_VERSION} | cut -c 1`" = "4" ]; then
+  MONGODB_CLIENT="mongo"
+fi
+if [ "`echo ${MONGODB_VERSION} | cut -c 1`" = "5" ] && [ ${MONGODB_VENDOR} == "percona/percona-server-mongodb" ]; then
+  MONGODB_CLIENT="mongo"
+fi
+echo "MongoDB vendor, client and version: ${MONGODB_VENDOR} ${MONGODB_CLIENT} ${MONGODB_VERSION}"
 
 mongodb1=`getent hosts ${MONGO1} | awk '{ print $1 }'`
 mongodb2=`getent hosts ${MONGO2} | awk '{ print $1 }'`
@@ -8,7 +20,7 @@ arbiter=`getent hosts ${ARBITER} | awk '{ print $1 }'`
 port=${PORT:-27017}
 
 echo "Waiting for startup.."
-until mongo --host ${mongodb1}:${port} --eval 'quit(db.runCommand({ ping: 1 }).ok ? 0 : 2)' &>/dev/null; do
+until ${MONGODB_CLIENT} --host ${mongodb1}:${port} --eval 'quit(db.runCommand({ ping: 1 }).ok ? 0 : 2)' &>/dev/null; do
   printf '.'
   sleep 1
 done
@@ -19,10 +31,11 @@ echo setup.sh time now: `date +"%T" `
 
 
 function cnf_servers() {
-    echo "setup cnf servers"
-    mongo --host ${mongodb1}:${port} <<EOF
+    echo "setup cnf servers on ${MONGO1}(${mongodb1}:${port})"
+    ${MONGODB_CLIENT} --host ${mongodb1}:${port} <<EOF
     var cfg = {
         "_id": "${RS}",
+        "version": 1,
         "protocolVersion": 1,
         "configsvr": true,
         "members": [
@@ -37,20 +50,21 @@ function cnf_servers() {
             {
                 "_id": 2,
                 "host": "${mongodb3}:${port}"
-            }
+            },
         ]
     };
-    rs.initiate(cfg, { force: true });
-    rs.reconfig(cfg, { force: true });
+
+    rs.initiate(cfg);
 EOF
 }
 
 function general_servers() {
-    echo "setup servers"
-    mongo --host ${mongodb1}:${port} <<EOF
+    echo "setup servers on ${MONGO1}(${mongodb1}:${port})"
+    ${MONGODB_CLIENT} --host ${mongodb1}:${port} <<EOF
     var cfg = {
         "_id": "${RS}",
         "protocolVersion": 1,
+        "version": 1,
         "members": [
             {
                 "_id": 0,
@@ -63,13 +77,15 @@ function general_servers() {
             {
                 "_id": 2,
                 "host": "${mongodb3}:${port}"
-            }
+            },
+            {
+                "_id": 3,
+                "host": "${arbiter}:${port}",
+                "arbiterOnly": true
+            },
         ]
     };
-    rs.initiate(cfg, { force: true });
-    rs.reconfig(cfg, { force: true });
-
-    rs.addArb("${arbiter}:${port}")
+    rs.initiate(cfg);
 EOF
 }
 
diff --git a/exporter/diagnostic_data_collector.go b/exporter/diagnostic_data_collector.go
index 160af1882..eb0b75b70 100644
--- a/exporter/diagnostic_data_collector.go
+++ b/exporter/diagnostic_data_collector.go
@@ -69,9 +69,8 @@ func (d *diagnosticDataCollector) collect(ch chan<- prometheus.Metric) {
 	cmd := bson.D{{Key: "getDiagnosticData", Value: "1"}}
 	res := client.Database("admin").RunCommand(d.ctx, cmd)
 	if res.Err() != nil {
-		if isArbiter, _ := isArbiter(d.ctx, client); isArbiter {
-			return
-		}
+		logger.Errorf("failed to run command: getDiagnosticData: %s", res.Err())
+		logger.Warn("cannot run getDiagnosticData, some metrics might be unavailable.")
 	}
 
 	if err := res.Decode(&m); err != nil {
@@ -85,6 +84,7 @@ func (d *diagnosticDataCollector) collect(ch chan<- prometheus.Metric) {
 	m, ok := m["data"].(bson.M)
 	if !ok {
 		err := errors.Wrapf(errUnexpectedDataType, "%T for data field", m["data"])
+
 		logger.Errorf("cannot decode getDiagnosticData: %s", err)
 	}
 
diff --git a/exporter/diagnostic_data_collector_test.go b/exporter/diagnostic_data_collector_test.go
index 7b69b5381..9e6937a9f 100644
--- a/exporter/diagnostic_data_collector_test.go
+++ b/exporter/diagnostic_data_collector_test.go
@@ -73,15 +73,9 @@ func TestDiagnosticDataCollector(t *testing.T) {
 	assert.NoError(t, err)
 }
 
-func TestDiagnosticDataCollectorWithCompatibleMode(t *testing.T) {
-	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
-	defer cancel()
-
-	client := tu.DefaultTestClient(ctx, t)
-	logger := logrus.New()
-	ti := labelsGetterMock{}
-
-	imageBaseName, version, err := tu.GetImageNameForDefault()
+func getMongoDBVersionInfo(t *testing.T, containerName string) (string, string) {
+	t.Helper()
+	imageBaseName, version, err := tu.GetImageNameForContainer(containerName)
 	require.NoError(t, err)
 
 	var vendor string
@@ -90,54 +84,115 @@ func TestDiagnosticDataCollectorWithCompatibleMode(t *testing.T) {
 	} else {
 		vendor = "MongoDB"
 	}
+	return version, vendor
+}
 
-	c := newDiagnosticDataCollector(ctx, client, logger, true, ti)
-
-	// The last \n at the end of this string is important
-	expected := strings.NewReader(fmt.Sprintf(`
+func TestCollectorWithCompatibleMode(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name          string
+		containerName string
+
+		// we use a metrics filter for two reasons:
+		// 1. The result is huge
+		// 2. We need to check against know values. Don't use metrics that return counters like uptime
+		//    or counters like the number of transactions because they won't return a known value to compare
+		metricsFilter   []string
+		expectedMetrics func() io.Reader
+	}{
+		{
+			name:          "basic metrics",
+			containerName: "mongo-1-1",
+			metricsFilter: []string{
+				"mongodb_mongod_storage_engine",
+				"mongodb_version_info",
+			},
+			expectedMetrics: func() io.Reader {
+				version, vendor := getMongoDBVersionInfo(t, "mongo-1-1")
+
+				// The last \n at the end of this string is important
+				return strings.NewReader(fmt.Sprintf(`
 	# HELP mongodb_mongod_storage_engine The storage engine used by the MongoDB instance
 	# TYPE mongodb_mongod_storage_engine gauge
 	mongodb_mongod_storage_engine{engine="wiredTiger"} 1
 	# HELP mongodb_version_info The server version
 	# TYPE mongodb_version_info gauge
 	mongodb_version_info{edition="Community",mongodb="%s",vendor="%s"} 1`, version, vendor) + "\n")
-
-	// Filter metrics for 2 reasons:
-	// 1. The result is huge
-	// 2. We need to check against know values. Don't use metrics that return counters like uptime
-	//    or counters like the number of transactions because they won't return a known value to compare
-	filter := []string{
-		"mongodb_mongod_storage_engine",
-		"mongodb_version_info",
+			},
+		},
+		{
+			name:          "replica set metrics from data-carrying node",
+			containerName: "mongo-1-1",
+			metricsFilter: []string{
+				"mongodb_mongod_storage_engine",
+				"mongodb_version_info",
+				"mongodb_mongod_replset_number_of_members",
+			},
+			expectedMetrics: func() io.Reader {
+				version, vendor := getMongoDBVersionInfo(t, "mongo-1-1")
+
+				// The last \n at the end of this string is important
+				return strings.NewReader(fmt.Sprintf(`
+    # HELP mongodb_mongod_replset_number_of_members The number of replica set members.
+    # TYPE mongodb_mongod_replset_number_of_members gauge
+    mongodb_mongod_replset_number_of_members{set="rs1"} 4
+	# HELP mongodb_mongod_storage_engine The storage engine used by the MongoDB instance
+	# TYPE mongodb_mongod_storage_engine gauge
+	mongodb_mongod_storage_engine{engine="wiredTiger"} 1
+	# HELP mongodb_version_info The server version
+	# TYPE mongodb_version_info gauge
+	mongodb_version_info{edition="Community",mongodb="%s",vendor="%s"} 1`, version, vendor) + "\n")
+			},
+		},
+		{
+			name:          "replica set metrics on arbiter node",
+			containerName: "mongo-1-arbiter",
+			metricsFilter: []string{
+				"mongodb_mongod_storage_engine",
+				"mongodb_version_info",
+				"mongodb_mongod_replset_my_state",
+				"mongodb_mongod_replset_number_of_members",
+			},
+			expectedMetrics: func() io.Reader {
+				version, vendor := getMongoDBVersionInfo(t, "mongo-1-1")
+
+				// The last \n at the end of this string is important
+				return strings.NewReader(fmt.Sprintf(`
+    # HELP mongodb_mongod_replset_number_of_members The number of replica set members.
+    # TYPE mongodb_mongod_replset_number_of_members gauge
+    mongodb_mongod_replset_number_of_members{set="rs1"} 4
+    # HELP mongodb_mongod_replset_my_state An integer between 0 and 10 that represents the replica state of the current member
+    # TYPE mongodb_mongod_replset_my_state gauge
+    mongodb_mongod_replset_my_state{set="rs1"} 7
+	# HELP mongodb_mongod_storage_engine The storage engine used by the MongoDB instance
+	# TYPE mongodb_mongod_storage_engine gauge
+	mongodb_mongod_storage_engine{engine="wiredTiger"} 1
+	# HELP mongodb_version_info The server version
+	# TYPE mongodb_version_info gauge
+	mongodb_version_info{edition="Community",mongodb="%s",vendor="%s"} 1`, version, vendor) + "\n")
+			},
+		},
 	}
 
-	err = testutil.CollectAndCompare(c, expected, filter...)
-	assert.NoError(t, err)
-}
+	for _, tt := range testCases {
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+			ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+			defer cancel()
 
-func getMongoDBVersion(t *testing.T, client *mongo.Client, ctx context.Context, logger *logrus.Logger) (string, error) {
-	var m bson.M
-	cmd := bson.D{{Key: "getDiagnosticData", Value: "1"}}
-	res := client.Database("admin").RunCommand(ctx, cmd)
-	if res.Err() != nil {
-		return "", res.Err()
-	}
-
-	if err := res.Decode(&m); err != nil {
-		logger.Errorf("cannot run getDiagnosticData: %s", err)
-	}
+			port, err := tu.PortForContainer(tt.containerName)
+			require.NoError(t, err)
+			client := tu.TestClient(ctx, port, t)
+			logger := logrus.New()
+			ti := labelsGetterMock{}
 
-	m, ok := m["data"].(bson.M)
-	if !ok {
-		return "", errors.New("cannot decode getDiagnosticData")
-	}
+			c := newDiagnosticDataCollector(ctx, client, logger, true, ti)
 
-	v := walkTo(m, []string{"serverStatus", "version"})
-	serverVersion, ok := v.(string)
-	if !ok {
-		serverVersion = "server version is unavailable"
+			err = testutil.CollectAndCompare(c, tt.expectedMetrics(), tt.metricsFilter...)
+			assert.NoError(t, err)
+		})
 	}
-	return serverVersion, nil
 }
 
 func TestAllDiagnosticDataCollectorMetrics(t *testing.T) {
@@ -287,9 +342,6 @@ func TestDisconnectedDiagnosticDataCollector(t *testing.T) {
 
 	// The last \n at the end of this string is important
 	expected := strings.NewReader(`
-	# HELP mongodb_mongod_replset_my_state An integer between 0 and 10 that represents the replica state of the current member
-	# TYPE mongodb_mongod_replset_my_state gauge
-	mongodb_mongod_replset_my_state{set=""} 6
 	# HELP mongodb_version_info The server version
 	# TYPE mongodb_version_info gauge
 	mongodb_version_info{edition="",mongodb="",vendor=""} 1` + "\n")
@@ -298,7 +350,6 @@ func TestDisconnectedDiagnosticDataCollector(t *testing.T) {
 	// 2. We need to check against know values. Don't use metrics that return counters like uptime
 	//    or counters like the number of transactions because they won't return a known value to compare
 	filter := []string{
-		"mongodb_mongod_replset_my_state",
 		"mongodb_mongod_storage_engine",
 		"mongodb_version_info",
 	}
diff --git a/exporter/exporter.go b/exporter/exporter.go
index 53d793de1..b211ab30a 100644
--- a/exporter/exporter.go
+++ b/exporter/exporter.go
@@ -68,6 +68,7 @@ type Opts struct {
 	EnableIndexStats         bool
 	EnableCollStats          bool
 	EnableProfile            bool
+	EnableShards             bool
 
 	EnableOverrideDescendingIndex bool
 
@@ -163,6 +164,7 @@ func (e *Exporter) makeRegistry(ctx context.Context, client *mongo.Client, topol
 		e.opts.EnableIndexStats = true
 		e.opts.EnableCurrentopMetrics = true
 		e.opts.EnableProfile = true
+		e.opts.EnableShards = true
 	}
 
 	// arbiter only have isMaster privileges
@@ -175,6 +177,7 @@ func (e *Exporter) makeRegistry(ctx context.Context, client *mongo.Client, topol
 		e.opts.EnableIndexStats = false
 		e.opts.EnableCurrentopMetrics = false
 		e.opts.EnableProfile = false
+		e.opts.EnableShards = false
 	}
 
 	// If we manually set the collection names we want or auto discovery is set.
@@ -230,6 +233,11 @@ func (e *Exporter) makeRegistry(ctx context.Context, client *mongo.Client, topol
 		registry.MustRegister(rsgsc)
 	}
 
+	if e.opts.EnableShards && requestOpts.EnableShards {
+		sc := newShardsCollector(ctx, client, e.opts.Logger, e.opts.CompatibleMode)
+		registry.MustRegister(sc)
+	}
+
 	return registry
 }
 
@@ -304,6 +312,8 @@ func (e *Exporter) Handler() http.Handler {
 				requestOpts.EnableCollStats = true
 			case "profile":
 				requestOpts.EnableProfile = true
+			case "shards":
+				requestOpts.EnableShards = true
 			}
 		}
 
diff --git a/exporter/shards_collector.go b/exporter/shards_collector.go
new file mode 100644
index 000000000..9a5ed9941
--- /dev/null
+++ b/exporter/shards_collector.go
@@ -0,0 +1,189 @@
+// mongodb_exporter
+// Copyright (C) 2017 Percona LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package exporter
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/sirupsen/logrus"
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/bson/primitive"
+	"go.mongodb.org/mongo-driver/mongo"
+)
+
+type shardsCollector struct {
+	ctx        context.Context
+	base       *baseCollector
+	compatible bool
+}
+
+// newShardsCollector creates collector collecting metrics about chunks for shards Mongo.
+func newShardsCollector(ctx context.Context, client *mongo.Client, logger *logrus.Logger, compatibleMode bool) *shardsCollector {
+	return &shardsCollector{
+		ctx:        ctx,
+		base:       newBaseCollector(client, logger),
+		compatible: compatibleMode,
+	}
+}
+
+func (d *shardsCollector) Describe(ch chan<- *prometheus.Desc) {
+	d.base.Describe(d.ctx, ch, d.collect)
+}
+
+func (d *shardsCollector) Collect(ch chan<- prometheus.Metric) {
+	d.base.Collect(ch)
+}
+
+func (d *shardsCollector) collect(ch chan<- prometheus.Metric) {
+	defer measureCollectTime(ch, "mongodb", "shards")()
+
+	client := d.base.client
+	logger := d.base.logger
+	prefix := "shards collection chunks"
+
+	databaseNames, err := client.ListDatabaseNames(d.ctx, bson.D{})
+	if err != nil {
+		logger.Errorf("cannot get database names: %s", err)
+	}
+	for _, database := range databaseNames {
+		collections := d.getCollectionsForDBName(database)
+		for _, row := range collections {
+			if len(row) == 0 {
+				continue
+			}
+
+			var ok bool
+			if _, ok = row["_id"]; !ok {
+				continue
+			}
+			var rowID string
+			if rowID, ok = row["_id"].(string); !ok {
+				continue
+			}
+
+			chunks := d.getChunksForCollection(row)
+			for _, c := range chunks {
+				labels, chunks, success := d.getInfoForChunk(c, database, rowID)
+				if !success {
+					continue
+				}
+				for _, metric := range makeMetrics(prefix, primitive.M{"count": chunks}, labels, d.compatible) {
+					ch <- metric
+				}
+			}
+		}
+	}
+}
+
+func (d *shardsCollector) getInfoForChunk(c primitive.M, database, rowID string) (map[string]string, int32, bool) {
+	var ok bool
+	if _, ok = c["dropped"]; ok {
+		if dropped, ok := c["dropped"].(bool); ok && dropped {
+			return nil, 0, false
+		}
+	}
+
+	if _, ok = c["shard"]; !ok {
+		return nil, 0, ok
+	}
+	var shard string
+	if shard, ok = c["shard"].(string); !ok {
+		return nil, 0, ok
+	}
+
+	if _, ok = c["nChunks"]; !ok {
+		return nil, 0, ok
+	}
+	var chunks int32
+	if chunks, ok = c["nChunks"].(int32); !ok {
+		return nil, 0, ok
+	}
+
+	labels := make(map[string]string)
+	labels["database"] = database
+	labels["collection"] = strings.Replace(rowID, fmt.Sprintf("%s.", database), "", 1)
+	labels["shard"] = shard
+
+	logger := d.base.logger
+	logger.Debug("$shards metrics for config.chunks")
+	debugResult(logger, primitive.M{database: c})
+
+	return labels, chunks, true
+}
+
+func (d *shardsCollector) getCollectionsForDBName(database string) []primitive.M {
+	client := d.base.client
+	logger := d.base.logger
+
+	cursor := client.Database("config").Collection("collections")
+	rs, err := cursor.Find(d.ctx, bson.M{"_id": bson.M{"$regex": fmt.Sprintf("^%s.", database), "$options": "i"}})
+	if err != nil {
+		logger.Errorf("cannot find _id starting with \"%s.\":%s", database, err)
+		return nil
+	}
+
+	var decoded []bson.M
+	err = rs.All(d.ctx, &decoded)
+	if err != nil {
+		logger.Errorf("cannot decode collections: %s", err)
+		return nil
+	}
+
+	return decoded
+}
+
+func (d *shardsCollector) getChunksForCollection(row primitive.M) []bson.M {
+	var chunksMatchPredicate bson.M
+	if _, ok := row["timestamp"]; ok {
+		if uuid, ok := row["uuid"]; ok {
+			chunksMatchPredicate = bson.M{"uuid": uuid}
+		}
+	} else {
+		if id, ok := row["_id"]; ok {
+			chunksMatchPredicate = bson.M{"_id": id}
+		}
+	}
+
+	aggregation := bson.A{
+		bson.M{"$match": chunksMatchPredicate},
+		bson.M{"$group": bson.M{"_id": "$shard", "cnt": bson.M{"$sum": 1}}},
+		bson.M{"$project": bson.M{"_id": 0, "shard": "$_id", "nChunks": "$cnt"}},
+		bson.M{"$sort": bson.M{"shard": 1}},
+	}
+
+	client := d.base.client
+	logger := d.base.logger
+
+	cur, err := client.Database("config").Collection("chunks").Aggregate(context.Background(), aggregation)
+	if err != nil {
+		logger.Errorf("cannot get $shards cursor for collection config.chunks: %s", err)
+		return nil
+	}
+
+	var chunks []bson.M
+	err = cur.All(context.Background(), &chunks)
+	if err != nil {
+		logger.Errorf("cannot decode $shards for collection config.chunks: %s", err)
+		return nil
+	}
+
+	return chunks
+}
+
+var _ prometheus.Collector = (*shardsCollector)(nil)
diff --git a/exporter/shards_collector_test.go b/exporter/shards_collector_test.go
new file mode 100644
index 000000000..efb7c613c
--- /dev/null
+++ b/exporter/shards_collector_test.go
@@ -0,0 +1,69 @@
+// mongodb_exporter
+// Copyright (C) 2017 Percona LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package exporter
+
+import (
+	"context"
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/sirupsen/logrus"
+	"github.com/stretchr/testify/assert"
+
+	"github.com/percona/mongodb_exporter/internal/tu"
+)
+
+//nolint:paralleltest
+func TestShardsCollector(t *testing.T) {
+	t.Skip("This is failing in GitHub actions. Shards are not ready yet")
+	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+	defer cancel()
+
+	client := tu.DefaultTestClientMongoS(ctx, t)
+	c := newShardsCollector(ctx, client, logrus.New(), false)
+
+	reg := prometheus.NewPedanticRegistry()
+	if err := reg.Register(c); err != nil {
+		panic(fmt.Errorf("registering collector failed: %w", err))
+	}
+
+	expected := []map[string]string{
+		{"collection": "shard", "database": "test", "shard": "rs1"},
+		{"collection": "shard", "database": "test", "shard": "rs2"},
+	}
+
+	got, err := reg.Gather()
+	assert.NoError(t, err)
+	res := []map[string]string{}
+	for _, r := range got {
+		if r.GetName() != "mongodb_shards_collection_chunks_count" {
+			continue
+		}
+		for _, m := range r.Metric {
+			row := make(map[string]string)
+			for _, l := range m.GetLabel() {
+				row[l.GetName()] = l.GetValue()
+			}
+
+			res = append(res, row)
+		}
+	}
+	for _, v := range expected {
+		assert.Contains(t, res, v)
+	}
+}
diff --git a/exporter/topology_info.go b/exporter/topology_info.go
index 8e05a244e..2cf1d927f 100644
--- a/exporter/topology_info.go
+++ b/exporter/topology_info.go
@@ -128,7 +128,7 @@ func (t *topologyInfo) loadLabels(ctx context.Context) error {
 	t.labels[labelClusterID] = cid
 
 	// Standalone instances or mongos instances won't have a replicaset state
-	state, err := util.MyState(ctx, t.client)
+	_, state, err := util.MyState(ctx, t.client)
 	if err == nil {
 		t.labels[labelReplicasetState] = fmt.Sprintf("%d", state)
 	}
diff --git a/exporter/topology_info_test.go b/exporter/topology_info_test.go
index c8702c5b0..d1e4f364f 100644
--- a/exporter/topology_info_test.go
+++ b/exporter/topology_info_test.go
@@ -37,7 +37,7 @@ func TestTopologyLabels(t *testing.T) {
 			containerName: "mongos",
 			want: map[string]string{
 				labelReplicasetName:  "",
-				labelReplicasetState: "0",
+				labelReplicasetState: "",
 				labelClusterRole:     "mongos",
 				labelClusterID:       "q",
 			},
@@ -63,8 +63,8 @@ func TestTopologyLabels(t *testing.T) {
 		{
 			containerName: "mongo-1-arbiter",
 			want: map[string]string{
-				labelReplicasetName:  "",
-				labelReplicasetState: "0",
+				labelReplicasetName:  "rs1",
+				labelReplicasetState: "7",
 				labelClusterRole:     "shardsvr",
 				labelClusterID:       "",
 			},
@@ -73,7 +73,7 @@ func TestTopologyLabels(t *testing.T) {
 			containerName: "standalone",
 			want: map[string]string{
 				labelReplicasetName:  "",
-				labelReplicasetState: "0",
+				labelReplicasetState: "",
 				labelClusterRole:     "",
 				labelClusterID:       "",
 			},
@@ -84,18 +84,20 @@ func TestTopologyLabels(t *testing.T) {
 	defer cancel()
 
 	for _, tc := range tests {
-		port, err := tu.PortForContainer(tc.containerName)
-		require.NoError(t, err)
+		t.Run(tc.containerName, func(t *testing.T) {
+			port, err := tu.PortForContainer(tc.containerName)
+			require.NoError(t, err)
 
-		client := tu.TestClient(ctx, port, t)
-		ti := newTopologyInfo(ctx, client, logrus.New())
-		bl := ti.baseLabels()
-		assert.Equal(t, tc.want[labelReplicasetName], bl[labelReplicasetName], tc.containerName)
-		assert.Equal(t, tc.want[labelReplicasetState], bl[labelReplicasetState], tc.containerName)
-		assert.Equal(t, tc.want[labelClusterRole], bl[labelClusterRole], tc.containerName)
-		if tc.want[labelClusterID] != "" {
-			assert.NotEmpty(t, bl[labelClusterID], tc.containerName) // this is variable inside a container
-		}
+			client := tu.TestClient(ctx, port, t)
+			ti := newTopologyInfo(ctx, client, logrus.New())
+			bl := ti.baseLabels()
+			assert.Equal(t, tc.want[labelReplicasetName], bl[labelReplicasetName], tc.containerName)
+			assert.Equal(t, tc.want[labelReplicasetState], bl[labelReplicasetState], tc.containerName)
+			assert.Equal(t, tc.want[labelClusterRole], bl[labelClusterRole], tc.containerName)
+			if tc.want[labelClusterID] != "" {
+				assert.NotEmpty(t, bl[labelClusterID], tc.containerName) // this is variable inside a container
+			}
+		})
 	}
 }
 
diff --git a/exporter/v1_compatibility.go b/exporter/v1_compatibility.go
index 55f9274ad..8f7191a02 100644
--- a/exporter/v1_compatibility.go
+++ b/exporter/v1_compatibility.go
@@ -35,10 +35,19 @@ import (
 )
 
 const (
-	// UnknownState is the values for an unknown rs state.
-	// From MongoDB documentation: https://docs.mongodb.com/manual/reference/replica-states/
+	// PrimaryState is the state of the primary node in a replica set.
+	// See: https://docs.mongodb.com/manual/reference/replica-states/
+	PrimaryState = 1
+
+	// SecondaryState is the state of a secondary node in a replica set.
+	SecondaryState = 2
+
+	// UnknownState is the state of an unknown node in a replica set.
 	UnknownState = 6
 
+	// ArbiterState is the state of an arbiter in a replica set.
+	ArbiterState = 7
+
 	// EnterpriseEdition shows that MongoDB is Enterprise edition.
 	EnterpriseEdition = "Enterprise"
 	// CommunityEdition shows that MongoDB is Community edition.
@@ -804,10 +813,16 @@ func specialMetrics(ctx context.Context, client *mongo.Client, m bson.M, l *logr
 		metrics = append(metrics, engine)
 	}
 	metrics = append(metrics, serverVersion(buildInfo))
-	metrics = append(metrics, myState(ctx, client))
 
-	if mm := replSetMetrics(m); mm != nil {
-		metrics = append(metrics, mm...)
+	if isArbiter, _ := isArbiter(ctx, client); isArbiter {
+		if hm := myRole(ctx, client, l); hm != nil {
+			metrics = append(metrics, hm...)
+		}
+	} else {
+		metrics = append(metrics, myState(ctx, client))
+		if rm := replSetMetrics(m); rm != nil {
+			metrics = append(metrics, rm...)
+		}
 	}
 
 	if opLogMetrics, err := oplogStatus(ctx, client); err != nil {
@@ -889,17 +904,11 @@ func serverVersion(bi buildInfo) prometheus.Metric { //nolint:ireturn
 }
 
 func myState(ctx context.Context, client *mongo.Client) prometheus.Metric {
-	state, err := util.MyState(ctx, client)
+	id, state, err := util.MyState(ctx, client)
 	if err != nil {
 		state = UnknownState
 	}
 
-	var id string
-	rs, err := util.ReplicasetConfig(ctx, client)
-	if err == nil {
-		id = rs.Config.ID
-	}
-
 	name := "mongodb_mongod_replset_my_state"
 	help := "An integer between 0 and 10 that represents the replica state of the current member"
 
@@ -911,6 +920,38 @@ func myState(ctx context.Context, client *mongo.Client) prometheus.Metric {
 	return metric
 }
 
+// myRole returns metrics based on the role of the mongo instance.
+func myRole(ctx context.Context, client *mongo.Client, l *logrus.Logger) []prometheus.Metric {
+	response, err := util.MyRole(ctx, client)
+	if err != nil {
+		l.Errorf("cannot get role of the running instance: %s", err)
+		return nil
+	}
+
+	var metrics []prometheus.Metric
+	if response.ArbiterOnly {
+		createMetric := func(name, help string, value float64, labels map[string]string) {
+			const prefix = "mongodb_mongod_replset_"
+			d := prometheus.NewDesc(prefix+name, help, nil, labels)
+			metrics = append(metrics, prometheus.MustNewConstMetric(d, prometheus.GaugeValue, value))
+		}
+
+		createMetric("my_state",
+			"An integer between 0 and 10 that represents the replica state of the current member",
+			float64(ArbiterState), map[string]string{
+				"set": response.SetName,
+			})
+
+		createMetric("number_of_members",
+			"The number of replica set members.",
+			float64(len(response.Hosts)+len(response.Arbiters)), map[string]string{
+				"set": response.SetName,
+			})
+	}
+
+	return metrics
+}
+
 func oplogStatus(ctx context.Context, client *mongo.Client) ([]prometheus.Metric, error) {
 	oplogRS := client.Database("local").Collection("oplog.rs")
 	type oplogRSResult struct {
diff --git a/exporter/v1_compatibility_test.go b/exporter/v1_compatibility_test.go
index 6dcbff713..752e63663 100644
--- a/exporter/v1_compatibility_test.go
+++ b/exporter/v1_compatibility_test.go
@@ -29,6 +29,7 @@ import (
 	dto "github.com/prometheus/client_model/go"
 	"github.com/sirupsen/logrus"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	"go.mongodb.org/mongo-driver/bson"
 
 	"github.com/percona/mongodb_exporter/internal/tu"
@@ -162,7 +163,7 @@ func TestSumMetrics(t *testing.T) {
 	for _, tt := range tests {
 		testCase := tt
 
-		t.Run(tt.name, func(t *testing.T) {
+		t.Run(testCase.name, func(t *testing.T) {
 			buf, err := os.ReadFile(filepath.Join("testdata/", "get_diagnostic_data.json"))
 			assert.NoError(t, err)
 
@@ -208,23 +209,84 @@ func TestCreateOldMetricFromNew(t *testing.T) {
 // myState should always return a metric. If there is no connection, the value
 // should be the MongoDB unknown state = 6
 func TestMyState(t *testing.T) {
-	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
-	defer cancel()
+	t.Parallel()
+	tests := []struct {
+		name          string
+		containerName string
+		allowedStates []float64
+	}{
+		{
+			name:          "correctly gets state for data-carrying node",
+			containerName: "mongo-1-1",
+			allowedStates: []float64{float64(PrimaryState), float64(SecondaryState)},
+		},
+		{
+			name:          "correctly gets state for arbiter node",
+			containerName: "mongo-1-arbiter",
+			allowedStates: []float64{float64(ArbiterState)},
+		},
+		{
+			name:          "gets unknown state for standalone instance",
+			containerName: "standalone",
+			allowedStates: []float64{float64(UnknownState)},
+		},
+	}
 
-	client := tu.DefaultTestClient(ctx, t)
+	for _, tt := range tests {
+		testCase := tt
+		t.Run(testCase.name, func(t *testing.T) {
+			t.Parallel()
+			ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+			defer cancel()
+
+			port, err := tu.PortForContainer(testCase.containerName)
+			require.NoError(t, err)
+			client := tu.TestClient(ctx, port, t)
+			var m dto.Metric
+
+			metric := myState(ctx, client)
+			err = metric.Write(&m)
+			assert.NoError(t, err)
+			assert.Contains(t, testCase.allowedStates, *m.Gauge.Value)
 
-	var m dto.Metric
+			err = client.Disconnect(ctx)
+			assert.NoError(t, err)
 
-	metric := myState(ctx, client)
-	err := metric.Write(&m)
-	assert.NoError(t, err)
-	assert.NotEqual(t, float64(UnknownState), *m.Gauge.Value)
+			metric = myState(ctx, client)
+			err = metric.Write(&m)
+			assert.NoError(t, err)
+			assert.Equal(t, float64(UnknownState), *m.Gauge.Value)
+		})
+	}
+}
 
-	err = client.Disconnect(ctx)
-	assert.NoError(t, err)
+func TestMyRole(t *testing.T) {
+	t.Parallel()
+	t.Run("correctly gets member count from arbiter node", func(t *testing.T) {
+		t.Parallel()
+		containerName := "mongo-1-arbiter"
+
+		logger := logrus.New()
+		ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+		defer cancel()
+
+		port, err := tu.PortForContainer(containerName)
+		require.NoError(t, err)
+		client := tu.TestClient(ctx, port, t)
+		metrics := myRole(ctx, client, logger)
+		var rsMembers dto.Metric
+		for _, m := range metrics {
+			if strings.HasPrefix(m.Desc().String(), `Desc{fqName: "mongodb_mongod_replset_number_of_members"`) {
+				err = m.Write(&rsMembers)
+				assert.NoError(t, err)
+
+				break
+			}
+		}
+		assert.NoError(t, err)
+		assert.Equal(t, float64(4), *rsMembers.Gauge.Value)
 
-	metric = myState(ctx, client)
-	err = metric.Write(&m)
-	assert.NoError(t, err)
-	assert.Equal(t, float64(UnknownState), *m.Gauge.Value)
+		err = client.Disconnect(ctx)
+		assert.NoError(t, err)
+	})
 }
diff --git a/internal/proto/replstatus.go b/internal/proto/replstatus.go
index 602d8a3fa..0e46b7cc6 100644
--- a/internal/proto/replstatus.go
+++ b/internal/proto/replstatus.go
@@ -136,11 +136,17 @@ type ShardIdentity struct {
 	ConfigsvrConnectionString string             `bson:"configsvrConnectionString"`
 }
 
-// MyState is a subset of getDiagnosticData result used to tag metrics in the MongoDB exporter
-type MyState struct {
-	Data struct {
-		ReplicasetGetStatus struct {
-			MyState int `bson:"myState"`
-		} `bson:"replSetGetStatus"`
-	} `bson:"data"`
+// HelloResponse represents the response from a Mongo `hello` command.
+type HelloResponse struct {
+	ArbiterOnly bool     `bson:"arbiterOnly"`
+	Arbiters    []string `bson:"arbiters"`
+	Hosts       []string `bson:"hosts"`
+	IsMaster    bool     `bson:"ismaster"`
+	Me          string   `bson:"me"`
+	Ok          int      `bson:"ok"`
+	Primary     string   `bson:"primary"`
+	ReadOnly    bool     `bson:"readOnly"`
+	Secondary   bool     `bson:"secondary"`
+	SetName     string   `bson:"setName"`
+	SetVersion  int      `bson:"setVersion"`
 }
diff --git a/internal/tu/testutils.go b/internal/tu/testutils.go
index a93ccdfe1..a8f2466b4 100644
--- a/internal/tu/testutils.go
+++ b/internal/tu/testutils.go
@@ -71,10 +71,20 @@ func DefaultTestClient(ctx context.Context, t *testing.T) *mongo.Client {
 	return TestClient(ctx, port, t)
 }
 
-// GetImageNameForDefault returns image name and version of running
-// default test mongo container.
-func GetImageNameForDefault() (string, string, error) {
-	di, err := InspectContainer("mongo-1-1")
+// DefaultTestClientMongoS returns the mongos MongoDB connection used for tests. It is a direct
+// connection to the mongos server.
+func DefaultTestClientMongoS(ctx context.Context, t *testing.T) *mongo.Client {
+	t.Helper()
+
+	port, err := PortForContainer("mongos")
+	require.NoError(t, err)
+
+	return TestClient(ctx, port, t)
+}
+
+// GetImageNameForContainer returns image name and version of a running test container.
+func GetImageNameForContainer(containerName string) (string, string, error) {
+	di, err := InspectContainer(containerName)
 	if err != nil {
 		return "", "", errors.Wrapf(err, "cannot get error for container %q", "mongo-1-1")
 	}
diff --git a/internal/util/util.go b/internal/util/util.go
index cc3f7a5bc..bebf5ee18 100644
--- a/internal/util/util.go
+++ b/internal/util/util.go
@@ -31,15 +31,27 @@ const (
 	ErrNotPrimaryOrSecondary = int32(13436)
 )
 
-func MyState(ctx context.Context, client *mongo.Client) (int, error) {
-	var ms proto.MyState
+// MyState returns the replica set and the instance's state if available.
+func MyState(ctx context.Context, client *mongo.Client) (string, int, error) {
+	var status proto.ReplicaSetStatus
 
-	err := client.Database("admin").RunCommand(ctx, bson.M{"getDiagnosticData": 1}).Decode(&ms)
+	err := client.Database("admin").RunCommand(ctx, bson.M{"replSetGetStatus": 1}).Decode(&status)
 	if err != nil {
-		return 0, err
+		return "", 0, err
 	}
 
-	return ms.Data.ReplicasetGetStatus.MyState, nil
+	return status.Set, int(status.MyState), nil
+}
+
+// MyRole returns the role of the mongo instance.
+func MyRole(ctx context.Context, client *mongo.Client) (*proto.HelloResponse, error) {
+	var role proto.HelloResponse
+	err := client.Database("admin").RunCommand(ctx, bson.M{"isMaster": 1}).Decode(&role)
+	if err != nil {
+		return nil, err
+	}
+
+	return &role, nil
 }
 
 func ReplicasetConfig(ctx context.Context, client *mongo.Client) (*proto.ReplicasetConfig, error) {
diff --git a/main.go b/main.go
index 260c1e809..d0819a7f3 100644
--- a/main.go
+++ b/main.go
@@ -57,6 +57,7 @@ type GlobalFlags struct {
 	EnableIndexStats         bool `name:"collector.indexstats" help:"Enable collecting metrics from $indexStats"`
 	EnableCollStats          bool `name:"collector.collstats" help:"Enable collecting metrics from $collStats"`
 	EnableProfile            bool `name:"collector.profile" help:"Enable collecting metrics from profile"`
+	EnableShards             bool `help:"Enable collecting metrics from sharded Mongo clusters about chunks" name:"collector.shards"`
 
 	EnableOverrideDescendingIndex bool `name:"metrics.overridedescendingindex" help:"Enable descending index name override to replace -1 with _DESC"`
 
@@ -152,6 +153,7 @@ func buildExporter(opts GlobalFlags, uri string, log *logrus.Logger) *exporter.E
 		EnableIndexStats:         opts.EnableIndexStats,
 		EnableCollStats:          opts.EnableCollStats,
 		EnableProfile:            opts.EnableProfile,
+		EnableShards:             opts.EnableShards,
 
 		EnableOverrideDescendingIndex: opts.EnableOverrideDescendingIndex,