Reuse DumpPodsAndLogs.

Signed-off-by: Revital Sur <eres@il.ibm.com>

Author: revit13

test/coordinator/e2e/coordinator/coordinator_test.go

@@ -127,11 +127,7 @@ func runCoordinatorPipeline(body []byte, expectedSteps []string, expectedImages
 		if !ginkgo.CurrentSpecReport().Failed() && !printCoordinatorLogs {
 			return
 		}
-		dumpDeploymentLogs(nsName, "llm-d-coordinator", "coordinator")
-		dumpDeploymentLogs(nsName, eppName+"-encode", "epp")
-		dumpDeploymentLogs(nsName, eppName+"-prefill", "epp")
-		dumpDeploymentLogs(nsName, eppName+"-decode", "epp")
-		dumpDeploymentLogs(nsName, "envoy", "envoy")
+		testutils.DumpPodsAndLogs(testConfig, nsName, testutils.WithFullLogs())
 		dumpEnvoyClusters(nsName)
 	})
 
@@ -177,21 +173,6 @@ func runCoordinatorPipeline(body []byte, expectedSteps []string, expectedImages
 	verifyCoordinatorSteps(nsName, expectedSteps, expectedImages, true, true)
 }
 
-// dumpDeploymentLogs writes a deployment's container logs to the Ginkgo output.
-// A kubectl error is reported inline rather than failing the spec.
-func dumpDeploymentLogs(nsName, deployment, container string) {
-	args := []string{"logs", "deployment/" + deployment, "-c", container, "--namespace=" + nsName}
-	if k8sContext != "" {
-		args = append(args, "--context="+k8sContext)
-	}
-	out, err := exec.Command("kubectl", args...).CombinedOutput()
-	if err != nil {
-		fmt.Fprintf(ginkgo.GinkgoWriter, "\n--- %s logs (kubectl error: %v) ---\n%s\n---\n", deployment, err, string(out))
-		return
-	}
-	fmt.Fprintf(ginkgo.GinkgoWriter, "\n--- %s logs ---\n%s\n---\n", deployment, string(out))
-}
-
 // dumpEnvoyClusters writes Envoy's admin /clusters (resolved endpoints and health
 // per cluster) to the Ginkgo output. Best-effort; yields nothing if the envoy
 // image lacks a usable HTTP client.

test/coordinator/e2e/coordinator/setup_test.go

