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

internal/eventstore/handler/handler_projection.go

@@ -10,6 +10,7 @@ import (
 
 	"github.com/zitadel/zitadel/internal/api/authz"
 	"github.com/zitadel/zitadel/internal/eventstore"
+	"github.com/zitadel/zitadel/internal/repository/pseudo"
 )
 
 const (
@@ -49,19 +50,20 @@ type NowFunc func() time.Time
 
 type ProjectionHandler struct {
 	Handler
-	ProjectionName        string
-	reduce                Reduce
-	update                Update
-	searchQuery           SearchQuery
-	triggerProjection     *time.Timer
-	lock                  Lock
-	unlock                Unlock
-	requeueAfter          time.Duration
-	retryFailedAfter      time.Duration
-	retries               int
-	concurrentInstances   int
-	handleActiveInstances time.Duration
-	nowFunc               NowFunc
+	ProjectionName             string
+	reduce                     Reduce
+	update                     Update
+	searchQuery                SearchQuery
+	triggerProjection          *time.Timer
+	lock                       Lock
+	unlock                     Unlock
+	requeueAfter               time.Duration
+	retryFailedAfter           time.Duration
+	retries                    int
+	concurrentInstances        int
+	handleActiveInstances      time.Duration
+	nowFunc                    NowFunc
+	reduceScheduledPseudoEvent bool
 }
 
 func NewProjectionHandler(
@@ -73,32 +75,35 @@ func NewProjectionHandler(
 	lock Lock,
 	unlock Unlock,
 	initialized <-chan bool,
+	reduceScheduledPseudoEvent bool,
 ) *ProjectionHandler {
 	concurrentInstances := int(config.ConcurrentInstances)
 	if concurrentInstances < 1 {
 		concurrentInstances = 1
 	}
 	h := &ProjectionHandler{
-		Handler:               NewHandler(config.HandlerConfig),
-		ProjectionName:        config.ProjectionName,
-		reduce:                reduce,
-		update:                update,
-		searchQuery:           query,
-		lock:                  lock,
-		unlock:                unlock,
-		requeueAfter:          config.RequeueEvery,
-		triggerProjection:     time.NewTimer(0), // first trigger is instant on startup
-		retryFailedAfter:      config.RetryFailedAfter,
-		retries:               int(config.Retries),
-		concurrentInstances:   concurrentInstances,
-		handleActiveInstances: config.HandleActiveInstances,
-		nowFunc:               time.Now,
+		Handler:                    NewHandler(config.HandlerConfig),
+		ProjectionName:             config.ProjectionName,
+		reduce:                     reduce,
+		update:                     update,
+		searchQuery:                query,
+		lock:                       lock,
+		unlock:                     unlock,
+		requeueAfter:               config.RequeueEvery,
+		triggerProjection:          time.NewTimer(0), // first trigger is instant on startup
+		retryFailedAfter:           config.RetryFailedAfter,
+		retries:                    int(config.Retries),
+		concurrentInstances:        concurrentInstances,
+		handleActiveInstances:      config.HandleActiveInstances,
+		nowFunc:                    time.Now,
+		reduceScheduledPseudoEvent: reduceScheduledPseudoEvent,
 	}
 
 	go func() {
 		<-initialized
-		go h.subscribe(ctx)
-
+		if !h.reduceScheduledPseudoEvent {
+			go h.subscribe(ctx)
+		}
 		go h.schedule(ctx)
 	}()
 
@@ -158,6 +163,13 @@ func (h *ProjectionHandler) Process(ctx context.Context, events ...eventstore.Ev
 
 // FetchEvents checks the current sequences and filters for newer events
 func (h *ProjectionHandler) FetchEvents(ctx context.Context, instances ...string) ([]eventstore.Event, bool, error) {
+	if h.reduceScheduledPseudoEvent {
+		return h.fetchPseudoEvents(ctx, instances...)
+	}
+	return h.fetchDBEvents(ctx, instances...)
+}
+
+func (h *ProjectionHandler) fetchDBEvents(ctx context.Context, instances ...string) ([]eventstore.Event, bool, error) {
 	eventQuery, eventsLimit, err := h.searchQuery(ctx, instances)
 	if err != nil {
 		return nil, false, err
@@ -169,6 +181,10 @@ func (h *ProjectionHandler) FetchEvents(ctx context.Context, instances ...string
 	return events, int(eventsLimit) == len(events), err
 }
 
+func (h *ProjectionHandler) fetchPseudoEvents(ctx context.Context, instances ...string) ([]eventstore.Event, bool, error) {
+	return []eventstore.Event{pseudo.NewScheduledEvent(ctx, time.Now(), instances...)}, false, nil
+}
+
 func (h *ProjectionHandler) subscribe(ctx context.Context) {
 	ctx, cancel := context.WithCancel(ctx)
 	defer func() {