PMM-5680 store logs

agentlocal/agent_local.go

@@ -16,10 +16,13 @@
 package agentlocal
 
 import (
+	"archive/zip"
 	"bytes"
 	"context"
 	_ "expvar" // register /debug/vars
+	"fmt"
 	"html/template"
+	"io"
 	"log"
 	"net"
 	"net/http"
@@ -47,6 +50,7 @@ import (
 	"google.golang.org/protobuf/types/known/durationpb"
 
 	"github.com/percona/pmm-agent/config"
+	"github.com/percona/pmm-agent/storelogs"
 )
 
 const (
@@ -61,23 +65,28 @@ type Server struct {
 	configFilepath string
 
 	l               *logrus.Entry
+	ringLogs        *storelogs.LogsStore
 	reload          chan struct{}
 	reloadCloseOnce sync.Once
 
 	agentlocalpb.UnimplementedAgentLocalServer
 }
 
 // NewServer creates new server.
-//
+
 // Caller should call Run.
-func NewServer(cfg *config.Config, supervisor supervisor, client client, configFilepath string) *Server {
+func NewServer(cfg *config.Config, supervisor supervisor, client client, configFilepath string, ringLog *storelogs.LogsStore) *Server {
+	logger := logrus.New()
+	logger.Out = io.MultiWriter(os.Stderr, ringLog)
+
 	return &Server{
 		cfg:            cfg,
 		supervisor:     supervisor,
 		client:         client,
 		configFilepath: configFilepath,
-		l:              logrus.WithField("component", "local-server"),
+		l:              logger.WithField("component", "local-server"),
 		reload:         make(chan struct{}),
+		ringLogs:       ringLog,
 	}
 }
 
@@ -289,6 +298,7 @@ func (s *Server) runJSONServer(ctx context.Context, grpcAddress string) {
 	mux.Handle("/debug/", http.DefaultServeMux)
 	mux.Handle("/debug", debugPageHandler)
 	mux.Handle("/", proxyMux)
+	mux.HandleFunc("/logs.zip", s.Zip)
 
 	server := &http.Server{
 		Addr:     address,
@@ -314,7 +324,53 @@ func (s *Server) runJSONServer(ctx context.Context, grpcAddress string) {
 	_ = server.Close() // call Close() in all cases
 }
 
+// addData add data to zip file
+func addData(zipW *zip.Writer, name string, data []byte) {
+	f, err := zipW.Create(name)
+	if err != nil {
+		log.Fatal(err)
+	}
+	_, err = f.Write(data)
+	if err != nil {
+		log.Fatal(err)
+	}
+}
+
 // check interfaces
 var (
 	_ agentlocalpb.AgentLocalServer = (*Server)(nil)
 )
+
+func (s *Server) Zip(w http.ResponseWriter, r *http.Request) {
+	buf := &bytes.Buffer{}
+	writer := zip.NewWriter(buf)
+	b := &bytes.Buffer{}
+	for _, serverLog := range s.ringLogs.GetLogs() {
+		_, err := b.WriteString(serverLog)
+		if err != nil {
+			log.Fatal(err)
+		}
+	}
+	addData(writer, "server.txt", b.Bytes())
+
+	for id, logs := range s.supervisor.AgentsLogs() {
+		b := &bytes.Buffer{}
+		for _, l := range logs {
+			_, err := b.WriteString(l + "\n")
+			if err != nil {
+				log.Fatal(err)
+			}
+		}
+		addData(writer, fmt.Sprintf("%s.txt", id), b.Bytes())
+	}
+	err := writer.Close()
+	if err != nil {
+		log.Fatal(err)
+	}
+	w.Header().Set("Content-Type", "application/zip")
+	w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=\"%s.zip\"", "logs"))
+	_, err = w.Write(buf.Bytes())
+	if err != nil {
+		log.Fatal(err)
+	}
+}

agentlocal/agent_local_test.go

@@ -16,7 +16,14 @@
 package agentlocal
 
 import (
+	"archive/zip"
+	"bufio"
+	"bytes"
 	"context"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"net/http/httptest"
 	"testing"
 	"time"
 
@@ -28,6 +35,7 @@ import (
 	"google.golang.org/protobuf/types/known/durationpb"
 
 	"github.com/percona/pmm-agent/config"
+	"github.com/percona/pmm-agent/storelogs"
 )
 
 func TestServerStatus(t *testing.T) {
@@ -61,7 +69,8 @@ func TestServerStatus(t *testing.T) {
 		agentInfo, supervisor, client, cfg := setup(t)
 		defer supervisor.AssertExpectations(t)
 		defer client.AssertExpectations(t)
-		s := NewServer(cfg, supervisor, client, "/some/dir/pmm-agent.yaml")
+		ringLog := storelogs.New(500)
+		s := NewServer(cfg, supervisor, client, "/some/dir/pmm-agent.yaml", ringLog)
 
 		// without network info
 		actual, err := s.Status(context.Background(), &agentlocalpb.StatusRequest{GetNetworkInfo: false})
@@ -87,7 +96,8 @@ func TestServerStatus(t *testing.T) {
 		client.On("GetNetworkInformation").Return(latency, clockDrift, nil)
 		defer supervisor.AssertExpectations(t)
 		defer client.AssertExpectations(t)
-		s := NewServer(cfg, supervisor, client, "/some/dir/pmm-agent.yaml")
+		ringLog := storelogs.New(500)
+		s := NewServer(cfg, supervisor, client, "/some/dir/pmm-agent.yaml", ringLog)
 
 		// with network info
 		actual, err := s.Status(context.Background(), &agentlocalpb.StatusRequest{GetNetworkInfo: true})
@@ -108,3 +118,128 @@ func TestServerStatus(t *testing.T) {
 		assert.Equal(t, expected, actual)
 	})
 }
+
+func TestGetZipFile(t *testing.T) {
+	setup := func(t *testing.T) ([]*agentlocalpb.AgentInfo, *mockSupervisor, *mockClient, *config.Config) {
+		agentInfo := []*agentlocalpb.AgentInfo{{
+			AgentId:   "/agent_id/00000000-0000-4000-8000-000000000002",
+			AgentType: inventorypb.AgentType_NODE_EXPORTER,
+			Status:    inventorypb.AgentStatus_RUNNING,
+		}}
+		var supervisor mockSupervisor
+		supervisor.Test(t)
+		supervisor.On("AgentsList").Return(agentInfo)
+		agentLogs := make(map[string][]string)
+		agentLogs[inventorypb.AgentType_NODE_EXPORTER.String()] = []string{
+			"logs1",
+			"logs2",
+		}
+		supervisor.On("AgentsLogs").Return(agentLogs)
+		var client mockClient
+		client.Test(t)
+		client.On("GetServerConnectMetadata").Return(&agentpb.ServerConnectMetadata{
+			AgentRunsOnNodeID: "/node_id/00000000-0000-4000-8000-000000000003",
+			ServerVersion:     "2.0.0-dev",
+		})
+		cfg := &config.Config{
+			ID: "/agent_id/00000000-0000-4000-8000-000000000001",
+			Server: config.Server{
+				Address:  "127.0.0.1:8443",
+				Username: "username",
+				Password: "password",
+			},
+		}
+		return agentInfo, &supervisor, &client, cfg
+	}
+
+	t.Run("test zip file", func(t *testing.T) {
+		_, supervisor, client, cfg := setup(t)
+		defer supervisor.AssertExpectations(t)
+		defer client.AssertExpectations(t)
+		ringLog := storelogs.New(10)
+		s := NewServer(cfg, supervisor, client, "/some/dir/pmm-agent.yaml", ringLog)
+		_, err := s.Status(context.Background(), &agentlocalpb.StatusRequest{GetNetworkInfo: false})
+		require.NoError(t, err)
+
+		rec := httptest.NewRecorder()
+		req := httptest.NewRequest("GET", "/logs.zip", nil)
+		s.Zip(rec, req)
+		existFile, err := ioutil.ReadAll(rec.Body)
+		require.NoError(t, err)
+
+		expectedFile, err := generateTestZip(s)
+		require.NoError(t, err)
+		bufExp := bytes.NewReader(expectedFile)
+		bufExs := bytes.NewReader(existFile)
+
+		zipExp, err := zip.NewReader(bufExp, bufExp.Size())
+		require.NoError(t, err)
+		zipExs, err := zip.NewReader(bufExp, bufExs.Size())
+		require.NoError(t, err)
+
+		for i, ex := range zipExp.File {
+			assert.Equal(t, ex.Name, zipExs.File[i].Name)
+			deepCompare(t, ex, zipExs.File[i])
+		}
+		require.NoError(t, err)
+		assert.Equal(t, expectedFile, existFile)
+	})
+}
+
+// generateTestZip generate test zip file.
+func generateTestZip(s *Server) ([]byte, error) {
+	agentLogs := make(map[string][]string)
+	agentLogs[inventorypb.AgentType_NODE_EXPORTER.String()] = []string{
+		"logs1",
+		"logs2",
+	}
+	buf := &bytes.Buffer{}
+	writer := zip.NewWriter(buf)
+	b := &bytes.Buffer{}
+	for _, serverLog := range s.ringLogs.GetLogs() {
+		_, err := b.WriteString(serverLog)
+		if err != nil {
+			return nil, err
+		}
+	}
+	addData(writer, "server.txt", b.Bytes())
+
+	for id, logs := range agentLogs {
+		b := &bytes.Buffer{}
+		for _, l := range logs {
+			_, err := b.WriteString(l + "\n")
+			if err != nil {
+				return nil, err
+			}
+		}
+		addData(writer, fmt.Sprintf("%s.txt", id), b.Bytes())
+	}
+	err := writer.Close()
+	if err != nil {
+		return nil, err
+	}
+	return buf.Bytes(), nil
+}
+
+// deepCompare compare two zip files.
+func deepCompare(t *testing.T, file1, file2 *zip.File) bool {
+	sf, err := file1.Open()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	df, err := file2.Open()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	sscan := bufio.NewScanner(sf)
+	dscan := bufio.NewScanner(df)
+
+	for sscan.Scan() {
+		dscan.Scan()
+		assert.Equal(t, sscan.Bytes(), dscan.Bytes())
+	}
+
+	return false
+}

agentlocal/deps.go

@@ -39,4 +39,5 @@ type client interface {
 // We use it instead of real type for testing and to avoid dependency cycle.
 type supervisor interface {
 	AgentsList() []*agentlocalpb.AgentInfo
+	AgentsLogs() map[string][]string
 }

agents/process/process_child.go

@@ -25,7 +25,7 @@ import (
 	"context"
 	"flag"
 	"fmt"
-	"io"
+	"io/ioutil"
 	"time"
 
 	"github.com/percona/pmm/api/inventorypb"
@@ -37,9 +37,8 @@ import (
 func main() {
 	flag.Parse()
 	logger := logrus.New()
-	logger.SetOutput(io.Discard)
+	logger.SetOutput(ioutil.Discard)
 	l := logrus.NewEntry(logger)
-
 	p := process.New(&process.Params{Path: "sleep", Args: []string{"100500"}}, nil, l)
 	go p.Run(context.Background())
 

agents/process/process_test.go

@@ -17,6 +17,7 @@ package process
 
 import (
 	"context"
+	"io/ioutil"
 	"os"
 	"os/exec"
 	"runtime"
@@ -123,7 +124,7 @@ func TestProcess(t *testing.T) {
 	})
 
 	t.Run("Killed", func(t *testing.T) {
-		f, err := os.CreateTemp("", "pmm-agent-process-test-noterm")
+		f, err := ioutil.TempFile("", "pmm-agent-process-test-noterm")
 		require.NoError(t, err)
 		require.NoError(t, f.Close())
 		defer func() {
@@ -146,7 +147,7 @@ func TestProcess(t *testing.T) {
 			t.Skip("Pdeathsig is implemented only on Linux")
 		}
 
-		f, err := os.CreateTemp("", "pmm-agent-process-test-child")
+		f, err := ioutil.TempFile("", "pmm-agent-process-test-child")
 		require.NoError(t, err)
 		require.NoError(t, f.Close())
 		defer func() {