diff --git a/cmd/collector/app/handler/grpc_handler.go b/cmd/collector/app/handler/grpc_handler.go
index 3c62b666f5c..bbca9cbfd85 100644
--- a/cmd/collector/app/handler/grpc_handler.go
+++ b/cmd/collector/app/handler/grpc_handler.go
@@ -10,7 +10,6 @@ import (
 	"go.uber.org/zap"
 	"google.golang.org/grpc/codes"
 	_ "google.golang.org/grpc/encoding/gzip" // register zip encoding
-	"google.golang.org/grpc/metadata"
 	"google.golang.org/grpc/status"
 
 	"github.com/jaegertracing/jaeger-idl/model/v1"
@@ -97,22 +96,5 @@ func (c *batchConsumer) validateTenant(ctx context.Context) (string, error) {
 	if !c.tenancyMgr.Enabled {
 		return "", nil
 	}
-
-	md, ok := metadata.FromIncomingContext(ctx)
-	if !ok {
-		return "", status.Errorf(codes.PermissionDenied, "missing tenant header")
-	}
-
-	tenants := md.Get(c.tenancyMgr.Header)
-	if len(tenants) < 1 {
-		return "", status.Errorf(codes.PermissionDenied, "missing tenant header")
-	} else if len(tenants) > 1 {
-		return "", status.Errorf(codes.PermissionDenied, "extra tenant header")
-	}
-
-	if !c.tenancyMgr.Valid(tenants[0]) {
-		return "", status.Errorf(codes.PermissionDenied, "unknown tenant")
-	}
-
-	return tenants[0], nil
+	return tenancy.GetValidTenant(ctx, c.tenancyMgr)
 }
diff --git a/cmd/collector/app/span_processor_test.go b/cmd/collector/app/span_processor_test.go
index cec4dc0f215..3451125d113 100644
--- a/cmd/collector/app/span_processor_test.go
+++ b/cmd/collector/app/span_processor_test.go
@@ -10,8 +10,10 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"net/http"
 	"reflect"
 	"slices"
+	"strings"
 	"sync"
 	"sync/atomic"
 	"testing"
@@ -19,12 +21,24 @@ import (
 
 	"github.com/gogo/protobuf/jsonpb"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
+	"go.opentelemetry.io/collector/config/configgrpc"
+	"go.opentelemetry.io/collector/config/confighttp"
+	"go.opentelemetry.io/collector/config/confignet"
+	"go.opentelemetry.io/collector/pdata/ptrace"
+	otlptrace "go.opentelemetry.io/proto/otlp/collector/trace/v1"
+	tracepb "go.opentelemetry.io/proto/otlp/trace/v1"
 	"go.uber.org/zap"
+	"go.uber.org/zap/zaptest"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials/insecure"
+	"google.golang.org/grpc/metadata"
 
 	"github.com/jaegertracing/jaeger-idl/model/v1"
 	"github.com/jaegertracing/jaeger-idl/thrift-gen/jaeger"
 	zc "github.com/jaegertracing/jaeger-idl/thrift-gen/zipkincore"
+	cFlags "github.com/jaegertracing/jaeger/cmd/collector/app/flags"
 	"github.com/jaegertracing/jaeger/cmd/collector/app/handler"
 	"github.com/jaegertracing/jaeger/cmd/collector/app/processor"
 	zipkinsanitizer "github.com/jaegertracing/jaeger/cmd/collector/app/sanitizer/zipkin"
@@ -32,6 +46,7 @@ import (
 	"github.com/jaegertracing/jaeger/pkg/metrics"
 	"github.com/jaegertracing/jaeger/pkg/tenancy"
 	"github.com/jaegertracing/jaeger/pkg/testutils"
+	"github.com/jaegertracing/jaeger/storage_v2/tracestore/mocks"
 	"github.com/jaegertracing/jaeger/storage_v2/v1adapter"
 )
 
@@ -807,3 +822,213 @@ func TestSpanProcessorWithOnDroppedSpanOption(t *testing.T) {
 	require.EqualError(t, err, processor.ErrBusy.Error())
 	assert.Equal(t, []string{"op3"}, droppedOperations)
 }
+
+func optionsWithPorts(portHttp string, portGrpc string) *cFlags.CollectorOptions {
+	opts := &cFlags.CollectorOptions{
+		OTLP: struct {
+			Enabled bool
+			GRPC    configgrpc.ServerConfig
+			HTTP    confighttp.ServerConfig
+		}{
+			Enabled: true,
+			HTTP: confighttp.ServerConfig{
+				Endpoint:        portHttp,
+				IncludeMetadata: true,
+			},
+			GRPC: configgrpc.ServerConfig{
+				NetAddr: confignet.AddrConfig{
+					Endpoint:  portGrpc,
+					Transport: confignet.TransportTypeTCP,
+				},
+			},
+		},
+	}
+	return opts
+}
+
+func TestOTLPReceiverWithV2Storage(t *testing.T) {
+	tests := []struct {
+		name           string
+		requestType    string
+		tenant         string
+		expectedTenant string
+		expectedError  bool
+		executeRequest func(ctx context.Context, url string, tenant string) error
+	}{
+		{
+			name:           "Valid tenant via HTTP",
+			requestType:    "http",
+			tenant:         "test-tenant",
+			expectedTenant: "test-tenant",
+			expectedError:  false,
+			executeRequest: sendHTTPRequest,
+		},
+		{
+			name:           "Invalid tenant via HTTP",
+			requestType:    "http",
+			tenant:         "invalid-tenant",
+			expectedTenant: "",
+			expectedError:  true,
+			executeRequest: sendHTTPRequest,
+		},
+		{
+			name:           "Valid tenant via gRPC",
+			requestType:    "grpc",
+			tenant:         "test-tenant",
+			expectedTenant: "test-tenant",
+			expectedError:  false,
+			executeRequest: sendGRPCRequest,
+		},
+		{
+			name:           "Invalid tenant via gRPC",
+			requestType:    "grpc",
+			tenant:         "invalid-tenant",
+			expectedTenant: "",
+			expectedError:  true,
+			executeRequest: sendGRPCRequest,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			mockWriter := mocks.NewWriter(t)
+
+			spanProcessor, err := NewSpanProcessor(
+				mockWriter,
+				nil,
+				Options.NumWorkers(1),
+				Options.QueueSize(1),
+				Options.ReportBusy(true),
+			)
+			require.NoError(t, err)
+			defer spanProcessor.Close()
+			logger := zaptest.NewLogger(t)
+
+			portHttp := "4317"
+			portGrpc := "4318"
+
+			var receivedTraces atomic.Pointer[ptrace.Traces]
+			var receivedCtx atomic.Pointer[context.Context]
+			if !tt.expectedError {
+				mockWriter.On("WriteTraces", mock.Anything, mock.Anything).
+					Run(func(args mock.Arguments) {
+						storeContext := args.Get(0).(context.Context)
+						storeTrace := args.Get(1).(ptrace.Traces)
+						receivedTraces.Store(&storeTrace)
+						receivedCtx.Store(&storeContext)
+					}).Return(nil)
+			}
+
+			tenancyMgr := tenancy.NewManager(&tenancy.Options{
+				Enabled: true,
+				Header:  "x-tenant",
+				Tenants: []string{"test-tenant"},
+			})
+
+			rec, err := handler.StartOTLPReceiver(
+				optionsWithPorts(fmt.Sprintf("localhost:%v", portHttp), fmt.Sprintf("localhost:%v", portGrpc)),
+				logger,
+				spanProcessor,
+				tenancyMgr,
+			)
+			require.NoError(t, err)
+			ctx := context.Background()
+			defer rec.Shutdown(ctx)
+
+			var url string
+			if tt.requestType == "http" {
+				url = fmt.Sprintf("http://localhost:%v/v1/traces", portHttp)
+			} else {
+				url = fmt.Sprintf("localhost:%v", portGrpc)
+			}
+			err = tt.executeRequest(ctx, url, tt.tenant)
+			if tt.expectedError {
+				assert.Error(t, err)
+				return
+			}
+			require.NoError(t, err)
+
+			assert.Eventually(t, func() bool {
+				storedTraces := receivedTraces.Load()
+				storedCtx := receivedCtx.Load()
+				if storedTraces == nil || storedCtx == nil {
+					return false
+				}
+				receivedSpan := storedTraces.ResourceSpans().At(0).
+					ScopeSpans().At(0).
+					Spans().At(0)
+				receivedTenant := tenancy.GetTenant(*storedCtx)
+				return receivedSpan.Name() == "test-trace" && receivedTenant == tt.expectedTenant
+			}, 1*time.Second, 100*time.Millisecond)
+
+			mockWriter.AssertExpectations(t)
+		})
+	}
+}
+
+// Helper function to send HTTP request
+func sendHTTPRequest(ctx context.Context, url string, tenant string) error {
+	traceJSON := `{
+		"resourceSpans": [{
+			"scopeSpans": [{
+				"spans": [{
+					"name": "test-trace"
+				}]
+			}]
+		}]
+	}`
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, strings.NewReader(traceJSON))
+	if err != nil {
+		return err
+	}
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("x-tenant", tenant)
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("unexpected status code: %d", resp.StatusCode)
+	}
+	return nil
+}
+
+// Helper function to send gRPC request
+func sendGRPCRequest(ctx context.Context, url string, tenant string) error {
+	conn, err := grpc.NewClient(
+		url,
+		grpc.WithTransportCredentials(insecure.NewCredentials()),
+	)
+	if err != nil {
+		return err
+	}
+	defer conn.Close()
+
+	md := metadata.New(map[string]string{
+		"x-tenant": tenant,
+	})
+	ctxWithMD := metadata.NewOutgoingContext(ctx, md)
+
+	client := otlptrace.NewTraceServiceClient(conn)
+	req := &otlptrace.ExportTraceServiceRequest{
+		ResourceSpans: []*tracepb.ResourceSpans{
+			{
+				ScopeSpans: []*tracepb.ScopeSpans{
+					{
+						Spans: []*tracepb.Span{
+							{
+								Name: "test-trace",
+							},
+						},
+					},
+				},
+			},
+		},
+	}
+
+	_, err = client.Export(ctxWithMD, req)
+	return err
+}
diff --git a/cmd/jaeger/internal/extension/remotesampling/extension.go b/cmd/jaeger/internal/extension/remotesampling/extension.go
index 3caa071595e..335e42ea292 100644
--- a/cmd/jaeger/internal/extension/remotesampling/extension.go
+++ b/cmd/jaeger/internal/extension/remotesampling/extension.go
@@ -172,7 +172,7 @@ func (ext *rsExtension) startFileBasedStrategyProvider(_ context.Context) error
 	}
 
 	// contextcheck linter complains about next line that context is not passed.
