Rename TenancyManager to tenancy.Manager

cmd/all-in-one/main.go

@@ -156,7 +156,7 @@ by default uses only in-memory database.`,
 				logger.Fatal("Failed to configure query service", zap.Error(err))
 			}
 
-			tm := tenancy.NewTenancyManager(&cOpts.GRPC.Tenancy)
+			tm := tenancy.NewManager(&cOpts.GRPC.Tenancy)
 
 			// collector
 			c := collectorApp.New(&collectorApp.CollectorParams{
@@ -269,7 +269,7 @@ func startQuery(
 	depReader dependencystore.Reader,
 	metricsQueryService querysvc.MetricsQueryService,
 	baseFactory metrics.Factory,
-	tm *tenancy.TenancyManager,
+	tm *tenancy.Manager,
 ) *queryApp.Server {
 	spanReader = storageMetrics.NewReadMetricsDecorator(spanReader, baseFactory.Namespace(metrics.NSOptions{Name: "query"}))
 	qs := querysvc.NewQueryService(spanReader, depReader, *queryOpts)

cmd/collector/app/collector.go

@@ -53,7 +53,7 @@ type Collector struct {
 	hCheck         *healthcheck.HealthCheck
 	spanProcessor  processor.SpanProcessor
 	spanHandlers   *SpanHandlers
-	tenancyMgr     *tenancy.TenancyManager
+	tenancyMgr     *tenancy.Manager
 
 	// state, read only
 	hServer                    *http.Server
@@ -74,7 +74,7 @@ type CollectorParams struct {
 	StrategyStore  strategystore.StrategyStore
 	Aggregator     strategystore.Aggregator
 	HealthCheck    *healthcheck.HealthCheck
-	TenancyMgr     *tenancy.TenancyManager
+	TenancyMgr     *tenancy.Manager
 }
 
 // New constructs a new collector component, ready to be started

cmd/collector/app/collector_test.go

@@ -54,7 +54,7 @@ func TestNewCollector(t *testing.T) {
 	baseMetrics := metricstest.NewFactory(time.Hour)
 	spanWriter := &fakeSpanWriter{}
 	strategyStore := &mockStrategyStore{}
-	tm := &tenancy.TenancyManager{}
+	tm := &tenancy.Manager{}
 
 	c := New(&CollectorParams{
 		ServiceName:    "collector",
@@ -80,7 +80,7 @@ func TestCollector_StartErrors(t *testing.T) {
 			baseMetrics := metricstest.NewFactory(time.Hour)
 			spanWriter := &fakeSpanWriter{}
 			strategyStore := &mockStrategyStore{}
-			tm := &tenancy.TenancyManager{}
+			tm := &tenancy.Manager{}
 
 			c := New(&CollectorParams{
 				ServiceName:    "collector",
@@ -135,7 +135,7 @@ func TestCollector_PublishOpts(t *testing.T) {
 	metricsFactory := fork.New("internal", forkFactory, baseMetrics)
 	spanWriter := &fakeSpanWriter{}
 	strategyStore := &mockStrategyStore{}
-	tm := &tenancy.TenancyManager{}
+	tm := &tenancy.Manager{}
 
 	c := New(&CollectorParams{
 		ServiceName:    "collector",
@@ -171,7 +171,7 @@ func TestAggregator(t *testing.T) {
 	spanWriter := &fakeSpanWriter{}
 	strategyStore := &mockStrategyStore{}
 	agg := &mockAggregator{}
-	tm := &tenancy.TenancyManager{}
+	tm := &tenancy.Manager{}
 
 	c := New(&CollectorParams{
 		ServiceName:    "collector",

cmd/collector/app/handler/grpc_handler.go

@@ -36,7 +36,7 @@ type GRPCHandler struct {
 }
 
 // NewGRPCHandler registers routes for this handler on the given router.
-func NewGRPCHandler(logger *zap.Logger, spanProcessor processor.SpanProcessor, tenancyMgr *tenancy.TenancyManager) *GRPCHandler {
+func NewGRPCHandler(logger *zap.Logger, spanProcessor processor.SpanProcessor, tenancyMgr *tenancy.Manager) *GRPCHandler {
 	return &GRPCHandler{
 		logger: logger,
 		batchConsumer: newBatchConsumer(logger,
@@ -58,10 +58,10 @@ type batchConsumer struct {
 	logger        *zap.Logger
 	spanProcessor processor.SpanProcessor
 	spanOptions   processor.SpansOptions
-	tenancyMgr    *tenancy.TenancyManager
+	tenancyMgr    *tenancy.Manager
 }
 
-func newBatchConsumer(logger *zap.Logger, spanProcessor processor.SpanProcessor, transport processor.InboundTransport, spanFormat processor.SpanFormat, tenancyMgr *tenancy.TenancyManager) batchConsumer {
+func newBatchConsumer(logger *zap.Logger, spanProcessor processor.SpanProcessor, transport processor.InboundTransport, spanFormat processor.SpanFormat, tenancyMgr *tenancy.Manager) batchConsumer {
 	return batchConsumer{
 		logger:        logger,
 		spanProcessor: spanProcessor,

cmd/collector/app/handler/grpc_handler_test.go

@@ -98,7 +98,7 @@ func newClient(t *testing.T, addr net.Addr) (api_v2.CollectorServiceClient, *grp
 func TestPostSpans(t *testing.T) {
 	processor := &mockSpanProcessor{}
 	server, addr := initializeGRPCTestServer(t, func(s *grpc.Server) {
-		handler := NewGRPCHandler(zap.NewNop(), processor, &tenancy.TenancyManager{})
+		handler := NewGRPCHandler(zap.NewNop(), processor, &tenancy.Manager{})
 		api_v2.RegisterCollectorServiceServer(s, handler)
 	})
 	defer server.Stop()
@@ -133,7 +133,7 @@ func TestPostSpans(t *testing.T) {
 func TestGRPCCompressionEnabled(t *testing.T) {
 	processor := &mockSpanProcessor{}
 	server, addr := initializeGRPCTestServer(t, func(s *grpc.Server) {
-		handler := NewGRPCHandler(zap.NewNop(), processor, &tenancy.TenancyManager{})
+		handler := NewGRPCHandler(zap.NewNop(), processor, &tenancy.Manager{})
 		api_v2.RegisterCollectorServiceServer(s, handler)
 	})
 	defer server.Stop()
@@ -171,7 +171,7 @@ func TestPostSpansWithError(t *testing.T) {
 			processor := &mockSpanProcessor{expectedError: test.processorError}
 			logger, logBuf := testutils.NewLogger()
 			server, addr := initializeGRPCTestServer(t, func(s *grpc.Server) {
-				handler := NewGRPCHandler(logger, processor, &tenancy.TenancyManager{})
+				handler := NewGRPCHandler(logger, processor, &tenancy.Manager{})
 				api_v2.RegisterCollectorServiceServer(s, handler)
 			})
 			defer server.Stop()
@@ -210,7 +210,7 @@ func TestPostTenantedSpans(t *testing.T) {
 	processor := &mockSpanProcessor{}
 	server, addr := initializeGRPCTestServer(t, func(s *grpc.Server) {
 		handler := NewGRPCHandler(zap.NewNop(), processor,
-			tenancy.NewTenancyManager(&tenancy.Options{
+			tenancy.NewManager(&tenancy.Options{
 				Enabled: true,
 				Header:  tenantHeader,
 				Tenants: []string{dummyTenant},
@@ -346,7 +346,7 @@ func TestGetTenant(t *testing.T) {
 
 	processor := &mockSpanProcessor{}
 	handler := NewGRPCHandler(zap.NewNop(), processor,
-		tenancy.NewTenancyManager(&tenancy.Options{
+		tenancy.NewManager(&tenancy.Options{
 			Enabled: true,
 			Header:  tenantHeader,
 			Tenants: validTenants,

cmd/collector/app/handler/otlp_receiver.go

@@ -40,7 +40,7 @@ import (
 var _ component.Host = (*otelHost)(nil) // API check
 
 // StartOTLPReceiver starts OpenTelemetry OTLP receiver listening on gRPC and HTTP ports.
-func StartOTLPReceiver(options *flags.CollectorOptions, logger *zap.Logger, spanProcessor processor.SpanProcessor, tm *tenancy.TenancyManager) (component.TracesReceiver, error) {
+func StartOTLPReceiver(options *flags.CollectorOptions, logger *zap.Logger, spanProcessor processor.SpanProcessor, tm *tenancy.Manager) (component.TracesReceiver, error) {
 	otlpFactory := otlpreceiver.NewFactory()
 	return startOTLPReceiver(
 		options,
@@ -60,7 +60,7 @@ func startOTLPReceiver(
 	options *flags.CollectorOptions,
 	logger *zap.Logger,
 	spanProcessor processor.SpanProcessor,
-	tm *tenancy.TenancyManager,
+	tm *tenancy.Manager,
 	// from here: params that can be mocked in tests
 	otlpFactory component.ReceiverFactory,
 	newTraces func(consume consumer.ConsumeTracesFunc, options ...consumer.Option) (consumer.Traces, error),
@@ -140,7 +140,7 @@ func applyTLSSettings(opts *tlscfg.Options) *configtls.TLSServerSetting {
 	}
 }
 
-func newConsumerDelegate(logger *zap.Logger, spanProcessor processor.SpanProcessor, tm *tenancy.TenancyManager) *consumerDelegate {
+func newConsumerDelegate(logger *zap.Logger, spanProcessor processor.SpanProcessor, tm *tenancy.Manager) *consumerDelegate {
 	return &consumerDelegate{
 		batchConsumer: newBatchConsumer(logger,
 			spanProcessor,

cmd/collector/app/handler/otlp_receiver_test.go

@@ -49,7 +49,7 @@ func optionsWithPorts(port string) *flags.CollectorOptions {
 func TestStartOtlpReceiver(t *testing.T) {
 	spanProcessor := &mockSpanProcessor{}
 	logger, _ := testutils.NewLogger()
-	tm := &tenancy.TenancyManager{}
+	tm := &tenancy.Manager{}
 	rec, err := StartOTLPReceiver(optionsWithPorts(":0"), logger, spanProcessor, tm)
 	require.NoError(t, err)
 	defer func() {
@@ -81,7 +81,7 @@ func TestConsumerDelegate(t *testing.T) {
 		t.Run(test.expectLog, func(t *testing.T) {
 			logger, logBuf := testutils.NewLogger()
 			spanProcessor := &mockSpanProcessor{expectedError: test.expectErr}
-			consumer := newConsumerDelegate(logger, spanProcessor, &tenancy.TenancyManager{})
+			consumer := newConsumerDelegate(logger, spanProcessor, &tenancy.Manager{})
 
 			err := consumer.consume(context.Background(), makeTracesOneSpan())
 
@@ -100,7 +100,7 @@ func TestStartOtlpReceiver_Error(t *testing.T) {
 	spanProcessor := &mockSpanProcessor{}
 	logger, _ := testutils.NewLogger()
 	opts := optionsWithPorts(":-1")
-	tm := &tenancy.TenancyManager{}
+	tm := &tenancy.Manager{}
 	_, err := StartOTLPReceiver(opts, logger, spanProcessor, tm)
 	require.Error(t, err)
 	assert.Contains(t, err.Error(), "could not start the OTLP receiver")
@@ -109,7 +109,7 @@ func TestStartOtlpReceiver_Error(t *testing.T) {
 		return nil, errors.New("mock error")
 	}
 	f := otlpreceiver.NewFactory()
-	_, err = startOTLPReceiver(opts, logger, spanProcessor, &tenancy.TenancyManager{}, f, newTraces, f.CreateTracesReceiver)
+	_, err = startOTLPReceiver(opts, logger, spanProcessor, &tenancy.Manager{}, f, newTraces, f.CreateTracesReceiver)
 	require.Error(t, err)
 	assert.Contains(t, err.Error(), "could not create the OTLP consumer")
 
@@ -118,7 +118,7 @@ func TestStartOtlpReceiver_Error(t *testing.T) {
 	) (component.TracesReceiver, error) {
 		return nil, errors.New("mock error")
 	}
-	_, err = startOTLPReceiver(opts, logger, spanProcessor, &tenancy.TenancyManager{}, f, consumer.NewTraces, createTracesReceiver)
+	_, err = startOTLPReceiver(opts, logger, spanProcessor, &tenancy.Manager{}, f, consumer.NewTraces, createTracesReceiver)
 	require.Error(t, err)
 	assert.Contains(t, err.Error(), "could not create the OTLP receiver")
 }

cmd/collector/app/server/grpc_test.go

@@ -40,7 +40,7 @@ func TestFailToListen(t *testing.T) {
 	logger, _ := zap.NewDevelopment()
 	server, err := StartGRPCServer(&GRPCServerParams{
 		HostPort:      ":-1",
-		Handler:       handler.NewGRPCHandler(logger, &mockSpanProcessor{}, &tenancy.TenancyManager{}),
+		Handler:       handler.NewGRPCHandler(logger, &mockSpanProcessor{}, &tenancy.Manager{}),
 		SamplingStore: &mockSamplingStore{},
 		Logger:        logger,
 	})
@@ -57,7 +57,7 @@ func TestFailServe(t *testing.T) {
 
 	logger := zap.New(core)
 	serveGRPC(grpc.NewServer(), lis, &GRPCServerParams{
-		Handler:       handler.NewGRPCHandler(logger, &mockSpanProcessor{}, &tenancy.TenancyManager{}),
+		Handler:       handler.NewGRPCHandler(logger, &mockSpanProcessor{}, &tenancy.Manager{}),
 		SamplingStore: &mockSamplingStore{},
 		Logger:        logger,
 		OnError: func(e error) {
@@ -72,7 +72,7 @@ func TestFailServe(t *testing.T) {
 func TestSpanCollector(t *testing.T) {
 	logger, _ := zap.NewDevelopment()
 	params := &GRPCServerParams{
-		Handler:                 handler.NewGRPCHandler(logger, &mockSpanProcessor{}, &tenancy.TenancyManager{}),
+		Handler:                 handler.NewGRPCHandler(logger, &mockSpanProcessor{}, &tenancy.Manager{}),
 		SamplingStore:           &mockSamplingStore{},
 		Logger:                  logger,
 		MaxReceiveMessageLength: 1024 * 1024,
@@ -97,7 +97,7 @@ func TestSpanCollector(t *testing.T) {
 func TestCollectorStartWithTLS(t *testing.T) {
 	logger, _ := zap.NewDevelopment()
 	params := &GRPCServerParams{
-		Handler:       handler.NewGRPCHandler(logger, &mockSpanProcessor{}, &tenancy.TenancyManager{}),
+		Handler:       handler.NewGRPCHandler(logger, &mockSpanProcessor{}, &tenancy.Manager{}),
 		SamplingStore: &mockSamplingStore{},
 		Logger:        logger,
 		TLSConfig: tlscfg.Options{
@@ -116,7 +116,7 @@ func TestCollectorStartWithTLS(t *testing.T) {
 func TestCollectorReflection(t *testing.T) {
 	logger, _ := zap.NewDevelopment()
 	params := &GRPCServerParams{
-		Handler:       handler.NewGRPCHandler(logger, &mockSpanProcessor{}, &tenancy.TenancyManager{}),
+		Handler:       handler.NewGRPCHandler(logger, &mockSpanProcessor{}, &tenancy.Manager{}),
 		SamplingStore: &mockSamplingStore{},
 		Logger:        logger,
 	}

cmd/collector/app/span_handler_builder.go

@@ -36,7 +36,7 @@ type SpanHandlerBuilder struct {
 	CollectorOpts  *flags.CollectorOptions
 	Logger         *zap.Logger
 	MetricsFactory metrics.Factory
-	TenancyMgr     *tenancy.TenancyManager
+	TenancyMgr     *tenancy.Manager
 }
 
 // SpanHandlers holds instances to the span handlers built by the SpanHandlerBuilder

cmd/collector/app/span_handler_builder_test.go

@@ -42,7 +42,7 @@ func TestNewSpanHandlerBuilder(t *testing.T) {
 	builder := &SpanHandlerBuilder{
 		SpanWriter:    spanWriter,
 		CollectorOpts: cOpts,
-		TenancyMgr:    &tenancy.TenancyManager{},
+		TenancyMgr:    &tenancy.Manager{},
 	}
 	assert.NotNil(t, builder.logger())
 	assert.NotNil(t, builder.metricsFactory())
@@ -52,7 +52,7 @@ func TestNewSpanHandlerBuilder(t *testing.T) {
 		CollectorOpts:  cOpts,
 		Logger:         zap.NewNop(),
 		MetricsFactory: metrics.NullFactory,
-		TenancyMgr:     &tenancy.TenancyManager{},
+		TenancyMgr:     &tenancy.Manager{},
 	}
 
 	spanProcessor := builder.BuildSpanProcessor()

cmd/collector/main.go

@@ -103,7 +103,7 @@ func main() {
 			if err != nil {
 				logger.Fatal("Failed to initialize collector", zap.Error(err))
 			}
-			tm := tenancy.NewTenancyManager(&collectorOpts.GRPC.Tenancy)
+			tm := tenancy.NewManager(&collectorOpts.GRPC.Tenancy)
 
 			collector := app.New(&app.CollectorParams{
 				ServiceName:    serviceName,

cmd/query/app/apiv3/grpc_gateway.go

@@ -31,7 +31,7 @@ import (
 )
 
 // RegisterGRPCGateway registers api_v3 endpoints into provided mux.
-func RegisterGRPCGateway(ctx context.Context, logger *zap.Logger, r *mux.Router, basePath string, grpcEndpoint string, grpcTLS tlscfg.Options, tm *tenancy.TenancyManager) error {
+func RegisterGRPCGateway(ctx context.Context, logger *zap.Logger, r *mux.Router, basePath string, grpcEndpoint string, grpcTLS tlscfg.Options, tm *tenancy.Manager) error {
 	jsonpb := &runtime.JSONPb{}
 
 	muxOpts := []runtime.ServeMuxOption{

cmd/query/app/apiv3/grpc_gateway_test.go

@@ -66,7 +66,7 @@ func setupGRPCGateway(t *testing.T, basePath string, serverTLS tlscfg.Options, c
 		serverGRPCOpts = append(serverGRPCOpts, grpc.Creds(creds))
 	}
 	if tenancyOptions.Enabled {
-		tm := tenancy.NewTenancyManager(&tenancyOptions)
+		tm := tenancy.NewManager(&tenancyOptions)
 		serverGRPCOpts = append(serverGRPCOpts,
 			grpc.StreamInterceptor(tenancy.NewGuardingStreamInterceptor(tm)),
 			grpc.UnaryInterceptor(tenancy.NewGuardingUnaryInterceptor(tm)),
@@ -86,7 +86,7 @@ func setupGRPCGateway(t *testing.T, basePath string, serverTLS tlscfg.Options, c
 	router := &mux.Router{}
 	router = router.PathPrefix(basePath).Subrouter()
 	ctx, cancel := context.WithCancel(context.Background())
-	err := RegisterGRPCGateway(ctx, zap.NewNop(), router, basePath, lis.Addr().String(), clientTLS, tenancy.NewTenancyManager(&tenancyOptions))
+	err := RegisterGRPCGateway(ctx, zap.NewNop(), router, basePath, lis.Addr().String(), clientTLS, tenancy.NewManager(&tenancyOptions))
 	require.NoError(t, err)
 
 	httpLis, err := net.Listen("tcp", ":0")
@@ -176,7 +176,7 @@ func TestTenancyGRPCGateway(t *testing.T) {
 	tenancyOptions := tenancy.Options{
 		Enabled: true,
 	}
-	tm := tenancy.NewTenancyManager(&tenancyOptions)
+	tm := tenancy.NewManager(&tenancyOptions)
 	testGRPCGatewayWithTenancy(t, "/", tlscfg.Options{}, tlscfg.Options{},
 		// Configure the gateway to forward tenancy header from HTTP to GRPC
 		tenancyOptions,
@@ -217,7 +217,7 @@ func TestTenancyGRPCRejection(t *testing.T) {
 	require.Equal(t, http.StatusForbidden, response.StatusCode)
 
 	// Try again with tenant header set
-	tm := tenancy.NewTenancyManager(&tenancyOptions)
+	tm := tenancy.NewManager(&tenancyOptions)
 	req.Header.Set(tm.Header, "acme")
 	response, err = http.DefaultClient.Do(req)
 	require.NoError(t, err)