Skip to content

armgit / Piik

Public Imported from GitHub
0

Free, open-source screen sharing for private live streams with friends. Watch together in a browser or self-host Piik. 免费开源的私密屏幕共享,支持游戏直播、一起看电影与自部署。

12.8 KB
Raw Blame
package diagnostics

import (
	"archive/zip"
	"bytes"
	"compress/gzip"
	"encoding/json"
	"errors"
	"fmt"
	"go.uber.org/zap/zapcore"
	"io"
	"log/slog"
	"os"
	"path/filepath"
	"runtime"
	"strings"
	"sync"
	"syscall"
	"testing"
	"time"
)

func TestRecorderRotationAndExport(t *testing.T) {
	directory := t.TempDir()
	const private = "private-environment-and-media-sentinel"
	t.Setenv("PIIK_DIAGNOSTICS_TEST_SECRET", private)
	if err := os.WriteFile(filepath.Join(directory, "private-config.json"), []byte(private), 0600); err != nil {
		t.Fatal(err)
	}
	recorder, err := Open(directory, "client", "test-revision")
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { _ = recorder.Close() })
	chunk := bytes.Repeat([]byte("x"), maxFileBytes/2)
	for range 5 {
		if _, err := recorder.log.Write(chunk); err != nil {
			t.Fatal(err)
		}
	}
	recorder.Logger().Debug("capture state", "event", "started")
	for _, path := range []string{recorder.LogPath(), recorder.LogPath() + ".1"} {
		info, err := os.Stat(path)
		if err != nil || info.Size() > maxFileBytes {
			t.Fatalf("bounded log %s: %v, %v", path, info, err)
		}
	}
	if _, err := os.Stat(recorder.LogPath() + ".2"); !errors.Is(err, os.ErrNotExist) {
		t.Fatalf("unexpected second backup: %v", err)
	}
	archivePath, err := recorder.Export()
	if err != nil {
		t.Fatal(err)
	}
	archive, err := zip.OpenReader(archivePath)
	if err != nil {
		t.Fatal(err)
	}
	defer archive.Close()
	expected := map[string]bool{"client.log": false, "client.log.1": false, "metadata.json": false, "memory.json": false, "heap.pprof": false, "goroutines.txt": false, "context.json": false, "README.txt": false}
	for _, file := range archive.File {
		if _, ok := expected[file.Name]; !ok {
			t.Fatalf("unexpected archive entry: %s", file.Name)
		}
		expected[file.Name] = true
		entry, err := file.Open()
		if err != nil {
			t.Fatal(err)
		}
		data, readErr := io.ReadAll(entry)
		if err := errors.Join(readErr, entry.Close()); err != nil {
			t.Fatal(err)
		}
		if bytes.Contains(data, []byte(private)) {
			t.Fatalf("private data in %s", file.Name)
		}
		switch file.Name {
		case "client.log":
			if !bytes.Contains(data, []byte(`"level":"DEBUG"`)) {
				t.Fatal("debug event was not persisted")
			}
		case "metadata.json":
			var metadata map[string]any
			if err := json.Unmarshal(data, &metadata); err != nil {
				t.Fatal(err)
			}
			if metadata["revision"] != "test-revision" || metadata["component"] != "client" || metadata["goos"] != runtime.GOOS || metadata["reportId"] == "" || metadata["partial"] != true {
				t.Fatalf("unexpected metadata: %v", metadata)
			}
		case "memory.json":
			var memory runtime.MemStats
			if err := json.Unmarshal(data, &memory); err != nil || memory.Sys == 0 {
				t.Fatalf("invalid memory counters: %v", err)
			}
		case "heap.pprof":
			profile, err := gzip.NewReader(bytes.NewReader(data))
			if err != nil {
				t.Fatal(err)
			}
			profileData, err := io.ReadAll(profile)
			if err != nil || len(profileData) == 0 || bytes.Contains(profileData, []byte(private)) {
				t.Fatalf("invalid or private heap allocation profile: %v", err)
			}
			if err := profile.Close(); err != nil {
				t.Fatal(err)
			}
		case "goroutines.txt":
			if !bytes.HasPrefix(data, []byte("goroutine profile: total ")) || bytes.Contains(data, []byte("[running]:")) {
				t.Fatal("expected aggregated goroutine profile")
			}
		}
	}
	for name, found := range expected {
		if !found {
			t.Fatalf("missing archive entry: %s", name)
		}
	}
	second, err := recorder.Export()
	if err != nil || second == archivePath || recorder.LastExportPath() != second {
		t.Fatalf("export must have a unique path: %q, %v", second, err)
	}
	_ = recorder.Close()
	reopened, err := Open(directory, "client", "next-process")
	if err != nil {
		t.Fatal(err)
	}
	defer reopened.Close()
	if reopened.log.retention()["earlierHistoryMayBeMissing"] != true {
		t.Fatal("restart incorrectly claimed complete prior history")
	}
}

