feat: push telemetry (#6027)

* document analytics config * rework configuration and docs * describe HandleActiveInstances better * describe active instances on quotas better * only projected events are considered * cleanup * describe changes at runtime * push milestones * stop tracking events * calculate and push 4 in 6 milestones * reduce milestone pushed * remove docs * fix scheduled pseudo event projection * push 5 in 6 milestones * push 6 in 6 milestones * ignore client ids * fix text array contains * push human readable milestone type * statement unit tests * improve dev and db performance * organize imports * cleanup * organize imports * test projection * check rows.Err() * test search query * pass linting * review * test 4 milestones * simplify milestone by instance ids query * use type NamespacedCondition * cleanup * lint * lint * dont overwrite original error * no opt-in in examples * cleanup * prerelease * enable request headers * make limit configurable * review fixes * only requeue special handlers secondly * include integration tests * Revert "include integration tests" This reverts commit 96db9504ecdb4e73451f09554fd749cd7c27341f. * pass reducers * test handlers * fix unit test * feat: increment version * lint * remove prerelease * fix integration tests
2026-11-09 15:45:12 +00:00 · 2023-07-06 08:38:13 +02:00
parent fa93bb7e85
commit bb756482c7
53 changed files with 2214 additions and 231 deletions
@@ -11,6 +11,7 @@ import (
 	"github.com/zitadel/zitadel/internal/errors"
 	"github.com/zitadel/zitadel/internal/eventstore"
 	"github.com/zitadel/zitadel/internal/eventstore/handler"
+	"github.com/zitadel/zitadel/internal/repository/pseudo"
 )

 var (
@@ -49,6 +50,8 @@ type StatementHandler struct {
 	initialized chan bool

 	bulkLimit uint64
+
+	reduceScheduledPseudoEvent bool
 }

 func NewStatementHandler(
@@ -57,30 +60,40 @@ func NewStatementHandler(
 ) StatementHandler {
 	aggregateTypes := make([]eventstore.AggregateType, 0, len(config.Reducers))
 	reduces := make(map[eventstore.EventType]handler.Reduce, len(config.Reducers))
+	reduceScheduledPseudoEvent := false
 	for _, aggReducer := range config.Reducers {
 		aggregateTypes = append(aggregateTypes, aggReducer.Aggregate)
+		if aggReducer.Aggregate == pseudo.AggregateType {
+			reduceScheduledPseudoEvent = true
+			if len(config.Reducers) != 1 ||
+				len(aggReducer.EventRedusers) != 1 ||
+				aggReducer.EventRedusers[0].Event != pseudo.ScheduledEventType {
+				panic("if a pseudo.AggregateType is reduced, exactly one event reducer for pseudo.ScheduledEventType is supported and no other aggregate can be reduced")
+			}
+		}
 		for _, eventReducer := range aggReducer.EventRedusers {
 			reduces[eventReducer.Event] = eventReducer.Reduce
 		}
 	}

 	h := StatementHandler{
-		client:                  config.Client,
-		sequenceTable:           config.SequenceTable,
-		maxFailureCount:         config.MaxFailureCount,
-		currentSequenceStmt:     fmt.Sprintf(currentSequenceStmtFormat, config.SequenceTable),
-		updateSequencesBaseStmt: fmt.Sprintf(updateCurrentSequencesStmtFormat, config.SequenceTable),
-		failureCountStmt:        fmt.Sprintf(failureCountStmtFormat, config.FailedEventsTable),
-		setFailureCountStmt:     fmt.Sprintf(setFailureCountStmtFormat, config.FailedEventsTable),
-		aggregates:              aggregateTypes,
-		reduces:                 reduces,
-		bulkLimit:               config.BulkLimit,
-		Locker:                  NewLocker(config.Client.DB, config.LockTable, config.ProjectionName),
-		initCheck:               config.InitCheck,
-		initialized:             make(chan bool),
+		client:                     config.Client,
+		sequenceTable:              config.SequenceTable,
+		maxFailureCount:            config.MaxFailureCount,
+		currentSequenceStmt:        fmt.Sprintf(currentSequenceStmtFormat, config.SequenceTable),
+		updateSequencesBaseStmt:    fmt.Sprintf(updateCurrentSequencesStmtFormat, config.SequenceTable),
+		failureCountStmt:           fmt.Sprintf(failureCountStmtFormat, config.FailedEventsTable),
+		setFailureCountStmt:        fmt.Sprintf(setFailureCountStmtFormat, config.FailedEventsTable),
+		aggregates:                 aggregateTypes,
+		reduces:                    reduces,
+		bulkLimit:                  config.BulkLimit,
+		Locker:                     NewLocker(config.Client.DB, config.LockTable, config.ProjectionName),
+		initCheck:                  config.InitCheck,
+		initialized:                make(chan bool),
+		reduceScheduledPseudoEvent: reduceScheduledPseudoEvent,
 	}

-	h.ProjectionHandler = handler.NewProjectionHandler(ctx, config.ProjectionHandlerConfig, h.reduce, h.Update, h.SearchQuery, h.Lock, h.Unlock, h.initialized)
+	h.ProjectionHandler = handler.NewProjectionHandler(ctx, config.ProjectionHandlerConfig, h.reduce, h.Update, h.searchQuery, h.Lock, h.Unlock, h.initialized, reduceScheduledPseudoEvent)

 	return h
 }
@@ -88,10 +101,19 @@ func NewStatementHandler(
 func (h *StatementHandler) Start() {
 	h.initialized <- true
 	close(h.initialized)
-	h.Subscribe(h.aggregates...)
+	if !h.reduceScheduledPseudoEvent {
+		h.Subscribe(h.aggregates...)
+	}
 }

-func (h *StatementHandler) SearchQuery(ctx context.Context, instanceIDs []string) (*eventstore.SearchQueryBuilder, uint64, error) {
+func (h *StatementHandler) searchQuery(ctx context.Context, instanceIDs []string) (*eventstore.SearchQueryBuilder, uint64, error) {
+	if h.reduceScheduledPseudoEvent {
+		return nil, 1, nil
+	}
+	return h.dbSearchQuery(ctx, instanceIDs)
+}
+
+func (h *StatementHandler) dbSearchQuery(ctx context.Context, instanceIDs []string) (*eventstore.SearchQueryBuilder, uint64, error) {
 	sequences, err := h.currentSequences(ctx, h.client.QueryContext, instanceIDs)
 	if err != nil {
 		return nil, 0, err
@@ -115,7 +137,6 @@ func (h *StatementHandler) SearchQuery(ctx context.Context, instanceIDs []string
 				InstanceID(instanceID)
 		}
 	}
-
 	return queryBuilder, h.bulkLimit, nil
 }