feat: inject DGD id in planner env variables (#2460)

deploy/cloud/operator/api/v1alpha1/dynamocomponentdeployment_types.go

@@ -260,3 +260,16 @@ func (s *DynamoComponentDeploymentSharedSpec) GetNumberOfNodes() int32 {
 	}
 	return 1
 }
+
+func (s *DynamoComponentDeployment) GetParentGraphDeploymentName() string {
+	for _, ownerRef := range s.ObjectMeta.OwnerReferences {
+		if ownerRef.Kind == "DynamoGraphDeployment" {
+			return ownerRef.Name
+		}
+	}
+	return ""
+}
+
+func (s *DynamoComponentDeployment) GetParentGraphDeploymentNamespace() string {
+	return s.GetNamespace()
+}

deploy/cloud/operator/api/v1alpha1/dynamocomponentdeployment_types_test.go

@@ -210,3 +210,54 @@ func TestDynamoComponentDeployment_SetDynamoDeploymentConfig(t *testing.T) {
 		})
 	}
 }
+
+func TestDynamoComponentDeployment_GetParentGraphDeploymentName(t *testing.T) {
+	type fields struct {
+		TypeMeta   metav1.TypeMeta
+		ObjectMeta metav1.ObjectMeta
+		Spec       DynamoComponentDeploymentSpec
+		Status     DynamoComponentDeploymentStatus
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		want   string
+	}{
+		{
+			name: "test",
+			fields: fields{
+				ObjectMeta: metav1.ObjectMeta{
+					OwnerReferences: []metav1.OwnerReference{
+						{
+							Kind: "DynamoGraphDeployment",
+							Name: "name",
+						},
+					},
+				},
+			},
+			want: "name",
+		},
+		{
+			name: "no owner reference",
+			fields: fields{
+				ObjectMeta: metav1.ObjectMeta{
+					OwnerReferences: []metav1.OwnerReference{},
+				},
+			},
+			want: "",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			s := &DynamoComponentDeployment{
+				TypeMeta:   tt.fields.TypeMeta,
+				ObjectMeta: tt.fields.ObjectMeta,
+				Spec:       tt.fields.Spec,
+				Status:     tt.fields.Status,
+			}
+			if got := s.GetParentGraphDeploymentName(); got != tt.want {
+				t.Errorf("DynamoComponentDeployment.GetParentGraphDeploymentName() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

deploy/cloud/operator/internal/dynamo/component_common.go

@@ -14,15 +14,15 @@ import (
 type ComponentDefaults interface {
 	// GetBaseContainer returns the base container configuration for this component type
 	// The numberOfNodes parameter indicates the total number of nodes in the deployment
-	GetBaseContainer(numberOfNodes int32) (corev1.Container, error)
+	GetBaseContainer(context ComponentContext) (corev1.Container, error)
 
 	// GetBasePodSpec returns the base pod spec configuration for this component type
 	// The numberOfNodes parameter indicates the total number of nodes in the deployment
-	GetBasePodSpec(numberOfNodes int32) (corev1.PodSpec, error)
+	GetBasePodSpec(context ComponentContext) (corev1.PodSpec, error)
 }
 
 // ComponentDefaultsFactory creates appropriate defaults based on component type and number of nodes
-func ComponentDefaultsFactory(componentType string, numberOfNodes int32) ComponentDefaults {
+func ComponentDefaultsFactory(componentType string) ComponentDefaults {
 	switch componentType {
 	case commonconsts.ComponentTypeFrontend:
 		return NewFrontendDefaults()
@@ -38,15 +38,22 @@ func ComponentDefaultsFactory(componentType string, numberOfNodes int32) Compone
 // BaseComponentDefaults provides common defaults shared by all components
 type BaseComponentDefaults struct{}
 
-func (b *BaseComponentDefaults) GetBaseContainer(numberOfNodes int32) (corev1.Container, error) {
-	return b.getCommonContainer(), nil
+type ComponentContext struct {
+	numberOfNodes                  int32
+	DynamoNamespace                string
+	ParentGraphDeploymentName      string
+	ParentGraphDeploymentNamespace string
 }
 
-func (b *BaseComponentDefaults) GetBasePodSpec(numberOfNodes int32) (corev1.PodSpec, error) {
+func (b *BaseComponentDefaults) GetBaseContainer(context ComponentContext) (corev1.Container, error) {
+	return b.getCommonContainer(context), nil
+}
+
+func (b *BaseComponentDefaults) GetBasePodSpec(context ComponentContext) (corev1.PodSpec, error) {
 	return corev1.PodSpec{}, nil
 }
 
-func (b *BaseComponentDefaults) getCommonContainer() corev1.Container {
+func (b *BaseComponentDefaults) getCommonContainer(context ComponentContext) corev1.Container {
 	container := corev1.Container{
 		Name: "main",
 		Command: []string{
@@ -54,6 +61,20 @@ func (b *BaseComponentDefaults) getCommonContainer() corev1.Container {
 			"-c",
 		},
 	}
+	container.Env = []corev1.EnvVar{
+		{
+			Name:  "DYN_NAMESPACE",
+			Value: context.DynamoNamespace,
+		},
+		{
+			Name:  "DYN_PARENT_DGD_K8S_NAME",
+			Value: context.ParentGraphDeploymentName,
+		},
+		{
+			Name:  "DYN_PARENT_DGD_K8S_NAMESPACE",
+			Value: context.ParentGraphDeploymentNamespace,
+		},
+	}
 
 	return container
 }

deploy/cloud/operator/internal/dynamo/component_frontend.go

@@ -23,9 +23,9 @@ func NewFrontendDefaults() *FrontendDefaults {
 	return &FrontendDefaults{&BaseComponentDefaults{}}
 }
 
-func (f *FrontendDefaults) GetBaseContainer(numberOfNodes int32) (corev1.Container, error) {
+func (f *FrontendDefaults) GetBaseContainer(context ComponentContext) (corev1.Container, error) {
 	// Frontend doesn't need backend-specific config
-	container := f.getCommonContainer()
+	container := f.getCommonContainer(context)
 
 	// Add HTTP port
 	container.Ports = []corev1.ContainerPort{
@@ -78,12 +78,12 @@ func (f *FrontendDefaults) GetBaseContainer(numberOfNodes int32) (corev1.Contain
 	}
 
 	// Add standard environment variables
-	container.Env = []corev1.EnvVar{
+	container.Env = append(container.Env, []corev1.EnvVar{
 		{
 			Name:  commonconsts.EnvDynamoServicePort,
 			Value: fmt.Sprintf("%d", commonconsts.DynamoServicePort),
 		},
-	}
+	}...)
 
 	return container, nil
 }

deploy/cloud/operator/internal/dynamo/component_planner.go

@@ -20,8 +20,8 @@ func NewPlannerDefaults() *PlannerDefaults {
 	return &PlannerDefaults{&BaseComponentDefaults{}}
 }
 
-func (p *PlannerDefaults) GetBaseContainer(numberOfNodes int32) (corev1.Container, error) {
-	container := p.getCommonContainer()
+func (p *PlannerDefaults) GetBaseContainer(context ComponentContext) (corev1.Container, error) {
+	container := p.getCommonContainer(context)
 
 	// Add planner-specific defaults
 	container.Resources = corev1.ResourceRequirements{
@@ -38,7 +38,7 @@ func (p *PlannerDefaults) GetBaseContainer(numberOfNodes int32) (corev1.Containe
 	return container, nil
 }
 
-func (p *PlannerDefaults) GetBasePodSpec(numberOfNodes int32) (corev1.PodSpec, error) {
+func (p *PlannerDefaults) GetBasePodSpec(context ComponentContext) (corev1.PodSpec, error) {
 	podSpec := corev1.PodSpec{
 		ServiceAccountName: commonconsts.PlannerServiceAccountName,
 	}

deploy/cloud/operator/internal/dynamo/component_planner_test.go

+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package dynamo
+
+import (
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+	corev1 "k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/resource"
+)
+
+func TestPlannerDefaults_GetBaseContainer(t *testing.T) {
+	type fields struct {
+		BaseComponentDefaults *BaseComponentDefaults
+	}
+	type args struct {
+		numberOfNodes                  int32
+		parentGraphDeploymentName      string
+		parentGraphDeploymentNamespace string
+		dynamoNamespace                string
+	}
+	tests := []struct {
+		name    string
+		fields  fields
+		args    args
+		want    corev1.Container
+		wantErr bool
+	}{
+		{
+			name: "test",
+			fields: fields{
+				BaseComponentDefaults: &BaseComponentDefaults{},
+			},
+			args: args{
+				numberOfNodes:                  1,
+				parentGraphDeploymentName:      "name",
+				parentGraphDeploymentNamespace: "namespace",
+				dynamoNamespace:                "dynamo-namespace",
+			},
+			want: corev1.Container{
+				Name: "main",
+				Command: []string{
+					"/bin/sh",
+					"-c",
+				},
+				Resources: corev1.ResourceRequirements{
+					Requests: corev1.ResourceList{
+						corev1.ResourceCPU:    resource.MustParse("2"),
+						corev1.ResourceMemory: resource.MustParse("2Gi"),
+					},
+					Limits: corev1.ResourceList{
+						corev1.ResourceCPU:    resource.MustParse("2"),
+						corev1.ResourceMemory: resource.MustParse("2Gi"),
+					},
+				},
+				Env: []corev1.EnvVar{
+					{Name: "DYN_NAMESPACE", Value: "dynamo-namespace"},
+					{Name: "DYN_PARENT_DGD_K8S_NAME", Value: "name"},
+					{Name: "DYN_PARENT_DGD_K8S_NAMESPACE", Value: "namespace"},
+				},
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			p := &PlannerDefaults{
+				BaseComponentDefaults: tt.fields.BaseComponentDefaults,
+			}
+			got, err := p.GetBaseContainer(ComponentContext{
+				numberOfNodes:                  tt.args.numberOfNodes,
+				ParentGraphDeploymentName:      tt.args.parentGraphDeploymentName,
+				ParentGraphDeploymentNamespace: tt.args.parentGraphDeploymentNamespace,
+				DynamoNamespace:                tt.args.dynamoNamespace,
+			})
+			if (err != nil) != tt.wantErr {
+				t.Errorf("PlannerDefaults.GetBaseContainer() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			diff := cmp.Diff(got, tt.want)
+			if diff != "" {
+				t.Errorf("PlannerDefaults.GetBaseContainer() = %v, want %v", diff, tt.want)
+			}
+		})
+	}
+}

deploy/cloud/operator/internal/dynamo/component_worker.go

@@ -23,8 +23,8 @@ func NewWorkerDefaults() *WorkerDefaults {
 	return &WorkerDefaults{&BaseComponentDefaults{}}
 }
 
-func (w *WorkerDefaults) GetBaseContainer(numberOfNodes int32) (corev1.Container, error) {
-	container := w.getCommonContainer()
+func (w *WorkerDefaults) GetBaseContainer(context ComponentContext) (corev1.Container, error) {
+	container := w.getCommonContainer(context)
 
 	// Add system port
 	container.Ports = []corev1.ContainerPort{
@@ -84,7 +84,7 @@ func (w *WorkerDefaults) GetBaseContainer(numberOfNodes int32) (corev1.Container
 		FailureThreshold: 60,
 	}
 
-	container.Env = []corev1.EnvVar{
+	container.Env = append(container.Env, []corev1.EnvVar{
 		{
 			Name:  "DYN_SYSTEM_ENABLED",
 			Value: "true",
@@ -97,7 +97,7 @@ func (w *WorkerDefaults) GetBaseContainer(numberOfNodes int32) (corev1.Container
 			Name:  "DYN_SYSTEM_PORT",
 			Value: fmt.Sprintf("%d", commonconsts.DynamoSystemPort),
 		},
-	}
+	}...)
 
 	return container, nil
 }

deploy/cloud/operator/internal/dynamo/graph.go

@@ -105,7 +105,7 @@ func (s ServiceConfig) GetNamespace() *string {
 	return &s.Config.Dynamo.Namespace
 }
 
-func GetDefaultDynamoNamespace(ctx context.Context, dynamoDeployment *v1alpha1.DynamoGraphDeployment) string {
+func GetDefaultDynamoNamespace(dynamoDeployment *v1alpha1.DynamoGraphDeployment) string {
 	return fmt.Sprintf("dynamo-%s", dynamoDeployment.Name)
 }
 
@@ -118,7 +118,10 @@ func ParseDynDeploymentConfig(ctx context.Context, jsonContent []byte) (DynDeplo
 // GenerateDynamoComponentsDeployments generates a map of DynamoComponentDeployments from a DynamoGraphConfig
 func GenerateDynamoComponentsDeployments(ctx context.Context, parentDynamoGraphDeployment *v1alpha1.DynamoGraphDeployment, defaultIngressSpec *v1alpha1.IngressSpec) (map[string]*v1alpha1.DynamoComponentDeployment, error) {
 	deployments := make(map[string]*v1alpha1.DynamoComponentDeployment)
-	graphDynamoNamespace := ""
+	graphDynamoNamespace, err := getDynamoNamespace(parentDynamoGraphDeployment)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get the graph dynamo namespace: %w", err)
+	}
 	for componentName, component := range parentDynamoGraphDeployment.Spec.Services {
 		deployment := &v1alpha1.DynamoComponentDeployment{}
 		deployment.Spec.DynamoComponentDeploymentSharedSpec = component.DynamoComponentDeploymentSharedSpec
@@ -126,22 +129,14 @@ func GenerateDynamoComponentsDeployments(ctx context.Context, parentDynamoGraphD
 		deployment.Spec.BackendFramework = parentDynamoGraphDeployment.Spec.BackendFramework
 		deployment.Namespace = parentDynamoGraphDeployment.Namespace
 		deployment.Spec.ServiceName = componentName
-		dynamoNamespace := GetDefaultDynamoNamespace(ctx, parentDynamoGraphDeployment)
-		if component.DynamoNamespace != nil && *component.DynamoNamespace != "" {
-			dynamoNamespace = *component.DynamoNamespace
-		}
-		if graphDynamoNamespace != "" && graphDynamoNamespace != dynamoNamespace {
-			return nil, fmt.Errorf("namespace mismatch for component %s: graph uses namespace %s but component specifies %s", componentName, graphDynamoNamespace, dynamoNamespace)
-		}
-		graphDynamoNamespace = dynamoNamespace
-		deployment.Spec.DynamoNamespace = &dynamoNamespace
+		deployment.Spec.DynamoNamespace = &graphDynamoNamespace
 		labels := make(map[string]string)
 		// add the labels in the spec in order to label all sub-resources
 		deployment.Spec.Labels = labels
 		// and add the labels to the deployment itself
 		deployment.Labels = labels
 		labels[commonconsts.KubeLabelDynamoComponent] = componentName
-		labels[commonconsts.KubeLabelDynamoNamespace] = dynamoNamespace
+		labels[commonconsts.KubeLabelDynamoNamespace] = graphDynamoNamespace
 
 		// Propagate metrics annotation from parent deployment if present
 		if parentDynamoGraphDeployment.Annotations != nil {
@@ -190,6 +185,24 @@ func GenerateDynamoComponentsDeployments(ctx context.Context, parentDynamoGraphD
 	return deployments, nil
 }
 
+func getDynamoNamespace(parentDynamoGraphDeployment *v1alpha1.DynamoGraphDeployment) (string, error) {
+	graphDynamoNamespace := ""
+	for componentName, component := range parentDynamoGraphDeployment.Spec.Services {
+		dynamoNamespace := ""
+		if component.DynamoNamespace != nil && *component.DynamoNamespace != "" {
+			dynamoNamespace = *component.DynamoNamespace
+		}
+		if graphDynamoNamespace != "" && graphDynamoNamespace != dynamoNamespace {
+			return "", fmt.Errorf("namespace mismatch for component %s: graph uses namespace %s but component specifies %s", componentName, graphDynamoNamespace, dynamoNamespace)
+		}
+		graphDynamoNamespace = dynamoNamespace
+	}
+	if graphDynamoNamespace == "" {
+		graphDynamoNamespace = GetDefaultDynamoNamespace(parentDynamoGraphDeployment)
+	}
+	return graphDynamoNamespace, nil
+}
+
 // updateDynDeploymentConfig updates the runtime config object for the given dynamoDeploymentComponent
 // It updates the port for the given service (if it is the main component)
 func updateDynDeploymentConfig(dynamoDeploymentComponent *v1alpha1.DynamoComponentDeployment, newPort int) error {
@@ -667,6 +680,7 @@ func GenerateBasePodSpec(
 	component *v1alpha1.DynamoComponentDeploymentOverridesSpec,
 	backendFramework BackendFramework,
 	secretsRetriever SecretsRetriever,
+	parentGraphDeploymentName string,
 	namespace string,
 	role Role,
 	numberOfNodes int32,
@@ -675,8 +689,9 @@ func GenerateBasePodSpec(
 	serviceName string,
 ) (corev1.PodSpec, error) {
 	// Start with base container generated per component type
-	componentDefaults := ComponentDefaultsFactory(component.ComponentType, numberOfNodes)
-	container, err := componentDefaults.GetBaseContainer(numberOfNodes)
+	componentContext := generateComponentContext(component, parentGraphDeploymentName, namespace, numberOfNodes)
+	componentDefaults := ComponentDefaultsFactory(component.ComponentType)
+	container, err := componentDefaults.GetBaseContainer(componentContext)
 	if err != nil {
 		return corev1.PodSpec{}, fmt.Errorf("failed to get base container: %w", err)
 	}
@@ -778,7 +793,7 @@ func GenerateBasePodSpec(
 	backend.UpdateContainer(&container, numberOfNodes, role, component, serviceName, multinodeDeployer)
 
 	// get base podspec from component
-	podSpec, err := componentDefaults.GetBasePodSpec(numberOfNodes)
+	podSpec, err := componentDefaults.GetBasePodSpec(componentContext)
 	if err != nil {
 		return corev1.PodSpec{}, fmt.Errorf("failed to get base podspec: %w", err)
 	}
@@ -808,6 +823,18 @@ func setMetricsLabels(labels map[string]string, dynamoGraphDeployment *v1alpha1.
 	labels[commonconsts.KubeLabelMetricsEnabled] = commonconsts.KubeLabelValueTrue
 }
 
+func generateComponentContext(component *v1alpha1.DynamoComponentDeploymentOverridesSpec, parentGraphDeploymentName string, namespace string, numberOfNodes int32) ComponentContext {
+	componentContext := ComponentContext{
+		numberOfNodes:                  numberOfNodes,
+		ParentGraphDeploymentName:      parentGraphDeploymentName,
+		ParentGraphDeploymentNamespace: namespace,
+	}
+	if component.DynamoNamespace != nil {
+		componentContext.DynamoNamespace = *component.DynamoNamespace
+	}
+	return componentContext
+}
+
 // GeneratePodSpecForComponent creates a PodSpec for Grove deployments (simplified wrapper)
 func GeneratePodSpecForComponent(
 	component *v1alpha1.DynamoComponentDeploymentOverridesSpec,
@@ -823,7 +850,7 @@ func GeneratePodSpecForComponent(
 	if len(dynamoDeployment.Spec.Envs) > 0 {
 		component.Envs = MergeEnvs(dynamoDeployment.Spec.Envs, component.Envs)
 	}
-	podSpec, err := GenerateBasePodSpec(component, backendFramework, secretsRetriever, dynamoDeployment.Namespace, role, numberOfNodes, controllerConfig, multinodeDeploymentType, serviceName)
+	podSpec, err := GenerateBasePodSpec(component, backendFramework, secretsRetriever, dynamoDeployment.Name, dynamoDeployment.Namespace, role, numberOfNodes, controllerConfig, multinodeDeploymentType, serviceName)
 	if err != nil {
 		return corev1.PodSpec{}, err
 	}
@@ -847,9 +874,13 @@ func GenerateGrovePodGangSet(
 	if controllerConfig.Grove.TerminationDelay > 0 {
 		gangSet.Spec.Template.TerminationDelay = &metav1.Duration{Duration: controllerConfig.Grove.TerminationDelay}
 	}
-
+	dynamoNamespace, err := getDynamoNamespace(dynamoDeployment)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get the graph dynamo namespace: %w", err)
+	}
 	var scalingGroups []grovev1alpha1.PodCliqueScalingGroupConfig
 	for serviceName, component := range dynamoDeployment.Spec.Services {
+		component.DynamoNamespace = &dynamoNamespace
 		// Determine backend framework using hybrid approach
 		backendFramework, err := getBackendFrameworkFromComponent(component, dynamoDeployment)
 		if err != nil {
@@ -1129,6 +1160,7 @@ func GenerateBasePodSpecForController(
 		componentSpec,
 		backendFramework,
 		secretsRetriever,
+		dynComponent.GetParentGraphDeploymentName(),
 		dynComponent.Namespace,
 		role,
 		numberOfNodes,

deploy/cloud/operator/internal/dynamo/graph_test.go

@@ -1303,6 +1303,18 @@ func TestGenerateGrovePodGangSet(t *testing.T) {
 														Name:  "ETCD_ENDPOINTS",
 														Value: "etcd-address",
 													},
+													{
+														Name:  "DYN_NAMESPACE",
+														Value: "dynamo-test-dynamo-graph-deployment",
+													},
+													{
+														Name:  "DYN_PARENT_DGD_K8S_NAME",
+														Value: "test-dynamo-graph-deployment",
+													},
+													{
+														Name:  "DYN_PARENT_DGD_K8S_NAMESPACE",
+														Value: "test-namespace",
+													},
 												},
 												Resources: corev1.ResourceRequirements{
 													Requests: corev1.ResourceList{
@@ -1418,6 +1430,18 @@ func TestGenerateGrovePodGangSet(t *testing.T) {
 														Name:  "ETCD_ENDPOINTS",
 														Value: "etcd-address",
 													},
+													{
+														Name:  "DYN_NAMESPACE",
+														Value: "dynamo-test-dynamo-graph-deployment",
+													},
+													{
+														Name:  "DYN_PARENT_DGD_K8S_NAME",
+														Value: "test-dynamo-graph-deployment",
+													},
+													{
+														Name:  "DYN_PARENT_DGD_K8S_NAMESPACE",
+														Value: "test-namespace",
+													},
 												},
 												Resources: corev1.ResourceRequirements{
 													Requests: corev1.ResourceList{
@@ -1746,6 +1770,18 @@ func TestGenerateGrovePodGangSet(t *testing.T) {
 														Name:  "ETCD_ENDPOINTS",
 														Value: "etcd-address",
 													},
+													{
+														Name:  "DYN_NAMESPACE",
+														Value: "dynamo-test-dynamo-graph-deployment",
+													},
+													{
+														Name:  "DYN_PARENT_DGD_K8S_NAME",
+														Value: "test-dynamo-graph-deployment",
+													},
+													{
+														Name:  "DYN_PARENT_DGD_K8S_NAMESPACE",
+														Value: "test-namespace",
+													},
 												},
 												Resources: corev1.ResourceRequirements{
 													Requests: corev1.ResourceList{
@@ -1881,6 +1917,18 @@ func TestGenerateGrovePodGangSet(t *testing.T) {
 														Name:  "ETCD_ENDPOINTS",
 														Value: "etcd-address",
 													},
+													{
+														Name:  "DYN_NAMESPACE",
+														Value: "dynamo-test-dynamo-graph-deployment",
+													},
+													{
+														Name:  "DYN_PARENT_DGD_K8S_NAME",
+														Value: "test-dynamo-graph-deployment",
+													},
+													{
+														Name:  "DYN_PARENT_DGD_K8S_NAMESPACE",
+														Value: "test-namespace",
+													},
 												},
 												Resources: corev1.ResourceRequirements{
 													Requests: corev1.ResourceList{
@@ -1992,6 +2040,18 @@ func TestGenerateGrovePodGangSet(t *testing.T) {
 														Name:  "ETCD_ENDPOINTS",
 														Value: "etcd-address",
 													},
+													{
+														Name:  "DYN_NAMESPACE",
+														Value: "dynamo-test-dynamo-graph-deployment",
+													},
+													{
+														Name:  "DYN_PARENT_DGD_K8S_NAME",
+														Value: "test-dynamo-graph-deployment",
+													},
+													{
+														Name:  "DYN_PARENT_DGD_K8S_NAMESPACE",
+														Value: "test-namespace",
+													},
 												},
 												Resources: corev1.ResourceRequirements{
 													Requests: corev1.ResourceList{
@@ -2107,6 +2167,18 @@ func TestGenerateGrovePodGangSet(t *testing.T) {
 														Name:  "ETCD_ENDPOINTS",
 														Value: "etcd-address",
 													},
+													{
+														Name:  "DYN_NAMESPACE",
+														Value: "dynamo-test-dynamo-graph-deployment",
+													},
+													{
+														Name:  "DYN_PARENT_DGD_K8S_NAME",
+														Value: "test-dynamo-graph-deployment",
+													},
+													{
+														Name:  "DYN_PARENT_DGD_K8S_NAMESPACE",
+														Value: "test-namespace",
+													},
 												},
 												Resources: corev1.ResourceRequirements{
 													Requests: corev1.ResourceList{
@@ -2459,6 +2531,18 @@ func TestGenerateGrovePodGangSet(t *testing.T) {
 														Name:  "ETCD_ENDPOINTS",
 														Value: "etcd-address",
 													},
+													{
+														Name:  "DYN_NAMESPACE",
+														Value: "dynamo-test-dynamo-graph-deployment",
+													},
+													{
+														Name:  "DYN_PARENT_DGD_K8S_NAME",
+														Value: "test-dynamo-graph-deployment",
+													},
+													{
+														Name:  "DYN_PARENT_DGD_K8S_NAMESPACE",
+														Value: "test-namespace",
+													},
 												},
 												Resources: corev1.ResourceRequirements{
 													Requests: corev1.ResourceList{
@@ -2582,6 +2666,18 @@ func TestGenerateGrovePodGangSet(t *testing.T) {
 														Name:  "ETCD_ENDPOINTS",
 														Value: "etcd-address",
 													},
+													{
+														Name:  "DYN_NAMESPACE",
+														Value: "dynamo-test-dynamo-graph-deployment",
+													},
+													{
+														Name:  "DYN_PARENT_DGD_K8S_NAME",
+														Value: "test-dynamo-graph-deployment",
+													},
+													{
+														Name:  "DYN_PARENT_DGD_K8S_NAMESPACE",
+														Value: "test-namespace",
+													},
 												},
 												Resources: corev1.ResourceRequirements{
 													Requests: corev1.ResourceList{
@@ -2693,6 +2789,18 @@ func TestGenerateGrovePodGangSet(t *testing.T) {
 														Name:  "ETCD_ENDPOINTS",
 														Value: "etcd-address",
 													},
+													{
+														Name:  "DYN_NAMESPACE",
+														Value: "dynamo-test-dynamo-graph-deployment",
+													},
+													{
+														Name:  "DYN_PARENT_DGD_K8S_NAME",
+														Value: "test-dynamo-graph-deployment",
+													},
+													{
+														Name:  "DYN_PARENT_DGD_K8S_NAMESPACE",
+														Value: "test-namespace",
+													},
 												},
 												Resources: corev1.ResourceRequirements{
 													Requests: corev1.ResourceList{
@@ -2808,6 +2916,18 @@ func TestGenerateGrovePodGangSet(t *testing.T) {
 														Name:  "ETCD_ENDPOINTS",
 														Value: "etcd-address",
 													},
+													{
+														Name:  "DYN_NAMESPACE",
+														Value: "dynamo-test-dynamo-graph-deployment",
+													},
+													{
+														Name:  "DYN_PARENT_DGD_K8S_NAME",
+														Value: "test-dynamo-graph-deployment",
+													},
+													{
+														Name:  "DYN_PARENT_DGD_K8S_NAMESPACE",
+														Value: "test-namespace",
+													},
 												},
 												Resources: corev1.ResourceRequirements{
 													Requests: corev1.ResourceList{
@@ -4126,6 +4246,7 @@ func TestGenerateBasePodSpec_PlannerServiceAccount(t *testing.T) {
 				tt.component,
 				BackendFrameworkSGLang,
 				secretsRetriever,
+				"test-deployment",
 				"default",
 				RoleMain,
 				1,