Function NewStoreReconciler

enterprise/coderd/prebuilds/reconcile.go:93–147

(store database.Store,
	ps pubsub.Pubsub,
	fileCache *files.Cache,
	cfg codersdk.PrebuildsConfig,
	logger slog.Logger,
	clock quartz.Clock,
	registerer prometheus.Registerer,
	notifEnq notifications.Enqueuer,
	buildUsageChecker *atomic.Pointer[wsbuilder.UsageChecker],
	tracerProvider trace.TracerProvider,
	maxDBConnections int,
	workspaceBuilderMetrics *wsbuilder.Metrics,
)

}

func NewStoreReconciler(store database.Store,
	ps pubsub.Pubsub,
	fileCache *files.Cache,
	cfg codersdk.PrebuildsConfig,
	logger slog.Logger,
	clock quartz.Clock,
	registerer prometheus.Registerer,
	notifEnq notifications.Enqueuer,
	buildUsageChecker *atomic.Pointer[wsbuilder.UsageChecker],
	tracerProvider trace.TracerProvider,
	maxDBConnections int,
	workspaceBuilderMetrics *wsbuilder.Metrics,
) *StoreReconciler {
	reconciliationConcurrency := calculateReconciliationConcurrency(maxDBConnections)

	logger.Debug(context.Background(), "reconciler initialized",
		slog.F("reconciliation_concurrency", reconciliationConcurrency),
		slog.F("max_db_connections", maxDBConnections))

	reconciler := &StoreReconciler{
		store:                     store,
		pubsub:                    ps,
		fileCache:                 fileCache,
		logger:                    logger,
		cfg:                       cfg,
		clock:                     clock,
		registerer:                registerer,
		notifEnq:                  notifEnq,
		buildUsageChecker:         buildUsageChecker,
		tracer:                    tracerProvider.Tracer(tracing.TracerName),
		done:                      make(chan struct{}, 1),
		provisionNotifyCh:         make(chan database.ProvisionerJob, 10),
		reconciliationConcurrency: reconciliationConcurrency,
		workspaceBuilderMetrics:   workspaceBuilderMetrics,
	}

	if registerer != nil {
		reconciler.metrics = NewMetricsCollector(store, logger, reconciler)
		if err := registerer.Register(reconciler.metrics); err != nil {
			// If the registerer fails to register the metrics collector, it's not fatal.
			logger.Error(context.Background(), "failed to register prometheus metrics", slog.Error(err))
		}

		factory := promauto.With(registerer)
		reconciler.reconciliationDuration = factory.NewHistogram(prometheus.HistogramOpts{
			Namespace: "coderd",
			Subsystem: "prebuilds",
			Name:      "reconciliation_duration_seconds",
			Help:      "Duration of each prebuilds reconciliation cycle.",
			Buckets:   prometheus.DefBuckets,
		})
	}

	return reconciler
}

// calculateReconciliationConcurrency determines the number of concurrent
// goroutines for preset reconciliation. Each preset may perform multiple