@@ -245,15 +245,18 @@ func applyManifest(path string, subs map[string]string, excludeKinds ...string)
 // churn per spec. Mirrors the non-coordinator e2e, which creates the EPP
 // Services and RBAC once in its setup and recreates only the Deployment per test.
 func createStableInfra() []string {
-	objects := make([]string, 0, 12)
+	eppManifests := []string{encodeEPPManifest, prefillEPPManifest, decodeEPPManifest}
+	// Coordinator Service + ServiceAccount, plus Service + ServiceAccount +
+	// RoleBinding per EPP.
+	objects := make([]string, 0, 2+len(eppManifests)*3)
 
 	docs := e2eutil.RunKustomize(coordinatorComponentDir)
 	docs = e2eutil.FilterKinds(docs, "ConfigMap", "Deployment")
 	docs = e2eutil.SubstituteMany(docs, coordinatorSubstitutions())
 	docs = e2eutil.RemoveEmptyArgs(docs)
 	objects = append(objects, testutils.CreateObjsFromYaml(testConfig, docs, getNamespace())...)
 
-	for _, manifest := range []string{encodeEPPManifest, prefillEPPManifest, decodeEPPManifest} {
+	for _, manifest := range eppManifests {
 		objects = append(objects, applyManifest(manifest, eppSubstitutions(), "Deployment")...)
 	}
 	return objects

test/utils/dump.go

@@ -37,15 +37,36 @@ const (
 	dumpLimitBytes = int64(1 << 20) // 1MiB
 )
 
+// dumpConfig controls how much container log DumpPodsAndLogs fetches.
+type dumpConfig struct {
+	tailLines  int64
+	limitBytes int64
+}
+
+// DumpOption overrides DumpPodsAndLogs defaults.
+type DumpOption func(*dumpConfig)
+
+// WithFullLogs streams complete container logs instead of the default tail, for
+// callers that need the entire log (e.g. a gateway access log). A non-positive
+// tail/limit disables that cap.
+func WithFullLogs() DumpOption {
+	return func(c *dumpConfig) { c.tailLines, c.limitBytes = 0, 0 }
+}
+
 // DumpPodsAndLogs prints pod statuses and container logs for the given namespace
 // to the Ginkgo writer. Call this before cleanup to ensure the information is
 // available when CI tests fail.
-func DumpPodsAndLogs(cfg *TestConfig, nsName string) {
+func DumpPodsAndLogs(cfg *TestConfig, nsName string, opts ...DumpOption) {
 	if cfg == nil || cfg.KubeCli == nil {
 		ginkgo.GinkgoWriter.Println("Skipping pod dump: cluster not initialized")
 		return
 	}
 
+	dc := dumpConfig{tailLines: dumpTailLines, limitBytes: dumpLimitBytes}
+	for _, opt := range opts {
+		opt(&dc)
+	}
+
 	ginkgo.GinkgoWriter.Printf("\n=== Dumping pod states and logs (namespace: %s) ===\n", nsName)
 
 	ctx, cancel := context.WithTimeout(cfg.Context, dumpTimeout)
@@ -113,15 +134,15 @@ func DumpPodsAndLogs(cfg *TestConfig, nsName string) {
 
 		for _, c := range pod.Spec.InitContainers {
 			if restarted[c.Name] {
-				dumpContainerLogs(ctx, cfg, pod.Namespace, pod.Name, c.Name, true)
+				dumpContainerLogs(ctx, cfg, pod.Namespace, pod.Name, c.Name, true, dc)
 			}
-			dumpContainerLogs(ctx, cfg, pod.Namespace, pod.Name, c.Name, false)
+			dumpContainerLogs(ctx, cfg, pod.Namespace, pod.Name, c.Name, false, dc)
 		}
 		for _, c := range pod.Spec.Containers {
 			if restarted[c.Name] {
-				dumpContainerLogs(ctx, cfg, pod.Namespace, pod.Name, c.Name, true)
+				dumpContainerLogs(ctx, cfg, pod.Namespace, pod.Name, c.Name, true, dc)
 			}
-			dumpContainerLogs(ctx, cfg, pod.Namespace, pod.Name, c.Name, false)
+			dumpContainerLogs(ctx, cfg, pod.Namespace, pod.Name, c.Name, false, dc)
 		}
 	}
 	ginkgo.GinkgoWriter.Println("=== End of pod dump ===")
@@ -138,15 +159,15 @@ func printContainerStatus(kind string, cs corev1.ContainerStatus) {
 	ginkgo.GinkgoWriter.Println(status)
 }
 
-func dumpContainerLogs(ctx context.Context, cfg *TestConfig, nsName, podName, containerName string, previous bool) {
-	tailLines := dumpTailLines
-	limitBytes := dumpLimitBytes
-	req := cfg.KubeCli.CoreV1().Pods(nsName).GetLogs(podName, &corev1.PodLogOptions{
-		Container:  containerName,
-		TailLines:  &tailLines,
-		LimitBytes: &limitBytes,
-		Previous:   previous,
-	})
+func dumpContainerLogs(ctx context.Context, cfg *TestConfig, nsName, podName, containerName string, previous bool, dc dumpConfig) {
+	logOpts := &corev1.PodLogOptions{Container: containerName, Previous: previous}
+	if dc.tailLines > 0 {
+		logOpts.TailLines = &dc.tailLines
+	}
+	if dc.limitBytes > 0 {
+		logOpts.LimitBytes = &dc.limitBytes
+	}
+	req := cfg.KubeCli.CoreV1().Pods(nsName).GetLogs(podName, logOpts)
 	stream, err := req.Stream(ctx)
 	if err != nil {
 		ginkgo.GinkgoWriter.Printf("  [logs] %s/%s: failed to stream logs: %v\n", podName, containerName, err)
@@ -163,9 +184,12 @@ func dumpContainerLogs(ctx context.Context, cfg *TestConfig, nsName, podName, co
 		ginkgo.GinkgoWriter.Printf("  [logs] %s/%s: failed to read logs: %v\n", podName, containerName, err)
 		return
 	}
-	label := fmt.Sprintf("last %d lines", dumpTailLines)
+	scope := "full log"
+	if dc.tailLines > 0 {
+		scope = fmt.Sprintf("last %d lines", dc.tailLines)
+	}
 	if previous {
-		label = fmt.Sprintf("previous instance, last %d lines", dumpTailLines)
+		scope = "previous instance, " + scope
 	}
-	ginkgo.GinkgoWriter.Printf("  [logs] %s/%s (%s):\n%s\n", podName, containerName, label, buf.String())
+	ginkgo.GinkgoWriter.Printf("  [logs] %s/%s (%s):\n%s\n", podName, containerName, scope, buf.String())
 }