Use "docker cp" to copy internal logs (#509)

* WIP

* Adjust Jenkinsfile

* Fix

* Fix archive artifacts

Author: mtojek

.ci/Jenkinsfile

@@ -91,8 +91,8 @@ pipeline {
               dir("${BASE_DIR}") {
                 script {
                   parallel([
-                    'stack-command': generateTestCommandStage(command: 'test-stack-command', artifacts: ['build/elastic-stack-dump/**/*.log']),
-                    'check-packages': generateTestCommandStage(command: 'test-check-packages', artifacts: ['build/test-results/*.xml', 'build/kubectl-dump.txt', 'build/elastic-stack-dump/**/*.log'], junitArtifacts: true, publishCoverage: true),
+                    'stack-command': generateTestCommandStage(command: 'test-stack-command', artifacts: ['build/elastic-stack-dump/stack/logs/*.log', 'build/elastic-stack-dump/stack/logs/fleet-server-internal/*']),
+                    'check-packages': generateTestCommandStage(command: 'test-check-packages', artifacts: ['build/test-results/*.xml', 'build/kubectl-dump.txt', 'build/elastic-stack-dump/check/logs/*.log', 'build/elastic-stack-dump/check/logs/fleet-server-internal/*'], junitArtifacts: true, publishCoverage: true),
                     'profiles-command': generateTestCommandStage(command: 'test-profiles-command'),
                   ])
                 }

internal/docker/docker.go

@@ -60,7 +60,7 @@ func Pull(image string) error {
 		cmd.Stderr = os.Stderr
 	}
 
-	logger.Debugf("running command: %s", cmd)
+	logger.Debugf("run command: %s", cmd)
 	err := cmd.Run()
 	if err != nil {
 		return errors.Wrap(err, "running docker command failed")
@@ -112,7 +112,7 @@ func ConnectToNetwork(containerID, network string) error {
 	errOutput := new(bytes.Buffer)
 	cmd.Stderr = errOutput
 
-	logger.Debugf("output command: %s", cmd)
+	logger.Debugf("run command: %s", cmd)
 	if err := cmd.Run(); err != nil {
 		return errors.Wrapf(err, "could not attach container to the stack network (stderr=%q)", errOutput.String())
 	}
@@ -142,19 +142,15 @@ func InspectContainers(containerIDs ...string) ([]ContainerDescription, error) {
 	return containerDescriptions, nil
 }
 
-// Exec function executes command inside of the container
-func Exec(containerName string, args ...string) ([]byte, error) {
-	cmdArgs := []string{"exec", "-t", containerName}
-	cmdArgs = append(cmdArgs, args...)
-
-	cmd := exec.Command("docker", cmdArgs...)
+// Copy function copies resources from the container to the local destination.
+func Copy(containerName, containerPath, localPath string) error {
+	cmd := exec.Command("docker", "cp", containerName+":"+containerPath, localPath)
 	errOutput := new(bytes.Buffer)
 	cmd.Stderr = errOutput
 
-	logger.Debugf("output command: %s", cmd)
-	output, err := cmd.Output()
-	if err != nil {
-		return nil, errors.Wrapf(err, "exec failed (stderr=%q)", errOutput.String())
+	logger.Debugf("run command: %s", cmd)
+	if err := cmd.Run(); err != nil {
+		return errors.Wrapf(err, "could not copy files from the container (stderr=%q)", errOutput.String())
 	}
-	return output, nil
+	return nil
 }

internal/stack/dump.go

@@ -15,9 +15,12 @@ import (
 	"github.com/elastic/elastic-package/internal/profile"
 )
 
-const fleetServerService = "fleet-server"
+const (
+	elasticAgentService = "elastic-agent"
+	fleetServerService  = "fleet-server"
+)
 
-var observedServices = []string{"elasticsearch", "elastic-agent", fleetServerService, "kibana", "package-registry"}
+var observedServices = []string{"elasticsearch", elasticAgentService, fleetServerService, "kibana", "package-registry"}
 
 // DumpOptions defines dumping options for Elatic stack data.
 type DumpOptions struct {
@@ -46,7 +49,7 @@ func dumpStackLogs(options DumpOptions) error {
 	logsPath := filepath.Join(options.Output, "logs")
 	err = os.MkdirAll(logsPath, 0755)
 	if err != nil {
-		return errors.Wrap(err, "can't create output location")
+		return errors.Wrapf(err, "can't create output location (path: %s)", logsPath)
 	}
 
 	snapshotPath := options.Profile.FetchPath(profile.SnapshotFile)
@@ -61,11 +64,9 @@ func dumpStackLogs(options DumpOptions) error {
 			writeLogFiles(logsPath, serviceName, content)
 		}
 
-		content, ok, err := dockerInternalLogs(serviceName)
+		err = copyDockerInternalLogs(serviceName, logsPath)
 		if err != nil {
-			logger.Errorf("can't fetch internal logs (service: %s): %v", serviceName, err)
-		} else if ok {
-			writeLogFiles(logsPath, serviceName+"-internal", content)
+			logger.Errorf("can't copy internal logs (service: %s): %v", serviceName, err)
 		}
 	}
 	return nil

internal/stack/logs.go

@@ -5,6 +5,8 @@
 package stack
 
 import (
+	"path/filepath"
+
 	"github.com/pkg/errors"
 
 	"github.com/elastic/elastic-package/internal/compose"
@@ -28,20 +30,23 @@ func dockerComposeLogs(serviceName string, snapshotFile string) ([]byte, error)
 	return out, nil
 }
 
-func dockerInternalLogs(serviceName string) ([]byte, bool, error) {
-	if serviceName != fleetServerService {
-		return nil, false, nil // we need to pull internal logs only from the Fleet Server container
+func copyDockerInternalLogs(serviceName, outputPath string) error {
+	switch serviceName {
+	case elasticAgentService, fleetServerService:
+	default:
+		return nil // we need to pull internal logs only from Elastic-Agent and Fleets Server container
 	}
 
 	p, err := compose.NewProject(DockerComposeProjectName)
 	if err != nil {
-		return nil, false, errors.Wrap(err, "could not create docker compose project")
+		return errors.Wrap(err, "could not create docker compose project")
 	}
 
+	outputPath = filepath.Join(outputPath, serviceName+"-internal")
 	serviceContainer := p.ContainerName(serviceName)
-	out, err := docker.Exec(serviceContainer, "sh", "-c", `find data/logs/default/fleet-server-json* -printf '%p\n' -exec cat {} \;`)
+	err = docker.Copy(serviceContainer, "/usr/share/elastic-agent/data/logs/default", outputPath)
 	if err != nil {
-		return nil, false, errors.Wrap(err, "docker exec failed")
+		return errors.Wrap(err, "docker copy failed")
 	}
-	return out, true, nil
+	return nil
 }