Add registry to Filebeat's diagnostic

CHANGELOG.next.asciidoc

@@ -346,6 +346,7 @@ https://github.com/elastic/beats/compare/v8.8.1\...main[Check the HEAD diff]
 - Add ability to remove request trace logs from http_endpoint input. {pull}40005[40005]
 - Add ability to remove request trace logs from entityanalytics input. {pull}40004[40004]
 - Update CEL mito extensions to v1.16.0. {pull}41727[41727]
+- Filebeat's registry is now added to the Elastic-Agent diagnostics bundle {issue}33238[33238] {pull}41795[41795]
 
 *Auditbeat*
 

filebeat/beater/diagnostics.go

@@ -0,0 +1,150 @@
+// Licensed to Elasticsearch B.V. under one or more contributor
+// license agreements. See the NOTICE file distributed with
+// this work for additional information regarding copyright
+// ownership. Elasticsearch B.V. licenses this file to you under
+// the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+package beater
+
+import (
+	"archive/tar"
+	"bytes"
+	"compress/gzip"
+	"fmt"
+	"io"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/elastic/elastic-agent-libs/logp"
+	"github.com/elastic/elastic-agent-libs/paths"
+)
+
+func gzipRegistry() []byte {
+	logger := logp.L().Named("diagnostics")
+	buf := bytes.Buffer{}
+	dataPath := paths.Resolve(paths.Data, "")
+	registryPath := filepath.Join(dataPath, "registry")
+	f, err := os.CreateTemp("", "filebeat-registry-*.tar")
+	if err != nil {
+		logger.Errorw("cannot create temporary registry archive", "error.message", err)
+	}
+	// Close the file, we just need the empty file created to use it later
+	f.Close()
+	defer logger.Debug("finished gziping Filebeat's registry")
+
+	defer func() {
+		if err := os.Remove(f.Name()); err != nil {
+			logp.L().Named("diagnostics").Warnf("cannot remove temporary registry archive '%s': '%s'", f.Name(), err)
+		}
+	}()
+
+	logger.Debugf("temporary file '%s' created", f.Name())
+	if err := tarFolder(logger, registryPath, f.Name()); err != nil {
+		logger.Errorw(fmt.Sprintf("cannot archive Filebeat's registry at '%s'", f.Name()), "error.message", err)
+	}
+
+	if err := gzipFile(logger, f.Name(), &buf); err != nil {
+		logger.Errorw("cannot gzip Filebeat's registry", "error.message", err)
+	}
+
+	return buf.Bytes()
+}
+
+// gzipFile gzips src writing the compressed data to dst
+func gzipFile(logger *logp.Logger, src string, dst io.Writer) error {
+	reader, err := os.Open(src)
+	if err != nil {
+		return fmt.Errorf("cannot open '%s': '%w'", src, err)
+	}
+	defer reader.Close()
+
+	writer := gzip.NewWriter(dst)
+	defer writer.Close()
+	writer.Name = filepath.Base(src)
+
+	if _, err := io.Copy(writer, reader); err != nil {
+		if err != nil {
+			return fmt.Errorf("cannot gzip file '%s': '%w'", src, err)
+		}
+	}
+
+	return nil
+}
+
+// tarFolder creates a tar archive from the folder src and stores it at dst.
+//
+// dst must be the full path with extension, e.g: /tmp/foo.tar
+// If src is not a folder an error is retruned
+func tarFolder(logger *logp.Logger, src, dst string) error {
+	fullPath, err := filepath.Abs(src)
+	if err != nil {
+		return fmt.Errorf("cannot get full path from '%s': '%w'", src, err)
+	}
+
+	tarFile, err := os.Create(dst)
+	if err != nil {
+		return fmt.Errorf("cannot create tar file '%s': '%w'", dst, err)
+	}
+	defer tarFile.Close()
+
+	tarWriter := tar.NewWriter(tarFile)
+	defer tarWriter.Close()
+
+	info, err := os.Stat(fullPath)
+	if err != nil {
+		return fmt.Errorf("cannot stat '%s': '%w'", fullPath, err)
+	}
+
+	if !info.IsDir() {
+		return fmt.Errorf("'%s' is not a directory", fullPath)
+	}
+	baseDir := filepath.Base(src)
+
+	logger.Debugf("starting to walk '%s'", fullPath)
+	return filepath.Walk(fullPath, func(path string, info fs.FileInfo, prevErr error) error {
+		// Stop if there is any errors
+		if prevErr != nil {
+			return prevErr
+		}
+
+		header, err := tar.FileInfoHeader(info, info.Name())
+		if err != nil {
+			return fmt.Errorf("cannot create tar info header: '%w'", err)
+		}
+		header.Name = filepath.Join(baseDir, strings.TrimPrefix(path, src))
+
+		if err := tarWriter.WriteHeader(header); err != nil {
+			return fmt.Errorf("cannot write tar header for '%s': '%w'", path, err)
+		}
+
+		if info.IsDir() {
+			return nil
+		}
+
+		file, err := os.Open(path)
+		if err != nil {
+			return fmt.Errorf("cannot open '%s' for reading: '%w", path, err)
+		}
+		defer file.Close()
+
+		logger.Debugf("adding '%s' to the tar archive", file.Name())
+		if _, err := io.Copy(tarWriter, file); err != nil {
+			return fmt.Errorf("cannot read '%s': '%w'", path, err)
+		}
+
+		return nil
+	})
+}

filebeat/beater/filebeat.go

@@ -144,6 +144,13 @@ func newBeater(b *beat.Beat, plugins PluginFactory, rawConfig *conf.C) (beat.Bea
 				}
 				return data
 			})
+
+		b.Manager.RegisterDiagnosticHook(
+			"registry",
+			"Filebeat's registry",
+			"registry.tar.gz",
+			"application/octet-stream",
+			gzipRegistry)
 	}
 
 	// Add inputs created by the modules

filebeat/input/v2/compat/compat.go

@@ -159,6 +159,19 @@ func (r *runner) Stop() {
 	r.statusReporter = nil
 }
 
+// func (r *runner) Diagnostics() []diagnostics.DiagnosticSetup {
+// 	fmt.Println("================================================== Diagnostics called!")
+// 	setup := diagnostics.DiagnosticSetup{
+// 		Name:        "registry collector",
+// 		Description: "Collect Filebeat's registry",
+// 		Filename:    "registry.tar.gz",
+// 		ContentType: "application/octet-stream",
+// 		Callback:    getRegistry,
+// 	}
+
+// 	return []diagnostics.DiagnosticSetup{setup}
+// }
+
 func configID(config *conf.C) (string, error) {
 	tmp := struct {
 		ID string `config:"id"`