PMM-12805 Collstats, indexstats iterate only over collections, not views.

exporter/collstats_collector.go

@@ -77,7 +77,14 @@ func (d *collstatsCollector) collect(ch chan<- prometheus.Metric) {
 		collections = fromMapToSlice(namespaces)
 	}
 
-	for _, dbCollection := range collections {
+	onlyCollections, err := filterCollectionsWithoutViews(d.ctx, client, collections)
+	if err != nil {
+		logger.Errorf("cannot list collections: %s", err.Error())
+
+		return
+	}
+
+	for _, dbCollection := range onlyCollections {
 		parts := strings.Split(dbCollection, ".")
 		if len(parts) < 2 { //nolint:gomnd
 			continue

exporter/common.go

@@ -17,6 +17,7 @@
 
 import (
 	"context"
+	"fmt"
 	"sort"
 	"strings"
 
@@ -153,6 +154,58 @@
 	return list
 }
 
+func listCollectionsWithoutViews(ctx context.Context, client *mongo.Client) ([]string, error) {
+	dbs, err := databases(ctx, client, nil, nil)
+	if err != nil {
+		return nil, errors.Wrap(err, "cannot make the list of databases to list all collections")
+	}
+
+	var res []string
+	for _, db := range dbs {
+		if db == "" {
+			continue
+		}
+
+		collections, err := client.Database(db).ListCollectionNames(ctx, bson.M{"type": "collection"})
+		if err != nil {
+			return nil, errors.Wrap(err, fmt.Sprintf("cannot get the list of collections from database %s", db))
+		}
+		for _, collection := range collections {
+			res = append(res, fmt.Sprintf("%s.%s", db, collection))
+		}
+	}
+
+	return res, nil
+}
+
+func isInArray(array []string, item string) bool {
+	for _, i := range array {
+		if item == i {
+			return true
+		}
+	}
+
+	return false
+}
+
+func filterCollectionsWithoutViews(ctx context.Context, client *mongo.Client, collections []string) ([]string, error) {
+	var filteredCollections []string
+	onlyCollections, err := listCollectionsWithoutViews(ctx, client)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, collection := range collections {
+		if !isInArray(onlyCollections, collection) {
+			continue
+		}
+
+		filteredCollections = append(filteredCollections, collection)
+	}
+
+	return filteredCollections, nil
+}
+
 func listAllCollections(ctx context.Context, client *mongo.Client, filterInNamespaces []string, excludeDBs []string) (map[string][]string, error) {
 	namespaces := make(map[string][]string)
 

exporter/common_test.go

@@ -32,6 +32,7 @@
 var (
 	testDBs   = []string{"testdb01", "testdb02"}
 	testColls = []string{"col01", "col02", "colxx", "colyy"}
+	testViews = []string{"view01", "view02"}
 )
 
 func setupDB(ctx context.Context, t *testing.T, client *mongo.Client) {
@@ -45,6 +46,10 @@
 			}
 		}
 	}
+	for _, view := range testViews {
+		err := client.Database(testDBs[0]).CreateView(ctx, view, testColls[0], mongo.Pipeline{})
+		assert.NoError(t, err)
+	}
 }
 
 func cleanupDB(ctx context.Context, client *mongo.Client) {
@@ -115,7 +120,7 @@
 	t.Run("With namespaces list", func(t *testing.T) {
 		// Advanced filtering test
 		wantNS := map[string][]string{
-			"testdb01": {"col01", "col02", "colxx", "colyy"},
+			"testdb01": {"col01", "col02", "colxx", "colyy", "system.views", "view01", "view02"},
 			"testdb02": {"col01", "col02"},
 		}
 		// List all collections in testdb01 (inDBs[0]) but only col01 and col02 from testdb02.
@@ -127,18 +132,27 @@
 
 	t.Run("Empty namespaces list", func(t *testing.T) {
 		wantNS := map[string][]string{
-			"testdb01": {"col01", "col02", "colxx", "colyy"},
+			"testdb01": {"col01", "col02", "colxx", "colyy", "system.views", "view01", "view02"},
 			"testdb02": {"col01", "col02", "colxx", "colyy"},
 		}
 		namespaces, err := listAllCollections(ctx, client, nil, systemDBs)
 		assert.NoError(t, err)
 		assert.Equal(t, wantNS, namespaces)
 	})
 
+	t.Run("Collections without views", func(t *testing.T) {
+		expected := []string{"testdb01.system.views", "testdb01.col01", "testdb01.colxx", "testdb01.colyy", "testdb02.colxx", "testdb02.colyy", "testdb02.col02", "testdb02.col01"}
+		collections, err := listCollectionsWithoutViews(ctx, client)
+		assert.NoError(t, err)
+		for _, expectedCollection := range expected {
+			assert.Contains(t, collections, expectedCollection)
+		}
+	})
+
 	t.Run("Count basic", func(t *testing.T) {
 		count, err := nonSystemCollectionsCount(ctx, client, nil, nil)
 		assert.NoError(t, err)
-		assert.Equal(t, 8, count)
+		assert.Equal(t, 11, count)
 	})
 
 	t.Run("Filtered count", func(t *testing.T) {
@@ -172,3 +186,18 @@
 		assert.Equal(t, tc.wantCollection, coll)
 	}
 }
+
+func TestFilterCollectionsWithoutViews(t *testing.T) {
+	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+	defer cancel()
+
+	client := tu.DefaultTestClient(ctx, t)
+
+	setupDB(ctx, t, client)
+	defer cleanupDB(ctx, client)
+
+	expected := []string{"testdb01.col01", "testdb01.system.views"}
+	filtered, err := filterCollectionsWithoutViews(ctx, client, []string{"testdb01.col01", "testdb01.system.views", "testdb01.view01"})
+	assert.NoError(t, err)
+	assert.Equal(t, expected, filtered)
+}