func TestRecorderKeepsTheLastSuccessfulExportAfterFailureAndClose(t *testing.T) {
	recorder, err := Open(t.TempDir(), "client", "test")
	if err != nil {
		t.Fatal(err)
	}
	defer recorder.Close()
	if path := recorder.LastExportPath(); path != "" {
		t.Fatalf("unexpected initial report: %q", path)
	}
	saved, err := recorder.Export()
	if err != nil {
		t.Fatal(err)
	}
	original := recorder.log.path
	// A regular file in the directory position makes archive creation fail on every OS.
	recorder.log.path = filepath.Join(original, "unavailable", "client.log")
	path, exportErr := recorder.Export()
	recorder.log.path = original
	if path != "" || exportErr == nil || recorder.LastExportPath() != saved {
		t.Fatalf("failed export replaced the saved report: %q, %v", path, exportErr)
	}
	if err := recorder.Close(); err != nil {
		t.Fatal(err)
	}
	if path, err := recorder.Export(); path != "" || !errors.Is(err, os.ErrClosed) || recorder.LastExportPath() != saved {
		t.Fatalf("closed recorder lost the saved report: %q, %v", path, err)
	}
	archive, err := zip.OpenReader(saved)
	if err != nil {
		t.Fatalf("saved report is unavailable or incomplete: %v", err)
	}
	_ = archive.Close()
}

type exportContext func() ([]byte, error)

func (value exportContext) MarshalJSON() ([]byte, error) { return value() }

func TestRecorderCloseWaitsForAnExportAlreadyInProgress(t *testing.T) {
	recorder, err := Open(t.TempDir(), "client", "test")
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { _ = recorder.Close() })
	started, release := make(chan struct{}), make(chan struct{})
	resume := sync.OnceFunc(func() { close(release) })
	defer resume()
	recorder.context = map[string]any{"barrier": exportContext(func() ([]byte, error) {
		close(started)
		<-release
		return []byte("null"), nil
	})}
	type result struct {
		path string
		err  error
	}
	exported := make(chan result, 1)
	go func() {
		path, err := recorder.Export()
		exported <- result{path, err}
	}()
	select {
	case <-started:
	case <-time.After(5 * time.Second):
		t.Fatal("export did not reach the archive writer")
	}
	closing, closed := make(chan struct{}), make(chan error, 1)
	go func() { close(closing); closed <- recorder.Close() }()
	<-closing
	select {
	case err := <-closed:
		t.Fatalf("Close returned before the archive finished: %v", err)
	case <-time.After(25 * time.Millisecond):
	}
	resume()
	completed := <-exported
	if err := <-closed; err != nil || completed.err != nil || completed.path == "" || recorder.LastExportPath() != completed.path {
		t.Fatalf("Close lost the completed report: %v, %v, %q", err, completed.err, completed.path)
	}
	archive, err := zip.OpenReader(completed.path)
	if err != nil {
		t.Fatalf("Close exposed an unfinished archive: %v", err)
	}
	_ = archive.Close()
}

