sql: prep migration of sql_perf logging channels

In v26.1, sql perf events will be moved from the SQL_PERF and
SQL_INTERNAL_PERF logging channel to the SQL_EXEC logging
channel.

This commit gates this migration under the cluster setting:
`log.channel_compatibility_mode.enabled` and will log these events
to the SQL_EXEC channel if this setting is set to false. Users can
set this setting to false in their clusters to validate, test, and
identify potential downstream impacts to their logging setups and
pipelines.

Epic: CRDB-53410
Part of: CRDB-53412
Release note (ops change): sql perf events will be moved to the
SQL_EXEC channel in 26.1. In order to test the impact of these
changes, users can set the setting:
`log.channel_compatibility_mode.enabled` to false. Note that this
will cause these logs to start logging in the SQL_EXEC channel so
this shouldn't be tested in a production environment.

Author: kyle-a-wong

docs/generated/eventlog.md

@@ -2771,6 +2771,11 @@ Note: these events are not written to `system.eventlog`, even
 when the cluster setting `system.eventlog.enabled` is set. They
 are only emitted via external logging.
 
+In version 26.1, these events will be moved to the `SQL_EXEC` channel.
+To test compatability before this, set the cluster setting
+`log.channel_compatibility_mode.enabled` to false. This will send the
+events to `SQL_EXEC` instead of `SQL_PERF`.
+
 Events in this category are logged to the `SQL_PERF` channel.
 
 
@@ -2901,6 +2906,11 @@ Note: these events are not written to `system.eventlog`, even
 when the cluster setting `system.eventlog.enabled` is set. They
 are only emitted via external logging.
 
+In version 26.1, these events will be moved to the `SQL_EXEC` channel.
+To test compatability before this, set the cluster setting
+`log.channel_compatibility_mode.enabled` to false. This will send the
+events to `SQL_EXEC` instead of `SQL_INTERNAL_PERF`.
+
 Events in this category are logged to the `SQL_INTERNAL_PERF` channel.
 
 

pkg/sql/conn_executor_exec.go

@@ -3345,7 +3345,10 @@ func (ex *connExecutor) handleTxnRowsGuardrails(
 					CommonTxnRowsLimitDetails: commonTxnRowsLimitDetails,
 				}
 			}
-			log.StructuredEvent(ctx, severity.INFO, event)
+			migrator := log.NewStructuredEventMigrator(func() bool {
+				return log.ShouldMigrateEvent(ex.planner.ExecCfg().SV())
+			}, logpb.Channel_SQL_EXEC)
+			migrator.StructuredEvent(ctx, severity.INFO, event)
 			logCounter.Inc(1)
 		}
 	}

pkg/sql/event_log.go

@@ -165,6 +165,11 @@ func (p *planner) getCommonSQLEventDetails() eventpb.CommonSQLEventDetails {
 		User:            p.SessionData().SessionUser().Normalized(),
 		ApplicationName: p.SessionData().ApplicationName,
 	}