-	//nolint
+	//nolint:contextcheck
 	provider, err := file.NewProvider(opts, ext.telemetry.Logger)
 	if err != nil {
 		return fmt.Errorf("failed to create the local file strategy store: %w", err)
diff --git a/pkg/tenancy/grpc.go b/pkg/tenancy/grpc.go
index 7652c69952a..ad8a4834b21 100644
--- a/pkg/tenancy/grpc.go
+++ b/pkg/tenancy/grpc.go
@@ -6,6 +6,7 @@ package tenancy
 import (
 	"context"
 
+	"go.opentelemetry.io/collector/client"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/metadata"
@@ -22,32 +23,55 @@ func (tss *tenantedServerStream) Context() context.Context {
 	return tss.context
 }
 
-func getValidTenant(ctx context.Context, tc *Manager) (string, error) {
-	// Handle case where tenant is already directly in the context
-	tenant := GetTenant(ctx)
-	if tenant != "" {
-		if !tc.Valid(tenant) {
-			return tenant, status.Errorf(codes.PermissionDenied, "unknown tenant")
-		}
+func GetValidTenant(ctx context.Context, tm *Manager) (string, error) {
+	tenant, err := extractTenantFromSources(ctx, tm.Header)
+	if err != nil {
+		return "", err
+	}
+
+	if !tm.Valid(tenant) {
+		return "", status.Errorf(codes.PermissionDenied, "unknown tenant")
+	}
+
+	return tenant, nil
+}
+
+// helper function to extract tenant from different sources
+func extractTenantFromSources(ctx context.Context, header string) (string, error) {
+	if tenant := GetTenant(ctx); tenant != "" {
 		return tenant, nil
 	}
 
-	// Handle case where tenant is in the context metadata
+	if cli := client.FromContext(ctx); cli.Metadata.Get(header) != nil {
+		if tenants := cli.Metadata.Get(header); len(tenants) > 0 {
+			return extractSingleTenant(tenants)
+		}
+	}
+
 	md, ok := metadata.FromIncomingContext(ctx)
 	if !ok {
 		return "", status.Errorf(codes.PermissionDenied, "missing tenant header")
 	}
 
-	var err error
-	tenant, err = tenantFromMetadata(md, tc.Header)
-	if err != nil {
-		return "", err
-	}
-	if !tc.Valid(tenant) {
-		return tenant, status.Errorf(codes.PermissionDenied, "unknown tenant")
-	}
+	return extractSingleTenant(md.Get(header))
+}
 
-	return tenant, nil
+// Helper function for metadata extraction
+func tenantFromMetadata(md metadata.MD, header string) (string, error) {
+	tenants := md.Get(header)
+	return extractSingleTenant(tenants)
+}
+
+// Ensures single tenant value exists
+func extractSingleTenant(tenants []string) (string, error) {
+	switch len(tenants) {
+	case 0:
+		return "", status.Errorf(codes.Unauthenticated, "missing tenant header")
+	case 1:
+		return tenants[0], nil
+	default:
+		return "", status.Errorf(codes.PermissionDenied, "extra tenant header")
+	}
 }
 
 func directlyAttachedTenant(ctx context.Context) bool {
@@ -58,7 +82,7 @@ func directlyAttachedTenant(ctx context.Context) bool {
 // It also ensures the tenant is directly in the context, rather than context metadata.
 func NewGuardingStreamInterceptor(tc *Manager) grpc.StreamServerInterceptor {
 	return func(srv any, ss grpc.ServerStream, _ *grpc.StreamServerInfo, handler grpc.StreamHandler) error {
-		tenant, err := getValidTenant(ss.Context(), tc)
+		tenant, err := GetValidTenant(ss.Context(), tc)
 		if err != nil {
 			return err
 		}
@@ -75,22 +99,11 @@ func NewGuardingStreamInterceptor(tc *Manager) grpc.StreamServerInterceptor {
 	}
 }
 
-func tenantFromMetadata(md metadata.MD, tenancyHeader string) (string, error) {
-	tenants := md.Get(tenancyHeader)
-	if len(tenants) < 1 {
-		return "", status.Errorf(codes.Unauthenticated, "missing tenant header")
-	} else if len(tenants) > 1 {
-		return "", status.Errorf(codes.PermissionDenied, "extra tenant header")
-	}
-
-	return tenants[0], nil
-}
-
 // NewGuardingUnaryInterceptor blocks handling of RPCs whose tenancy header doesn't meet tenancy requirements.
 // It also ensures the tenant is directly in the context, rather than context metadata.
 func NewGuardingUnaryInterceptor(tc *Manager) grpc.UnaryServerInterceptor {
 	return func(ctx context.Context, req any, _ *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (any, error) {
-		tenant, err := getValidTenant(ctx, tc)
+		tenant, err := GetValidTenant(ctx, tc)
 		if err != nil {
 			return nil, err
 		}
diff --git a/pkg/tenancy/grpc_test.go b/pkg/tenancy/grpc_test.go
index 45b39af16cc..b914f6dbd1d 100644
--- a/pkg/tenancy/grpc_test.go
+++ b/pkg/tenancy/grpc_test.go
@@ -10,6 +10,7 @@ import (
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"go.opentelemetry.io/collector/client"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/metadata"
 )
@@ -63,6 +64,38 @@ func TestTenancyInterceptors(t *testing.T) {
 			ctx:        metadata.NewIncomingContext(context.Background(), map[string][]string{"x-tenant": {"acme", "megacorp"}}),
 			errMsg:     "rpc error: code = PermissionDenied desc = extra tenant header",
 		},
+		{
+			name:       "missing tenant context",
+			tenancyMgr: NewManager(&Options{Enabled: true}),
+			ctx: client.NewContext(context.Background(), client.Info{
+				Metadata: client.NewMetadata(map[string][]string{}),
+			}),
+			errMsg: "rpc error: code = PermissionDenied desc = missing tenant header",
+		},
+		{
+			name:       "invalid tenant context",
+			tenancyMgr: NewManager(&Options{Enabled: true, Tenants: []string{"megacorp"}}),
+			ctx: client.NewContext(context.Background(), client.Info{
+				Metadata: client.NewMetadata(map[string][]string{"x-tenant": {"acme"}}),
+			}),
+			errMsg: "rpc error: code = PermissionDenied desc = unknown tenant",
+		},
+		{
+			name:       "valid tenant context",
+			tenancyMgr: NewManager(&Options{Enabled: true, Tenants: []string{"acme"}}),
+			ctx: client.NewContext(context.Background(), client.Info{
+				Metadata: client.NewMetadata(map[string][]string{"x-tenant": {"acme"}}),
+			}),
+			errMsg: "",
+		},
+		{
+			name:       "extra tenant context",
+			tenancyMgr: NewManager(&Options{Enabled: true, Tenants: []string{"acme"}}),
+			ctx: client.NewContext(context.Background(), client.Info{
+				Metadata: client.NewMetadata(map[string][]string{"x-tenant": {"acme", "megacorp"}}),
+			}),
+			errMsg: "rpc error: code = PermissionDenied desc = extra tenant header",
+		},
 	}
 
 	for _, test := range tests {