func TestRecorderCloseAndFailures(t *testing.T) {
	if _, err := Open(t.TempDir(), "../client", "test"); err == nil {
		t.Fatal("accepted a component path")
	}
	recorder, err := Open(t.TempDir(), "server", "test")
	if err != nil {
		t.Fatal(err)
	}
	var workers sync.WaitGroup
	var started sync.WaitGroup
	started.Add(4)
	stop := make(chan struct{})
	defer func() {
		close(stop)
		workers.Wait()
	}()
	for worker := range 4 {
		workers.Go(func() {
			recorder.Logger().Debug("concurrent log", "worker", worker)
			started.Done()
			for {
				select {
				case <-stop:
					return
				default:
				}
				recorder.Logger().Debug("concurrent log", "worker", worker)
			}
		})
	}
	started.Wait()
	if _, err := recorder.Export(); err != nil {
		t.Fatal(err)
	}
	workers.Go(func() {
		if _, err := recorder.Export(); err != nil && !errors.Is(err, os.ErrClosed) {
			t.Errorf("concurrent export: %v", err)
		}
	})
	if err := recorder.Close(); err != nil {
		t.Fatal(err)
	}
	if err := recorder.Close(); err != nil {
		t.Fatal(err)
	}
	if _, err := recorder.Export(); !errors.Is(err, os.ErrClosed) {
		t.Fatalf("export after close: %v", err)
	}
	failing, err := Open(t.TempDir(), "client", "test")
	if err != nil {
		t.Fatal(err)
	}
	if err := failing.log.file.Close(); err != nil {
		t.Fatal(err)
	}
	failing.Logger().Error("write fails")
	partial, err := failing.Export()
	if err != nil {
		t.Fatalf("one failed log writer discarded usable runtime evidence: %v", err)
	}
	archive, err := zip.OpenReader(partial)
	if err != nil {
		t.Fatal(err)
	}
	defer archive.Close()
	entry, err := archive.Open("metadata.json")
	if err != nil {
		t.Fatal(err)
	}
	var metadata map[string]any
	if err = json.NewDecoder(entry).Decode(&metadata); err != nil {
		t.Fatal(err)
	}
	_ = entry.Close()
	if metadata["partial"] != true || len(metadata["collectorErrors"].([]any)) == 0 {
		t.Fatalf("partial export hid failed collection: %v", metadata)
	}
	if err := failing.Close(); !errors.Is(err, os.ErrClosed) {
		t.Fatalf("close hid a log write failure: %v", err)
	}
	if _, err := (&boundedWriter{writer: io.Discard, remaining: 1}).Write([]byte("xx")); err == nil || !strings.Contains(err.Error(), "8 MiB") {
		t.Fatalf("profile output limit: %v", err)
	}
}

func TestPionDependencyLogsRespectDiagnosticOptIn(t *testing.T) {
	recorder, err := Open(t.TempDir(), "client", "test")
	if err != nil {
		t.Fatal(err)
	}
	defer recorder.Close()
	stderr, err := os.CreateTemp(t.TempDir(), "stderr")
	if err != nil {
		t.Fatal(err)
	}
	previousLogger, previousStderr := slog.Default(), os.Stderr
	os.Stderr = stderr
	defer func() {
		os.Stderr = previousStderr
		slog.SetDefault(previousLogger)
		_ = stderr.Close()
	}()
	const secret = "must-not-appear-in-report"
	var normal bytes.Buffer
	slog.SetDefault(slog.New(slog.NewTextHandler(&normal, nil)))
	PionLoggerFactory().NewLogger("pc").Errorf("dropping candidate with ufrag %s because it doesn't match", secret)
	slog.Error("capture process failed", Error(errors.New("capture process stopped unexpectedly")))
	slog.SetDefault(recorder.Logger())
	PionLoggerFactory().NewLogger("pc").Errorf("dropping candidate with ufrag %s because it doesn't match", secret)
	output, err := os.ReadFile(stderr.Name())
	if err != nil {
		t.Fatal(err)
	}
	if len(output) != 0 {
		t.Fatal("dependency details bypassed the opt-in diagnostic writer through stderr")
	}
	if strings.Contains(normal.String(), "dropping candidate") || strings.Contains(normal.String(), secret) ||
		!strings.Contains(normal.String(), "capture process stopped unexpectedly") {
		t.Fatal("normal logging lost the owning failure or exposed ICE details")
	}
	data, err := os.ReadFile(recorder.LogPath())
	if err != nil {
		t.Fatal(err)
	}
	if bytes.Contains(data, []byte(secret)) || !bytes.Contains(data, []byte("dropping candidate with ufrag [redacted]")) {
		t.Fatal("Debug logging lost the dependency cause or retained its ICE credential")
	}
}