+	txn := p.InternalSQLTxn()
+	if txn != nil {
+		commonSQLEventDetails.TxnReadTimestamp = txn.KV().ReadTimestamp().WallTime
+	}
+
 	if pls := p.extendedEvalCtx.Context.Placeholders.Values; len(pls) > 0 {
 		commonSQLEventDetails.PlaceholderValues = make([]string, len(pls))
 		for idx, val := range pls {
@@ -274,10 +279,6 @@ func logEventInternalForSQLStatements(
 		// Overwrite with the common details.
 		*m = commonSQLEventDetails
 
-		if txn != nil {
-			m.TxnReadTimestamp = txn.KV().ReadTimestamp().WallTime
-		}
-
 		// If the common details didn't have a descriptor ID, keep the
 		// one that was in the event already.
 		if m.DescriptorID == 0 {

pkg/sql/event_log_test.go

@@ -251,15 +251,27 @@ func (p *planner) maybeLogStatementInternal(
 	(slowLogFullTableScans && (execDetails.FullTableScan || execDetails.FullIndexScan)) ||
 		// Is the query actually slow?
 		queryDuration > slowLogThreshold) {
+		commonSQLEventDetails := p.getCommonSQLEventDetails()
+		migrator := log.NewStructuredEventMigrator(func() bool {
+			return !log.ChannelCompatibilityModeEnabled.Get(p.ExecCfg().SV())
+		}, logpb.Channel_SQL_EXEC)
 		switch {
 		case execType == executorTypeExec:
 			// Non-internal queries are always logged to the slow query log.
-			p.logEventsOnlyExternally(ctx, &eventpb.SlowQuery{CommonSQLExecDetails: execDetails})
-
+			event := &eventpb.SlowQuery{
+				CommonSQLEventDetails: commonSQLEventDetails,
+				CommonSQLExecDetails:  execDetails,
+			}
+			migrator.StructuredEvent(ctx, severity.INFO, event)
 		case execType == executorTypeInternal && slowInternalQueryLogEnabled:
 			// Internal queries that surpass the slow query log threshold should only
 			// be logged to the slow-internal-only log if the cluster setting dictates.
-			p.logEventsOnlyExternally(ctx, &eventpb.SlowQueryInternal{CommonSQLExecDetails: execDetails})
+			event := &eventpb.SlowQueryInternal{
+				CommonSQLEventDetails: commonSQLEventDetails,
+				CommonSQLExecDetails:  execDetails,
+			}
+			migrator.StructuredEvent(ctx, severity.INFO,
+				event)
 		}
 	}
 

pkg/sql/exec_log.go

@@ -113,6 +113,7 @@ type RowHelper struct {
 	// Used to check row size.
 	maxRowSizeLog, maxRowSizeErr uint32
 	metrics                      *rowinfra.Metrics
+	migrateLargeRowLog           bool
 }
 
 func NewRowHelper(
@@ -134,6 +135,7 @@ func NewRowHelper(
 		Indexes:                    indexes,
 		UniqueWithTombstoneIndexes: uniqueWithTombstoneIndexesSet,
 		sd:                         sd,
+		migrateLargeRowLog:         log.ShouldMigrateEvent(sv),
 		metrics:                    metrics,
 		maxRowSizeLog:              uint32(maxRowSizeLog.Get(sv)),
 		maxRowSizeErr:              uint32(maxRowSizeErr.Get(sv)),
@@ -473,7 +475,10 @@ func (rh *RowHelper) CheckRowSize(
 		} else {
 			event = &eventpb.LargeRow{CommonLargeRowDetails: details}
 		}
-		log.StructuredEvent(ctx, severity.INFO, event)
+		migrator := log.NewStructuredEventMigrator(func() bool {
+			return rh.migrateLargeRowLog
+		}, logpb.Channel_SQL_EXEC)
+		migrator.StructuredEvent(ctx, severity.INFO, event)
 	}
 	if shouldErr {
 		if rh.metrics != nil {

pkg/sql/row/helper.go

@@ -86,6 +86,10 @@ message RoleBasedAuditEvent {
   string role = 4 [(gogoproto.jsontag) = ",omitempty"];
 }
 
+// TODO (#151948): Update channel from SQL_PERF to SQL_EXEC once the
+// `log.channel_compatibility_mode.enabled` cluster setting is set to false
+// by default and cluster setting is set for removal.
+
 // Category: SQL Slow Query Log
 // Channel: SQL_PERF
 //
@@ -95,6 +99,10 @@ message RoleBasedAuditEvent {
 // when the cluster setting `system.eventlog.enabled` is set. They
 // are only emitted via external logging.
 //
+// In version 26.1, these events will be moved to the `SQL_EXEC` channel.
+// To test compatability before this, set the cluster setting
+// `log.channel_compatibility_mode.enabled` to false. This will send the
+// events to `SQL_EXEC` instead of `SQL_PERF`.
 
 // SlowQuery is recorded when a query triggers the "slow query" condition.
 //
@@ -163,6 +171,10 @@ message TxnRowsReadLimit {
   CommonTxnRowsLimitDetails info = 3 [(gogoproto.nullable) = false, (gogoproto.jsontag) = "", (gogoproto.embed) = true];
 }
 
+// TODO (#151948): Update channel from SQL_INTERNAL_PERF to SQL_EXEC once the
+// `log.channel_compatibility_mode.enabled` cluster setting is set to false
+// by default and cluster setting is set for removal.
+
 // Category: SQL Slow Query Log (Internal)
 // Channel: SQL_INTERNAL_PERF
 //
@@ -173,6 +185,11 @@ message TxnRowsReadLimit {
 // Note: these events are not written to `system.eventlog`, even
 // when the cluster setting `system.eventlog.enabled` is set. They
 // are only emitted via external logging.
+//
+// In version 26.1, these events will be moved to the `SQL_EXEC` channel.
+// To test compatability before this, set the cluster setting
+// `log.channel_compatibility_mode.enabled` to false. This will send the
+// events to `SQL_EXEC` instead of `SQL_INTERNAL_PERF`.
 
 // SlowQueryInternal is recorded when a query triggers the "slow query" condition,
 // and the cluster setting `sql.log.slow_query.internal_queries.enabled` is