*: add telemetry support for IndexMerge (#39469)

close #39475

executor/adapter.go

@@ -198,6 +198,7 @@ type TelemetryInfo struct {
 	UseFlashbackToCluster bool
 	PartitionTelemetry    *PartitionTelemetryInfo
 	AccountLockTelemetry  *AccountLockTelemetryInfo
+	UseIndexMerge         bool
 }
 
 // PartitionTelemetryInfo records table partition telemetry information during execution.

executor/builder.go

@@ -3977,6 +3977,9 @@ func buildNoRangeIndexMergeReader(b *executorBuilder, v *plannercore.PhysicalInd
 }
 
 func (b *executorBuilder) buildIndexMergeReader(v *plannercore.PhysicalIndexMergeReader) Executor {
+	if b.Ti != nil {
+		b.Ti.UseIndexMerge = true
+	}
 	ts := v.TablePlans[0].(*plannercore.PhysicalTableScan)
 	if err := b.validCanReadTemporaryOrCacheTable(ts.Table); err != nil {
 		b.err = err

metrics/telemetry.go

@@ -155,6 +155,13 @@ var (
 			Name:      "flashback_cluster_usage",
 			Help:      "Counter of usage of flashback cluster",
 		})
+	TelemetryIndexMergeUsage = prometheus.NewCounter(
+		prometheus.CounterOpts{
+			Namespace: "tidb",
+			Subsystem: "telemetry",
+			Name:      "index_merge_usage",
+			Help:      "Counter of usage of index merge",
+		})
 	TelemetryCompactPartitionCnt = prometheus.NewCounter(
 		prometheus.CounterOpts{
 			Namespace: "tidb",
@@ -396,3 +403,22 @@ func GetDDLUsageCounter() DDLUsageCounter {
 		FlashbackClusterUsed: readCounter(TelemetryFlashbackClusterCnt),
 	}
 }
+
+// IndexMergeUsageCounter records the usages of IndexMerge feature.
+type IndexMergeUsageCounter struct {
+	IndexMergeUsed int64 `json:"index_merge_used"`
+}
+
+// Sub returns the difference of two counters.
+func (i IndexMergeUsageCounter) Sub(rhs IndexMergeUsageCounter) IndexMergeUsageCounter {
+	return IndexMergeUsageCounter{
+		IndexMergeUsed: i.IndexMergeUsed - rhs.IndexMergeUsed,
+	}
+}
+
+// GetIndexMergeCounter gets the IndexMerge usage counter.
+func GetIndexMergeCounter() IndexMergeUsageCounter {
+	return IndexMergeUsageCounter{
+		IndexMergeUsed: readCounter(TelemetryIndexMergeUsage),
+	}
+}

session/session.go

@@ -150,6 +150,8 @@ var (
 	telemetryLockUserUsage          = metrics.TelemetryAccountLockCnt.WithLabelValues("lockUser")
 	telemetryUnlockUserUsage        = metrics.TelemetryAccountLockCnt.WithLabelValues("unlockUser")
 	telemetryCreateOrAlterUserUsage = metrics.TelemetryAccountLockCnt.WithLabelValues("createOrAlterUser")
+
+	telemetryIndexMerge = metrics.TelemetryIndexMergeUsage
 )
 
 // Session context, it is consistent with the lifecycle of a client connection.
@@ -3588,6 +3590,10 @@ func (s *session) updateTelemetryMetric(es *executor.ExecStmt) {
 		telemetryCTEUsageNotCTE.Inc()
 	}
 
+	if ti.UseIndexMerge {
+		telemetryIndexMerge.Inc()
+	}
+
 	if ti.UseMultiSchemaChange {
 		telemetryMultiSchemaChangeUsage.Inc()
 	}

telemetry/data_feature_usage.go

@@ -58,6 +58,7 @@ type featureUsage struct {
 	DDLUsageCounter           *m.DDLUsageCounter               `json:"DDLUsageCounter"`
 	EnableGlobalMemoryControl bool                             `json:"enableGlobalMemoryControl"`
 	AutoIDNoCache             bool                             `json:"autoIDNoCache"`
+	IndexMergeUsageCounter    *m.IndexMergeUsageCounter        `json:"indexMergeUsageCounter"`
 }
 
 type placementPolicyUsage struct {
@@ -108,6 +109,8 @@ func getFeatureUsage(ctx context.Context, sctx sessionctx.Context) (*featureUsag
 
 	usage.EnableGlobalMemoryControl = getGlobalMemoryControl()
 
+	usage.IndexMergeUsageCounter = getIndexMergeUsageInfo()
+
 	return &usage, nil
 }
 
@@ -244,6 +247,7 @@ var initialTablePartitionCounter m.TablePartitionUsageCounter
 var initialSavepointStmtCounter int64
 var initialLazyPessimisticUniqueCheckSetCount int64
 var initialDDLUsageCounter m.DDLUsageCounter
+var initialIndexMergeCounter m.IndexMergeUsageCounter
 
 // getTxnUsageInfo gets the usage info of transaction related features. It's exported for tests.
 func getTxnUsageInfo(ctx sessionctx.Context) *TxnUsage {
@@ -402,3 +406,13 @@ func getDDLUsageInfo(ctx sessionctx.Context) *m.DDLUsageCounter {
 func getGlobalMemoryControl() bool {
 	return memory.ServerMemoryLimit.Load() > 0
 }
+
+func postReportIndexMergeUsage() {
+	initialIndexMergeCounter = m.GetIndexMergeCounter()
+}
+
+func getIndexMergeUsageInfo() *m.IndexMergeUsageCounter {
+	curr := m.GetIndexMergeCounter()
+	diff := curr.Sub(initialIndexMergeCounter)
+	return &diff
+}

telemetry/data_feature_usage_test.go

@@ -554,3 +554,32 @@ func TestGlobalMemoryControl(t *testing.T) {
 	require.NoError(t, err)
 	require.False(t, usage.EnableGlobalMemoryControl)
 }
+
+func TestIndexMergeUsage(t *testing.T) {
+	store := testkit.CreateMockStore(t)
+	tk := testkit.NewTestKit(t, store)
+
+	tk.MustExec("use test")
+	tk.MustExec("create table t1(c1 int, c2 int, index idx1(c1), index idx2(c2))")
+	res := tk.MustQuery("explain select /*+ use_index_merge(t1, idx1, idx2) */ * from t1 where c1 = 1 and c2 = 1").Rows()
+	require.Contains(t, res[0][0], "IndexMerge")
+
+	usage, err := telemetry.GetFeatureUsage(tk.Session())
+	require.NoError(t, err)
+	require.Equal(t, usage.IndexMergeUsageCounter.IndexMergeUsed, int64(0))
+
+	tk.MustExec("select /*+ use_index_merge(t1, idx1, idx2) */ * from t1 where c1 = 1 and c2 = 1")
+	usage, err = telemetry.GetFeatureUsage(tk.Session())
+	require.NoError(t, err)
+	require.Equal(t, int64(1), usage.IndexMergeUsageCounter.IndexMergeUsed)
+
+	tk.MustExec("select /*+ use_index_merge(t1, idx1, idx2) */ * from t1 where c1 = 1 or c2 = 1")
+	usage, err = telemetry.GetFeatureUsage(tk.Session())
+	require.NoError(t, err)
+	require.Equal(t, int64(2), usage.IndexMergeUsageCounter.IndexMergeUsed)
+
+	tk.MustExec("select /*+ no_index_merge() */ * from t1 where c1 = 1 or c2 = 1")
+	usage, err = telemetry.GetFeatureUsage(tk.Session())
+	require.NoError(t, err)
+	require.Equal(t, int64(2), usage.IndexMergeUsageCounter.IndexMergeUsed)
+}