func TestDependencyDiagnosticsPreserveCausesWithoutSecrets(t *testing.T) {
	recorder, err := Open(t.TempDir(), "client", "test")
	if err != nil {
		t.Fatal(err)
	}
	defer recorder.Close()
	previous := slog.Default()
	slog.SetDefault(recorder.Logger())
	defer slog.SetDefault(previous)
	const secret = "must-not-appear-in-report"
	recorder.Logger().Error("operation", Error(fmt.Errorf("interface enumeration: %w", syscall.EAFNOSUPPORT)),
		"requestId", "request-17", "nested", map[string]any{"instanceToken": secret, "state": "checking"})
	PionLoggerFactory().NewLogger("ice").Debugf("Started agent: remoteUfrag: %q, remotePwd: %q", secret, secret)
	PionLoggerFactory().NewLogger("ice").Warnf("mismatch username expected(%x) actual(%x)", secret, secret)
	PionLoggerFactory().NewLogger("pc").Errorf("dropping candidate with ufrag %s because it doesn't match", secret)
	PionLoggerFactory().NewLogger("ice").Warnf("Failed to get TCP connections by ufrag: tcp4 127.0.0.1:1 %s", secret)
	PionLoggerFactory().NewLogger("pc").Debugf("got new track: &{id:%s streamID:private-track-identity peeked:[1 2]}", secret)
	writer := Writer("capture")
	for _, part := range []string{"stage=device-open\nAuthorization: Bear", "er " + secret + "\n",
		"-----BEGIN PRIVATE KEY-----\n", secret + "\n-----END PRIVATE KEY-----\n",
		"https://example.test/r/1234#v=" + secret + "\n", "hresult=0x80070005"} {
		if _, err := writer.Write([]byte(part)); err != nil {
			t.Fatal(err)
		}
	}
	_ = writer.Close()
	MediaLogger("test").Warnw("media initialization", fmt.Errorf("network adapter unavailable"), "trackId", "private-track-identity", "stats", diagnosticObject{value: secret})
	data, err := os.ReadFile(recorder.LogPath())
	if err != nil {
		t.Fatal(err)
	}
	for _, forbidden := range []string{secret, fmt.Sprintf("%x", secret), "private-track-identity"} {
		if bytes.Contains(data, []byte(forbidden)) {
			t.Fatalf("sensitive value retained: %q", forbidden)
		}
	}
	for _, useful := range []string{"request-17", "interface enumeration", "systemCode", "device-open", "0x80070005", "network adapter unavailable", "checking", `"jitter":12`} {
		if !bytes.Contains(data, []byte(useful)) {
			t.Fatalf("missing diagnostic context: %q", useful)
		}
	}
}

type diagnosticObject struct{ value string }

func (object diagnosticObject) MarshalLogObject(encoder zapcore.ObjectEncoder) error {
	encoder.AddInt("jitter", 12)
	encoder.AddString("password", object.value)
	return nil
}