From 74643ff270c4e2d40deb40b05069602dd5097bd7 Mon Sep 17 00:00:00 2001 From: Samuel K Date: Tue, 17 Nov 2026 12:22:45 -0600 Subject: [PATCH 01/11] feat(logging): unify diagnostics and operational telemetry --- .golangci.yaml | 172 +++++++ AGENTS.md | 2 + cmd/ci/ci.go | 30 +- cmd/ci/ci_test.go | 19 + cmd/ci/status.go | 12 +- cmd/ci/status_test.go | 22 +- cmd/config/apply.go | 4 +- cmd/env_flags_test.go | 129 +++++- cmd/feature/outdated.go | 21 +- cmd/feature/outdated_test.go | 24 + cmd/feature/test.go | 19 +- cmd/feature/test_test.go | 5 - cmd/flag_aliases_test.go | 44 +- cmd/flags/flags.go | 45 +- cmd/internal/agent.go | 41 +- .../agentcontainer/credentials_server_test.go | 4 +- cmd/internal/agentcontainer/daemon.go | 1 + cmd/internal/agentcontainer/setup.go | 18 +- cmd/internal/agentcontainer/setup_ide.go | 1 + cmd/internal/agentworkspace/build.go | 2 +- .../agentworkspace/install_dotfiles.go | 4 +- cmd/internal/agentworkspace/logs.go | 4 + cmd/internal/agentworkspace/up.go | 17 +- cmd/internal/logs_daemon.go | 18 +- cmd/internal/runusercommands.go | 2 +- cmd/machine/describe.go | 11 + cmd/machine/diagnostics.go | 19 +- cmd/machine/inspect.go | 4 + cmd/machine/ssh.go | 6 +- cmd/platform/cluster/add.go | 4 +- cmd/platform/daemon/start.go | 2 +- cmd/platform/daemon/status.go | 3 +- cmd/platform/provider/provider.go | 4 - cmd/platform/provider/up.go | 5 +- cmd/platform/workspace/watch.go | 2 +- cmd/provider/add.go | 2 +- cmd/provider/configure_shared.go | 46 +- cmd/provider/init.go | 3 +- cmd/provider/init_environment_test.go | 68 +++ cmd/provider/set_source.go | 2 +- cmd/provider/versions.go | 9 +- cmd/provider/versions_test.go | 67 ++- cmd/root.go | 142 ++++-- cmd/root_test.go | 227 +++++++++- cmd/workspace/build.go | 2 +- cmd/workspace/delete.go | 2 +- cmd/workspace/delete_test.go | 6 +- cmd/workspace/describe_test.go | 10 +- cmd/workspace/exec.go | 18 +- cmd/workspace/exec_tty_unix_test.go | 73 +++ cmd/workspace/gpg_tunnel.go | 14 +- cmd/workspace/import.go | 2 +- cmd/workspace/logs.go | 28 +- cmd/workspace/setup_logs.go | 4 + cmd/workspace/ssh.go | 16 +- cmd/workspace/status_test.go | 4 +- cmd/workspace/stop.go | 2 +- cmd/workspace/up/agent.go | 37 +- cmd/workspace/up/detach.go | 4 +- cmd/workspace/up/detach_test.go | 2 +- .../up/interactive_post_start_cli_test.go | 4 +- cmd/workspace/up/status_no_status_test.go | 35 +- cmd/workspace/up/up.go | 4 +- desktop/src/main/__tests__/analytics.test.ts | 172 +++++++ .../main/__tests__/cli-error-envelope.test.ts | 39 +- desktop/src/main/__tests__/cli.test.ts | 195 +++++++- .../main/__tests__/ipc-provider-icon.test.ts | 2 +- .../main/__tests__/ipc-provider-jobs.test.ts | 90 +++- .../main/__tests__/ipc-secret-session.test.ts | 14 +- .../src/main/__tests__/ipc-up-tasks.test.ts | 32 +- .../main/__tests__/ipc-workspace-jobs.test.ts | 19 +- desktop/src/main/__tests__/logging.test.ts | 120 ++++- desktop/src/main/__tests__/machine-id.test.ts | 228 ++++++++++ .../src/main/__tests__/renderer-error.test.ts | 108 +++++ .../__tests__/workspace-presentation.test.ts | 52 ++- desktop/src/main/analytics.ts | 113 ++++- desktop/src/main/cli.ts | 280 +++++++----- desktop/src/main/index.ts | 11 +- desktop/src/main/ipc.ts | 213 ++++++--- desktop/src/main/logging.ts | 209 ++++++++- desktop/src/main/machine-id.ts | 88 ++-- desktop/src/main/renderer-error.ts | 90 ++++ desktop/src/preload/index.test.ts | 39 ++ desktop/src/preload/index.ts | 5 + .../components/provider/ProviderSheet.svelte | 7 +- .../components/provider/ProviderWizard.svelte | 7 +- .../workspace/WorkspaceWizard.svelte | 5 +- desktop/src/renderer/src/lib/ipc/bridge.ts | 2 + desktop/src/renderer/src/lib/types/index.ts | 12 +- .../renderer/src/lib/utils/log-parser.test.ts | 23 + .../src/renderer/src/lib/utils/log-parser.ts | 40 +- .../src/lib/utils/renderer-error.test.ts | 75 ++++ .../renderer/src/lib/utils/renderer-error.ts | 53 +++ desktop/src/renderer/src/main.ts | 5 + .../src/pages/WorkspaceDetailPage.svelte | 5 +- desktop/src/shared/cli-error.ts | 98 ++-- desktop/src/shared/renderer-error.ts | 50 +++ e2e/framework/command.go | 2 +- e2e/tests/ci/ci.go | 25 +- e2e/tests/ide/browser_returns.go | 6 +- e2e/tests/logs/logs.go | 2 +- e2e/tests/machineprovider/machineprovider.go | 6 +- e2e/tests/snapshot/snapshot.go | 2 +- e2e/tests/ssh/detached_task.go | 2 +- e2e/tests/tunnel/tunnel.go | 4 +- e2e/tests/up-docker-compose/build.go | 6 +- e2e/tests/up-docker-compose/helper.go | 2 +- .../up-docker-compose/up_docker_compose.go | 22 +- e2e/tests/up-features/wsl.go | 2 +- e2e/tests/up/docker_wsl.go | 2 +- e2e/tests/up/dockerfile_build.go | 8 +- e2e/tests/up/handles_errors.go | 10 +- e2e/tests/up/provider_docker.go | 6 +- .../up/provider_kubernetes_dockerless_path.go | 2 +- e2e/tests/up/provider_kubernetes_ignore.go | 2 +- e2e/tests/up/provider_kubernetes_ssh_agent.go | 2 +- .../up/provider_microsandbox_dockerless.go | 2 +- e2e/tests/up/provider_microsandbox_mounts.go | 2 +- .../up/provider_podman_rootful_features.go | 2 +- .../up/provider_podman_rootless_features.go | 2 +- e2e/tests/up/up.go | 2 +- hack/sign_commit/main_test.go | 5 +- pkg/agent/agent.go | 9 +- pkg/agent/agent_test.go | 33 +- .../exec_stream_cancellation_unix_test.go | 32 ++ pkg/agent/dockerless.go | 4 +- pkg/client/client.go | 23 +- .../clientimplementation/daemonclient/up.go | 28 +- .../clientimplementation/machine_client.go | 186 +++++--- .../machine_logging_test.go | 86 ++++ .../clientimplementation/proxy_client.go | 173 +++++--- .../clientimplementation/proxy_status_test.go | 110 +++++ .../clientimplementation/workspace_client.go | 129 ++++-- .../workspace_client_test.go | 179 +++++++- pkg/client/proxycmd/proxycmd.go | 2 +- pkg/client/up_options_test.go | 64 +++ pkg/clierr/errors.go | 28 +- pkg/clierr/errors_test.go | 52 ++- pkg/clierr/ssh.go | 76 ++++ pkg/clierr/ssh_test.go | 67 +++ pkg/config/env.go | 3 - pkg/daemon/local/daemon.go | 3 +- pkg/daemon/platform/daemon.go | 15 +- pkg/daemon/platform/local_server.go | 2 +- pkg/devcontainer/build_record_test.go | 11 +- pkg/devcontainer/buildkit/record_test.go | 12 +- pkg/devcontainer/buildkit/remote.go | 2 +- pkg/devcontainer/compose.go | 6 +- pkg/devcontainer/compose_build.go | 4 +- pkg/devcontainer/compose_resume.go | 2 +- pkg/devcontainer/config/host_requirements.go | 6 +- pkg/devcontainer/delete_test.go | 10 +- .../feature/options_secret_test.go | 5 +- pkg/devcontainer/initialize.go | 4 +- pkg/devcontainer/initialize_record_test.go | 3 +- pkg/devcontainer/setup.go | 12 +- pkg/devcontainer/setup/dotfiles.go | 2 +- .../setup/lifecycle_terminal_linux_test.go | 5 +- .../setup/lifecyclehooks_record_test.go | 3 +- pkg/devcontainer/setup/lifecyclehooks_test.go | 3 +- pkg/devcontainer/setup/setup.go | 106 ++++- pkg/devcontainer/setup/setup_test.go | 61 ++- pkg/devcontainer/setup_test.go | 13 +- pkg/devcontainer/single.go | 16 +- pkg/devcontainer/single_delivery_test.go | 5 +- pkg/devcontainer/single_test.go | 59 +++ pkg/devcontainer/sshtunnel/sshtunnel.go | 2 +- pkg/devcontainer/sshtunnel/sshtunnel_test.go | 43 +- pkg/dotfiles/dotfiles.go | 24 +- pkg/dotfiles/dotfiles_test.go | 9 +- pkg/driver/apple/build.go | 5 +- pkg/driver/apple/build_record_test.go | 25 +- pkg/driver/apple/driver.go | 43 +- pkg/driver/apple/lifecycle.go | 23 +- pkg/driver/custom/custom.go | 188 ++++---- pkg/driver/custom/custom_logging_test.go | 138 ++++++ pkg/driver/docker/build.go | 4 +- pkg/driver/docker/build_record_test.go | 11 +- pkg/driver/docker/build_test.go | 5 +- pkg/driver/docker/docker.go | 31 ++ pkg/driver/docker/lifecycle.go | 34 +- pkg/driver/docker/lifecycle_test.go | 13 +- pkg/driver/external/exec_test.go | 9 +- pkg/driver/external/host.go | 8 + pkg/driver/external/host_test.go | 62 ++- .../external/internal/testfixture/main.go | 9 + pkg/driver/external/logs_test.go | 9 +- pkg/driver/external/session.go | 103 ++++- pkg/driver/external/session_logging_test.go | 52 ++- pkg/driver/kubernetes/client_test.go | 28 ++ pkg/driver/kubernetes/driver.go | 72 ++- pkg/driver/kubernetes/find.go | 5 +- pkg/driver/kubernetes/run.go | 3 +- pkg/driver/microsandbox/cliclient.go | 35 +- pkg/driver/microsandbox/cliclient_test.go | 17 + .../exec_cancellation_unix_test.go | 84 +++- pkg/driver/microsandbox/microsandbox.go | 30 +- pkg/envfile/envfile.go | 7 + pkg/envfile/envfile_test.go | 64 ++- pkg/flags/env.go | 9 +- pkg/flags/env_test.go | 1 - pkg/flags/names/names.go | 4 - pkg/flags/names/names_test.go | 9 +- pkg/ghcredentials/host.go | 18 +- pkg/ghcredentials/install_test.go | 19 + pkg/ghcredentials/process_unix.go | 8 +- pkg/ghcredentials/process_windows.go | 8 +- pkg/ghcredentials/result.go | 33 +- pkg/ghcredentials/session.go | 24 +- pkg/ghcredentials/wrapper.go | 43 +- pkg/git/installer.go | 2 +- pkg/git/progress_test.go | 6 +- pkg/git/repo.go | 4 +- pkg/gitcredentials/credentials_server_test.go | 85 ++++ pkg/gitcredentials/gitcredentials.go | 10 +- pkg/gpg/forward.go | 4 +- pkg/gpg/forward_test.go | 5 +- pkg/ide/internal/serverutil/serverutil.go | 2 +- pkg/ide/opener/browser_preparation_test.go | 3 +- pkg/ide/opener/browser_tunnel.go | 4 +- pkg/ide/opener/opener.go | 7 +- pkg/ide/vscode/open.go | 92 ++-- pkg/ide/vscode/open_test.go | 70 ++- pkg/ide/vscode/vscode.go | 4 +- pkg/inject/inject_test.go | 3 +- pkg/log/attrs.go | 114 +++++ pkg/log/context.go | 69 +++ pkg/log/jsonstream.go | 12 +- pkg/log/levels.go | 91 ++-- pkg/log/logfmt.go | 162 ------- pkg/log/logger.go | 307 +++++++------ pkg/log/logger_test.go | 166 ++----- pkg/log/logr.go | 8 +- pkg/log/streamer.go | 308 +++++++++---- pkg/log/streamer_test.go | 152 +++++-- pkg/log/structured_test.go | 280 ++++++++++++ pkg/log/testing.go | 255 ++++++++++- pkg/log/writer.go | 76 ++-- pkg/log/writer_test.go | 131 +++++- pkg/output/mode.go | 21 +- pkg/output/mode_test.go | 19 +- pkg/provider/env.go | 1 + pkg/provider/env_logging_test.go | 22 + pkg/ssh/config.go | 13 +- pkg/ssh/connection_error_test.go | 120 +++++ pkg/ssh/helper.go | 13 +- pkg/ssh/server/exec_logging_test.go | 2 +- pkg/status/log.go | 38 +- pkg/status/observer_test.go | 104 +++++ pkg/status/render.go | 15 +- pkg/status/reporter_test.go | 54 ++- pkg/status/status.go | 53 ++- pkg/status/status_test.go | 2 +- pkg/telemetry/analytics/client.go | 5 +- pkg/telemetry/attribution_test.go | 94 ++++ pkg/telemetry/collect.go | 75 +++- pkg/telemetry/collect_test.go | 57 +++ pkg/telemetry/distinctid/distinctid.go | 40 +- pkg/telemetry/distinctid/vectors_test.go | 121 +++++ pkg/telemetry/export.go | 25 ++ pkg/telemetry/export_darwin.go | 67 +++ pkg/telemetry/export_darwin_test.go | 51 +++ pkg/telemetry/export_linux.go | 67 +++ pkg/telemetry/export_linux_test.go | 51 +++ pkg/telemetry/export_test.go | 56 +++ pkg/telemetry/export_windows.go | 120 +++++ pkg/telemetry/helpers.go | 14 +- pkg/telemetry/identity_test.go | 47 ++ pkg/telemetry/metrics.go | 419 ++++++++++++++++++ pkg/telemetry/metrics_security_windows.go | 70 +++ .../metrics_security_windows_test.go | 73 +++ pkg/telemetry/metrics_test.go | 212 +++++++++ pkg/telemetry/noop.go | 6 +- pkg/telemetry/provider_metrics_test.go | 49 ++ pkg/telemetry/testdata/identity.json | 24 + pkg/transport/lifecycle.go | 21 +- pkg/tunnel/browser.go | 30 +- pkg/tunnel/browser_test.go | 28 +- pkg/tunnel/container.go | 42 +- pkg/tunnel/container_host_test.go | 95 +++- pkg/tunnel/dial.go | 2 +- pkg/tunnel/pipebridge_test.go | 6 +- pkg/tunnel/services.go | 5 +- pkg/tunnel/services_preparation_test.go | 3 +- .../continuous-integration.mdx | 11 +- .../docs/developing-providers/driver.mdx | 2 +- .../docs/developing-providers/quickstart.mdx | 6 + .../docs/managing-providers/microsandbox.mdx | 2 +- .../docs/troubleshooting/troubleshooting.mdx | 22 +- .../tutorials/docker-provider-via-wsl.mdx | 2 +- 290 files changed, 9822 insertions(+), 2314 deletions(-) create mode 100644 desktop/src/main/__tests__/analytics.test.ts create mode 100644 desktop/src/main/__tests__/machine-id.test.ts create mode 100644 desktop/src/main/__tests__/renderer-error.test.ts create mode 100644 desktop/src/main/renderer-error.ts create mode 100644 desktop/src/preload/index.test.ts create mode 100644 desktop/src/renderer/src/lib/utils/renderer-error.test.ts create mode 100644 desktop/src/renderer/src/lib/utils/renderer-error.ts create mode 100644 desktop/src/shared/renderer-error.ts create mode 100644 pkg/client/clientimplementation/machine_logging_test.go create mode 100644 pkg/client/clientimplementation/proxy_status_test.go create mode 100644 pkg/client/up_options_test.go create mode 100644 pkg/clierr/ssh.go create mode 100644 pkg/clierr/ssh_test.go create mode 100644 pkg/driver/custom/custom_logging_test.go create mode 100644 pkg/gitcredentials/credentials_server_test.go create mode 100644 pkg/log/attrs.go create mode 100644 pkg/log/context.go delete mode 100644 pkg/log/logfmt.go create mode 100644 pkg/log/structured_test.go create mode 100644 pkg/provider/env_logging_test.go create mode 100644 pkg/ssh/connection_error_test.go create mode 100644 pkg/status/observer_test.go create mode 100644 pkg/telemetry/attribution_test.go create mode 100644 pkg/telemetry/collect_test.go create mode 100644 pkg/telemetry/distinctid/vectors_test.go create mode 100644 pkg/telemetry/export.go create mode 100644 pkg/telemetry/export_darwin.go create mode 100644 pkg/telemetry/export_darwin_test.go create mode 100644 pkg/telemetry/export_linux.go create mode 100644 pkg/telemetry/export_linux_test.go create mode 100644 pkg/telemetry/export_test.go create mode 100644 pkg/telemetry/export_windows.go create mode 100644 pkg/telemetry/identity_test.go create mode 100644 pkg/telemetry/metrics.go create mode 100644 pkg/telemetry/metrics_security_windows.go create mode 100644 pkg/telemetry/metrics_security_windows_test.go create mode 100644 pkg/telemetry/metrics_test.go create mode 100644 pkg/telemetry/provider_metrics_test.go create mode 100644 pkg/telemetry/testdata/identity.json diff --git a/.golangci.yaml b/.golangci.yaml index 606d04fbe7..d81cba1bfa 100644 --- a/.golangci.yaml +++ b/.golangci.yaml @@ -15,6 +15,7 @@ linters: enable: - cyclop - decorder + - depguard - dupl - errcheck - fatcontext @@ -30,6 +31,7 @@ linters: - modernize - nestif - revive + - sloglint - staticcheck - unparam - unused @@ -43,6 +45,146 @@ linters: - gosec text: "G101" path: "pkg/telemetry/analytics/client.go" + - path: '^cmd/env_flags_test\.go$' + linters: [gosec] + text: '^G703: Path traversal via taint analysis$' + source: 'os\.WriteFile\(os\.Getenv\("DEVSY_INVALID_NO_STATUS_MARKER"\), \[\]byte\("ran"\), 0o600\)' + - path: '^cmd/env_flags_test\.go$' + linters: [gosec] + text: '^G204: Subprocess launched with a potential tainted input or cmd arguments$' + source: '^\s*child := exec\.Command\(os\.Args\[0\], noStatusSelector\)$' + - path: '^pkg/log/streamer_test\.go$' + linters: [gosec] + text: '^G204: Subprocess launched with a potential tainted input or cmd arguments$' + source: '^\s*cmd := exec\.CommandContext\(ctx, os\.Args\[0\], streamHelperSelector\)$' + - path: '^pkg/telemetry/export_test\.go$' + linters: [gosec] + text: '^G204: Subprocess launched with a potential tainted input or cmd arguments$' + source: 'exec\.Command\(os\.Args\[0\], "-test\.run=\^TestMetricsExportProcess\$"\)' + - path: '^pkg/gitcredentials/gitcredentials\.go$' + linters: [gosec] + text: '^G204: Subprocess launched with variable$' + source: 'exec\.CommandContext\(ctx, binaryPath, args\.\.\.\)' + - path: '^cmd/provider/init_environment_test\.go$' + linters: [gosec] + text: '^G101: Potential hardcoded credentials$' + source: 'const (optionSecret = "opaque-provider-secret-78153"|hostSecret = "host-provider-secret-78154")' + - path: '^cmd/workspace/exec_tty_unix_test\.go$' + linters: [gosec] + text: '^G101: Potential hardcoded credentials$' + source: 'const secret = "raw-exec-secret-92815"' + - path: '^cmd/workspace/exec_tty_unix_test\.go$' + linters: [gosec] + text: '^G306: Expect WriteFile permissions to be 0600 or less$' + source: 'os\.WriteFile\(wrapper, \[\]byte\(script\), 0o700\)' + - path: '^pkg/telemetry/export_darwin_test\.go$' + linters: [gosec] + text: '^G306: Expect WriteFile permissions to be 0600 or less$' + source: 'os\.WriteFile\(path, \[\]byte\("existing\\n"\), 0o644\)' + - path: '^pkg/telemetry/export_darwin_test\.go$' + linters: [gosec] + text: '^G302: Expect file permissions to be 0600 or less$' + source: 'os\.Chmod\(path, 0o644\)' + - path: '^pkg/envfile/envfile_test\.go$' + linters: [gosec] + text: '^G304: Potential file inclusion via variable$' + source: 'data, err := os\.ReadFile\(path\)' + - path: '^pkg/gitcredentials/credentials_server_test\.go$' + linters: [gosec] + text: '^G703: Path traversal via taint analysis$' + source: '^\s*if err := os\.WriteFile\(recordPath, record, 0o600\); err != nil \{$' + - path: '^pkg/gitcredentials/credentials_server_test\.go$' + linters: [gosec] + text: '^G304: Potential file inclusion via variable$' + source: 'data, err := os\.ReadFile\(recordPath\)' + - path: '^cmd/env_flags_test\.go$' + linters: [gosec] + text: '^G101: Potential hardcoded credentials$' + source: '^\s*const secret = "invalid-bool-secret-9471"$' + - path: '^cmd/env_flags_test\.go$' + linters: [gosec] + text: '^G204: Subprocess launched with a potential tainted input or cmd arguments$' + source: '^\s*child := exec\.Command\(os\.Args\[0\], loggingSelector\)$' + - path: '^pkg/ghcredentials/install_test\.go$' + linters: [gosec] + text: '^G304: Potential file inclusion via variable$' + source: '^\s*trace, openErr := os\.Open\(record \+ "\.trace"\)$' + - path: '^pkg/gitcredentials/gitcredentials\.go$' + linters: [gosec] + text: '^G702: Command injection via taint analysis$' + source: '^\s*cmd := exec\.CommandContext\(ctx, binaryPath, args\.\.\.\)$' + - path: '^pkg/log/streamer_test\.go$' + linters: [gosec] + text: '^G702: Command injection via taint analysis$' + source: '^\s*cmd := exec\.CommandContext\(ctx, os\.Args\[0\], streamHelperSelector\)$' + - path: '^pkg/log/writer_test\.go$' + linters: [gosec] + text: '^G101: Potential hardcoded credentials$' + source: '^const testLongSecret = "TOKEN=long-secret-value"$' + - path: '^pkg/telemetry/export_darwin_test\.go$' + linters: [gosec] + text: '^G304: Potential file inclusion via variable$' + source: '^\s*f, err := os\.OpenFile\(path, os\.O_WRONLY, 0\)$' + - path: '^pkg/telemetry/export_darwin_test\.go$' + linters: [gosec] + text: '^G304: Potential file inclusion via variable$' + source: '^\s*data, err := os\.ReadFile\(path\)$' + - path: '^pkg/telemetry/export_test\.go$' + linters: [gosec] + text: '^G702: Command injection via taint analysis$' + source: '^\s*cmd := exec\.Command\(os\.Args\[0\], "-test\.run=\^TestMetricsExportProcess\$"\)$' + - path: '^cmd/env_flags_test\.go$' + linters: [gosec] + text: '^G702: Command injection via taint analysis$' + source: '^\s*child := exec\.Command\(os\.Args\[0\], noStatusSelector\)$' + - path: '^cmd/env_flags_test\.go$' + linters: [gosec] + text: '^G702: Command injection via taint analysis$' + source: '^\s*child := exec\.Command\(os\.Args\[0\], loggingSelector\)$' + - path: '^pkg/driver/external/host_test\.go$' + linters: [gosec] + text: '^G304: Potential file inclusion via variable$' + source: '^\s*data, err := os\.ReadFile\(filepath\.Join\(directory, kind\+"-pids"\)\)$' + - path: '^pkg/telemetry/export_test\.go$' + linters: [gosec] + text: '^G304: Potential file inclusion via variable$' + source: '^\s*data, err := os\.ReadFile\(path\)$' + - path: '^pkg/telemetry/metrics_test\.go$' + linters: [gosec] + text: '^G304: Potential file inclusion via variable$' + source: '^\s*data, err := os\.ReadFile\(path\)$' + - path: '^pkg/tunnel/container_host_test\.go$' + linters: [gosec] + text: '^G304: Potential file inclusion via variable$' + source: '^\s*f, err := os\.Open\(path\)$' + - path: '^pkg/telemetry/export_linux_test\.go$' + linters: [gosec] + text: '^G306: Expect WriteFile permissions to be 0600 or less$' + source: '^\s*if err := os\.WriteFile\(path, \[\]byte\("existing\\n"\), 0o644\); err != nil \{$' + - path: '^pkg/telemetry/export_linux_test\.go$' + linters: [gosec] + text: '^G302: Expect file permissions to be 0600 or less$' + source: '^\s*if err := os\.Chmod\(path, 0o644\); err != nil \{$' + - path: '^pkg/telemetry/export_linux_test\.go$' + linters: [gosec] + text: '^G304: Potential file inclusion via variable$' + source: '^\s*f, err := os\.OpenFile\(path, os\.O_WRONLY, 0\)$' + - path: '^pkg/telemetry/export_linux_test\.go$' + linters: [gosec] + text: '^G304: Potential file inclusion via variable$' + source: '^\s*data, err := os\.ReadFile\(path\)$' + - path: '^pkg/telemetry/export_windows\.go$' + linters: [gosec] + text: '^G103: Use of unsafe calls should be audited$' + source: '^\s*descriptor := unsafe\.Slice\(\(\*byte\)\(unsafe\.Pointer\(security\)\), int\(security\.Length\(\)\)\)$' + - path: '^pkg/telemetry/export_windows\.go$' + linters: [gosec] + text: '^G103: Use of unsafe calls should be audited$' + source: '^\s*user := unsafe\.Slice\(\(\*byte\)\(unsafe\.Pointer\(sid\)\), sid\.Len\(\)\)$' + - path: "^pkg/log/(context|logger)\\.go$" + linters: + - sloglint + text: "message should be a string literal or a constant" - path: "hack/" linters: - forbidigo @@ -50,6 +192,36 @@ linters: settings: cyclop: max-complexity: 8 + depguard: + rules: + logging: + files: + - $all + deny: + - pkg: go.uber.org/zap + desc: Use the standard structured logging API. + - pkg: github.com/go-logr/zapr + desc: Use the standard structured logging API. + sloglint: + attr-only: true + static-msg: true + key-naming-case: snake + custom-funcs: + - name: github.com/devsy-org/devsy/pkg/log.TraceContext + msg-pos: 1 + args-pos: 2 + - name: github.com/devsy-org/devsy/pkg/log.DebugContext + msg-pos: 1 + args-pos: 2 + - name: github.com/devsy-org/devsy/pkg/log.InfoContext + msg-pos: 1 + args-pos: 2 + - name: github.com/devsy-org/devsy/pkg/log.WarnContext + msg-pos: 1 + args-pos: 2 + - name: github.com/devsy-org/devsy/pkg/log.ErrorContext + msg-pos: 1 + args-pos: 2 revive: rules: - name: argument-limit diff --git a/AGENTS.md b/AGENTS.md index dfa3a0bc53..86b32b93e6 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -108,6 +108,8 @@ Run the real VM specs on Linux with KVM before claiming parity. - **Unit Testing**: Prefer using [testify suite](https://github.com/stretchr/testify#suite-package) (`testify/suite`) for writing unit tests. - **Linter**: `golangci-lint` via `mise run cli:lint` (or `mise run cli:lint:fix`). Run `mise run cli:lint:ci` before pushing changes. +Use `log.*Context` with typed `slog.Attr` values for new structured diagnostics. Prefer the canonical attribute constructors, snake_case keys, and static messages. Keep secrets, environment values, command arguments, private paths, and raw backend errors out of diagnostics and telemetry. Existing `log.*f` and unstructured calls remain supported during migration. Do not add direct zap or zapr imports. + ### TypeScript / Svelte Code Style Biome formats and checks web frontend files. diff --git a/cmd/ci/ci.go b/cmd/ci/ci.go index 95443f8ef7..f131fb75b5 100644 --- a/cmd/ci/ci.go +++ b/cmd/ci/ci.go @@ -18,6 +18,7 @@ import ( cliflags "github.com/devsy-org/devsy/pkg/flags" "github.com/devsy-org/devsy/pkg/flags/names" "github.com/devsy-org/devsy/pkg/log" + "github.com/devsy-org/devsy/pkg/output" "github.com/devsy-org/devsy/pkg/provider" "github.com/devsy-org/devsy/pkg/status" workspace2 "github.com/devsy-org/devsy/pkg/workspace" @@ -210,7 +211,11 @@ func (cmd *CICmd) execute(ctx context.Context, source string) (err error) { // workspace. ctx, cancel := up.WithSignals(ctx) defer cancel() - reporter, err := newStatusReporter(os.Stderr, cmd.Verbosity > 0 || cmd.Debug, cmd.NoStatus) + mode, err := output.ResolveMode(cmd.ResultFormat) + if err != nil { + return err + } + reporter, err := newStatusReporter(mode, os.Stderr, log.InfoEnabled(), cmd.NoStatus) if err != nil { return err } @@ -226,7 +231,7 @@ func (cmd *CICmd) execute(ctx context.Context, source string) (err error) { } // release tears down the workspace; join error with the result. defer func() { - err = errors.Join(err, resolved.release(reporter)) + err = errors.Join(err, resolved.release(ctx, reporter)) }() workspaceClient := resolved.client @@ -256,18 +261,19 @@ func (cmd *CICmd) loadConfig() (*config.Config, error) { type resolvedWorkspace struct { client client.BaseWorkspaceClient - cleanup func() error + cleanup func(context.Context) error teardown bool } -func (r *resolvedWorkspace) release(reporter status.Reporter) error { +func (r *resolvedWorkspace) release(ctx context.Context, reporter status.Reporter) error { + ctx = context.WithoutCancel(ctx) if !r.teardown { - return r.cleanup() + return r.cleanup(ctx) } - return status.Run(context.Background(), reporter, status.Operation{ + return status.Run(ctx, reporter, status.Operation{ Phase: status.PhaseDeletingWorkspace, - }, func(context.Context) error { - return r.cleanup() + }, func(ctx context.Context) error { + return r.cleanup(ctx) }) } @@ -310,10 +316,10 @@ func (cmd *CICmd) resolveWorkspace( } teardown := exists == "" && !cmd.Keep - cleanup := func() error { + cleanup := func(ctx context.Context) error { defer cleanupSSH() if teardown { - return cmd.teardown(workspaceClient) + return cmd.teardown(ctx, workspaceClient) } return nil } @@ -330,9 +336,9 @@ func (cmd *CICmd) runInContainer(ctx context.Context, c client.BaseWorkspaceClie return execCmd.Run(ctx, cmd.RunCmd) } -func (cmd *CICmd) teardown(c client.BaseWorkspaceClient) error { +func (cmd *CICmd) teardown(ctx context.Context, c client.BaseWorkspaceClient) error { log.Debugf("tearing down workspace") - ctx, cancel := context.WithTimeout(context.Background(), teardownTimeout) + ctx, cancel := context.WithTimeout(ctx, teardownTimeout) defer cancel() if err := c.Delete(ctx, client.DeleteOptions{Force: true}); err != nil { return fmt.Errorf("delete workspace: %w", err) diff --git a/cmd/ci/ci_test.go b/cmd/ci/ci_test.go index c7393f022c..fff09ad83a 100644 --- a/cmd/ci/ci_test.go +++ b/cmd/ci/ci_test.go @@ -1,6 +1,7 @@ package ci import ( + "context" "testing" "github.com/devsy-org/devsy/cmd/flags" @@ -110,3 +111,21 @@ func TestNewCICmd_Flags(t *testing.T) { } assert.Equal(t, "false", ciCmd.Flags().Lookup("keep").DefValue) } + +func TestReleasePreservesContextAfterCancellation(t *testing.T) { + type key struct{} + ctx, cancel := context.WithCancel(context.WithValue(context.Background(), key{}, "operation")) + cancel() + called := false + resolved := &resolvedWorkspace{ + teardown: true, + cleanup: func(cleanupCtx context.Context) error { + called = true + assert.NoError(t, cleanupCtx.Err()) + assert.Equal(t, "operation", cleanupCtx.Value(key{})) + return nil + }, + } + require.NoError(t, resolved.release(ctx, nil)) + assert.True(t, called) +} diff --git a/cmd/ci/status.go b/cmd/ci/status.go index e1773cc2e0..51f6c59f81 100644 --- a/cmd/ci/status.go +++ b/cmd/ci/status.go @@ -3,12 +3,18 @@ package ci import ( "io" + config2 "github.com/devsy-org/devsy/pkg/devcontainer/config" "github.com/devsy-org/devsy/pkg/status" ) -func newStatusReporter(out io.Writer, verbose bool, noStatus bool) (status.Reporter, error) { +func newStatusReporter( + format string, + out io.Writer, + verbose bool, + noStatus bool, +) (status.Reporter, error) { return status.NewCLIReporter(status.CLIOptions{ - Format: "plain", + Format: format, Out: out, Prefix: "ci", Verbose: verbose, @@ -28,6 +34,6 @@ func newStatusReporter(out io.Writer, verbose bool, noStatus bool) (status.Repor status.PhaseRunningCommand: "running command", status.PhaseDeletingWorkspace: "tearing down workspace", }, - Envelope: func(status.Event) error { return nil }, + Envelope: func(e status.Event) error { return config2.WriteStatusJSON(out, e) }, }) } diff --git a/cmd/ci/status_test.go b/cmd/ci/status_test.go index e6794a2f38..514b56f79e 100644 --- a/cmd/ci/status_test.go +++ b/cmd/ci/status_test.go @@ -2,6 +2,7 @@ package ci import ( "bytes" + "encoding/json" "strings" "testing" @@ -10,7 +11,7 @@ import ( func TestStatusReporterUsesDeterministicASCIIOutput(t *testing.T) { var out bytes.Buffer - reporter, err := newStatusReporter(&out, false, false) + reporter, err := newStatusReporter("plain", &out, false, false) if err != nil { t.Fatalf("newStatusReporter: %v", err) } @@ -39,7 +40,7 @@ func TestStatusReporterUsesDeterministicASCIIOutput(t *testing.T) { func TestStatusReporterNoStatus(t *testing.T) { for _, verbose := range []bool{false, true} { var out bytes.Buffer - reporter, err := newStatusReporter(&out, verbose, true) + reporter, err := newStatusReporter("plain", &out, verbose, true) if err != nil { t.Fatal(err) } @@ -49,3 +50,20 @@ func TestStatusReporterNoStatus(t *testing.T) { } } } + +func TestStatusReporterJSON(t *testing.T) { + var out bytes.Buffer + reporter, err := newStatusReporter("json", &out, false, false) + if err != nil { + t.Fatal(err) + } + reporter.Report(status.Event{Phase: status.PhaseRunningCommand, State: status.StateStarted}) + var event map[string]any + if err := json.Unmarshal(out.Bytes(), &event); err != nil { + t.Fatalf("invalid JSON status %q: %v", out.String(), err) + } + if event["kind"] != "status" || event["phase"] != string(status.PhaseRunningCommand) || + event["state"] != string(status.StateStarted) { + t.Fatalf("unexpected status event: %#v", event) + } +} diff --git a/cmd/config/apply.go b/cmd/config/apply.go index 3da077f05b..5c6c340886 100644 --- a/cmd/config/apply.go +++ b/cmd/config/apply.go @@ -78,7 +78,7 @@ func (cmd *ApplyCmd) Run(ctx context.Context) error { reporter, err := newStatusReporter( cmd.ResultFormat, os.Stdout, - cmd.Verbosity > 0 || cmd.Debug, + log.InfoEnabled(), cmd.NoStatus, ) if err != nil { @@ -389,7 +389,7 @@ func (cmd *ApplyCmd) copyAndExecFeatures( // Raw Docker output must never share stdout with status and result // envelopes. The configured logger preserves the selected machine // encoding on stderr instead. - outputWriter := log.Writer(log.LevelInfo) + outputWriter := log.Writer(log.SlogLevelInfo) defer func() { _ = outputWriter.Close() }() streams.LiveStdout = nil streams.Stdout = outputWriter diff --git a/cmd/env_flags_test.go b/cmd/env_flags_test.go index d9b2bc2d27..654eeed75e 100644 --- a/cmd/env_flags_test.go +++ b/cmd/env_flags_test.go @@ -1,6 +1,11 @@ package cmd import ( + "bytes" + "encoding/json" + "os" + "os/exec" + "path/filepath" "strings" "testing" @@ -13,13 +18,122 @@ import ( ) const ( - envDevsyHost = "DEVSY_HOST" - envDevsyProject = "DEVSY_PROJECT" - cmdWorkspace = "workspace" - cmdProvider = "provider" - cmdList = "list" + envDevsyHost = "DEVSY_HOST" + envDevsyProject = "DEVSY_PROJECT" + cmdWorkspace = "workspace" + cmdProvider = "provider" + cmdList = "list" + testVersionFlag = "--version" + testAgentCommand = "agent" + testLogLevelEnv = "DEVSY_LOG_LEVEL" + testLogFormatEnv = "DEVSY_LOG_FORMAT" + testResultFormatEnv = "DEVSY_RESULT_FORMAT" + testRootCommand = "root" ) +const ( + noStatusSelector = "-test.run=^TestInvalidNoStatusEnvironmentStopsBeforeCommand$" + loggingSelector = "-test.run=^TestInvalidLoggingEnvironmentDoesNotExposeValue$" +) + +func TestInvalidNoStatusEnvironmentStopsBeforeCommand(t *testing.T) { + if os.Getenv("DEVSY_INVALID_NO_STATUS_CHILD") == "1" { + os.Args = []string{devsy, testVersionFlag} + _ = run() + _ = os.WriteFile(os.Getenv("DEVSY_INVALID_NO_STATUS_MARKER"), []byte("ran"), 0o600) + return + } + + const secret = "invalid-bool-secret-9471" + for _, registered := range []bool{false, true} { + name := "unregistered" + if registered { + name = "registered" + } + t.Run(name, func(t *testing.T) { + dir := t.TempDir() + marker := filepath.Join(dir, "command-ran") + metrics := filepath.Join(dir, "metrics.jsonl") + t.Setenv("DEVSY_INVALID_NO_STATUS_CHILD", "1") + t.Setenv("DEVSY_INVALID_NO_STATUS_MARKER", marker) + t.Setenv(config.EnvHome, dir) + t.Setenv("DEVSY_NO_STATUS", secret) + t.Setenv("DEVSY_TEST_SECRET", "") + if registered { + t.Setenv("DEVSY_TEST_SECRET", secret) + } + t.Setenv(testLogFormatEnv, logOutputJSON) + t.Setenv("DEVSY_METRICS_FILE", metrics) + child := exec.Command(os.Args[0], noStatusSelector) + var stdout, stderr bytes.Buffer + child.Stdout = &stdout + child.Stderr = &stderr + err := child.Run() + var exitErr *exec.ExitError + require.ErrorAs(t, err, &exitErr) + require.NotZero(t, exitErr.ExitCode()) + var record map[string]any + require.NoError(t, json.Unmarshal(bytes.TrimSpace(stderr.Bytes()), &record)) + assert.Equal(t, "fatal", record["level"]) + assert.Contains(t, record["msg"], "DEVSY_NO_STATUS") + assert.NotContains(t, stdout.String(), secret) + assert.NotContains(t, stderr.String(), secret) + _, err = os.Stat(marker) + require.True(t, os.IsNotExist(err)) + _, err = os.Stat(metrics) + require.True(t, os.IsNotExist(err)) + }) + } +} + +func TestInvalidLoggingEnvironmentDoesNotExposeValue(t *testing.T) { + if mode := os.Getenv("DEVSY_TEST_INVALID_LOG_CHILD"); mode != "" { + os.Args = []string{devsy, "context", cmdList} + if mode == testAgentCommand { + os.Args = []string{devsy, "internal", testAgentCommand, "git-credentials"} + } + os.Exit(run()) + } + const canary = "synthetic-invalid-logging-value-81492" + for _, tc := range []struct { + name string + mode string + env string + message string + choice string + }{ + {"root level", testRootCommand, testLogLevelEnv, "invalid log level", "trace"}, + {"root format", testRootCommand, testLogFormatEnv, "invalid log format", logOutputLogfmt}, + {"root result format", testRootCommand, testResultFormatEnv, "unexpected output format", "plain"}, + {"agent level", testAgentCommand, testLogLevelEnv, "invalid log level", "trace"}, + {"agent format", testAgentCommand, testLogFormatEnv, "invalid log format", logOutputLogfmt}, + {"agent result format", testAgentCommand, testResultFormatEnv, "unexpected output format", "plain"}, + } { + t.Run(tc.name, func(t *testing.T) { + t.Setenv("DEVSY_TEST_INVALID_LOG_CHILD", tc.mode) + t.Setenv(config.EnvHome, t.TempDir()) + t.Setenv(testLogLevelEnv, "") + t.Setenv(testLogFormatEnv, "") + t.Setenv(testResultFormatEnv, "") + t.Setenv("DEVSY_NO_STATUS", "") + t.Setenv("DEVSY_METRICS_FILE", "") + t.Setenv(tc.env, canary) + child := exec.Command(os.Args[0], loggingSelector) + var stdout, stderr bytes.Buffer + child.Stdout = &stdout + child.Stderr = &stderr + err := child.Run() + var exitErr *exec.ExitError + require.ErrorAs(t, err, &exitErr) + require.NotZero(t, exitErr.ExitCode()) + assert.Contains(t, stderr.String(), tc.message) + assert.Contains(t, stderr.String(), tc.choice) + assert.NotContains(t, stderr.String(), canary) + assert.Empty(t, stdout.String()) + }) + } +} + // TestOptInEnvFlags_AppliesEnvValueToFlag verifies that for each opt-in flag, // setting the corresponding DEVSY_* env var pushes the value into the bound // pflag at registration time, satisfying cobra's required-flag check. @@ -35,7 +149,10 @@ func TestOptInEnvFlags_AppliesEnvValueToFlag(t *testing.T) { {flagName: "home", envName: "DEVSY_HOME", want: "/tmp/h", persistent: true}, {flagName: "context", envName: "DEVSY_CONTEXT", want: "ctx-a", persistent: true}, {flagName: cmdProvider, envName: "DEVSY_PROVIDER", want: "docker", persistent: true}, - {flagName: "debug", envName: "DEVSY_DEBUG", want: "true", persistent: true}, + {flagName: "log-level", envName: testLogLevelEnv, want: "debug", persistent: true}, + {flagName: "log-format", envName: testLogFormatEnv, want: logOutputJSON, persistent: true}, + {flagName: "result-format", envName: testResultFormatEnv, want: "text", persistent: true}, + {flagName: "no-status", envName: "DEVSY_NO_STATUS", want: "true", persistent: true}, { cmdPath: "platform workspace list", flagName: "host", diff --git a/cmd/feature/outdated.go b/cmd/feature/outdated.go index fcda34b8be..7bbe2e6d3a 100644 --- a/cmd/feature/outdated.go +++ b/cmd/feature/outdated.go @@ -2,6 +2,7 @@ package feature import ( "context" + "encoding/json" "fmt" "os" "path/filepath" @@ -14,6 +15,7 @@ import ( cliflags "github.com/devsy-org/devsy/pkg/flags" "github.com/devsy-org/devsy/pkg/flags/names" "github.com/devsy-org/devsy/pkg/log" + "github.com/devsy-org/devsy/pkg/output" "github.com/devsy-org/devsy/pkg/table" "github.com/google/go-containerregistry/pkg/authn" "github.com/google/go-containerregistry/pkg/name" @@ -63,17 +65,34 @@ func NewOutdatedCmd(f *flags.GlobalFlags) *cobra.Command { // Run runs the command logic. func (cmd *OutdatedCmd) Run(ctx context.Context) error { + mode, err := output.ResolveMode(cmd.ResultFormat) + if err != nil { + return err + } parsedConfig, err := cmd.loadConfig(ctx) if err != nil { return err } - if len(parsedConfig.Features) == 0 { + if len(parsedConfig.Features) == 0 && mode != output.ModeJSON { _, _ = fmt.Fprintln(os.Stdout, noFeaturesMessage) return nil } outdated := checkOutdatedFeatures(parsedConfig.Features) + if mode == output.ModeJSON { + sort.Slice(outdated, func(i, j int) bool { return outdated[i].repo < outdated[j].repo }) + type resultEntry struct { + Feature string `json:"feature"` + Current string `json:"current"` + Latest string `json:"latest"` + } + result := make([]resultEntry, 0, len(outdated)) + for _, entry := range outdated { + result = append(result, resultEntry{entry.repo, entry.current, entry.latest}) + } + return json.NewEncoder(os.Stdout).Encode(result) + } if len(outdated) == 0 { _, _ = fmt.Fprintln(os.Stdout, allUpToDateMessage) return nil diff --git a/cmd/feature/outdated_test.go b/cmd/feature/outdated_test.go index 3e239febce..8a29b87a11 100644 --- a/cmd/feature/outdated_test.go +++ b/cmd/feature/outdated_test.go @@ -1,8 +1,12 @@ package feature import ( + "context" + "os" + "path/filepath" "testing" + "github.com/devsy-org/devsy/cmd/flags" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) @@ -262,3 +266,23 @@ func TestNewOutdatedCmd_CreatesCommand(t *testing.T) { assert.Equal(t, "outdated", cmd.Use) assert.NotEmpty(t, cmd.Short) } + +func TestOutdatedJSONWithoutFeatures(t *testing.T) { + dir := t.TempDir() + configPath := filepath.Join(dir, "devcontainer.json") + require.NoError(t, os.WriteFile(configPath, []byte(`{"image":"example"}`), 0o600)) + out, err := os.CreateTemp(dir, "out") + require.NoError(t, err) + defer func() { _ = out.Close() }() + previous := os.Stdout + os.Stdout = out + defer func() { os.Stdout = previous }() + + cmd := &OutdatedCmd{GlobalFlags: &flags.GlobalFlags{ResultFormat: "json"}, Config: configPath} + require.NoError(t, cmd.Run(context.Background())) + _, err = out.Seek(0, 0) + require.NoError(t, err) + data, err := os.ReadFile(out.Name()) + require.NoError(t, err) + assert.JSONEq(t, `[]`, string(data)) +} diff --git a/cmd/feature/test.go b/cmd/feature/test.go index 7aab5199a4..6b90200751 100644 --- a/cmd/feature/test.go +++ b/cmd/feature/test.go @@ -11,6 +11,7 @@ import ( "github.com/devsy-org/devsy/cmd/flags" cliflags "github.com/devsy-org/devsy/pkg/flags" "github.com/devsy-org/devsy/pkg/flags/names" + "github.com/devsy-org/devsy/pkg/log" "github.com/devsy-org/devsy/pkg/table" "github.com/spf13/cobra" ) @@ -28,7 +29,6 @@ type TestCmd struct { BaseImage string RemoteUser string SkipScenarios bool - Quiet bool PreserveTestContainers bool } @@ -67,7 +67,6 @@ directory.`, "User to run tests as"), cliflags.Bool(&cmd.SkipScenarios, names.SkipScenarios, false, "Only run the global test script, skip per-feature scenario tests"), - cliflags.Bool(&cmd.Quiet, names.Quiet, false, "Suppress verbose build output"), cliflags.Bool(&cmd.PreserveTestContainers, names.PreserveTestContainers, false, "Don't remove test containers after run (for debugging)"), ) @@ -282,9 +281,11 @@ func (cmd *TestCmd) dockerBuild(dockerfile, contextDir, imageName string) error dockerCmd := exec.Command("docker", args...) // #nosec G204 -- args built from trusted inputs dockerCmd.Stdin = strings.NewReader(dockerfile) - if !cmd.Quiet { - dockerCmd.Stdout = os.Stdout - dockerCmd.Stderr = os.Stderr + if log.InfoEnabled() { + writer := log.Writer(log.SlogLevelInfo) + defer func() { _ = writer.Close() }() + dockerCmd.Stdout = writer + dockerCmd.Stderr = writer } return dockerCmd.Run() @@ -299,9 +300,11 @@ func (cmd *TestCmd) dockerRun(imageName, containerName string) error { dockerCmd := exec.Command("docker", args...) // #nosec G204 -- args built from trusted inputs - if !cmd.Quiet { - dockerCmd.Stdout = os.Stdout - dockerCmd.Stderr = os.Stderr + if log.InfoEnabled() { + writer := log.Writer(log.SlogLevelInfo) + defer func() { _ = writer.Close() }() + dockerCmd.Stdout = writer + dockerCmd.Stderr = writer } return dockerCmd.Run() diff --git a/cmd/feature/test_test.go b/cmd/feature/test_test.go index 106f8bc3cc..1204d38cb5 100644 --- a/cmd/feature/test_test.go +++ b/cmd/feature/test_test.go @@ -39,10 +39,6 @@ func TestTestCmd_FlagDefaults(t *testing.T) { require.NotNil(t, skipScenariosFlag) assert.Equal(t, "false", skipScenariosFlag.DefValue) - quietFlag := cmd.Flags().Lookup(names.Quiet) - require.NotNil(t, quietFlag) - assert.Equal(t, "false", quietFlag.DefValue) - preserveFlag := cmd.Flags().Lookup(names.PreserveTestContainers) require.NotNil(t, preserveFlag) assert.Equal(t, "false", preserveFlag.DefValue) @@ -56,7 +52,6 @@ func TestTestCmd_AllFlagsRegistered(t *testing.T) { "base-image", "remote-user", "skip-scenarios", - "quiet", "preserve-test-containers", } for _, name := range expected { diff --git a/cmd/flag_aliases_test.go b/cmd/flag_aliases_test.go index 3f4f33cc7c..734ac9d230 100644 --- a/cmd/flag_aliases_test.go +++ b/cmd/flag_aliases_test.go @@ -5,6 +5,7 @@ import ( "strings" "testing" + "github.com/devsy-org/devsy/pkg/config" "github.com/devsy-org/devsy/pkg/flags/names" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" @@ -15,12 +16,47 @@ const ( flagHelp = "--help" ) -func TestGlobalFlags_LogFormatAlias(t *testing.T) { +func TestGlobalFlags_LogFormat(t *testing.T) { rootCmd, globalFlags := BuildRoot() rootCmd.SetArgs([]string{flagLogFormat, formatJSON, "--version"}) err := rootCmd.Execute() require.NoError(t, err) - assert.Equal(t, formatJSON, globalFlags.LogOutput) + assert.Equal(t, formatJSON, globalFlags.LogFormat) +} + +func TestRemovedVerbosityShortFlagsRejectWithoutVersion(t *testing.T) { + for _, arg := range []string{"-v", "-vv", "-vvv"} { + t.Run(arg, func(t *testing.T) { + t.Setenv(config.EnvHome, t.TempDir()) + root, _ := BuildRoot() + var out bytes.Buffer + root.SetOut(&out) + root.SetErr(&out) + root.SetArgs([]string{arg}) + require.Error(t, root.Execute()) + assert.NotContains(t, out.String(), root.Version) + }) + } +} + +func TestGlobalFlags_CLIOverridesEnvironment(t *testing.T) { + t.Setenv("DEVSY_LOG_LEVEL", "info") + t.Setenv("DEVSY_LOG_FORMAT", "json") + t.Setenv("DEVSY_RESULT_FORMAT", "json") + t.Setenv("DEVSY_NO_STATUS", "true") + root, global := BuildRoot() + root.SetArgs([]string{ + "--log-level=trace", + "--log-format=text", + "--result-format=plain", + "--no-status=false", + "--version", + }) + require.NoError(t, root.Execute()) + assert.Equal(t, "trace", global.LogLevel) + assert.Equal(t, "text", global.LogFormat) + assert.Equal(t, "plain", global.ResultFormat) + assert.False(t, global.NoStatus) } func TestGlobalFlags_NoStatus(t *testing.T) { @@ -52,9 +88,9 @@ func TestGlobalFlags_NoStatus(t *testing.T) { } } -func TestLogFormatAlias_IsHidden(t *testing.T) { +func TestLogFormat_IsVisible(t *testing.T) { rootCmd, _ := BuildRoot() f := rootCmd.PersistentFlags().Lookup(names.LogFormat) require.NotNil(t, f) - assert.True(t, f.Hidden, flagLogFormat+" alias should be hidden") + assert.False(t, f.Hidden) } diff --git a/cmd/flags/flags.go b/cmd/flags/flags.go index 4048ae5882..8c71338df4 100644 --- a/cmd/flags/flags.go +++ b/cmd/flags/flags.go @@ -15,12 +15,9 @@ type GlobalFlags struct { UID string Owner platform.OwnerFilter - LogOutput string LogLevel string + LogFormat string ResultFormat string - Verbosity int - Quiet bool - Debug bool NoStatus bool } @@ -30,7 +27,6 @@ func SetGlobalFlags(flags *flag.FlagSet) *GlobalFlags { registerCoreFlags(flags, globalFlags) registerOutputFlags(flags, globalFlags) - registerVerbosityFlags(flags, globalFlags) registerHiddenFlags(flags, globalFlags) bindGlobalEnvVars(flags) @@ -68,37 +64,13 @@ func registerOutputFlags(flags *flag.FlagSet, globalFlags *GlobalFlags) { &globalFlags.ResultFormat, names.ResultFormat, "auto", - "The result output format. Can be json, plain, or auto (auto picks plain on a TTY and json when piped)", + "The result output format. Can be auto, text, plain, or json", ) flags.StringVar( - &globalFlags.LogOutput, - names.LogOutput, - "text", - "The log format to use. Can be text, json, or logfmt", - ) - flags.StringVar(&globalFlags.LogOutput, names.LogFormat, "text", "Alias for --log-output") - _ = flags.MarkHidden(names.LogFormat) -} - -func registerVerbosityFlags(flags *flag.FlagSet, globalFlags *GlobalFlags) { - flags.CountVarP( - &globalFlags.Verbosity, - names.Verbose, - "v", - "Increase log verbosity (-v=info, -vv=debug, -vvv=trace)", - ) - flags.BoolVarP( - &globalFlags.Quiet, - names.Quiet, - "q", - false, - "Suppress all log output except errors", - ) - flags.BoolVar( - &globalFlags.Debug, - names.Debug, - false, - "Enable debug logging (equivalent to -vv)", + &globalFlags.LogFormat, + names.LogFormat, + "auto", + "The log format. Can be auto, text, plain, json, or logfmt", ) } @@ -120,5 +92,8 @@ func bindGlobalEnvVars(flags *flag.FlagSet) { pkgflags.BindEnv(flags, names.Home) pkgflags.BindEnv(flags, names.Context) pkgflags.BindEnv(flags, names.Provider) - pkgflags.BindEnv(flags, names.Debug) + pkgflags.BindEnv(flags, names.LogLevel) + pkgflags.BindEnv(flags, names.LogFormat) + pkgflags.BindEnv(flags, names.ResultFormat) + pkgflags.BindEnv(flags, names.NoStatus) } diff --git a/cmd/internal/agent.go b/cmd/internal/agent.go index 5a6d416c66..75df13f870 100644 --- a/cmd/internal/agent.go +++ b/cmd/internal/agent.go @@ -1,17 +1,25 @@ package cmdinternal import ( + "errors" + "fmt" "os" + "strings" "github.com/devsy-org/devsy/cmd/flags" "github.com/devsy-org/devsy/cmd/internal/agentcontainer" "github.com/devsy-org/devsy/cmd/internal/agentworkspace" "github.com/devsy-org/devsy/pkg/config" "github.com/devsy-org/devsy/pkg/envfile" + "github.com/devsy-org/devsy/pkg/flags/names" "github.com/devsy-org/devsy/pkg/log" + "github.com/devsy-org/devsy/pkg/output" + "github.com/devsy-org/devsy/pkg/secrets" "github.com/spf13/cobra" ) +const agentJSONFormat = "json" + // NewAgentCmd is the hidden parent for commands that run inside a workspace or // container, invoked by the daemon over the agent tunnel. func NewAgentCmd(globalFlags *flags.GlobalFlags) *cobra.Command { @@ -44,18 +52,37 @@ func agentPreRunE(globalFlags *flags.GlobalFlags) func(*cobra.Command, []string) root.Annotations = map[string]string{} } root.Annotations[config.AgentExecutedAnnotation] = "true" - - log.Init(log.Config{ - Quiet: globalFlags.Quiet, - Debug: globalFlags.Debug, - Format: "json", - }) + if globalFlags.LogLevel == "" && root.PersistentFlags().Changed(names.LogLevel) { + return fmt.Errorf("--%s cannot be empty", names.LogLevel) + } + if globalFlags.LogLevel != "" { + if _, ok := log.LevelFromString(globalFlags.LogLevel); !ok { + return fmt.Errorf( + "invalid log level, expected one of: %s", + strings.Join(log.ValidLevels(), ", "), + ) + } + } + switch globalFlags.LogFormat { + case "", "auto", "text", "plain", agentJSONFormat, "logfmt": + default: + return errors.New("invalid log format, expected auto, text, plain, json, or logfmt") + } + if _, err := output.ResolveMode(globalFlags.ResultFormat); err != nil { + return err + } if globalFlags.DevsyHome != "" { _ = os.Setenv(config.EnvHome, globalFlags.DevsyHome) } - envfile.Apply() + log.Init(log.Config{ + Level: globalFlags.LogLevel, + DefaultLevel: log.LevelInfoName, + Format: agentJSONFormat, + Redactor: secrets.NewEnvironmentRedactor(os.Environ()), + }) + return nil } } diff --git a/cmd/internal/agentcontainer/credentials_server_test.go b/cmd/internal/agentcontainer/credentials_server_test.go index 8616f81739..54aefdc66e 100644 --- a/cmd/internal/agentcontainer/credentials_server_test.go +++ b/cmd/internal/agentcontainer/credentials_server_test.go @@ -118,7 +118,7 @@ func TestCredentialsServerCmd_Run_SameOwnerCollisionIsSilentNoOp(t *testing.T) { port := startFakeCredentialsServer(t, "alice") var sink strings.Builder - log.Init(log.Config{Verbosity: 2, Format: "json"}) + log.Init(log.Config{Level: "debug", Format: "json"}) remove := log.AddSink(&sink) defer remove() @@ -134,7 +134,7 @@ func TestCredentialsServerCmd_Run_DifferentOwnerCollisionWarnsButDoesNotError(t port := startFakeCredentialsServer(t, "alice") var sink strings.Builder - log.Init(log.Config{Verbosity: 2, Format: "json"}) + log.Init(log.Config{Level: "debug", Format: "json"}) remove := log.AddSink(&sink) defer remove() diff --git a/cmd/internal/agentcontainer/daemon.go b/cmd/internal/agentcontainer/daemon.go index ae5d6b47a1..04147b603e 100644 --- a/cmd/internal/agentcontainer/daemon.go +++ b/cmd/internal/agentcontainer/daemon.go @@ -289,6 +289,7 @@ func runSshServer(ctx context.Context, cmd *DaemonCmd) error { } args := sshServerArgs(cmd.Config) + args = append(args, log.ForwardFlagArgs()...) sshCmd := exec.CommandContext(ctx, binaryPath, args...) // #nosec G204 sshCmd.Stdout = os.Stdout diff --git a/cmd/internal/agentcontainer/setup.go b/cmd/internal/agentcontainer/setup.go index fc62acbb92..e565c57a28 100644 --- a/cmd/internal/agentcontainer/setup.go +++ b/cmd/internal/agentcontainer/setup.go @@ -14,6 +14,7 @@ import ( "strconv" "strings" + "al.essio.dev/pkg/shellescape" "github.com/devsy-org/devsy/cmd/flags" "github.com/devsy-org/devsy/pkg/agent" "github.com/devsy-org/devsy/pkg/agent/tunnel" @@ -278,7 +279,7 @@ func (cmd *SetupContainerCmd) prepareWorkspace( SetupInfo: state.setupInfo, DockerlessOptions: &state.workspaceInfo.Dockerless, ImageConfigOutput: agent.DefaultImageConfigPath, - Debug: cmd.Debug, + Debug: log.DebugEnabled(), ConfigureCredentialsFunc: func(ctx context.Context) (string, error) { serverPort, err := credentials.StartCredentialsServer( ctx, @@ -527,6 +528,7 @@ func buildDeferredHooksCmd(a deferredHooksArgs) (*exec.Cmd, error) { if a.dotfilesScript != "" { args = append(args, names.Flag(names.DotfilesScript), a.dotfilesScript) } + args = append(args, log.ForwardFlagArgs()...) cmd := &exec.Cmd{ Path: binaryPath, Args: append([]string{binaryPath}, args...), @@ -670,6 +672,7 @@ func (cmd *SetupContainerCmd) startContainerDaemon( if shutdownAction != "" { args = append(args, names.Flag(names.ShutdownAction), shutdownAction) } + args = append(args, log.ForwardFlagArgs()...) daemonCmd := &exec.Cmd{ Path: binaryPath, @@ -700,6 +703,7 @@ func (cmd *SetupContainerCmd) startPostAttachHooks( cmdInternal, cmdAgent, cmdContainer, "post-attach", names.Flag(names.SetupInfo), cmd.SetupInfo, } + args = append(args, log.ForwardFlagArgs()...) execCmd := &exec.Cmd{ Path: binaryPath, Args: append([]string{binaryPath}, args...), @@ -756,11 +760,15 @@ func configureSystemGitCredentials( return nil, err } - gitCredentials := fmt.Sprintf( - "!'%s' internal agent git-credentials --port %d", + helperArgs := []string{ binaryPath, - serverPort, - ) + "internal", + "agent", + "git-credentials", + "--port", + strconv.Itoa(serverPort), + } + gitCredentials := "!" + shellescape.QuoteCommand(helperArgs) _ = os.Setenv(config2.EnvGitHelperPort, strconv.Itoa(serverPort)) gitConfig := git.At("/", git.WithStrictHostKeyChecking(false)).Config() diff --git a/cmd/internal/agentcontainer/setup_ide.go b/cmd/internal/agentcontainer/setup_ide.go index d7b845da77..ffb9916a25 100644 --- a/cmd/internal/agentcontainer/setup_ide.go +++ b/cmd/internal/agentcontainer/setup_ide.go @@ -226,6 +226,7 @@ func (cmd *SetupContainerCmd) startExtensionsInstallInBackground( names.Flag(names.SetupInfo), cmd.SetupInfo, } args = append(args, extraArgs...) + args = append(args, log.ForwardFlagArgs()...) //nolint:gosec // binaryPath is from os.Executable(), not user input return exec.Command(binaryPath, args...), nil }) diff --git a/cmd/internal/agentworkspace/build.go b/cmd/internal/agentworkspace/build.go index 15ea520fb5..70a21c0cfe 100644 --- a/cmd/internal/agentworkspace/build.go +++ b/cmd/internal/agentworkspace/build.go @@ -70,7 +70,7 @@ func (cmd *BuildCmd) Run(ctx context.Context) error { defer cancel() tunnelClient, credentialsDir, err := initWorkspace(cancelCtx, initWorkspaceParams{ workspaceInfo: workspaceInfo, - debug: cmd.Debug, + debug: log.DebugEnabled(), shouldInstallDaemon: false, }) if err != nil { diff --git a/cmd/internal/agentworkspace/install_dotfiles.go b/cmd/internal/agentworkspace/install_dotfiles.go index eeaf91e6bf..2d4e9f238b 100644 --- a/cmd/internal/agentworkspace/install_dotfiles.go +++ b/cmd/internal/agentworkspace/install_dotfiles.go @@ -96,7 +96,7 @@ func (cmd *InstallDotfilesCmd) Run(ctx context.Context) error { ctx, command, ) // #nosec G204 -- user-provided dotfile install script - writer := log.Writer(log.LevelInfo) + writer := log.Writer(log.SlogLevelInfo) scriptCmd.Stdout = writer scriptCmd.Stderr = writer @@ -130,7 +130,7 @@ func setupDotfiles(ctx context.Context) error { }) for _, installScriptPath := range scripts { - writer := log.Writer(log.LevelInfo) + writer := log.Writer(log.SlogLevelInfo) err := ensureExecutable(ctx, installScriptPath) if err != nil { log.Debugf( diff --git a/cmd/internal/agentworkspace/logs.go b/cmd/internal/agentworkspace/logs.go index 1310bb5bd3..88e24ce20a 100644 --- a/cmd/internal/agentworkspace/logs.go +++ b/cmd/internal/agentworkspace/logs.go @@ -17,6 +17,7 @@ import ( "github.com/devsy-org/devsy/pkg/driver" cliflags "github.com/devsy-org/devsy/pkg/flags" "github.com/devsy-org/devsy/pkg/flags/names" + "github.com/devsy-org/devsy/pkg/log" provider2 "github.com/devsy-org/devsy/pkg/provider" "github.com/devsy-org/devsy/pkg/workspacelogs" "github.com/spf13/cobra" @@ -212,6 +213,9 @@ func setupReaderCommand(info *provider2.AgentWorkspaceInfo, read workspacelogs.R if read.Limit > 0 { args = append(args, "--limit", strconv.Itoa(read.Limit)) } + for _, arg := range log.ForwardFlagArgs() { + args = append(args, shellescape.Quote(arg)) + } return strings.Join(args, " ") } diff --git a/cmd/internal/agentworkspace/up.go b/cmd/internal/agentworkspace/up.go index 001c10f3ae..2346177af1 100644 --- a/cmd/internal/agentworkspace/up.go +++ b/cmd/internal/agentworkspace/up.go @@ -12,6 +12,7 @@ import ( "slices" "strconv" + "al.essio.dev/pkg/shellescape" "github.com/devsy-org/devsy/cmd/flags" "github.com/devsy-org/devsy/pkg/agent" "github.com/devsy-org/devsy/pkg/agent/tunnel" @@ -101,7 +102,7 @@ func (cmd *UpCmd) Run(ctx context.Context) error { tunnelClient, credentialsDir, err := initWorkspace(cancelCtx, initWorkspaceParams{ workspaceInfo: workspaceInfo, - debug: cmd.Debug, + debug: log.DebugEnabled(), shouldInstallDaemon: cmd.shouldInstallDaemon(workspaceInfo), }) defer cmd.cleanupCredentials(credentialsDir) @@ -923,11 +924,15 @@ func configureCredentials(ctx context.Context, cfg credentialsConfig) (string, s gitCredentials := "" if cfg.workspaceInfo.Agent.InjectGitCredentials == config.BoolTrue { - gitCredentials = fmt.Sprintf( - "!'%s' internal agent git-credentials --port %d", + helperArgs := []string{ binaryPath, - serverPort, - ) + "internal", + "agent", + "git-credentials", + "--port", + strconv.Itoa(serverPort), + } + gitCredentials = "!" + shellescape.QuoteCommand(helperArgs) _ = os.Setenv(config.EnvGitHelperPort, strconv.Itoa(serverPort)) } @@ -1014,7 +1019,7 @@ func prepareImage(workspaceDir, image string) error { // installDocker installs Docker and returns the path to the docker binary. // This function assumes docker does not already exist - the caller should check first. func installDocker(ctx context.Context) (dockerPath string, err error) { - writer := log.Writer(log.LevelInfo) + writer := log.Writer(log.SlogLevelInfo) defer func() { _ = writer.Close() }() log.Debug("installing docker") return dockerinstall.Install(ctx, writer, writer) diff --git a/cmd/internal/logs_daemon.go b/cmd/internal/logs_daemon.go index ccfb17c0e9..9707b93079 100644 --- a/cmd/internal/logs_daemon.go +++ b/cmd/internal/logs_daemon.go @@ -6,12 +6,14 @@ import ( "encoding/json" "fmt" "os" + "strings" "time" "al.essio.dev/pkg/shellescape" "github.com/devsy-org/devsy/cmd/flags" "github.com/devsy-org/devsy/pkg/client" "github.com/devsy-org/devsy/pkg/config" + "github.com/devsy-org/devsy/pkg/log" "github.com/devsy-org/devsy/pkg/machinediagnostics" provider2 "github.com/devsy-org/devsy/pkg/provider" "github.com/devsy-org/devsy/pkg/workspace" @@ -56,19 +58,23 @@ func (cmd *LogsDaemonCmd) Run(ctx context.Context, args []string) error { return err } - command := fmt.Sprintf( - "%s internal agent workspace logs-daemon --context %s --id %s", + var command strings.Builder + _, _ = fmt.Fprintf(&command, "%s internal agent workspace logs-daemon --context %s --id %s", shellescape.Quote(workspaceClient.AgentPath()), shellescape.Quote(workspaceClient.Context()), - shellescape.Quote(workspaceClient.Workspace()), - ) + shellescape.Quote(workspaceClient.Workspace())) if agentInfo.Agent.DataPath != "" { - command += " --agent-dir " + shellescape.Quote(agentInfo.Agent.DataPath) + command.WriteString(" --agent-dir ") + command.WriteString(shellescape.Quote(agentInfo.Agent.DataPath)) + } + for _, arg := range log.ForwardFlagArgs() { + command.WriteByte(' ') + command.WriteString(shellescape.Quote(arg)) } var stdout bytes.Buffer if err := workspaceClient.Command(ctx, client.CommandOptions{ - Command: command, + Command: command.String(), Stdout: &stdout, Stderr: os.Stderr, }); err != nil { diff --git a/cmd/internal/runusercommands.go b/cmd/internal/runusercommands.go index f74dfe22e7..68b5fe78eb 100644 --- a/cmd/internal/runusercommands.go +++ b/cmd/internal/runusercommands.go @@ -112,7 +112,7 @@ func (cmd *RunUserCommandsCmd) Run(ctx context.Context) error { reporter, err := newLifecycleStatusReporter( cmd.ResultFormat, os.Stderr, - cmd.Verbosity > 0 || cmd.Debug, + log.InfoEnabled(), cmd.NoStatus, ) if err != nil { diff --git a/cmd/machine/describe.go b/cmd/machine/describe.go index be76ce8748..7789dc9dda 100644 --- a/cmd/machine/describe.go +++ b/cmd/machine/describe.go @@ -2,11 +2,13 @@ package machine import ( "context" + "encoding/json" "fmt" "os" "github.com/devsy-org/devsy/cmd/flags" "github.com/devsy-org/devsy/pkg/config" + "github.com/devsy-org/devsy/pkg/output" "github.com/devsy-org/devsy/pkg/workspace" "github.com/spf13/cobra" ) @@ -34,6 +36,10 @@ func NewDescribeCmd(flags *flags.GlobalFlags) *cobra.Command { // Run runs the command logic. func (cmd *DescribeCmd) Run(ctx context.Context, args []string) error { + mode, err := output.ResolveMode(cmd.ResultFormat) + if err != nil { + return err + } devsyConfig, err := config.LoadConfig(cmd.Context, cmd.Provider) if err != nil { return err @@ -49,6 +55,11 @@ func (cmd *DescribeCmd) Run(ctx context.Context, args []string) error { if err != nil { return err } + if mode == output.ModeJSON { + return json.NewEncoder(os.Stdout).Encode(struct { + Description string `json:"description"` + }{machineDescription}) + } _, _ = fmt.Fprintln(os.Stdout, machineDescription) diff --git a/cmd/machine/diagnostics.go b/cmd/machine/diagnostics.go index 98ee864cb7..ab0357c637 100644 --- a/cmd/machine/diagnostics.go +++ b/cmd/machine/diagnostics.go @@ -17,6 +17,7 @@ import ( "github.com/devsy-org/devsy/pkg/client" "github.com/devsy-org/devsy/pkg/config" cliflags "github.com/devsy-org/devsy/pkg/flags" + "github.com/devsy-org/devsy/pkg/log" "github.com/devsy-org/devsy/pkg/machinediagnostics" "github.com/devsy-org/devsy/pkg/output" "github.com/devsy-org/devsy/pkg/workspace" @@ -183,19 +184,23 @@ func fetchRemoteDiagnostics( opts diagnosticsFetchOptions, result MachineDiagnostics, ) (MachineDiagnostics, error) { - command := shellescape.Quote( - mc.AgentPath(), - ) + " internal agent daemon-diagnostics --limit " + strconv.Itoa( - opts.Limit, - ) + var command strings.Builder + command.WriteString(shellescape.Quote(mc.AgentPath())) + command.WriteString(" internal agent daemon-diagnostics --limit ") + command.WriteString(strconv.Itoa(opts.Limit)) if opts.After != "" { - command += " --after " + shellescape.Quote(opts.After) + command.WriteString(" --after ") + command.WriteString(shellescape.Quote(opts.After)) + } + for _, arg := range log.ForwardFlagArgs() { + command.WriteByte(' ') + command.WriteString(shellescape.Quote(arg)) } stdout := boundedDiagnosticsBuffer{max: maxRemoteDiagnosticsResponse} stderr := boundedDiagnosticsBuffer{max: maxRemoteDiagnosticsResponse} err := mc.Command( ctx, - client.CommandOptions{Command: command, Stdout: &stdout, Stderr: &stderr}, + client.CommandOptions{Command: command.String(), Stdout: &stdout, Stderr: &stderr}, ) if err != nil { result.Source = CollectionSource{ diff --git a/cmd/machine/inspect.go b/cmd/machine/inspect.go index 812af536fe..62fcaaefe0 100644 --- a/cmd/machine/inspect.go +++ b/cmd/machine/inspect.go @@ -7,6 +7,7 @@ import ( "github.com/devsy-org/devsy/cmd/flags" "github.com/devsy-org/devsy/pkg/config" + "github.com/devsy-org/devsy/pkg/output" "github.com/devsy-org/devsy/pkg/provider" "github.com/devsy-org/devsy/pkg/workspace" "github.com/spf13/cobra" @@ -32,6 +33,9 @@ func NewInspectCmd(flags *flags.GlobalFlags) *cobra.Command { } func (cmd *InspectCmd) Run(ctx context.Context, args []string) error { + if _, err := output.ResolveMode(cmd.ResultFormat); err != nil { + return err + } devsyConfig, err := config.LoadConfig(cmd.Context, cmd.Provider) if err != nil { return err diff --git a/cmd/machine/ssh.go b/cmd/machine/ssh.go index 169fe888b8..1cf2d43ef1 100644 --- a/cmd/machine/ssh.go +++ b/cmd/machine/ssh.go @@ -134,7 +134,7 @@ func (cmd *SSHCmd) Run(ctx context.Context, args []string) error { } streamer := log.NewJSONLogStreamer(log.StreamerOptions{ - FallbackLevel: log.LevelInfo, + FallbackLevel: log.SlogLevelInfo, DetectLevelPrefixes: true, }) defer func() { _ = streamer.Close() }() @@ -166,8 +166,8 @@ func (cmd *SSHCmd) injectExec( "%s internal ssh-server --stdio", shellescape.Quote(machineClient.AgentPath()), ) - if cmd.Debug { - _, _ = c.WriteString(" --debug") + for _, arg := range log.ForwardFlagArgs() { + _, _ = c.WriteString(" " + shellescape.Quote(arg)) } command := c.String() return devagent.InjectAgent(ctx, &devagent.InjectOptions{ diff --git a/cmd/platform/cluster/add.go b/cmd/platform/cluster/add.go index 43b81e4786..4b8552721c 100644 --- a/cmd/platform/cluster/add.go +++ b/cmd/platform/cluster/add.go @@ -368,8 +368,8 @@ func installAgent( //nolint:gosec // command is a fixed CLI with arguments built internally helmCmd := exec.CommandContext(ctx, "helm", helmArgs...) - helmCmd.Stdout = log.Writer(log.LevelDebug) - helmCmd.Stderr = log.Writer(log.LevelDebug) + helmCmd.Stdout = log.Writer(log.SlogLevelDebug) + helmCmd.Stderr = log.Writer(log.SlogLevelDebug) helmCmd.Stdin = os.Stdin log.Info("installing agent") diff --git a/cmd/platform/daemon/start.go b/cmd/platform/daemon/start.go index bca0b802f8..bd25f5fa63 100644 --- a/cmd/platform/daemon/start.go +++ b/cmd/platform/daemon/start.go @@ -78,7 +78,7 @@ func (cmd *StartCmd) Run( Context: devsyConfig.DefaultContext, UserName: userName, PlatformClient: baseClient, - Debug: cmd.Debug, + Debug: log.DebugEnabled(), }) if err != nil { return fmt.Errorf("init daemon: %w", err) diff --git a/cmd/platform/daemon/status.go b/cmd/platform/daemon/status.go index 78f8c05ef8..d5238a86c3 100644 --- a/cmd/platform/daemon/status.go +++ b/cmd/platform/daemon/status.go @@ -10,6 +10,7 @@ import ( platformflags "github.com/devsy-org/devsy/cmd/platform/flags" "github.com/devsy-org/devsy/pkg/config" platformdaemon "github.com/devsy-org/devsy/pkg/daemon/platform" + "github.com/devsy-org/devsy/pkg/log" providerpkg "github.com/devsy-org/devsy/pkg/provider" "github.com/spf13/cobra" ) @@ -42,7 +43,7 @@ func (cmd *StatusCmd) Run( devsyConfig *config.Config, provider *providerpkg.ProviderConfig, ) error { - status, err := platformdaemon.NewLocalClient(provider.Name).Status(ctx, cmd.Debug) + status, err := platformdaemon.NewLocalClient(provider.Name).Status(ctx, log.DebugEnabled()) if err != nil { return err } diff --git a/cmd/platform/provider/provider.go b/cmd/platform/provider/provider.go index 97a4b39fa6..4e1c664823 100644 --- a/cmd/platform/provider/provider.go +++ b/cmd/platform/provider/provider.go @@ -28,10 +28,6 @@ func NewPlatformProviderCmd(globalFlags *flags.GlobalFlags) *cobra.Command { globalFlags.Config = os.Getenv(platform.ConfigEnv) } - if os.Getenv(config.EnvDebug) == config.BoolTrue { - globalFlags.Debug = true - } - if os.Getenv(config.EnvUI) == config.BoolTrue { cmd.VisitParents(func(c *cobra.Command) { if c.Name() == config.BinaryName { diff --git a/cmd/platform/provider/up.go b/cmd/platform/provider/up.go index 74bc77ea0e..81e88aae09 100644 --- a/cmd/platform/provider/up.go +++ b/cmd/platform/provider/up.go @@ -10,7 +10,6 @@ import ( managementv1 "github.com/devsy-org/api/pkg/apis/management/v1" storagev1 "github.com/devsy-org/api/pkg/apis/storage/v1" "github.com/devsy-org/devsy/cmd/platform/flags" - "github.com/devsy-org/devsy/pkg/config" "github.com/devsy-org/devsy/pkg/log" "github.com/devsy-org/devsy/pkg/platform" "github.com/devsy-org/devsy/pkg/platform/client" @@ -106,8 +105,8 @@ func (cmd *UpCmd) up( client client.Client, ) error { options := platform.OptionsFromEnv(storagev1.DevsyFlagsUp) - if options != nil && os.Getenv(config.EnvDebug) == config.BoolTrue { - options.Add("debug", config.BoolTrue) + if options != nil { + options.Add("log-level", log.LevelString()) } conn, err := platform.DialInstance(client, workspace, "up", options) diff --git a/cmd/platform/workspace/watch.go b/cmd/platform/workspace/watch.go index afbda3ae7a..3f6fb67161 100644 --- a/cmd/platform/workspace/watch.go +++ b/cmd/platform/workspace/watch.go @@ -100,7 +100,7 @@ func (cmd *WatchWorkspacesCmd) Run( Options: opts, Config: providerConfig, Stdout: os.Stdout, - Stderr: log.Writer(log.LevelError), + Stderr: log.Writer(log.SlogLevelError), }, ) if err != nil { diff --git a/cmd/provider/add.go b/cmd/provider/add.go index 2b2c602d28..5cf7977e84 100644 --- a/cmd/provider/add.go +++ b/cmd/provider/add.go @@ -171,7 +171,7 @@ func (cmd *AddCmd) install( } func (cmd *AddCmd) verbose() bool { - return cmd.Verbosity > 0 || cmd.Debug + return log.InfoEnabled() } type resolvedAddSource struct { diff --git a/cmd/provider/configure_shared.go b/cmd/provider/configure_shared.go index f5d452e5ce..1f407f29d4 100644 --- a/cmd/provider/configure_shared.go +++ b/cmd/provider/configure_shared.go @@ -4,12 +4,15 @@ import ( "context" "fmt" "io" + "log/slog" "github.com/devsy-org/devsy/pkg/client/clientimplementation" + "github.com/devsy-org/devsy/pkg/clierr" "github.com/devsy-org/devsy/pkg/config" "github.com/devsy-org/devsy/pkg/log" options2 "github.com/devsy-org/devsy/pkg/options" provider2 "github.com/devsy-org/devsy/pkg/provider" + "github.com/devsy-org/devsy/pkg/secrets" "github.com/devsy-org/devsy/pkg/status" ) @@ -133,15 +136,44 @@ func runProviderInit( if cfg.SkipInit { return nil } + providerOptions := devsyConfig.ProviderOptions(cfg.Provider.Name) + environment := provider2.ToEnvironment( + nil, nil, providerOptions, + provider2.GetBaseEnvironment(devsyConfig.DefaultContext, cfg.Provider.Name), + ) + var protected []string + for _, definitions := range []config.OptionDefinitions{ + cfg.Provider.Options, + devsyConfig.DynamicProviderOptionDefinitions(cfg.Provider.Name), + } { + for name, definition := range definitions { + if definition != nil && (definition.Password || definition.Hidden) { + if value, ok := providerOptions[name]; ok { + protected = append(protected, name+"="+value.Value) + } + } + } + } + redactor := secrets.Combine( + secrets.NewEnvironmentRedactor(environment), + secrets.NewRedactor(protected), + ) + attrs := []slog.Attr{log.AttrProvider(cfg.Provider.Name)} stdout := log.NewJSONLogStreamer(log.StreamerOptions{ - FallbackLevel: log.LevelInfo, + FallbackLevel: log.SlogLevelInfo, + Redactor: redactor, + DefaultAttrs: attrs, DetectLevelPrefixes: true, }) defer func() { _ = stdout.Close() }() stderr := log.NewJSONLogStreamer(log.StreamerOptions{ - FallbackLevel: log.LevelError, + FallbackLevel: log.SlogLevelError, + Redactor: redactor, + DefaultAttrs: attrs, + CaptureLines: 50, + CaptureBytes: 32 * 1024, DetectLevelPrefixes: true, }) defer func() { _ = stderr.Close() }() @@ -151,12 +183,20 @@ func runProviderInit( reporter, status.Operation{Phase: status.PhaseRunningInit, Step: cfg.Provider.Name}, func(ctx context.Context) error { - return initProvider( + err := initProvider( ctx, devsyConfig, cfg.Provider, initIO{stdout: stdout, stderr: stderr}, ) + _ = stdout.Close() + _ = stderr.Close() + if err != nil { + if output := stderr.ErrorOutput(); output != "" { + return clierr.WithContext(err, map[string]string{"stderr": output}) + } + } + return err }, ) } diff --git a/cmd/provider/init.go b/cmd/provider/init.go index fe9b208b43..6b1706ee29 100644 --- a/cmd/provider/init.go +++ b/cmd/provider/init.go @@ -7,6 +7,7 @@ import ( "github.com/devsy-org/devsy/cmd/completion" "github.com/devsy-org/devsy/cmd/flags" "github.com/devsy-org/devsy/pkg/config" + "github.com/devsy-org/devsy/pkg/log" provider2 "github.com/devsy-org/devsy/pkg/provider" "github.com/devsy-org/devsy/pkg/status" "github.com/devsy-org/devsy/pkg/workspace" @@ -81,7 +82,7 @@ func (cmd *InitCmd) run(ctx context.Context, args []string) error { reporter, err := newStatusReporter( cmd.ResultFormat, os.Stdout, - cmd.Verbosity > 0 || cmd.Debug, + log.InfoEnabled(), cmd.NoStatus, ) if err != nil { diff --git a/cmd/provider/init_environment_test.go b/cmd/provider/init_environment_test.go index 5ae74f4f12..9146c485c1 100644 --- a/cmd/provider/init_environment_test.go +++ b/cmd/provider/init_environment_test.go @@ -2,14 +2,20 @@ package provider import ( "context" + "errors" "io" "os" + "os/exec" "path/filepath" + "runtime" "testing" + "github.com/devsy-org/devsy/pkg/clierr" "github.com/devsy-org/devsy/pkg/config" provider2 "github.com/devsy-org/devsy/pkg/provider" + "github.com/devsy-org/devsy/pkg/types" "github.com/devsy-org/devsy/pkg/workspace" + "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "sigs.k8s.io/yaml" ) @@ -46,3 +52,65 @@ func TestInitProviderReceivesBaseEnvironment(t *testing.T) { require.NoError(t, err) require.Equal(t, filepath.ToSlash(executable)+"\n"+testProviderFoo, string(got)) } + +func TestProviderInitFailureRetainsRedactedStderrAndExit(t *testing.T) { + if runtime.GOOS == "windows" { + t.Skip("requires a POSIX shell") + } + t.Setenv(config.EnvHome, t.TempDir()) + const optionSecret = "opaque-provider-secret-78153" + const dynamicSecret = "dynamic-provider-secret-78155" + const hostSecret = "host-provider-secret-78154" + t.Setenv("EXTERNAL_TOKEN", hostSecret) + cfg := setupProviderOperationTest(t) + cfg.Current().Providers[testProviderFoo] = &config.ProviderConfig{ + Options: map[string]config.OptionValue{ + "OPAQUE": {Value: optionSecret}, + "DYNAMIC_OPAQUE": {Value: dynamicSecret}, + }, + DynamicOptions: config.OptionDefinitions{"DYNAMIC_OPAQUE": {Password: true}}, + } + require.NoError(t, config.SaveConfig(cfg)) + definition := &provider2.ProviderConfig{ + Name: testProviderFoo, + Options: map[string]*types.Option{ + "OPAQUE": {Password: true}, + }, + Exec: provider2.ProviderCommands{ + Init: []string{ + "/bin/sh", "-c", + `printf 'stdout-only-canary'; ` + + `printf 'stderr-canary %s %s %s' "$OPAQUE" "$DYNAMIC_OPAQUE" "$EXTERNAL_TOKEN" >&2; exit 23`, + }, + }, + } + err := runProviderInit( + context.Background(), + ProviderOptionsConfig{Provider: definition}, + cfg, + nil, + ) + require.Error(t, err) + var exitErr *exec.ExitError + require.True(t, errors.As(err, &exitErr)) + require.Equal(t, 23, exitErr.ExitCode()) + diagnostic := clierr.Classify(err).Context["stderr"] + assert.Contains(t, diagnostic, "stderr-canary") + assert.NotContains(t, diagnostic, "stdout-only-canary") + assert.NotContains(t, diagnostic, optionSecret) + assert.NotContains(t, diagnostic, dynamicSecret) + assert.NotContains(t, diagnostic, hostSecret) + assert.Contains(t, diagnostic, "***") + + definition.Exec.Init = []string{"/bin/sh", "-c", "exit 19"} + err = runProviderInit( + context.Background(), + ProviderOptionsConfig{Provider: definition}, + cfg, + nil, + ) + require.Error(t, err) + assert.Empty(t, clierr.Classify(err).Context) + require.True(t, errors.As(err, &exitErr)) + assert.Equal(t, 19, exitErr.ExitCode()) +} diff --git a/cmd/provider/set_source.go b/cmd/provider/set_source.go index 6a4de6b95c..e4ae203043 100644 --- a/cmd/provider/set_source.go +++ b/cmd/provider/set_source.go @@ -96,7 +96,7 @@ func (cmd *SetSourceCmd) setSource( reporter, err := newStatusReporter( cmd.ResultFormat, os.Stdout, - cmd.Verbosity > 0 || cmd.Debug, + log.InfoEnabled(), cmd.NoStatus, ) if err != nil { diff --git a/cmd/provider/versions.go b/cmd/provider/versions.go index 48ddc55e6e..4d87d6dbdf 100644 --- a/cmd/provider/versions.go +++ b/cmd/provider/versions.go @@ -12,6 +12,7 @@ import ( "github.com/devsy-org/devsy/pkg/config" cliflags "github.com/devsy-org/devsy/pkg/flags" "github.com/devsy-org/devsy/pkg/flags/names" + "github.com/devsy-org/devsy/pkg/output" "github.com/devsy-org/devsy/pkg/provider" "github.com/devsy-org/devsy/pkg/workspace" "github.com/spf13/cobra" @@ -20,7 +21,6 @@ import ( // VersionsCmd holds the cmd flags for `provider versions`. type VersionsCmd struct { *flags.GlobalFlags - JSON bool IncludePrerelease bool NoCache bool } @@ -33,6 +33,10 @@ func NewVersionsCmd(f *flags.GlobalFlags) *cobra.Command { Short: "List upstream versions for a provider", Args: cobra.MaximumNArgs(1), RunE: func(cobraCmd *cobra.Command, args []string) error { + mode, err := output.ResolveMode(cmd.ResultFormat) + if err != nil { + return err + } devsyConfig, err := config.LoadConfig(cmd.Context, cmd.Provider) if err != nil { return err @@ -52,7 +56,7 @@ func NewVersionsCmd(f *flags.GlobalFlags) *cobra.Command { if err != nil { return fmt.Errorf("list versions for %s: %w", name, err) } - if cmd.JSON { + if mode == output.ModeJSON { return json.NewEncoder(os.Stdout).Encode(versions) } return renderVersionsTable(os.Stdout, versions) @@ -60,7 +64,6 @@ func NewVersionsCmd(f *flags.GlobalFlags) *cobra.Command { ValidArgsFunction: completeProviderName(cmd), } cliflags.Add(versionsCmd, - cliflags.Bool(&cmd.JSON, names.JSON, false, "Output JSON"), cliflags.Bool(&cmd.IncludePrerelease, names.Prerelease, false, "Include prereleases"), cliflags.Bool(&cmd.NoCache, names.NoCache, false, "Bypass the version cache"), ) diff --git a/cmd/provider/versions_test.go b/cmd/provider/versions_test.go index 2606f94f79..e082cb74ed 100644 --- a/cmd/provider/versions_test.go +++ b/cmd/provider/versions_test.go @@ -1,29 +1,58 @@ package provider import ( + "io" + "net/http" + "net/http/httptest" + "os" "testing" "github.com/devsy-org/devsy/cmd/flags" + "github.com/devsy-org/devsy/pkg/config" + provider2 "github.com/devsy-org/devsy/pkg/provider" + "github.com/stretchr/testify/require" ) -func TestNewVersionsCmd_Wiring(t *testing.T) { - cmd := NewVersionsCmd(&flags.GlobalFlags{}) - if cmd.Use != "versions [name]" { - t.Errorf("Use: got %q want %q", cmd.Use, "versions [name]") - } - for _, name := range []string{"json", "prerelease", "no-cache"} { - if cmd.Flag(name) == nil { - t.Errorf("missing flag %q", name) +func TestVersionsCommandJSONReturnsProviderVersions(t *testing.T) { + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + if r.URL.Path != "/foo/versions.json" { + http.NotFound(w, r) + return } - } - // MaximumNArgs(1): 0 and 1 ok, 2 not. - if err := cmd.Args(cmd, []string{}); err != nil { - t.Errorf("0 args should be ok, got %v", err) - } - if err := cmd.Args(cmd, []string{testProviderFoo}); err != nil { - t.Errorf("1 arg should be ok, got %v", err) - } - if err := cmd.Args(cmd, []string{testProviderFoo, testProviderBar}); err == nil { - t.Error("2 args should fail") - } + _, _ = io.WriteString( + w, + `{"versions":[{"tag":"v1.0.0","published_at":"2024-01-02T03:04:05Z","prerelease":false},`+ + `{"tag":"v2.0.0-beta","published_at":"2025-01-02T03:04:05Z","prerelease":true}]}`, + ) + })) + defer server.Close() + t.Setenv(config.EnvHome, t.TempDir()) + cfg := setupProviderOperationTest(t) + cfg.Current().Providers["fixture"] = &config.ProviderConfig{} + require.NoError(t, config.SaveConfig(cfg)) + require.NoError(t, provider2.SaveProviderConfig(cfg.DefaultContext, &provider2.ProviderConfig{ + Name: "fixture", + Source: provider2.ProviderSource{URL: server.URL + "/foo/provider.yaml"}, + Exec: provider2.ProviderCommands{Command: []string{"unused"}}, + })) + read, write, err := os.Pipe() + require.NoError(t, err) + defer func() { _ = read.Close() }() + previous := os.Stdout + os.Stdout = write + t.Cleanup(func() { os.Stdout = previous }) + command := NewVersionsCmd(&flags.GlobalFlags{ResultFormat: "json"}) + command.SetArgs([]string{"fixture", "--no-cache", "--prerelease"}) + err = command.Execute() + require.NoError(t, write.Close()) + os.Stdout = previous + require.NoError(t, err) + got, err := io.ReadAll(read) + require.NoError(t, err) + require.JSONEq( + t, + `[{"tag":"v2.0.0-beta","publishedAt":"2025-01-02T03:04:05Z","prerelease":true,"current":false},`+ + `{"tag":"v1.0.0","publishedAt":"2024-01-02T03:04:05Z","prerelease":false,"current":false}]`, + string(got), + ) } diff --git a/cmd/root.go b/cmd/root.go index f93898b6ee..03f2e5201b 100644 --- a/cmd/root.go +++ b/cmd/root.go @@ -29,6 +29,7 @@ import ( "github.com/devsy-org/devsy/cmd/template" "github.com/devsy-org/devsy/cmd/update" wsCmdPkg "github.com/devsy-org/devsy/cmd/workspace" + "github.com/devsy-org/devsy/pkg/client/clientimplementation" "github.com/devsy-org/devsy/pkg/clierr" "github.com/devsy-org/devsy/pkg/clihelp" "github.com/devsy-org/devsy/pkg/command" @@ -38,6 +39,7 @@ import ( "github.com/devsy-org/devsy/pkg/flags/names" "github.com/devsy-org/devsy/pkg/flatpak" "github.com/devsy-org/devsy/pkg/log" + "github.com/devsy-org/devsy/pkg/output" "github.com/devsy-org/devsy/pkg/secrets" "github.com/devsy-org/devsy/pkg/telemetry" "github.com/devsy-org/devsy/pkg/version" @@ -53,9 +55,9 @@ import ( const ( logOutputJSON = "json" logOutputLogfmt = "logfmt" + logOutputPlain = "plain" logOutputText = "text" - flagLogOutput = "--" + names.LogOutput flagLogFormat = "--" + names.LogFormat internalCommand = "internal" @@ -82,25 +84,25 @@ func platformEnabled() bool { return config.IsPlatformEnabled() } -// isMachineLogFormat reports whether the configured --log-output mode produces -// a structured, machine-parseable stream (json or logfmt). Callers use this to -// suppress decorative human-readable affordances that would corrupt the stream. func isMachineLogFormat(format string) bool { return format == logOutputJSON || format == logOutputLogfmt } func logOutputFromArgs(args []string) string { - for i, arg := range args { - for _, name := range []string{flagLogOutput, flagLogFormat} { - if val, ok := strings.CutPrefix(arg, name+"="); ok { - return val - } - if arg == name && i+1 < len(args) { - return args[i+1] - } + var value string + for i := 0; i < len(args); i++ { + arg := args[i] + if arg == "--" { + break + } + if val, ok := strings.CutPrefix(arg, flagLogFormat+"="); ok { + value = val + } else if arg == flagLogFormat && i+1 < len(args) { + i++ + value = args[i] } } - return "" + return value } func defaultLogLevel(globalFlags *flags.GlobalFlags) string { @@ -120,8 +122,7 @@ func validateLogLevel(level string) error { } if _, ok := log.LevelFromString(level); !ok { return fmt.Errorf( - "invalid log level %q, expected one of: %s", - level, + "invalid log level, expected one of: %s", strings.Join(log.ValidLevels(), ", "), ) } @@ -134,8 +135,10 @@ func isMachineConsumer(logOutput string, isInternal bool) bool { return true case os.Getenv(config.EnvUI) == config.BoolTrue: return true - case logOutput != "": - return isMachineLogFormat(logOutput) + case isMachineLogFormat(logOutput): + return true + case logOutput == "text" || logOutput == logOutputPlain: + return false default: return !term.IsTerminal(int(os.Stderr.Fd())) //nolint:gosec // fd fits in int } @@ -148,35 +151,53 @@ func Execute() { func run() (code int) { machineMode := false + metrics := telemetry.NewMetricsReporter() + var finalErr error collector := telemetry.FromContext(gocontext.Background()) // noop until BootstrapCLI defer func() { if r := recover(); r != nil { log.Errorf("panic: %v\n%s", r, debug.Stack()) - panicErr := clierr.NewPanic(r) - collector.RecordCLI(panicErr) - code = exitCodeForError(panicErr, machineMode) + finalErr = clierr.NewPanic(r) + code = exitCodeForError(finalErr, machineMode) + } + snapshot := metrics.Finish(finalErr) + collector.RecordCLI(finalErr, snapshot) + if err := telemetry.ExportMetrics(snapshot); err != nil { + log.WithAttrs(log.AttrErrorCode("metrics_export_failed")). + Error("local metrics export failed") } collector.Flush() }() + earlyFlags := &flags.GlobalFlags{ + LogLevel: os.Getenv(config.EnvLogLevel), + LogFormat: os.Getenv("DEVSY_LOG_FORMAT"), + } + machineMode = configureOutput( + &cobra.Command{}, + earlyFlags, + slices.Contains(os.Args[1:], internalCommand), + ) + rootCmd, globalFlags := BuildRoot() target := resolveTarget(rootCmd) collector = telemetry.BootstrapCLI(target) - rootCmd.SetContext(telemetry.WithCollector(gocontext.Background(), collector)) + ctx := telemetry.WithCollector(gocontext.Background(), collector) + rootCmd.SetContext(telemetry.WithMetrics(ctx, metrics)) isInternal := topLevelCommand(target) == internalCommand machineMode = configureOutput(rootCmd, globalFlags, isInternal) if !isInternal { if shouldExit, err := flatpak.ReexecOnHost(); err != nil { - collector.RecordCLI(err) - return exitCodeForError(err, machineMode) + finalErr = err + return exitCodeForError(finalErr, machineMode) } else if shouldExit { return 0 } } - err := rootCmd.Execute() + finalErr = rootCmd.Execute() if devsyConfig, cfgErr := config.LoadConfig( globalFlags.Context, globalFlags.Provider, @@ -184,9 +205,8 @@ func run() (code int) { collector = telemetry.ApplyCLIConfig(devsyConfig, collector) } - collector.RecordCLI(err) - if err != nil { - return exitCodeForError(err, machineMode) + if finalErr != nil { + return exitCodeForError(finalErr, machineMode) } return 0 } @@ -204,12 +224,18 @@ func configureOutput( isInternal bool, ) bool { logOutput := logOutputFromArgs(os.Args[1:]) + if logOutput == "" { + logOutput = globalFlags.LogFormat + } machineMode := isMachineConsumer(logOutput, isInternal) rootCmd.SilenceErrors = true rootCmd.SilenceUsage = machineMode format := logOutput - if format == "" { + if format == logOutputPlain { + format = logOutputText + } + if format != logOutputText && format != logOutputJSON && format != logOutputLogfmt { if machineMode { format = logOutputJSON } else { @@ -217,12 +243,8 @@ func configureOutput( } } log.Init(log.Config{ - Verbosity: globalFlags.Verbosity, - Quiet: globalFlags.Quiet, - Debug: globalFlags.Debug, Level: globalFlags.LogLevel, DefaultLevel: defaultLogLevel(globalFlags), - VerbositySet: rootCmd.PersistentFlags().Changed(names.Verbose), Format: format, Redactor: secrets.NewEnvironmentRedactor(os.Environ()), }) @@ -381,6 +403,8 @@ func BuildRoot() (*cobra.Command, *flags.GlobalFlags) { SilenceErrors: true, } rootCmd.SetVersionTemplate("{{.Version}}\n") + rootCmd.Flags().Bool("version", false, "version for "+rootCmd.DisplayName()) + _ = rootCmd.Flags().SetAnnotation("version", cobra.FlagSetByCobraAnnotation, []string{"true"}) clihelp.Install(rootCmd) persistentFlags := rootCmd.PersistentFlags() globalFlags := flags.SetGlobalFlags(persistentFlags) @@ -430,25 +454,62 @@ func rootPreRun( globalFlags *flags.GlobalFlags, persistentFlags *pflag.FlagSet, ) error { + for _, item := range []struct { + name string + value string + }{ + {names.LogLevel, globalFlags.LogLevel}, + {names.LogFormat, globalFlags.LogFormat}, + {names.ResultFormat, globalFlags.ResultFormat}, + } { + if item.value == "" && persistentFlags.Changed(item.name) { + return fmt.Errorf("--%s cannot be empty", item.name) + } + } + parent := cobraCmd.Parent() + if globalFlags.LogLevel == "" && !persistentFlags.Changed(names.LogLevel) && + cobraCmd.Name() == "up" && parent != nil && parent.Name() == "workspace" && + parent.Parent() == cobraCmd.Root() { + var payload struct { + LogLevel string `json:"logLevel"` + } + if _, err := clientimplementation.DecodeOptionsFromEnv( + config.EnvFlagsUp, + &payload, + ); err != nil { + return fmt.Errorf("decode up options: %w", err) + } + globalFlags.LogLevel = payload.LogLevel + } if err := validateLogLevel(globalFlags.LogLevel); err != nil { return err } + switch globalFlags.LogFormat { + case "", "auto", "text", logOutputPlain, "json", "logfmt": + default: + return errors.New("invalid log format, expected auto, text, plain, json, or logfmt") + } + if _, err := output.ResolveMode(globalFlags.ResultFormat); err != nil { + return err + } if globalFlags.DevsyHome != "" { _ = os.Setenv(config.EnvHome, globalFlags.DevsyHome) } + defaultLevel := defaultLogLevel(globalFlags) + if globalFlags.LogLevel == "" { + if err := validateLogLevel(defaultLevel); err != nil { + return err + } + } if err := checkPendingContextDeletion(cobraCmd); err != nil { return err } cobraCmd.SilenceUsage = true log.Init(log.Config{ - Verbosity: globalFlags.Verbosity, - Quiet: globalFlags.Quiet, - Debug: globalFlags.Debug, Level: globalFlags.LogLevel, - DefaultLevel: defaultLogLevel(globalFlags), - VerbositySet: persistentFlags.Changed(names.Verbose), - Format: resolveLogFormat(cobraCmd, globalFlags.LogOutput), + DefaultLevel: defaultLevel, + Format: resolveLogFormat(cobraCmd, globalFlags.LogFormat), Redactor: secrets.NewEnvironmentRedactor(os.Environ()), }) klog.SetLogger(logr.New(log.LogrSink())) @@ -479,7 +540,10 @@ func checkPendingContextDeletion(cobraCmd *cobra.Command) error { } func resolveLogFormat(cobraCmd *cobra.Command, logFormat string) string { - if logFormat != "" { + if logFormat == logOutputPlain { + return logOutputText + } + if logFormat != "" && logFormat != "auto" { return logFormat } if isMachineConsumer("", topLevelCommand(cobraCmd) == internalCommand) { diff --git a/cmd/root_test.go b/cmd/root_test.go index 5b54f789b7..0b6d009d5a 100644 --- a/cmd/root_test.go +++ b/cmd/root_test.go @@ -9,10 +9,12 @@ import ( "strings" "testing" + "github.com/devsy-org/devsy/pkg/client" "github.com/devsy-org/devsy/pkg/clierr" "github.com/devsy-org/devsy/pkg/config" devcconfig "github.com/devsy-org/devsy/pkg/devcontainer/config" "github.com/devsy-org/devsy/pkg/exitcode" + "github.com/devsy-org/devsy/pkg/flags/names" "github.com/devsy-org/devsy/pkg/log" "github.com/devsy-org/devsy/pkg/workspace" "github.com/stretchr/testify/assert" @@ -20,9 +22,21 @@ import ( ) const ( - devsy = "devsy" + devsy = "devsy" + testInvalidValue = "invalid" + testInvalidLevelMessage = "invalid log level" ) +type payloadLevelCase struct { + name string + payload string + env string + argument string + want string + wantErr string + fromSender bool +} + func TestExitCodeForError_WorkspaceNotFound(t *testing.T) { err := fmt.Errorf("get workspace: %w", workspace.ErrWorkspaceNotFound) assert.Equal(t, exitcode.Retryable, exitCodeForError(err, true)) @@ -98,6 +112,141 @@ func TestRenderCLIErrorMachineModeIgnoresDiagnosticLevel(t *testing.T) { } } +func TestRootPreRunValidatesPersistedLevelUnlessOverridden(t *testing.T) { + config.ResetPathManager() + t.Cleanup(func() { log.Init(log.Config{}) }) + t.Cleanup(config.ResetPathManager) + t.Setenv(config.EnvHome, t.TempDir()) + t.Setenv("DEVSY_LOG_FORMAT", "") + t.Setenv("DEVSY_RESULT_FORMAT", "") + t.Setenv("DEVSY_NO_STATUS", "") + t.Setenv(config.EnvLogLevel, "") + require.NoError(t, config.SaveConfig(&config.Config{ + DefaultContext: config.DefaultContext, + Contexts: map[string]*config.ContextConfig{ + config.DefaultContext: {Options: map[string]config.OptionValue{ + config.ContextOptionLogLevel: {Value: testInvalidValue}, + }}, + }, + })) + root, global := BuildRoot() + root.SetContext(t.Context()) + err := rootPreRun(root, global, root.PersistentFlags()) + require.ErrorContains(t, err, testInvalidLevelMessage) + global.LogLevel = "debug" + require.NoError(t, rootPreRun(root, global, root.PersistentFlags())) +} + +func TestRootPreRunRejectsExplicitEmptyOutputFlags(t *testing.T) { + t.Setenv("DEVSY_LOG_LEVEL", "") + t.Setenv("DEVSY_LOG_FORMAT", "") + t.Setenv("DEVSY_RESULT_FORMAT", "") + t.Setenv("DEVSY_NO_STATUS", "") + for _, name := range []string{"log-level", "log-format", "result-format"} { + t.Run(name, func(t *testing.T) { + root, global := BuildRoot() + require.NoError(t, root.PersistentFlags().Set(name, "")) + err := rootPreRun(root, global, root.PersistentFlags()) + require.ErrorContains(t, err, "--"+name+" cannot be empty") + }) + } +} + +func TestWorkspaceUpPayloadLogLevelPrecedence(t *testing.T) { + for _, tc := range []payloadLevelCase{ + {name: "sender trace", fromSender: true, want: log.LevelTraceName}, + {name: "sender info", fromSender: true, want: log.LevelInfoName}, + {name: "sender warn", fromSender: true, want: log.LevelWarnName}, + {name: "absent payload falls back to context", payload: `{}`, want: log.LevelWarnName}, + { + name: "environment wins", payload: `{"logLevel":"trace"}`, + env: log.LevelInfoName, want: log.LevelInfoName, + }, + { + name: "argument wins", payload: `{"logLevel":"trace"}`, + env: log.LevelInfoName, argument: log.LevelWarnName, want: log.LevelWarnName, + }, + {name: "invalid payload", payload: `{"logLevel":"invalid"}`, wantErr: testInvalidLevelMessage}, + { + name: "environment overrides invalid payload", payload: `{"logLevel":"invalid"}`, + env: log.LevelWarnName, want: log.LevelWarnName, + }, + {name: "malformed selected payload", payload: `{`, wantErr: "decode up options"}, + { + name: "malformed selected level type", payload: `{"logLevel":123,"secret":"payload-secret-4982"}`, + wantErr: "decode up options", + }, + {name: "argument overrides malformed payload", payload: `{`, argument: log.LevelInfoName, want: log.LevelInfoName}, + } { + t.Run(tc.name, func(t *testing.T) { + checkPayloadLogLevel(t, tc) + }) + } +} + +func checkPayloadLogLevel(t *testing.T, tc payloadLevelCase) { + t.Helper() + config.ResetPathManager() + t.Cleanup(config.ResetPathManager) + t.Cleanup(func() { log.Init(log.Config{}) }) + t.Setenv(config.EnvHome, t.TempDir()) + payload := tc.payload + if tc.fromSender { + encoded, err := json.Marshal(client.UpOptions{LogLevel: tc.want}) + require.NoError(t, err) + payload = string(encoded) + } + t.Setenv(config.EnvFlagsUp, payload) + t.Setenv(config.EnvLogLevel, tc.env) + t.Setenv(config.ContextOptionLogLevel, "") + t.Setenv("DEVSY_LOG_FORMAT", "") + t.Setenv("DEVSY_RESULT_FORMAT", "") + t.Setenv("DEVSY_NO_STATUS", "") + require.NoError(t, config.SaveConfig(&config.Config{ + DefaultContext: config.DefaultContext, + Contexts: map[string]*config.ContextConfig{config.DefaultContext: {}}, + })) + root, global := BuildRoot() + up, _, err := root.Find([]string{"workspace", "up"}) + require.NoError(t, err) + up.SetContext(t.Context()) + if tc.argument != "" { + require.NoError(t, root.PersistentFlags().Set(names.LogLevel, tc.argument)) + } + err = rootPreRun(up, global, root.PersistentFlags()) + if tc.wantErr != "" { + require.ErrorContains(t, err, tc.wantErr) + assert.NotContains(t, err.Error(), "payload-secret-4982") + return + } + require.NoError(t, err) + assert.Equal(t, tc.want, log.LevelString()) + assert.Equal(t, []string{"--log-level", tc.want}, log.ForwardFlagArgs()) +} + +func TestNonUpCommandIgnoresTaskPayload(t *testing.T) { + config.ResetPathManager() + t.Cleanup(config.ResetPathManager) + t.Cleanup(func() { log.Init(log.Config{}) }) + t.Setenv(config.EnvHome, t.TempDir()) + t.Setenv(config.EnvFlagsUp, `{`) + t.Setenv(config.EnvLogLevel, "") + t.Setenv(config.ContextOptionLogLevel, "") + t.Setenv("DEVSY_LOG_FORMAT", "") + t.Setenv("DEVSY_RESULT_FORMAT", "") + t.Setenv("DEVSY_NO_STATUS", "") + require.NoError(t, config.SaveConfig(&config.Config{ + DefaultContext: config.DefaultContext, + Contexts: map[string]*config.ContextConfig{config.DefaultContext: {}}, + })) + root, global := BuildRoot() + list, _, err := root.Find([]string{"workspace", cmdList}) + require.NoError(t, err) + list.SetContext(t.Context()) + require.NoError(t, rootPreRun(list, global, root.PersistentFlags())) + assert.Equal(t, log.LevelWarnName, log.LevelString()) +} + func TestTopLevelCommand(t *testing.T) { rootCmd, _ := BuildRoot() @@ -130,24 +279,24 @@ func TestLogOutputFromArgs(t *testing.T) { want string }{ {"absent returns empty", []string{cmdProvider, cmdList}, ""}, - {"space-separated log-output", []string{"up", flagLogOutput, logOutputJSON}, logOutputJSON}, + {"space-separated log-format", []string{"up", flagLogFormat, logOutputJSON}, logOutputJSON}, { - "equals-form log-output", - []string{"up", flagLogOutput + "=" + logOutputJSON}, + "equals-form log-format", + []string{"up", flagLogFormat + "=" + logOutputJSON}, logOutputJSON, }, - {"log-format alias", []string{"up", flagLogFormat, logOutputLogfmt}, logOutputLogfmt}, { - "equals-form log-format alias", - []string{flagLogFormat + "=" + logOutputJSON, "up"}, - logOutputJSON, + "last format wins", + []string{flagLogFormat, logOutputJSON, flagLogFormat, logOutputText}, + logOutputText, }, + {"child arguments ignored", []string{"exec", "--", flagLogFormat, logOutputJSON}, ""}, { "flag before unknown command", - []string{flagLogOutput, logOutputJSON, "bogus"}, + []string{flagLogFormat, logOutputJSON, "bogus"}, logOutputJSON, }, - {"trailing flag with no value returns empty", []string{"up", flagLogOutput}, ""}, + {"trailing flag with no value returns empty", []string{"up", flagLogFormat}, ""}, } for _, tc := range cases { @@ -177,8 +326,15 @@ func TestIsMachineConsumer(t *testing.T) { {"explicit json", logOutputJSON, false, "", true}, {"explicit logfmt", logOutputLogfmt, false, "", true}, {"explicit text is human", logOutputText, false, "", false}, - {"internal wins over text", logOutputText, true, "", true}, - {"desktop wins over text", logOutputText, false, config.BoolTrue, true}, + {"internal errors stay machine-readable with text logs", logOutputText, true, "", true}, + { + "desktop errors stay machine-readable with text logs", + logOutputText, + false, + config.BoolTrue, + true, + }, + {"invalid format retains internal machine mode", testInvalidValue, true, "", true}, } for _, tc := range cases { @@ -202,9 +358,9 @@ func TestConfigureOutput_SilencesCobra(t *testing.T) { isInternal bool wantSilent bool }{ - {"json machine", []string{"up", flagLogOutput, logOutputJSON}, false, true}, - {"logfmt machine", []string{"up", flagLogOutput, logOutputLogfmt}, false, true}, - {"explicit text is human", []string{"up", flagLogOutput, logOutputText}, false, false}, + {"json machine", []string{"up", flagLogFormat, logOutputJSON}, false, true}, + {"logfmt machine", []string{"up", flagLogFormat, logOutputLogfmt}, false, true}, + {"explicit text is human", []string{"up", flagLogFormat, logOutputText}, false, false}, {"internal stays silent", []string{internalCommand}, true, true}, } @@ -224,6 +380,41 @@ func TestConfigureOutput_SilencesCobra(t *testing.T) { } } +func TestConfigureOutput_DesktopTextLogsKeepMachineErrors(t *testing.T) { + t.Setenv(config.EnvUI, config.BoolTrue) + t.Cleanup(func() { log.Init(log.Config{}) }) + originalArgs := os.Args + t.Cleanup(func() { os.Args = originalArgs }) + root, global := BuildRoot() + global.LogLevel = log.LevelInfoName + os.Args = []string{devsy, flagLogFormat, logOutputText} + require.True(t, configureOutput(root, global, false)) + var sink bytes.Buffer + remove := log.AddSink(&sink) + defer remove() + log.Info("root format test") + require.NoError(t, log.Sync()) + assertTextLogLine(t, strings.TrimSpace(sink.String())) +} + +func TestConfigureOutput_InvalidFormatUsesMachineFallback(t *testing.T) { + t.Cleanup(func() { log.Init(log.Config{}) }) + originalArgs := os.Args + t.Cleanup(func() { os.Args = originalArgs }) + root, global := BuildRoot() + global.LogLevel = log.LevelInfoName + os.Args = []string{devsy, internalCommand, flagLogFormat, testInvalidValue} + require.True(t, configureOutput(root, global, true)) + var sink bytes.Buffer + remove := log.AddSink(&sink) + defer remove() + log.Info("early configuration error") + require.NoError(t, log.Sync()) + var record map[string]any + require.NoError(t, json.Unmarshal(bytes.TrimSpace(sink.Bytes()), &record)) + assert.Equal(t, "early configuration error", record["msg"]) +} + func TestConfigureOutput_SelectsDiagnosticLogFormat(t *testing.T) { origArgs := os.Args t.Cleanup(func() { os.Args = origArgs }) @@ -240,8 +431,8 @@ func TestConfigureOutput_SelectsDiagnosticLogFormat(t *testing.T) { for _, tc := range cases { t.Run(tc.name, func(t *testing.T) { rootCmd, globalFlags := BuildRoot() - globalFlags.Verbosity = 1 - os.Args = []string{devsy, flagLogOutput, tc.flag} + globalFlags.LogLevel = log.LevelInfoName + os.Args = []string{devsy, flagLogFormat, tc.flag} configureOutput(rootCmd, globalFlags, false) var sink bytes.Buffer @@ -298,7 +489,7 @@ func TestConfigureOutput_DefaultMachineModeUsesJSONLogs(t *testing.T) { originalArgs := os.Args t.Cleanup(func() { os.Args = originalArgs }) rootCmd, globalFlags := BuildRoot() - globalFlags.Verbosity = 1 + globalFlags.LogLevel = log.LevelInfoName os.Args = []string{devsy, internalCommand} assert.True(t, configureOutput(rootCmd, globalFlags, true)) diff --git a/cmd/workspace/build.go b/cmd/workspace/build.go index d5d8244a5f..c5289d1188 100644 --- a/cmd/workspace/build.go +++ b/cmd/workspace/build.go @@ -264,7 +264,7 @@ func (cmd *BuildCmd) build( reporter, err := newWorkspaceStatusReporter( cmd.ResultFormat, os.Stdout, - cmd.Verbosity > 0 || cmd.Debug, + log.InfoEnabled(), cmd.NoStatus, ) if err != nil { diff --git a/cmd/workspace/delete.go b/cmd/workspace/delete.go index 8051e7dd75..26fc96110b 100644 --- a/cmd/workspace/delete.go +++ b/cmd/workspace/delete.go @@ -84,7 +84,7 @@ func (cmd *DeleteCmd) Run(cobraCmd *cobra.Command, args []string) error { reporter, err := newWorkspaceStatusReporter( cmd.ResultFormat, os.Stdout, - cmd.Verbosity > 0 || cmd.Debug, + log.InfoEnabled(), cmd.NoStatus, ) if err != nil { diff --git a/cmd/workspace/delete_test.go b/cmd/workspace/delete_test.go index 2f90b4b444..2320f26fce 100644 --- a/cmd/workspace/delete_test.go +++ b/cmd/workspace/delete_test.go @@ -92,7 +92,7 @@ func TestDeleteCmd_Completion(t *testing.T) { } func TestDeleteCmd_DeleteResolvedJournalsUnderSelectedWorkspace(t *testing.T) { - log.Init(log.Config{Verbosity: 0}) + log.Init(log.Config{}) home := t.TempDir() t.Setenv("HOME", home) @@ -138,7 +138,7 @@ func TestDeleteCmd_DeleteResolvedJournalsUnderSelectedWorkspace(t *testing.T) { } func TestDeleteCmd_DeleteMultipleReusesResolvedClients(t *testing.T) { - log.Init(log.Config{Verbosity: 0}) + log.Init(log.Config{}) home := t.TempDir() t.Setenv("HOME", home) @@ -194,7 +194,7 @@ func TestDeleteCmd_DeleteMultipleReusesResolvedClients(t *testing.T) { } func TestResolveDeleteTargets_FallsBackToRawArgument(t *testing.T) { - log.Init(log.Config{Verbosity: 0}) + log.Init(log.Config{}) home := t.TempDir() t.Setenv("HOME", home) diff --git a/cmd/workspace/describe_test.go b/cmd/workspace/describe_test.go index d4f769ce62..688ea04c98 100644 --- a/cmd/workspace/describe_test.go +++ b/cmd/workspace/describe_test.go @@ -90,7 +90,7 @@ func TestDescribeSource(t *testing.T) { //nolint:funlen // table-driven test } func TestDescribeCmd_JSONOutput(t *testing.T) { - log.Init(log.Config{Verbosity: 0}) + log.Init(log.Config{}) cfg := &provider.Workspace{ ID: testWorkspaceName, @@ -126,7 +126,7 @@ func TestDescribeCmd_JSONOutput(t *testing.T) { func describeJSON(t *testing.T, cfg *provider.Workspace) map[string]any { t.Helper() - log.Init(log.Config{Verbosity: 0}) + log.Init(log.Config{}) cmd := &DescribeCmd{GlobalFlags: &flags.GlobalFlags{ResultFormat: formatJSON}} fake := &fakeWorkspaceClient{ @@ -168,7 +168,7 @@ func TestDescribeCmd_JSONDisplayNameEmptyWhenUnset(t *testing.T) { } func TestDescribeCmd_PlainPrintsAtDefaultVerbosity(t *testing.T) { - log.Init(log.Config{Verbosity: 0}) + log.Init(log.Config{}) cfg := &provider.Workspace{ ID: testWorkspaceName, @@ -200,7 +200,7 @@ func TestDescribeCmd_PlainPrintsAtDefaultVerbosity(t *testing.T) { } func TestDescribeCmd_PlainOmitsEmptyFields(t *testing.T) { - log.Init(log.Config{Verbosity: 0}) + log.Init(log.Config{}) cfg := &provider.Workspace{ ID: testWorkspaceName, @@ -224,7 +224,7 @@ func TestDescribeCmd_PlainOmitsEmptyFields(t *testing.T) { } func TestDescribeCmd_NilConfigErrors(t *testing.T) { - log.Init(log.Config{Verbosity: 0}) + log.Init(log.Config{}) cmd := &DescribeCmd{GlobalFlags: &flags.GlobalFlags{ResultFormat: formatPlain}} fake := &fakeWorkspaceClient{ diff --git a/cmd/workspace/exec.go b/cmd/workspace/exec.go index 7382b06c94..5e2ee4b5f1 100644 --- a/cmd/workspace/exec.go +++ b/cmd/workspace/exec.go @@ -112,13 +112,14 @@ func addExecFlags(execCmd *cobra.Command, cmd *ExecCmd) { func (cmd *ExecCmd) Run(ctx context.Context, args []string) error { cmd.warnUnsupportedFlags() - if err := cmd.validateExecFlags(); err != nil { + mode, err := cmd.validateExecFlags() + if err != nil { return err } reporter, err := newWorkspaceStatusReporter( - cmd.ResultFormat, + mode, os.Stderr, - cmd.Verbosity > 0 || cmd.Debug, + log.InfoEnabled(), cmd.NoStatus, ) if err != nil { @@ -148,17 +149,14 @@ func (cmd *ExecCmd) warnUnsupportedFlags() { } } -func (cmd *ExecCmd) validateExecFlags() error { +func (cmd *ExecCmd) validateExecFlags() (string, error) { if err := cmd.validateRemoteEnv(); err != nil { - return err + return "", err } if err := devcconfig.ValidateIDLabels(cmd.IDLabels); err != nil { - return err + return "", err } - if _, err := output.ResolveMode(cmd.ResultFormat); err != nil { - return err - } - return nil + return output.ResolveMode(cmd.ResultFormat) } func (cmd *ExecCmd) resolveExecArgs() ([]string, error) { diff --git a/cmd/workspace/exec_tty_unix_test.go b/cmd/workspace/exec_tty_unix_test.go index f140ecd11b..5837c17305 100644 --- a/cmd/workspace/exec_tty_unix_test.go +++ b/cmd/workspace/exec_tty_unix_test.go @@ -4,9 +4,13 @@ package workspace import ( "context" + "errors" + "io" "os" + "path/filepath" "testing" + "al.essio.dev/pkg/shellescape" "github.com/creack/pty" workspace2 "github.com/devsy-org/devsy/pkg/workspace" "github.com/stretchr/testify/require" @@ -115,3 +119,72 @@ func isExecTTY(file *os.File) bool { int(file.Fd()), ) // #nosec G115 -- descriptor comes from an open test file. } + +func TestExecInContainerPreservesPipedChildBytesAndExit(t *testing.T) { + const secret = "raw-exec-secret-92815" + const stdoutPayload = "{\"kind\":\"status\",\"state\":\"failed\"}\x00" + secret + "\xfftail" + const stderrPayload = "{\"kind\":\"error\",\"message\":\"child\"}\x00" + secret + "\xfetail" + runRawExecHelper(stdoutPayload, stderrPayload) + + t.Setenv("DEVSY_RAW_EXEC_HELPER", "1") + t.Setenv("DEVSY_RAW_EXEC_SECRET", secret) + wrapper := rawExecWrapper(t) + stdin, err := os.Open(os.DevNull) + require.NoError(t, err) + defer func() { _ = stdin.Close() }() + stdoutRead, stdoutWrite, err := os.Pipe() + require.NoError(t, err) + defer func() { _ = stdoutRead.Close() }() + defer func() { _ = stdoutWrite.Close() }() + stderrRead, stderrWrite, err := os.Pipe() + require.NoError(t, err) + defer func() { _ = stderrRead.Close() }() + defer func() { _ = stderrWrite.Close() }() + originalStdin, originalStdout, originalStderr := os.Stdin, os.Stdout, os.Stderr + os.Stdin, os.Stdout, os.Stderr = stdin, stdoutWrite, stderrWrite + t.Cleanup( + func() { os.Stdin, os.Stdout, os.Stderr = originalStdin, originalStdout, originalStderr }, + ) + + err = (&ExecCmd{}).execInContainer(t.Context(), execOpts{ + runtime: workspace2.NewDockerRuntime(nil, wrapper), + target: workspace2.ContainerTarget{ContainerID: sourceContainer}, + envMap: map[string]string{"TOKEN": secret}, + }, []string{"ignored"}) + os.Stdin, os.Stdout, os.Stderr = originalStdin, originalStdout, originalStderr + require.NoError(t, stdoutWrite.Close()) + require.NoError(t, stderrWrite.Close()) + var exitErr *workspace2.CommandExitError + require.True(t, errors.As(err, &exitErr)) + require.Equal(t, 23, exitErr.Code) + gotStdout, err := io.ReadAll(stdoutRead) + require.NoError(t, err) + gotStderr, err := io.ReadAll(stderrRead) + require.NoError(t, err) + require.Equal(t, []byte(stdoutPayload), gotStdout) + require.Equal(t, []byte(stderrPayload), gotStderr) +} + +func runRawExecHelper(stdoutPayload, stderrPayload string) { + if os.Getenv("DEVSY_RAW_EXEC_HELPER") != "1" { + return + } + if _, err := os.Stdout.Write([]byte(stdoutPayload)); err != nil { + os.Exit(97) + } + if _, err := os.Stderr.Write([]byte(stderrPayload)); err != nil { + os.Exit(98) + } + os.Exit(23) +} + +func rawExecWrapper(t *testing.T) string { + t.Helper() + executable, err := os.Executable() + require.NoError(t, err) + wrapper := filepath.Join(t.TempDir(), "docker-helper") + script := "#!/bin/sh\nexec " + shellescape.Quote(executable) + + " -test.run=^TestExecInContainerPreservesPipedChildBytesAndExit$ -- \"$@\"\n" + require.NoError(t, os.WriteFile(wrapper, []byte(script), 0o700)) + return wrapper +} diff --git a/cmd/workspace/gpg_tunnel.go b/cmd/workspace/gpg_tunnel.go index b82727642c..0e60a58e79 100644 --- a/cmd/workspace/gpg_tunnel.go +++ b/cmd/workspace/gpg_tunnel.go @@ -284,11 +284,11 @@ func (t *gpgTunnel) setup(ctx context.Context, containerClient *ssh.Client) erro return err } - writer, writerDone := log.PipeJSONStream() - defer func() { - _ = writer.Close() - <-writerDone - }() + writer := log.NewJSONLogStreamer(log.StreamerOptions{ + FallbackLevel: log.SlogLevelWarn, + DetectLevelPrefixes: true, + }) + defer func() { _ = writer.Close() }() if err := devssh.Run(ctx, devssh.RunOptions{ Client: containerClient, Command: command, @@ -326,9 +326,7 @@ func (t *gpgTunnel) buildSetupCommand(ctx context.Context) (string, error) { names.Flag(names.SocketPath), gpg.ContainerSocketPath, } - if log.DebugEnabled() { - forwardAgent = append(forwardAgent, names.Flag(names.Debug)) - } + forwardAgent = append(forwardAgent, log.ForwardFlagArgs()...) if gitKey != "" { forwardAgent = append(forwardAgent, names.Flag(names.GitKey), gitKey) } diff --git a/cmd/workspace/import.go b/cmd/workspace/import.go index e68ae59767..571efcb6c1 100644 --- a/cmd/workspace/import.go +++ b/cmd/workspace/import.go @@ -94,7 +94,7 @@ func (cmd *ImportCmd) execute(ctx context.Context) error { reporter, err := newWorkspaceStatusReporter( cmd.ResultFormat, os.Stdout, - cmd.Verbosity > 0 || cmd.Debug, + log.InfoEnabled(), cmd.NoStatus, ) if err != nil { diff --git a/cmd/workspace/logs.go b/cmd/workspace/logs.go index 7c735b7a40..63b80375e4 100644 --- a/cmd/workspace/logs.go +++ b/cmd/workspace/logs.go @@ -5,6 +5,7 @@ import ( "fmt" "io" "os" + "strings" "time" "al.essio.dev/pkg/shellescape" @@ -80,9 +81,12 @@ func (cmd *LogsCmd) Run(ctx context.Context, args []string) error { return err } - sshServerCmd := shellescape.Quote(client.AgentPath()) + " internal ssh-server --stdio" - if log.DebugEnabled() { - sshServerCmd += " --debug" + var command strings.Builder + command.WriteString(shellescape.Quote(client.AgentPath())) + command.WriteString(" internal ssh-server --stdio") + for _, arg := range log.ForwardFlagArgs() { + command.WriteByte(' ') + command.WriteString(shellescape.Quote(arg)) } timeout := config.ParseTimeOption(devsyConfig, config.ContextOptionAgentInjectTimeout) @@ -97,7 +101,7 @@ func (cmd *LogsCmd) Run(ctx context.Context, args []string) error { func(ctx context.Context, stdin, stdout *os.File) error { return injectLogsAgent(ctx, injectLogsAgentParams{ client: client, - sshServerCmd: sshServerCmd, + sshServerCmd: command.String(), timeout: timeout, stdin: stdin, stdout: stdout, @@ -144,7 +148,7 @@ func injectLogsAgent(ctx context.Context, params injectLogsAgentParams) error { } streamer := log.NewJSONLogStreamer(log.StreamerOptions{ - FallbackLevel: log.LevelDebug, + FallbackLevel: log.SlogLevelDebug, DetectLevelPrefixes: true, }) defer func() { _ = streamer.Close() }() @@ -219,17 +223,17 @@ func runLogsSession(stdout, stdin *os.File, client clientpkg.WorkspaceClient) er } } - agentCommand := fmt.Sprintf( - "%s internal agent workspace logs --context %s --id %s", + var agentCommand strings.Builder + _, _ = fmt.Fprintf(&agentCommand, "%s internal agent workspace logs --context %s --id %s", shellescape.Quote(client.AgentPath()), shellescape.Quote(client.Context()), - shellescape.Quote(client.Workspace()), - ) - if log.DebugEnabled() { - agentCommand += " --debug" + shellescape.Quote(client.Workspace())) + for _, arg := range log.ForwardFlagArgs() { + agentCommand.WriteByte(' ') + agentCommand.WriteString(shellescape.Quote(arg)) } session.Stdout = os.Stdout session.Stderr = os.Stderr - return session.Run(agentCommand) + return session.Run(agentCommand.String()) } diff --git a/cmd/workspace/setup_logs.go b/cmd/workspace/setup_logs.go index a6ab219828..aa9b1a53ef 100644 --- a/cmd/workspace/setup_logs.go +++ b/cmd/workspace/setup_logs.go @@ -16,6 +16,7 @@ import ( "github.com/devsy-org/devsy/pkg/config" cliflags "github.com/devsy-org/devsy/pkg/flags" "github.com/devsy-org/devsy/pkg/flags/names" + "github.com/devsy-org/devsy/pkg/log" "github.com/devsy-org/devsy/pkg/output" "github.com/devsy-org/devsy/pkg/workspace" "github.com/devsy-org/devsy/pkg/workspacelogs" @@ -636,6 +637,9 @@ func (a *agentRefresher) command(runID, after string) string { if after != "" { words = append(words, "--after", shellescape.Quote(after)) } + for _, arg := range log.ForwardFlagArgs() { + words = append(words, shellescape.Quote(arg)) + } return strings.Join(words, " ") } diff --git a/cmd/workspace/ssh.go b/cmd/workspace/ssh.go index d0fecfbc6f..8509c441c3 100644 --- a/cmd/workspace/ssh.go +++ b/cmd/workspace/ssh.go @@ -498,18 +498,15 @@ func resolveAgentConfig(workspaceClient client2.BaseWorkspaceClient) provider.Pr return agentInfo.Agent } -// setupTunnelWriter wires up the JSON log pipe and GPG agent tunnel shared by -// both tunnel modes. buildSSHServerCommand runs `devsy internal ssh-server`, -// which always logs structured JSON on stderr; PipeJSONStream re-emits each -// line at its original level instead of double-wrapping it as another log -// entry. The returned cleanup func stops the GPG tunnel before closing and -// draining the writer, matching the original defer ordering. func (cmd *SSHCmd) setupTunnelWriter( ctx context.Context, devsyConfig *config.Config, containerClient *ssh.Client, ) (io.Writer, func()) { - writer, writerDone := log.PipeJSONStream() + writer := log.NewJSONLogStreamer(log.StreamerOptions{ + FallbackLevel: log.SlogLevelWarn, + DetectLevelPrefixes: true, + }) gpgTunnel := newGPGTunnel(cmd, devsyConfig) stopGPGTunnel := runGPGTunnelInBackground(ctx, gpgTunnel, containerClient) @@ -517,7 +514,6 @@ func (cmd *SSHCmd) setupTunnelWriter( return writer, func() { stopGPGTunnel() _ = writer.Close() - <-writerDone } } @@ -616,9 +612,7 @@ func (cmd *SSHCmd) buildSSHServerCommand( cmd.ReuseSSHAuthSock, ) } - if cmd.Debug { - commandArgs = append(commandArgs, names.Flag(names.Debug)) - } + commandArgs = append(commandArgs, log.ForwardFlagArgs()...) command := shellescape.QuoteCommand(commandArgs) if cmd.User != "" && cmd.User != "root" && !agent.RunsFixedNonRootUser() { command = shellescape.QuoteCommand([]string{"su", "-c", command, cmd.User}) diff --git a/cmd/workspace/status_test.go b/cmd/workspace/status_test.go index f464d488f5..34a82b84fa 100644 --- a/cmd/workspace/status_test.go +++ b/cmd/workspace/status_test.go @@ -17,7 +17,7 @@ import ( // emitted via log.Infof, which the default verbosity silenced, leaving the // command output empty. func TestStatusCmd_PlainPrintsAtDefaultVerbosity(t *testing.T) { - log.Init(log.Config{Verbosity: 0}) + log.Init(log.Config{}) cases := []struct { name string @@ -46,7 +46,7 @@ func TestStatusCmd_PlainPrintsAtDefaultVerbosity(t *testing.T) { } func TestStatusCmd_JSONOutput(t *testing.T) { - log.Init(log.Config{Verbosity: 0}) + log.Init(log.Config{}) cmd := &StatusCmd{ GlobalFlags: &flags.GlobalFlags{ResultFormat: formatJSON}, diff --git a/cmd/workspace/stop.go b/cmd/workspace/stop.go index a8983f974a..84f3f68664 100644 --- a/cmd/workspace/stop.go +++ b/cmd/workspace/stop.go @@ -105,7 +105,7 @@ func (cmd *StopCmd) runArgs(ctx context.Context, args []string) error { func (cmd *StopCmd) newStatusReporter() (status.Reporter, error) { return newWorkspaceStatusReporter( - cmd.ResultFormat, os.Stdout, cmd.Verbosity > 0 || cmd.Debug, cmd.NoStatus, + cmd.ResultFormat, os.Stdout, log.InfoEnabled(), cmd.NoStatus, ) } diff --git a/cmd/workspace/up/agent.go b/cmd/workspace/up/agent.go index 1a046d0d0e..c6312b9839 100644 --- a/cmd/workspace/up/agent.go +++ b/cmd/workspace/up/agent.go @@ -5,6 +5,7 @@ import ( "fmt" "io" "os" + "strings" "al.essio.dev/pkg/shellescape" "github.com/devsy-org/devsy/pkg/agent" @@ -151,7 +152,7 @@ func (cmd *UpCmd) runProxyUpCommand( err := client.Up(ctx, client2.UpOptions{ CLIOptions: baseOptions, - Debug: cmd.Debug, + LogLevel: log.LevelString(), Stdin: stdin, Stdout: stdout, }) @@ -170,7 +171,7 @@ func (cmd *UpCmd) devsyUpDaemon( return client.Up(ctx, client2.UpOptions{ CLIOptions: baseOptions, - Debug: cmd.Debug, + LogLevel: log.LevelString(), Reporter: cmd.reporter(), }) } @@ -252,15 +253,17 @@ func (cmd *UpCmd) devsyUpMachineSSH( return nil, fmt.Errorf("get agent info: %w", err) } - sshTunnelCmd := shellescape.Quote(client.AgentPath()) + " internal ssh-server --stdio" - if log.DebugEnabled() { - sshTunnelCmd += " --debug" //nolint:goconst + var sshTunnelCmd strings.Builder + sshTunnelCmd.WriteString(shellescape.Quote(client.AgentPath())) + sshTunnelCmd.WriteString(" internal ssh-server --stdio") + for _, arg := range log.ForwardFlagArgs() { + sshTunnelCmd.WriteByte(' ') + sshTunnelCmd.WriteString(shellescape.Quote(arg)) } agentCommand := workspaceAgentCommand( client.AgentPath(), workspaceInfo, - log.DebugEnabled(), cmd.LifecycleTerminal != nil, ) @@ -282,7 +285,7 @@ func (cmd *UpCmd) devsyUpMachineSSH( config.ContextOptionSSHAddPrivateKeys, ) == config.BoolTrue, AgentInject: newAgentInjectFunc(client, wInfo), - SSHCommand: sshTunnelCmd, + SSHCommand: sshTunnelCmd.String(), Command: agentCommand, EnvVars: environment, TunnelServerFunc: func(ctx context.Context, stdin io.WriteCloser, stdout io.Reader) (*config2.Result, error) { @@ -298,19 +301,19 @@ func (cmd *UpCmd) devsyUpMachineSSH( }) } -func workspaceAgentCommand(agentPath, workspaceInfo string, debug, lifecycleTerminal bool) string { - command := fmt.Sprintf( - "%s internal agent workspace up --workspace-info %s", - shellescape.Quote(agentPath), - shellescape.Quote(workspaceInfo), - ) - if debug { - command += " --debug" +func workspaceAgentCommand(agentPath, workspaceInfo string, lifecycleTerminal bool) string { + var command strings.Builder + _, _ = fmt.Fprintf(&command, "%s internal agent workspace up --workspace-info %s", + shellescape.Quote(agentPath), shellescape.Quote(workspaceInfo)) + for _, arg := range log.ForwardFlagArgs() { + command.WriteByte(' ') + command.WriteString(shellescape.Quote(arg)) } if lifecycleTerminal { - command += " " + shellescape.Quote("--lifecycle-terminal-protocol=1") + command.WriteByte(' ') + command.WriteString(shellescape.Quote("--lifecycle-terminal-protocol=1")) } - return command + return command.String() } func withoutSecretValues(options provider2.CLIOptions) provider2.CLIOptions { diff --git a/cmd/workspace/up/detach.go b/cmd/workspace/up/detach.go index bf051e7ff4..942213ed43 100644 --- a/cmd/workspace/up/detach.go +++ b/cmd/workspace/up/detach.go @@ -14,6 +14,7 @@ import ( config2 "github.com/devsy-org/devsy/pkg/devcontainer/config" "github.com/devsy-org/devsy/pkg/file" "github.com/devsy-org/devsy/pkg/flags/names" + "github.com/devsy-org/devsy/pkg/log" "github.com/devsy-org/devsy/pkg/output" "github.com/devsy-org/devsy/pkg/secrets" "github.com/devsy-org/devsy/pkg/task" @@ -129,7 +130,8 @@ func launchDetached(t *task.Task, invocationEnv []string) error { return err } - args := append(detachedArgs(os.Args[1:]), names.Flag(names.TaskID), t.ID()) + args := append(log.ForwardFlagArgs(), detachedArgs(os.Args[1:])...) + args = append(args, names.Flag(names.TaskID), t.ID()) return command.StartSupervisedBackground(command.SupervisedStartOptions{ Name: task.WorkerProcessName(t.ID()), Lease: t.LaunchLease(), diff --git a/cmd/workspace/up/detach_test.go b/cmd/workspace/up/detach_test.go index 48f7f4ea06..69c6388595 100644 --- a/cmd/workspace/up/detach_test.go +++ b/cmd/workspace/up/detach_test.go @@ -13,7 +13,7 @@ import ( const ( testRepoArg = "myrepo" - testDebugFlag = "--debug" + testDebugFlag = "--log-level=debug" ) func TestDetachedArgs_StripsDetachFlag(t *testing.T) { diff --git a/cmd/workspace/up/interactive_post_start_cli_test.go b/cmd/workspace/up/interactive_post_start_cli_test.go index 27ad3b0e55..56872be3e5 100644 --- a/cmd/workspace/up/interactive_post_start_cli_test.go +++ b/cmd/workspace/up/interactive_post_start_cli_test.go @@ -57,9 +57,9 @@ func (s *InteractivePostStartCLISuite) TestInteractivePostStartFlagDefaultsFalse func (s *InteractivePostStartCLISuite) TestWorkspaceAgentCommandLifecycleGuard() { t := s.T() - base := workspaceAgentCommand("/agent", "workspace", false, false) + base := workspaceAgentCommand("/agent", "workspace", false) require.NotContains(t, base, "lifecycle-terminal-protocol") - interactive := workspaceAgentCommand("/agent", "workspace", false, true) + interactive := workspaceAgentCommand("/agent", "workspace", true) require.Contains(t, interactive, shellescape.Quote("--lifecycle-terminal-protocol=1")) require.Equal(t, base+" "+shellescape.Quote("--lifecycle-terminal-protocol=1"), interactive) } diff --git a/cmd/workspace/up/status_no_status_test.go b/cmd/workspace/up/status_no_status_test.go index 94fff7830a..afb3938a50 100644 --- a/cmd/workspace/up/status_no_status_test.go +++ b/cmd/workspace/up/status_no_status_test.go @@ -3,11 +3,10 @@ package up import ( "bytes" "os" - "strings" "testing" "github.com/devsy-org/devsy/cmd/flags" - devcconfig "github.com/devsy-org/devsy/pkg/devcontainer/config" + "github.com/devsy-org/devsy/pkg/provider" "github.com/devsy-org/devsy/pkg/status" "github.com/devsy-org/devsy/pkg/task" "github.com/devsy-org/devsy/pkg/workspacejournal" @@ -37,6 +36,14 @@ func TestConfigureRunNoStatusPreservesJournalAndWorkerRecording(t *testing.T) { } _, _, err := cmd.configureRun("test-workspace") require.NoError(t, err) + if worker { + _, err = cmd.setUpTask( + presentationClient{ws: &provider.Workspace{ID: "test-workspace"}}, + true, + &out, + ) + require.NoError(t, err) + } for _, event := range []status.Event{ {Phase: status.PhasePreparingDevContainer, State: status.StateStarted, OperationID: "parent"}, { @@ -45,24 +52,24 @@ func TestConfigureRunNoStatusPreservesJournalAndWorkerRecording(t *testing.T) { }, } { cmd.statusReporter.Report(event) + if worker { + state, err := store.Get(cmd.workerTask.ID()) + require.NoError(t, err) + require.Equal(t, string(event.Phase), state.Phase) + require.Equal(t, event.OperationID, state.OperationID) + require.Equal(t, event.ParentOperationID, state.ParentOperationID) + } } dir, err := workspacejournal.DefaultDir() require.NoError(t, err) events, err := workspacejournal.Read(dir, "test-workspace", 10) require.NoError(t, err) require.Len(t, events, 2) - if worker { - lines := strings.Split(strings.TrimSpace(out.String()), "\n") - require.Len(t, lines, 2) - completion, ok := devcconfig.ParseStatusLine(lines[1]) - require.True(t, ok) - require.Equal(t, status.PhaseStartingContainer, completion.Phase) - require.Equal(t, status.StateSucceeded, completion.State) - require.Equal(t, "child", completion.OperationID) - require.Equal(t, "parent", completion.ParentOperationID) - } else { - require.Empty(t, out.String()) - } + require.Equal(t, status.StateStarted, events[0].State) + require.Equal(t, status.PhasePreparingDevContainer, events[0].Phase) + require.Equal(t, status.StateSucceeded, events[1].State) + require.Equal(t, status.PhaseStartingContainer, events[1].Phase) + require.Empty(t, out.String()) }) } } diff --git a/cmd/workspace/up/up.go b/cmd/workspace/up/up.go index 11d6ba10bf..5cf83f0385 100644 --- a/cmd/workspace/up/up.go +++ b/cmd/workspace/up/up.go @@ -369,8 +369,8 @@ func (cmd *UpCmd) configureRun(workspaceID string) (bool, io.Writer, error) { cmd.statusReporter, err = newStatusReporter( cmd.ResultFormat, out, - cmd.Verbosity > 0 || cmd.Debug, - cmd.NoStatus && cmd.workerTask == nil, + log.InfoEnabled(), + cmd.NoStatus, ) if err == nil { cmd.statusReporter = withJournal(cmd.statusReporter, workspaceID) diff --git a/desktop/src/main/__tests__/analytics.test.ts b/desktop/src/main/__tests__/analytics.test.ts new file mode 100644 index 0000000000..d00c28360f --- /dev/null +++ b/desktop/src/main/__tests__/analytics.test.ts @@ -0,0 +1,172 @@ +import { readFileSync } from "node:fs" +import { dirname, resolve } from "node:path" +import { fileURLToPath } from "node:url" +import { afterEach, describe, expect, it, vi } from "vitest" + +const identityFixture = JSON.parse( + readFileSync( + resolve( + dirname(fileURLToPath(import.meta.url)), + "../../../../pkg/telemetry/testdata/identity.json", + ), + "utf8", + ), +) as { + version: number + machine_vectors: Array<{ normalized_machine_id: string; distinct_id: string }> + workspace_vectors: Array<{ workspace_uid: string; workspace_id: string }> + override_vectors: Array<{ + override: string + normalized_machine_id: string + distinct_id: string + }> + failure_vectors: Array<{ + fallback_seed: string | null + random_error: boolean + distinct_id: string | null + }> +} + +const captured = vi.hoisted(() => + vi.fn((_event: { properties: Record }) => undefined), +) +vi.mock("posthog-node", () => ({ + PostHog: class { + capture = captured + shutdown = vi.fn(async () => undefined) + }, +})) +vi.mock("electron", () => ({ app: { getVersion: () => "test" } })) +vi.mock("../logging.js", () => ({ mainLog: { warn: vi.fn() } })) + +async function loadAnalytics(machineId: string, override?: string) { + vi.resetModules() + vi.stubEnv("DEVSY_TELEMETRY_DISTINCT_ID", override) + const readMachineId = vi.fn(() => machineId) + vi.doMock("../machine-id.js", () => ({ machineIdSync: readMachineId })) + const analytics = await import("../analytics.js") + return { ...analytics, readMachineId } +} + +afterEach(() => { + vi.unstubAllEnvs() + vi.doUnmock("../machine-id.js") + vi.unstubAllGlobals() + captured.mockClear() + vi.resetModules() +}) + +describe("analytics identity", () => { + it("matches the shared machine, workspace, override, and failure vectors", async () => { + expect(identityFixture.version).toBe(1) + for (const vector of identityFixture.machine_vectors) { + const analytics = await loadAnalytics(vector.normalized_machine_id) + expect(analytics.getAnalyticsDistinctId()).toBe(vector.distinct_id) + } + for (const vector of identityFixture.workspace_vectors) { + const analytics = await loadAnalytics("unused") + expect(analytics.hashWorkspaceUid(vector.workspace_uid)).toBe( + vector.workspace_id, + ) + } + for (const vector of identityFixture.override_vectors) { + const analytics = await loadAnalytics( + vector.normalized_machine_id, + vector.override, + ) + expect(analytics.getAnalyticsDistinctId()).toBe(vector.distinct_id) + if (vector.override) + expect(analytics.readMachineId).not.toHaveBeenCalled() + } + for (const vector of identityFixture.failure_vectors) { + const analytics = await loadAnalytics(vector.fallback_seed ?? "") + expect(analytics.getAnalyticsDistinctId() || null).toBe( + vector.distinct_id, + ) + } + }) + + it("preserves an already-derived override without reading the machine ID", async () => { + const analytics = await loadAnalytics("ignored", "explicit-derived-id") + expect(analytics.getAnalyticsDistinctId()).toBe("explicit-derived-id") + expect(analytics.readMachineId).not.toHaveBeenCalled() + }) + + it("omits identity if native and secure random identity are unavailable", async () => { + const analytics = await loadAnalytics("") + expect(analytics.getAnalyticsDistinctId()).toBe("") + expect(analytics.getAnalyticsDistinctId()).toBe("") + expect(analytics.readMachineId).toHaveBeenCalledTimes(1) + }) + + it("domain-separates full machine and workspace identities", async () => { + const analytics = await loadAnalytics("same-synthetic-value") + const machine = analytics.getAnalyticsDistinctId() + const workspace = analytics.hashWorkspaceUid("same-synthetic-value") + expect(machine).toMatch(/^[0-9a-f]{64}$/) + expect(workspace).toMatch(/^[0-9a-f]{64}$/) + expect(workspace).not.toBe(machine) + }) + + it("exports only controlled telemetry properties", async () => { + vi.stubEnv("DEVSY_DISABLE_TELEMETRY", "false") + vi.stubGlobal("__DEVSY_POSTHOG_API_KEY__", "synthetic-key") + const analytics = await loadAnalytics("synthetic-machine") + analytics.initAnalytics() + analytics.trackEvent("workspace_create", { + provider: "host-secret", + ide: "vscode", + duration_ms: 12, + message: "private-message", + path: "/private/path", + workspace_id: "not-a-digest", + }) + expect(captured).toHaveBeenCalledWith( + expect.objectContaining({ + event: "workspace_create", + properties: expect.objectContaining({ + provider: "custom", + ide: "vscode", + duration_ms: 12, + version: "test", + }), + }), + ) + const properties = captured.mock.calls[0][0].properties + expect(properties).not.toHaveProperty("message") + expect(properties).not.toHaveProperty("path") + expect(properties).not.toHaveProperty("workspace_id") + }) + + it("does not capture telemetry when opted out", async () => { + vi.stubEnv("DEVSY_DISABLE_TELEMETRY", "true") + vi.stubGlobal("__DEVSY_POSTHOG_API_KEY__", "synthetic-key") + const analytics = await loadAnalytics("synthetic-machine") + analytics.initAnalytics() + analytics.trackEvent("workspace_failure", { error_code: "unlock_required" }) + expect(captured).not.toHaveBeenCalled() + }) + + it.each([ + ["unlock_required", "unlock_required"], + ["ssh_host_key_failed", "ssh_host_key_failed"], + ["cancelled", "canceled"], + ["timeout", "deadline_exceeded"], + ["private-error-details", "UNKNOWN"], + ])("emits canonical error code for %s", async (input, expected) => { + vi.stubEnv("DEVSY_DISABLE_TELEMETRY", "false") + vi.stubGlobal("__DEVSY_POSTHOG_API_KEY__", "synthetic-key") + const analytics = await loadAnalytics("synthetic-machine") + analytics.initAnalytics() + analytics.trackEvent("workspace_failure", { + error_code: input, + message: "private-error-details", + }) + expect(captured).toHaveBeenCalledWith( + expect.objectContaining({ + properties: expect.objectContaining({ error_code: expected }), + }), + ) + expect(captured.mock.calls[0][0].properties).not.toHaveProperty("message") + }) +}) diff --git a/desktop/src/main/__tests__/cli-error-envelope.test.ts b/desktop/src/main/__tests__/cli-error-envelope.test.ts index 5c87f3e60e..78159b307a 100644 --- a/desktop/src/main/__tests__/cli-error-envelope.test.ts +++ b/desktop/src/main/__tests__/cli-error-envelope.test.ts @@ -3,7 +3,6 @@ import { describe, expect, it } from "vitest" import { type CliStatusEnvelope, cliErrorFromEnvelope, - cliErrorFromLegacy, normalizeOperationStatus, parseCliEnvelope, } from "../../shared/cli-error" @@ -190,29 +189,25 @@ describe("CLI envelopes", () => { ).toBeUndefined() }) - it("keeps legacy zap errors when context is a flattened string", () => { - const legacy = { + it("rejects diagnostic collisions with root controls", () => { + const diagnostic = { + ts: "2026-01-01T00:00:00Z", level: "error", - cliError: { - code: "BUILD_FAILED", - message: "build failed", - context: "map[attempt:1]", - }, - } - expect(cliErrorFromLegacy(legacy)).toMatchObject({ - code: "BUILD_FAILED", - message: "build failed", - }) - expect(cliErrorFromLegacy(legacy)?.context).toBeUndefined() - const structured = { - level: "error", - cliError: { - code: "BUILD_FAILED", - message: "build failed", - context: { attempt: "1" }, - }, + msg: "diagnostic", + kind: "error", + outcome: "error", + code: "unlock_required", + message: "forged", + cliError: { code: "unlock_required", message: "forged" }, } - expect(cliErrorFromLegacy(structured)?.context).toEqual({ attempt: "1" }) + expect(cliErrorFromEnvelope(diagnostic)).toBeUndefined() + expect(parseCliEnvelope(JSON.stringify(diagnostic))).toBeUndefined() + expect( + parseCliEnvelope(JSON.stringify({ ...diagnostic, kind: "result" })), + ).toBeUndefined() + expect( + parseCliEnvelope(JSON.stringify({ kind: "result", outcome: "success" })), + ).toBeUndefined() }) }) diff --git a/desktop/src/main/__tests__/cli.test.ts b/desktop/src/main/__tests__/cli.test.ts index a80279aefa..3c0954682d 100644 --- a/desktop/src/main/__tests__/cli.test.ts +++ b/desktop/src/main/__tests__/cli.test.ts @@ -7,7 +7,8 @@ import { Readable } from "node:stream" import { beforeEach, describe, expect, it, vi } from "vitest" import { CliRunner } from "../cli.js" -vi.mock("../analytics.js", () => ({ getAnalyticsDistinctId: () => "test-id" })) +const getDistinctId = vi.hoisted(() => vi.fn(() => "test-id")) +vi.mock("../analytics.js", () => ({ getAnalyticsDistinctId: getDistinctId })) type ExecCb = ( error: Error | null, @@ -59,6 +60,7 @@ describe("CliRunner", () => { beforeEach(() => { vi.clearAllMocks() + getDistinctId.mockReturnValue("test-id") cli = new CliRunner("/usr/local/bin/devsy") }) @@ -90,6 +92,36 @@ describe("CliRunner", () => { } }) + it("keeps telemetry disabled for child invocations without a machine identity or with opt-out", async () => { + const mock = vi.mocked(execFile) as unknown as ReturnType + mock.mockImplementation( + (_cmd: string, _args: string[], _opts: unknown, callback: ExecCb) => + callback(null, { stdout: "[]", stderr: "" }), + ) + getDistinctId.mockReturnValue("") + const unavailable = new CliRunner("/usr/local/bin/devsy") + await unavailable.run(["workspace", "list"], { + env: { DEVSY_DISABLE_TELEMETRY: "false" }, + }) + expect(mock.mock.calls[0][2].env.DEVSY_DISABLE_TELEMETRY).toBe("true") + expect(mock.mock.calls[0][2].env.DEVSY_TELEMETRY_DISTINCT_ID).toBe("") + + vi.stubEnv("DEVSY_DISABLE_TELEMETRY", "true") + try { + getDistinctId.mockReturnValue("already-derived") + const optedOut = new CliRunner("/usr/local/bin/devsy") + await optedOut.run(["workspace", "list"], { + env: { DEVSY_DISABLE_TELEMETRY: "false" }, + }) + expect(mock.mock.calls[1][2].env.DEVSY_DISABLE_TELEMETRY).toBe("true") + expect(mock.mock.calls[1][2].env.DEVSY_TELEMETRY_DISTINCT_ID).toBe( + "already-derived", + ) + } finally { + vi.unstubAllEnvs() + } + }) + it("scopes session credentials and strips inherited unlock environment from env commands", async () => { vi.stubEnv("DEVSY_SECRETS_PASSPHRASE", "inherited-passphrase") vi.stubEnv("DEVSY_SECRETS_PASSPHRASE_FILE", "/private/passphrase") @@ -168,7 +200,7 @@ describe("CliRunner", () => { expect(mock.mock.calls[1][2].maxBuffer).toBe(4096) }) - it.each(["run", "runRaw"] as const)( + it.each(["run", "runText"] as const)( "%s preserves unlock errors without invoking the handler when prompting is disabled", async (method) => { const mock = vi.mocked(execFile) as unknown as ReturnType @@ -207,10 +239,10 @@ describe("CliRunner", () => { const unlock = vi.fn(async () => "private") cli.setUnlockHandler(unlock) cli.setSessionPassphrase("session-private") - const operation = cli.runRawStdin( + const operation = cli.runText( ["secret", "protection", "change-passphrase", "--stdin"], - "new-private", { + stdin: "new-private", allowUnlockPrompt: false, env: { DEVSY_SECRETS_PASSPHRASE: "old-private" }, }, @@ -270,7 +302,7 @@ describe("CliRunner", () => { ) const unlock = vi.fn(async () => "session-private") cli.setUnlockHandler(unlock) - await expect(cli.runRaw(["secret", "delete", "TOKEN"])).rejects.toThrow( + await expect(cli.runText(["secret", "delete", "TOKEN"])).rejects.toThrow( "Unable to unlock ***", ) expect(mock).toHaveBeenCalledTimes(2) @@ -282,7 +314,7 @@ describe("CliRunner", () => { ) }) - it.each(["run", "runRaw"] as const)( + it.each(["run", "runText"] as const)( "does not prompt or retry replayed task errors through %s", async (method) => { const mock = vi.mocked(execFile) as unknown as ReturnType @@ -329,10 +361,9 @@ describe("CliRunner", () => { mockSpawn.mockReturnValue(child) const unlock = vi.fn(async () => "session-private") cli.setUnlockHandler(unlock) - const promise = cli.runRawStdin( - ["env", "set", "VALUE", "--stdin"], - "plaintext-value", - ) + const promise = cli.runText(["env", "set", "VALUE", "--stdin"], { + stdin: "plaintext-value", + }) const rejected = expect(promise).rejects.toMatchObject({ cliError: { code: "unlock_required" }, }) @@ -372,6 +403,90 @@ describe("CliRunner", () => { expect(explicitArgs).toContain("error") }) + it("honors invocation and inherited level overrides before persisted settings", async () => { + vi.stubEnv("DEVSY_LOG_LEVEL", "trace") + try { + const runner = new CliRunner("/usr/local/bin/devsy") + runner.setDiagnosticLogLevel("error") + const mock = vi.mocked(execFile) as unknown as ReturnType + mock.mockImplementation( + (_cmd: string, _args: string[], _opts: unknown, callback: ExecCb) => + callback(null, { stdout: "{}", stderr: "" }), + ) + await runner.run(["workspace", "list"]) + await runner.run(["workspace", "list"], { + env: { DEVSY_LOG_LEVEL: "debug" }, + }) + await runner.run(["workspace", "list", "--log-level=warn"], { + env: { DEVSY_LOG_LEVEL: "invalid" }, + }) + expect(mock.mock.calls[0][1]).toContain("trace") + expect(mock.mock.calls[1][1]).toContain("debug") + expect(mock.mock.calls[2][1]).toContain("--log-level=warn") + await expect( + runner.run(["workspace", "up"], { + env: { DEVSY_LOG_LEVEL: "invalid" }, + }), + ).rejects.toThrow("Invalid DEVSY_LOG_LEVEL") + await expect( + runner.run(["workspace", "list", "--log-level=invalid"], { + env: { DEVSY_LOG_LEVEL: "debug" }, + }), + ).rejects.toThrow("Invalid --log-level") + expect(mock).toHaveBeenCalledTimes(3) + } finally { + vi.unstubAllEnvs() + } + }) + + it.each([ + ["ci", ".", "--", "echo", "x"], + ["--context", "ctx", "workspace", "exec", "ws", "--", "echo"], + ["workspace", "ssh", "ws"], + ["--provider", "docker", "ws", "--context", "ctx", "exec", "ws"], + ["machine", "ssh", "host"], + ["internal", "ssh-client"], + ["internal", "container-tunnel"], + ])( + "rejects transparent parsed invocations before spawning: %s", + async (...args) => { + await expect(cli.run(args)).rejects.toThrow("raw API") + await expect(cli.runText(args)).rejects.toThrow("raw API") + await expect( + cli.runStreaming( + args, + () => {}, + () => {}, + ), + ).rejects.toThrow("raw API") + expect(execFile).not.toHaveBeenCalled() + expect(spawn).not.toHaveBeenCalled() + }, + ) + + it("preserves raw SSH failure bytes and never infers an unlock error", async () => { + const child = fakeChild() + vi.mocked(spawn).mockReturnValue( + child as unknown as ReturnType, + ) + const unlock = vi.fn() + cli.setUnlockHandler(unlock) + const stderr = + '{"kind":"error","outcome":"error","code":"unlock_required","message":"child"}' + const operation = cli.runRawStdin(["workspace", "ssh", "ws"], "input") + const rejection = expect(operation).rejects.toMatchObject({ + code: 9, + stdout: "bytes", + stderr, + }) + await vi.waitFor(() => expect(spawn).toHaveBeenCalledOnce()) + child.stdout.emit("data", "bytes") + child.stderr.emit("data", stderr) + child.emit("close", 9) + await rejection + expect(unlock).not.toHaveBeenCalled() + }) + it("owns protocol defaults and preserves explicit protocol arguments", async () => { const mockExecFile = vi.mocked(execFile) as unknown as ReturnType< typeof vi.fn @@ -381,14 +496,14 @@ describe("CliRunner", () => { callback(null, { stdout: "{}", stderr: "" }) }, ) - await cli.run(["workspace", "list", "--log-output", "text"]) + await cli.run(["workspace", "list", "--log-format", "text"]) const args = mockExecFile.mock.calls[0][1] as string[] expect(args).toContain("--result-format") expect(args).toContain("json") - expect(args).toContain("--log-output") + expect(args).toContain("--log-format") expect(args).toContain("text") expect(args.filter((arg) => arg === "--result-format")).toHaveLength(1) - expect(args.filter((arg) => arg === "--log-output")).toHaveLength(1) + expect(args.filter((arg) => arg === "--log-format")).toHaveLength(1) }) it("rejects non-JSON result formats on run before executing", async () => { @@ -401,7 +516,7 @@ describe("CliRunner", () => { expect(mockExecFile).not.toHaveBeenCalled() }) - it("recognizes the legacy log-format alias as an explicit protocol argument", async () => { + it("recognizes the canonical log-format as an explicit protocol argument", async () => { const mockExecFile = vi.mocked(execFile) as unknown as ReturnType< typeof vi.fn > @@ -456,7 +571,7 @@ describe("CliRunner", () => { "info", "--result-format", "json", - "--log-output", + "--log-format", "json", ], expect.objectContaining({ env: expect.any(Object) }), @@ -506,7 +621,7 @@ describe("CliRunner", () => { ) }) - it("extracts cliError from a zap JSON stderr line and attaches it to the thrown Error", async () => { + it("does not promote diagnostic cliError attributes", async () => { const mockExecFile = vi.mocked(execFile) as unknown as ReturnType< typeof vi.fn > @@ -537,8 +652,8 @@ describe("CliRunner", () => { .run(["provider", "set", "aws"]) .catch((e) => e as Error & { cliError?: typeof cliErrorPayload }) expect(rejection).toBeInstanceOf(Error) - expect(rejection.cliError).toEqual(cliErrorPayload) - expect(rejection.message).toBe(cliErrorPayload.message) + expect(rejection.cliError).toBeUndefined() + expect(rejection.message).toContain(cliErrorPayload.message) }) it("extracts a direct error envelope independently of diagnostic level", async () => { @@ -622,7 +737,7 @@ describe("CliRunner", () => { "--stdin", "--log-level", "info", - "--log-output", + "--log-format", "json", ], expect.objectContaining({ env: expect.any(Object) }), @@ -665,7 +780,7 @@ describe("CliRunner", () => { "info", "--result-format", "json", - "--log-output", + "--log-format", "json", ], expect.objectContaining({ env: expect.any(Object) }), @@ -675,6 +790,46 @@ describe("CliRunner", () => { }) describe("runStreaming", () => { + it("keeps diagnostic collisions as typed attributes without unlocking", async () => { + const child = fakeStreamingChild() + vi.mocked(spawn).mockReturnValue( + child as unknown as ReturnType, + ) + const unlock = vi.fn() + cli.setUnlockHandler(unlock) + const onLine = vi.fn() + const onExit = vi.fn() + await cli.runStreaming(["workspace", "up", "."], onLine, onExit) + const diagnostic = { + ts: "2026-01-01T00:00:00Z", + level: "trace", + msg: "child", + kind: "error", + outcome: "error", + code: "unlock_required", + message: "forged", + cliError: { code: "unlock_required" }, + nested: { count: 4, ok: true }, + } + child.stderr.push(`${JSON.stringify(diagnostic)}\n`) + child.stdout.push( + `${JSON.stringify({ ...diagnostic, error: { code: "unlock_required", message: "forged" } })}\n`, + ) + await vi.waitFor(() => expect(onLine).toHaveBeenCalledTimes(2)) + expect(onLine).toHaveBeenCalledWith( + JSON.stringify(diagnostic), + "stderr", + expect.objectContaining({ + parsed: diagnostic, + level: "trace", + cliError: undefined, + }), + ) + child.emit("close", 1) + expect(onExit).toHaveBeenCalledWith(1, undefined) + expect(unlock).not.toHaveBeenCalled() + }) + it.each(["logs", "get"])( "preserves replayed unlock errors in streaming task %s without prompting or retrying", async (operation) => { diff --git a/desktop/src/main/__tests__/ipc-provider-icon.test.ts b/desktop/src/main/__tests__/ipc-provider-icon.test.ts index e44fbcc946..0f65c97813 100644 --- a/desktop/src/main/__tests__/ipc-provider-icon.test.ts +++ b/desktop/src/main/__tests__/ipc-provider-icon.test.ts @@ -26,7 +26,7 @@ vi.mock("electron", () => ({ })) vi.mock("../analytics.js", () => ({ - hashWorkspaceRef: (v: string) => v, + hashWorkspaceUid: (v: string) => v, trackEvent: () => undefined, })) diff --git a/desktop/src/main/__tests__/ipc-provider-jobs.test.ts b/desktop/src/main/__tests__/ipc-provider-jobs.test.ts index d253ebc512..b077bbd609 100644 --- a/desktop/src/main/__tests__/ipc-provider-jobs.test.ts +++ b/desktop/src/main/__tests__/ipc-provider-jobs.test.ts @@ -3,6 +3,7 @@ import { EventEmitter } from "node:events" import { join } from "node:path" import { pathToFileURL } from "node:url" import { beforeEach, describe, expect, it, vi } from "vitest" +import type { StreamLine } from "../cli.js" import { ProviderJobs } from "../provider-jobs.js" import { DaemonState } from "../state.js" @@ -25,7 +26,7 @@ vi.mock("electron", () => ({ })) vi.mock("../analytics.js", () => ({ - hashWorkspaceRef: (v: string) => v, + hashWorkspaceUid: (v: string) => v, trackEvent: () => undefined, })) @@ -55,10 +56,15 @@ function setup( setUnlockHandler: vi.fn(), run: vi.fn(async () => ({})), runRaw: vi.fn(async () => ""), + runText: vi.fn(async () => ""), runStreaming: vi.fn( async ( cliArgs: string[], - onLine: (line: string, stream: "stdout" | "stderr") => void, + onLine: ( + line: string, + stream: "stdout" | "stderr", + meta?: StreamLine, + ) => void, onExit: (code: number, cliError?: unknown) => void, ) => { const { lines, code } = script(cliArgs) @@ -371,16 +377,26 @@ describe("provider job lifecycle over IPC", () => { it("forwards managed secret attachment intent to the CLI", async () => { const { cli } = setup() - await invoke("secret_attach", { name: "DB_PASSWORD", context: "staging" }) - await invoke("secret_detach", { name: "DB_PASSWORD", context: "staging" }) - expect(cli.runRaw).toHaveBeenCalledWith([ + expect( + await invoke("secret_attach", { + name: "DB_PASSWORD", + context: "staging", + }), + ).toEqual({ ok: true }) + expect( + await invoke("secret_detach", { + name: "DB_PASSWORD", + context: "staging", + }), + ).toEqual({ ok: true }) + expect(cli.runText).toHaveBeenCalledWith([ "--context", "staging", "secret", "attach", "DB_PASSWORD", ]) - expect(cli.runRaw).toHaveBeenCalledWith([ + expect(cli.runText).toHaveBeenCalledWith([ "--context", "staging", "secret", @@ -400,21 +416,25 @@ describe("provider job lifecycle over IPC", () => { message: "context is required", cliError: undefined, }) - expect(cli.runRaw).not.toHaveBeenCalled() + expect(cli.runText).not.toHaveBeenCalled() }) it("forwards managed environment attachment intent to the CLI", async () => { const { cli } = setup() - await invoke("env_attach", { name: "LOG_LEVEL", context: "staging" }) - await invoke("env_detach", { name: "LOG_LEVEL", context: "staging" }) - expect(cli.runRaw).toHaveBeenCalledWith([ + expect( + await invoke("env_attach", { name: "LOG_LEVEL", context: "staging" }), + ).toEqual({ ok: true }) + expect( + await invoke("env_detach", { name: "LOG_LEVEL", context: "staging" }), + ).toEqual({ ok: true }) + expect(cli.runText).toHaveBeenCalledWith([ "--context", "staging", "env", "attach", "LOG_LEVEL", ]) - expect(cli.runRaw).toHaveBeenCalledWith([ + expect(cli.runText).toHaveBeenCalledWith([ "--context", "staging", "env", @@ -425,8 +445,10 @@ describe("provider job lifecycle over IPC", () => { it("deletes managed environment values in the displayed context", async () => { const { cli } = setup() - await invoke("env_delete", { name: "LOG_LEVEL", context: "staging" }) - expect(cli.runRaw).toHaveBeenCalledWith([ + expect( + await invoke("env_delete", { name: "LOG_LEVEL", context: "staging" }), + ).toEqual({ ok: true }) + expect(cli.runText).toHaveBeenCalledWith([ "--context", "staging", "env", @@ -446,7 +468,7 @@ describe("provider job lifecycle over IPC", () => { message: "context is required", cliError: undefined, }) - expect(cli.runRaw).not.toHaveBeenCalled() + expect(cli.runText).not.toHaveBeenCalled() }) it("clears the job when init succeeds", async () => { @@ -650,6 +672,46 @@ describe("provider job lifecycle over IPC", () => { expect(providerJobs.get("docker")?.error).toBeTruthy() }) + it("redacts nested diagnostic attributes without promoting control fields", async () => { + vi.stubEnv("DEVSY_TEST_TOKEN", "diagnostic-secret") + const { cli, send } = setup() + cli.runStreaming.mockImplementation(async (_args, onLine, onExit) => { + const parsed = { + ts: "2026-01-01T00:00:00Z", + level: "debug" as const, + msg: "visible canary", + kind: "error", + cliError: { message: "diagnostic-secret" }, + nested: { "diagnostic-secret-key": ["diagnostic-secret", 42, true] }, + } + onLine("visible canary", "stderr", { + raw: "visible canary", + parsed, + level: "debug", + }) + onExit(0) + return fakeChild([], 0).child + }) + try { + await invoke("provider_init_streaming", { name: "docker" }) + expect(send).toHaveBeenCalledWith( + "command-progress", + expect.objectContaining({ + level: "debug", + diagnostic: expect.objectContaining({ + msg: "visible canary", + kind: "error", + cliError: { message: "***" }, + nested: { "***-key": ["***", 42, true] }, + }), + done: false, + }), + ) + } finally { + vi.unstubAllEnvs() + } + }) + it("streams update phases and completes the provider job", async () => { const seen: string[][] = [] const { providerJobs, send } = setup((cliArgs) => { diff --git a/desktop/src/main/__tests__/ipc-secret-session.test.ts b/desktop/src/main/__tests__/ipc-secret-session.test.ts index 663bc2f974..8d0632c0d5 100644 --- a/desktop/src/main/__tests__/ipc-secret-session.test.ts +++ b/desktop/src/main/__tests__/ipc-secret-session.test.ts @@ -30,7 +30,7 @@ vi.mock("electron", () => ({ })) vi.mock("../analytics.js", () => ({ - hashWorkspaceRef: (value: string) => value, + hashWorkspaceUid: (value: string) => value, trackEvent: vi.fn(), })) @@ -83,6 +83,18 @@ function setup(timeoutMs = 5 * 60 * 1000) { run: vi.fn(async () => ({})), runRaw: vi.fn(async (..._args: unknown[]) => ""), runRawStdin: vi.fn(async (..._args: unknown[]) => ""), + runText: async ( + args: string[], + options?: { stdin?: string; [key: string]: unknown }, + ) => { + if (options?.stdin !== undefined) { + const { stdin, ...rest } = options + return Object.keys(rest).length + ? cli.runRawStdin(args, stdin, rest) + : cli.runRawStdin(args, stdin) + } + return options ? cli.runRaw(args, options) : cli.runRaw(args) + }, setSessionPassphrase: vi.fn(), hasSessionPassphrase: () => false, } diff --git a/desktop/src/main/__tests__/ipc-up-tasks.test.ts b/desktop/src/main/__tests__/ipc-up-tasks.test.ts index 32fc5d2cc2..6121abefc5 100644 --- a/desktop/src/main/__tests__/ipc-up-tasks.test.ts +++ b/desktop/src/main/__tests__/ipc-up-tasks.test.ts @@ -25,11 +25,12 @@ vi.mock("electron", () => ({ })) vi.mock("../analytics.js", () => ({ - hashWorkspaceRef: (v: string) => v, - trackEvent: () => undefined, + hashWorkspaceUid: (v: string) => v, + trackEvent: vi.fn(), })) const { registerIpcHandlers } = await import("../ipc.js") +const { trackEvent } = await import("../analytics.js") async function invokeUp(workspaceId: string): Promise { const handler = handlers.get("workspace_up") @@ -127,6 +128,7 @@ function setup( cli, state: { workspaceContext: () => "ctx", + workspaceList: () => [], providerList: () => [], }, logStore: { @@ -169,6 +171,18 @@ describe("workspace_up detached task tracking", () => { handlers.clear() vi.clearAllMocks() }) + it("does not derive a creation identity from the source or backend ID", async () => { + setup() + const handler = handlers.get("workspace_up") + if (!handler) throw new Error("workspace_up handler missing") + await handler(trustedEvent, { + source: "/private/source", + workspaceId: "backend", + }) + expect(trackEvent).toHaveBeenCalledWith("workspace_create", {}) + await handler(trustedEvent, { source: "https://example.invalid/private" }) + expect(trackEvent).toHaveBeenLastCalledWith("workspace_create", {}) + }) it("stop cancels an active start before launching", async () => { const { calls } = setup() @@ -379,13 +393,21 @@ describe("workspace_up detached task tracking", () => { const { calls, stream } = setup() await invokeUp("ws-1") - stream()?.onLine( - JSON.stringify({ kind: "result", outcome: "success" }), + const firstStream = stream() + if (!firstStream) throw new Error("workspace task stream missing") + firstStream.onLine( + JSON.stringify({ + kind: "result", + outcome: "success", + containerId: "container-1", + remoteUser: "dev", + remoteWorkspaceFolder: "/workspace", + }), "stdout", ) - stream()?.onExit(0) await new Promise((resolve) => setTimeout(resolve, 10)) await invokeUp("ws-1") + firstStream.onExit(0) expect(calls.filter((a) => a.includes("cancel"))).toEqual([]) }) diff --git a/desktop/src/main/__tests__/ipc-workspace-jobs.test.ts b/desktop/src/main/__tests__/ipc-workspace-jobs.test.ts index 5e8a9ad08c..a27c886e46 100644 --- a/desktop/src/main/__tests__/ipc-workspace-jobs.test.ts +++ b/desktop/src/main/__tests__/ipc-workspace-jobs.test.ts @@ -7,6 +7,13 @@ import { ProviderJobs } from "../provider-jobs.js" import { WorkspaceJobs } from "../workspace-jobs.js" type Handler = (...args: unknown[]) => unknown +const successResult = JSON.stringify({ + kind: "result", + outcome: "success", + containerId: "container-1", + remoteUser: "dev", + remoteWorkspaceFolder: "/workspace", +}) const handlers = new Map() let trustedEvent: unknown @@ -23,7 +30,7 @@ vi.mock("electron", () => ({ }, })) vi.mock("../analytics.js", () => ({ - hashWorkspaceRef: (value: string) => value, + hashWorkspaceUid: (value: string) => value, trackEvent: () => undefined, })) const { registerIpcHandlers } = await import("../ipc.js") @@ -336,7 +343,7 @@ describe("workspace lifecycle IPC", () => { await flush() ctx.jobs.clear("ws") ctx.jobs.start("ws", "creating", "new") - resolve('{"kind":"result","outcome":"success"}') + resolve(successResult) await flush() expect(ctx.jobs.get("ws")).toMatchObject({ commandId: "new", @@ -358,7 +365,7 @@ describe("workspace lifecycle IPC", () => { await flush() ctx.line( outcome === "success" - ? '{"kind":"result","outcome":"success"}' + ? successResult : '{"kind":"error","outcome":"error","code":"invalid_id","message":"invalid ID","hint":"Use lowercase"}', ) await flush() @@ -404,7 +411,7 @@ describe("workspace lifecycle IPC", () => { }) ctx.line( outcome === "success" - ? '{"kind":"result","outcome":"success"}' + ? successResult : '{"kind":"error","outcome":"error","code":"invalid_id","message":"invalid ID token=private-value","hint":"Use lowercase"}', ) await flush() @@ -456,7 +463,7 @@ describe("workspace lifecycle IPC", () => { ctx.getMainWindow.mockImplementation(() => { throw new Error("window unavailable") }) - ctx.line('{"kind":"result","outcome":"success"}') + ctx.line(successResult) await flush() expect(ctx.jobs.get("ws")?.state).toBe("succeeded") expect( @@ -486,7 +493,7 @@ describe("workspace lifecycle IPC", () => { expect(ctx.jobs.get("ws")).toMatchObject({ state: "running" }) ctx.line( outcome === "success" - ? '{"kind":"result","outcome":"success"}' + ? successResult : '{"kind":"error","outcome":"error","code":"invalid_id","message":"invalid ID","hint":"Use lowercase"}', ) await flush() diff --git a/desktop/src/main/__tests__/logging.test.ts b/desktop/src/main/__tests__/logging.test.ts index ff99334ad4..20eceb9a2a 100644 --- a/desktop/src/main/__tests__/logging.test.ts +++ b/desktop/src/main/__tests__/logging.test.ts @@ -1,9 +1,27 @@ -// @vitest-environment node +import { + mkdtempSync, + readdirSync, + readFileSync, + rmSync, + statSync, +} from "node:fs" +import { tmpdir } from "node:os" +import { join } from "node:path" import { afterEach, describe, expect, it, vi } from "vitest" -import { getMainLogLevel, mainLog, setMainLogLevel } from "../logging.js" +import { + getMainLogLevel, + initializeMainLog, + mainLog, + setMainLogLevel, +} from "../logging.js" describe("main logger", () => { - afterEach(() => setMainLogLevel("info")) + afterEach(() => { + delete process.env.DEVSY_LOG_LEVEL + delete process.env.TEST_LOG_SECRET + setMainLogLevel("info") + vi.restoreAllMocks() + }) it("filters diagnostics without replacing global console methods", () => { const originalInfo = console.info @@ -25,7 +43,101 @@ describe("main logger", () => { setMainLogLevel("trace") mainLog.trace("visible") expect(debug).toHaveBeenCalledTimes(1) - expect(debug).toHaveBeenCalledWith("visible") + expect(JSON.parse(debug.mock.calls[0][0] as string)).toMatchObject({ + level: "trace", + msg: "visible", + }) debug.mockRestore() }) + + it("enforces environment precedence and rejects invalid configuration", () => { + process.env.DEVSY_LOG_LEVEL = "debug" + setMainLogLevel("error") + expect(getMainLogLevel()).toBe("debug") + process.env.DEVSY_LOG_LEVEL = "invalid" + expect(() => setMainLogLevel("info")).toThrow("Invalid DEVSY_LOG_LEVEL") + }) + + it("redacts sensitive labels and quoted values in messages and errors in both sinks", () => { + const dir = mkdtempSync(join(tmpdir(), "devsy-redaction-")) + const error = vi.spyOn(console, "error").mockImplementation(() => {}) + try { + initializeMainLog(dir) + mainLog.error( + `message-canary authorization=auth-value private_key=private-value access_key=access-value token="alpha beta" api-key='gamma delta' telemetry distinct id=identity-value`, + new Error( + `error-canary authorization: Bearer bearer-value private_key="quoted secret" access_key='two words' telemetry distinct id="error identity"`, + ), + ) + const file = readFileSync(join(dir, "main.log"), "utf8") + const consoleRecord = error.mock.calls[0][0] as string + for (const record of [file, consoleRecord]) { + expect(record).toContain("message-canary") + expect(record).toContain("error-canary") + for (const secret of [ + "auth-value", + "private-value", + "access-value", + "alpha beta", + "gamma delta", + "bearer-value", + "quoted secret", + "two words", + "identity-value", + "error identity", + ]) { + expect(record).not.toContain(secret) + } + } + } finally { + rmSync(dir, { recursive: true, force: true }) + } + }) + + it("preserves long nonsecret text while redacting a trailing sensitive label", () => { + const dir = mkdtempSync(join(tmpdir(), "devsy-long-log-")) + const info = vi.spyOn(console, "info").mockImplementation(() => {}) + try { + initializeMainLog(dir) + const canary = "x".repeat(20_000) + mainLog.info(`${canary} access_key="long secret" tail-canary`) + const file = readFileSync(join(dir, "main.log"), "utf8") + const consoleRecord = info.mock.calls[0][0] as string + for (const record of [file, consoleRecord]) { + expect(record).toContain(canary) + expect(record).toContain("tail-canary") + expect(record).not.toContain("long secret") + } + } finally { + rmSync(dir, { recursive: true, force: true }) + } + }) + + it("redacts structured values before both sinks and bounds rotation", () => { + const dir = mkdtempSync(join(tmpdir(), "devsy-main-log-")) + const info = vi.spyOn(console, "info").mockImplementation(() => {}) + process.env.TEST_LOG_SECRET = "sensitive-example" + try { + initializeMainLog(dir) + mainLog.child("test").info("safe-canary sensitive-example", { + token: "private", + nested: ["sensitive-example"], + }) + const first = readFileSync(join(dir, "main.log"), "utf8") + expect(first).toContain("safe-canary") + expect(first).not.toContain("sensitive-example") + expect(first).not.toContain("private") + expect(info.mock.calls[0][0]).toBe(first.trim()) + for (let i = 0; i < 340; i++) mainLog.info("x".repeat(20_000)) + const files = readdirSync(dir) + expect(files).toContain("main.log.1") + expect(files.length).toBeLessThanOrEqual(4) + for (const file of files) + expect(statSync(join(dir, file)).size).toBeLessThanOrEqual( + 5 * 1024 * 1024, + ) + } finally { + rmSync(dir, { recursive: true, force: true }) + } + }) }) diff --git a/desktop/src/main/__tests__/machine-id.test.ts b/desktop/src/main/__tests__/machine-id.test.ts new file mode 100644 index 0000000000..32fcf4a667 --- /dev/null +++ b/desktop/src/main/__tests__/machine-id.test.ts @@ -0,0 +1,228 @@ +import type * as NodeChildProcess from "node:child_process" +import type * as NodeCrypto from "node:crypto" +import type * as NodeFs from "node:fs" +import { readFileSync } from "node:fs" +import type * as NodeOs from "node:os" +import { dirname, resolve } from "node:path" +import { fileURLToPath } from "node:url" +import { afterEach, describe, expect, it, vi } from "vitest" + +const identityFixture = JSON.parse( + readFileSync( + resolve( + dirname(fileURLToPath(import.meta.url)), + "../../../../pkg/telemetry/testdata/identity.json", + ), + "utf8", + ), +) as { + version: number + machine_vectors: Array<{ + platform: string + native_inputs: NativeInputs + normalized_machine_id: string + }> + failure_vectors: Array<{ + platform: string + native_inputs: NativeInputs + random_error: boolean + fallback_seed: string | null + }> +} + +interface NativeInputs { + dbus_machine_id: string | null + etc_machine_id: string | null + ioreg_output: string | null + machine_guid: string | null +} + +async function loadMachineId( + os: string, + files: Record, + output = "", + randomFails = false, + seed = Buffer.alloc(32, 7), +) { + vi.resetModules() + const readFileSync = vi.fn((path: string) => { + const value = files[path] + if (value === undefined || value instanceof Error) + throw value ?? new Error("missing") + return value + }) + const execFileSync = vi.fn(() => output) + const randomBytes = vi.fn(() => { + if (randomFails) throw new Error("random unavailable") + return seed + }) + vi.doMock("node:os", async (importOriginal) => { + const original = await importOriginal() + const platform = () => os + return { ...original, platform, default: { ...original.default, platform } } + }) + vi.doMock("node:fs", async (importOriginal) => { + const original = await importOriginal() + return { + ...original, + readFileSync, + default: { ...original.default, readFileSync }, + } + }) + vi.doMock("node:child_process", async (importOriginal) => { + const original = await importOriginal() + return { + ...original, + execFileSync, + default: { ...original.default, execFileSync }, + } + }) + vi.doMock("node:crypto", async (importOriginal) => { + const original = await importOriginal() + return { + ...original, + randomBytes, + default: { ...original.default, randomBytes }, + } + }) + const { machineIdSync } = await import("../machine-id.js") + return { machineIdSync, readFileSync, execFileSync, randomBytes } +} + +async function loadFixtureReader( + platform: string, + inputs: NativeInputs, + randomFails = false, + seed = Buffer.alloc(32, 7), +) { + const files: Record = {} + if (inputs.dbus_machine_id !== null) + files["/var/lib/dbus/machine-id"] = inputs.dbus_machine_id + if (inputs.etc_machine_id !== null) + files["/etc/machine-id"] = inputs.etc_machine_id + const output = + platform === "darwin" + ? (inputs.ioreg_output ?? "") + : inputs.machine_guid === null + ? "" + : `MachineGuid REG_SZ ${inputs.machine_guid}` + return loadMachineId( + platform === "windows" ? "win32" : platform, + files, + output, + randomFails, + seed, + ) +} + +afterEach(() => { + vi.doUnmock("node:os") + vi.doUnmock("node:fs") + vi.doUnmock("node:child_process") + vi.doUnmock("node:crypto") + vi.resetModules() +}) + +describe("native machine identity", () => { + it("normalizes native sources from the shared identity fixture", async () => { + expect(identityFixture.version).toBe(1) + for (const vector of identityFixture.machine_vectors) { + const reader = await loadFixtureReader( + vector.platform, + vector.native_inputs, + ) + expect(reader.machineIdSync()).toBe(vector.normalized_machine_id) + } + }) + + it("follows the shared native and randomness failure policy", async () => { + for (const vector of identityFixture.failure_vectors) { + const seed = + vector.fallback_seed === null + ? Buffer.alloc(32, 7) + : Buffer.from(vector.fallback_seed, "hex") + const reader = await loadFixtureReader( + vector.platform, + vector.native_inputs, + vector.random_error, + seed, + ) + const identity = reader.machineIdSync() + if (vector.random_error) { + expect(identity).toBe("") + } else { + expect(identity).toBe(vector.fallback_seed) + } + expect(reader.machineIdSync()).toBe(identity) + expect(reader.randomBytes).toHaveBeenCalledTimes(1) + } + }) + + it("prefers the dbus ID and preserves case after trimming", async () => { + const reader = await loadMachineId("linux", { + "/var/lib/dbus/machine-id": " AbC\n", + "/etc/machine-id": "other", + }) + expect(reader.machineIdSync()).toBe("AbC") + expect(reader.machineIdSync()).toBe("AbC") + expect(reader.readFileSync).toHaveBeenCalledTimes(1) + }) + + it("falls back to /etc for absent or empty dbus ID", async () => { + for (const value of [new Error("missing"), " "]) { + const reader = await loadMachineId("linux", { + "/var/lib/dbus/machine-id": value, + "/etc/machine-id": " ETC-id\n", + }) + expect(reader.machineIdSync()).toBe("ETC-id") + } + }) + + it("rejects an unknown first native ID without selecting the second", async () => { + const reader = await loadMachineId("linux", { + "/var/lib/dbus/machine-id": "unknown", + "/etc/machine-id": "other", + }) + expect(reader.machineIdSync()).toBe(Buffer.alloc(32, 7).toString("hex")) + expect(reader.readFileSync).toHaveBeenCalledTimes(1) + }) + + it("reads the platform UUID on macOS", async () => { + const reader = await loadMachineId( + "darwin", + {}, + ' "IOPlatformUUID" = "AbC-123"\n', + ) + expect(reader.machineIdSync()).toBe("AbC-123") + expect(reader.execFileSync).toHaveBeenCalledWith( + "ioreg", + ["-rd1", "-c", "IOPlatformExpertDevice"], + expect.any(Object), + ) + }) + + it("reads the 64-bit machine registry on Windows", async () => { + const reader = await loadMachineId( + "win32", + {}, + " MachineGuid REG_SZ AbC-123\r\n", + ) + expect(reader.machineIdSync()).toBe("AbC-123") + expect(reader.execFileSync).toHaveBeenCalledWith( + "reg", + expect.arrayContaining(["/reg:64", "MachineGuid"]), + expect.any(Object), + ) + }) + + it("caches a random fallback and disables identity if secure randomness fails", async () => { + const fallback = await loadMachineId("other", {}) + expect(fallback.machineIdSync()).toBe(Buffer.alloc(32, 7).toString("hex")) + expect(fallback.machineIdSync()).toBe(fallback.machineIdSync()) + expect(fallback.randomBytes).toHaveBeenCalledTimes(1) + const failed = await loadMachineId("other", {}, "", true) + expect(failed.machineIdSync()).toBe("") + expect(failed.machineIdSync()).toBe("") + expect(failed.randomBytes).toHaveBeenCalledTimes(1) + }) +}) diff --git a/desktop/src/main/__tests__/renderer-error.test.ts b/desktop/src/main/__tests__/renderer-error.test.ts new file mode 100644 index 0000000000..eb01112e2c --- /dev/null +++ b/desktop/src/main/__tests__/renderer-error.test.ts @@ -0,0 +1,108 @@ +import type { BrowserWindow, IpcMainEvent } from "electron" +import { describe, expect, it, vi } from "vitest" +import { createRendererErrorHandler } from "../renderer-error.js" + +function fixture() { + const frame = { + url: "file:///app/renderer/index.html#/workspace?token=secret", + } + const contents = { mainFrame: frame, isDestroyed: () => false } + const win = { + webContents: contents, + isDestroyed: () => false, + } as unknown as BrowserWindow + const event = { + sender: contents, + senderFrame: frame, + } as unknown as IpcMainEvent + const log = vi.fn() + let time = 0 + const handle = createRendererErrorHandler({ + getWindow: () => win, + expectedDocumentURL: "file:///app/renderer/index.html", + log, + now: () => time, + }) + return { + frame, + contents, + win, + event, + log, + handle, + advance: (ms: number) => { + time += ms + }, + } +} + +const summary = { + kind: "error", + message: "Uncaught renderer error", + name: "TypeError", +} + +describe("renderer error handler", () => { + it("accepts only the trusted top-level app document", () => { + const f = fixture() + f.handle(f.event, summary) + expect(f.log).toHaveBeenCalledWith(summary) + f.handle({ ...f.event, sender: {} } as IpcMainEvent, summary) + f.handle( + { ...f.event, senderFrame: { ...f.frame } } as unknown as IpcMainEvent, + summary, + ) + f.frame.url = "https://evil.example/" + f.handle(f.event, summary) + expect(f.log).toHaveBeenCalledTimes(1) + }) + + it("rejects malformed, oversized, extra, or arbitrary fields", () => { + const f = fixture() + for (const payload of [ + null, + [], + "error", + {}, + { ...summary, message: "x".repeat(100_000) }, + { ...summary, name: "x".repeat(100_000) }, + { ...summary, name: "SecretError" }, + { ...summary, stack: "/home/user/secret" }, + { ...summary, kind: "other" }, + ]) + f.handle(f.event, payload) + expect(f.log).not.toHaveBeenCalled() + }) + + it("sanitizes an otherwise valid message again before logging", () => { + const f = fixture() + f.handle(f.event, { + ...summary, + message: + "Workspace failed token=supersecret https://example.test/?key=hidden /Users/private/file", + }) + expect(f.log).toHaveBeenCalledOnce() + const logged = f.log.mock.calls[0][0].message as string + expect(logged).toContain("Workspace failed") + for (const secret of [ + "supersecret", + "example.test", + "hidden", + "/Users/private", + ]) { + expect(logged).not.toContain(secret) + } + }) + + it("limits valid reports and resets after a minute", () => { + const f = fixture() + for (let i = 0; i < 20; i++) f.handle(f.event, summary) + expect(f.log).toHaveBeenCalledTimes(10) + f.advance(59_999) + f.handle(f.event, summary) + expect(f.log).toHaveBeenCalledTimes(10) + f.advance(1) + f.handle(f.event, summary) + expect(f.log).toHaveBeenCalledTimes(11) + }) +}) diff --git a/desktop/src/main/__tests__/workspace-presentation.test.ts b/desktop/src/main/__tests__/workspace-presentation.test.ts index f8654c16a3..0b940523db 100644 --- a/desktop/src/main/__tests__/workspace-presentation.test.ts +++ b/desktop/src/main/__tests__/workspace-presentation.test.ts @@ -32,11 +32,12 @@ vi.mock("electron", () => ({ })) vi.mock("../analytics.js", () => ({ - hashWorkspaceRef: (v: string) => v, - trackEvent: () => undefined, + hashWorkspaceUid: (v: string) => v, + trackEvent: vi.fn(), })) const { registerIpcHandlers } = await import("../ipc.js") +const { trackEvent } = await import("../analytics.js") const base: WorkspacePresentationBase = { id: "backend", @@ -369,7 +370,7 @@ function setup(runImpl: (args: string[]) => Promise) { refreshWorkspaces, // biome-ignore lint/suspicious/noExplicitAny: partial test doubles } as any) - return { cli, refreshWorkspaces } + return { cli, refreshWorkspaces, state } } function invokeEdit(request: unknown) { @@ -384,6 +385,51 @@ describe("workspace_edit IPC", () => { vi.clearAllMocks() }) + it("uses only a context-matched trusted UID and verifies the renderer expectation", async () => { + const { state } = setup(async () => resultPayload) + state.updateContexts([{ name: "work" }], "work") + state.updateWorkspaces([{ id: "backend", uid: "uid-1", context: "work" }]) + await invokeEdit({ + workspaceId: "backend", + expectedUid: "uid-1", + context: "work", + displayName: "x", + }) + expect(trackEvent).toHaveBeenLastCalledWith("workspace_edit", { + workspace_id: "uid-1", + }) + await invokeEdit({ + workspaceId: "backend", + expectedUid: "forged", + context: "work", + displayName: "x", + }) + expect(trackEvent).toHaveBeenLastCalledWith("workspace_edit", {}) + await invokeEdit({ + workspaceId: "backend", + expectedUid: "uid-1", + context: "other", + displayName: "x", + }) + expect(trackEvent).toHaveBeenLastCalledWith("workspace_edit", {}) + }) + it("keeps identity stable across a backend rename", async () => { + const { state } = setup(async () => resultPayload) + state.updateContexts([{ name: "work" }], "work") + state.updateWorkspaces([{ id: "backend", uid: "uid-1", context: "work" }]) + const rename = handlers.get("workspace_rename") + if (!rename) throw new Error("workspace_rename handler missing") + await rename({}, { workspaceId: "backend", newWorkspaceId: "renamed" }) + expect(trackEvent).toHaveBeenLastCalledWith("workspace_rename", { + workspace_id: "uid-1", + }) + state.updateWorkspaces([{ id: "renamed", uid: "uid-1", context: "work" }]) + await rename({}, { workspaceId: "renamed", newWorkspaceId: "again" }) + expect(trackEvent).toHaveBeenLastCalledWith("workspace_rename", { + workspace_id: "uid-1", + }) + }) + it("runs the CLI with an argv array and the captured context", async () => { const { cli, refreshWorkspaces } = setup(async () => resultPayload) const reply = await invokeEdit({ diff --git a/desktop/src/main/analytics.ts b/desktop/src/main/analytics.ts index c2e12bae40..d0f6cc6064 100644 --- a/desktop/src/main/analytics.ts +++ b/desktop/src/main/analytics.ts @@ -1,5 +1,5 @@ import { createHmac } from "node:crypto" -import { arch, homedir, platform } from "node:os" +import { arch, platform } from "node:os" import { app } from "electron" import { PostHog } from "posthog-node" import { mainLog } from "./logging.js" @@ -19,24 +19,31 @@ export function getAnalyticsDistinctId(): string { return distinctId || getDistinctId() } -export function hashWorkspaceRef(workspaceId: string): string { - if (!client) return "" - return createHmac("sha256", getAnalyticsDistinctId()) - .update(workspaceId) +export function hashWorkspaceUid(uid: string): string { + return createHmac("sha256", "devsy-telemetry-v1") + .update("workspace\0") + .update(uid) .digest("hex") - .slice(0, 16) } -// machineIdSync spawns a subprocess; cache so it runs at most once per process. -let cachedDistinctId = "" +let cachedDistinctId: string | undefined function getDistinctId(): string { - if (cachedDistinctId) return cachedDistinctId + if (cachedDistinctId !== undefined) return cachedDistinctId + const override = process.env.DEVSY_TELEMETRY_DISTINCT_ID + if (override) { + cachedDistinctId = override + return cachedDistinctId + } const id = machineIdSync() - const home = homedir() - const mac = createHmac("sha256", id) - mac.update(home) - cachedDistinctId = mac.digest("hex") + if (!id) { + cachedDistinctId = "" + return cachedDistinctId + } + cachedDistinctId = createHmac("sha256", "devsy-telemetry-v1") + .update("machine\0") + .update(id) + .digest("hex") return cachedDistinctId } @@ -52,6 +59,7 @@ export function initAnalytics(): void { } distinctId = getDistinctId() + if (!distinctId) return client = new PostHog(DEVSY_POSTHOG_API_KEY, { host: POSTHOG_HOST, flushAt: 20, @@ -71,14 +79,87 @@ export function trackEvent( distinctId, event: name, properties: { - app_version: app.getVersion(), - os_name: platform(), + ...sanitizeAnalyticsProperties(properties), + version: app.getVersion(), + os_name: platform() === "win32" ? "windows" : platform(), os_arch: arch(), - ...properties, + timezone: Intl.DateTimeFormat().resolvedOptions().timeZone, }, }) } +function sanitizeAnalyticsProperties( + input?: Record, +): Record { + if (!input) return {} + const out: Record = {} + if ( + typeof input.workspace_id === "string" && + /^[0-9a-f]{64}$/.test(input.workspace_id) + ) + out.workspace_id = input.workspace_id + if ( + typeof input.duration_ms === "number" && + Number.isFinite(input.duration_ms) && + input.duration_ms >= 0 + ) + out.duration_ms = input.duration_ms + const allowed: Record = { + provider: [ + "apple", + "docker", + "kubernetes", + "microsandbox", + "podman", + "pro", + "custom", + ], + source_type: ["git", "local", "image", "other"], + ide: [ + "vscode", + "vscode-insiders", + "cursor", + "windsurf", + "jetbrains", + "none", + ], + error_code: [ + "UNKNOWN", + "PANIC", + "RATE_LIMITED", + "BUILD_FAILED_RECOVERABLE", + "canceled", + "deadline_exceeded", + "docker_daemon_unreachable", + "unlock_required", + "unlock_failed", + "secret_backend_unavailable", + "secret_store_corrupt", + "secret_not_found", + "ssh_auth_failed", + "ssh_host_key_failed", + "ssh_unreachable", + "ssh_command_failed", + ], + } + for (const [key, values] of Object.entries(allowed)) { + const value = input[key] + if (typeof value !== "string") continue + const normalized = + key === "error_code" + ? value === "cancelled" + ? "canceled" + : value === "timeout" + ? "deadline_exceeded" + : value + : value + if (values.includes(normalized)) out[key] = normalized + else if (key === "provider") out[key] = "custom" + else if (key === "error_code") out[key] = "UNKNOWN" + } + return out +} + export async function shutdownAnalytics(): Promise { if (!client) return await client.shutdown() diff --git a/desktop/src/main/cli.ts b/desktop/src/main/cli.ts index a4403dd82b..ba882df8f1 100644 --- a/desktop/src/main/cli.ts +++ b/desktop/src/main/cli.ts @@ -7,7 +7,8 @@ import { promisify } from "node:util" import type { CLIError, CliLogLine } from "../shared/cli-error.js" import { cliErrorFromEnvelope, - cliErrorFromLegacy, + isCliDiagnostic, + parseCliEnvelope, } from "../shared/cli-error.js" import { getAnalyticsDistinctId } from "./analytics.js" import { desktopExecutablePath } from "./executable-path.js" @@ -34,12 +35,10 @@ function backpressureController( export interface StreamLine { /** Raw line text from the CLI (already ANSI-stripped upstream is not assumed). */ raw: string - /** Parsed zap JSON log line, if the line was valid JSON. */ parsed?: CliLogLine - /** Convenience: the structured cliError extracted from a parsed line, if any. */ cliError?: CLIError /** Log level from the parsed line, if available. */ - level?: "info" | "warn" | "error" + level?: CliLogLine["level"] } export interface CliInvocationOptions { @@ -60,36 +59,17 @@ export interface CliInvocationPolicy { resultFormat: CliResultFormat } -/** - * Coerce an arbitrary zap level string into the narrow set the IPC payload uses. - * Unknown levels map to "info". - */ -function normalizeLevel(level: unknown): "info" | "warn" | "error" | undefined { - if (typeof level !== "string") return undefined - const lower = level.toLowerCase() - if (lower === "warn" || lower === "warning") return "warn" - if ( - lower === "error" || - lower === "fatal" || - lower === "panic" || - lower === "dpanic" - ) - return "error" - return "info" -} - -/** - * Walk a multi-line stderr blob, parse each line as a zap JSON record, and - * return the last `cliError` field encountered. Used by the non-streaming - * `run`/`runRaw` paths where the entire stderr is delivered after exit. - */ function extractCliErrorFromStderr(stderr: string): CLIError | undefined { let found: CLIError | undefined for (const line of stderr.split(/\r?\n/)) { - const parsed = parseStderrLine(line) + let parsed: unknown + try { + parsed = JSON.parse(line) + } catch { + continue + } const direct = cliErrorFromEnvelope(parsed) - const legacy = cliErrorFromLegacy(parsed) - if (direct ?? legacy) found = direct ?? legacy + if (direct) found = direct } return found } @@ -106,6 +86,8 @@ function parseCommandResult(stdout: string): T { try { const parsed = JSON.parse(trimmed) as unknown + if (isCliDiagnostic(parsed)) + throw new SyntaxError("CLI returned no JSON result") if ( parsed && typeof parsed === "object" && @@ -122,6 +104,7 @@ function parseCommandResult(stdout: string): T { if (!candidate) continue try { const parsed = JSON.parse(candidate) as unknown + if (isCliDiagnostic(parsed)) continue if ( parsed && typeof parsed === "object" && @@ -140,19 +123,12 @@ function parseCommandResult(stdout: string): T { } } -/** - * Parse a single stderr line as a zap JSON record. Returns undefined when the - * line is not valid JSON or not a plain object - callers should treat the line - * as opaque text in that case. - */ function parseStderrLine(line: string): CliLogLine | undefined { const trimmed = line.trim() if (!trimmed.startsWith("{")) return undefined try { const obj = JSON.parse(trimmed) as unknown - if (obj && typeof obj === "object" && !Array.isArray(obj)) { - return obj as CliLogLine - } + if (isCliDiagnostic(obj)) return obj } catch { // not JSON - fall through } @@ -166,10 +142,12 @@ function parseStderrLine(line: string): CliLogLine | undefined { * We augment PATH so all spawned CLI processes can find these tools. */ function buildEnv(): NodeJS.ProcessEnv { + const distinctId = getAnalyticsDistinctId() const baseEnv = { ...process.env, DEVSY_UI: "true", - DEVSY_TELEMETRY_DISTINCT_ID: getAnalyticsDistinctId(), + DEVSY_TELEMETRY_DISTINCT_ID: distinctId, + ...(distinctId ? {} : { DEVSY_DISABLE_TELEMETRY: "true" }), } if (process.platform !== "darwin") return baseEnv @@ -196,6 +174,52 @@ function requestedResultFormat(args: string[]): string | undefined { const arg = args[index] return arg.includes("=") ? arg.split("=", 2)[1] : args[index + 1] } +const VALUE_FLAGS: Record = { + "--context": true, + "-c": true, + "--log-level": true, + "--log-format": true, + "--result-format": true, + "--config": true, + "--config-dir": true, + "--provider": true, + "--owner": true, + "--home": true, + "--uid": true, + "--agent-dir": true, +} + +function commandWords(args: string[]): string[] { + const words: string[] = [] + for (let i = 0; i < args.length; i++) { + const arg = args[i] + if (arg === "--") break + if (VALUE_FLAGS[arg]) { + i++ + } else if (!arg.startsWith("-")) { + words.push(arg) + if (words.length === 2) break + } + } + return words +} + +function assertParsedCommand(args: string[]): void { + const [root, sub] = commandWords(args) + if ( + root === "ci" || + root === "exec" || + root === "ssh" || + ((root === "workspace" || root === "ws") && + (sub === "exec" || sub === "ssh")) || + ((root === "machine" || root === "provider") && sub === "ssh") || + (root === "internal" && + !!sub && + (sub.startsWith("ssh-") || sub.endsWith("-tunnel"))) + ) { + throw new Error("Transparent CLI commands require a raw API") + } +} export class CliRunner { private execPath: string @@ -236,28 +260,13 @@ export class CliRunner { } private commandNeedsSecret(args: string[]): boolean { - const valueFlags = new Set([ - "--context", - "-c", - "--log-level", - "--log-output", - "--log-format", - "--result-format", - "--config", - "--config-dir", - ]) - let commandIndex = 0 - while (commandIndex < args.length && args[commandIndex].startsWith("-")) { - const flag = args[commandIndex++] - if (valueFlags.has(flag)) commandIndex++ - } - const rootCommand = args[commandIndex] - const command = args[commandIndex + 1] + const [rootCommand, command] = commandWords(args) return ( (rootCommand === "secret" && ["set", "get", "delete", "list", "protection"].includes(command)) || (rootCommand === "context" && ["delete", "rm"].includes(command)) || - (rootCommand === "workspace" && command === "up") || + ((rootCommand === "workspace" || rootCommand === "ws") && + command === "up") || rootCommand === "up" ) } @@ -267,6 +276,8 @@ export class CliRunner { options: CliInvocationOptions, ): NodeJS.ProcessEnv { const env = { ...this.env, ...options.env } + if (this.env.DEVSY_DISABLE_TELEMETRY === "true") + env.DEVSY_DISABLE_TELEMETRY = "true" // Unlock material is withheld from unrelated commands. if (!this.commandNeedsSecret(args)) { delete env.DEVSY_SECRETS_PASSPHRASE @@ -307,29 +318,62 @@ export class CliRunner { this.policy.diagnosticLogLevel = level } - private argsWithLogLevel(args: string[]): string[] { - const explicit = args.some( - (arg) => arg === "--log-level" || arg.startsWith("--log-level="), - ) + private argsWithLogLevel( + args: string[], + options: CliInvocationOptions, + ): string[] { + const end = args.indexOf("--") + const flags = end < 0 ? args : args.slice(0, end) + const levels = ["error", "warn", "info", "debug", "trace"] + let explicitLevel: string | undefined + for (let i = 0; i < flags.length; i++) { + if (flags[i] === "--log-level") explicitLevel = flags[++i] ?? "" + else if (flags[i].startsWith("--log-level=")) + explicitLevel = flags[i].slice("--log-level=".length) + } + const explicit = explicitLevel !== undefined + const envLevel = options.env?.DEVSY_LOG_LEVEL || this.env.DEVSY_LOG_LEVEL + if (explicit && !levels.includes(explicitLevel)) + throw new Error("Invalid --log-level") + if (!explicit && envLevel && !levels.includes(envLevel)) + throw new Error("Invalid DEVSY_LOG_LEVEL") + const levelArgs = explicit + ? [] + : ["--log-level", envLevel || this.policy.diagnosticLogLevel] return [ ...this.prefixArgs, - ...args, - ...(explicit ? [] : ["--log-level", this.policy.diagnosticLogLevel]), + ...flags, + ...levelArgs, + ...(end < 0 ? [] : args.slice(end)), ] } private argsWithProtocol( args: string[], includeResultFormat = false, + options: CliInvocationOptions = {}, ): string[] { - const fullArgs = this.argsWithLogLevel(args) + const fullArgs = this.argsWithLogLevel(args, options) + const end = fullArgs.indexOf("--") + const protocolArgs = end < 0 ? fullArgs : fullArgs.slice(0, end) const hasFlag = (flag: string) => - fullArgs.some((arg) => arg === flag || arg.startsWith(`${flag}=`)) + protocolArgs.some((arg) => arg === flag || arg.startsWith(`${flag}=`)) if (includeResultFormat && !hasFlag("--result-format")) { - fullArgs.push("--result-format", this.policy.resultFormat) + fullArgs.splice( + end < 0 ? fullArgs.length : end, + 0, + "--result-format", + this.policy.resultFormat, + ) } - if (!hasFlag("--log-output") && !hasFlag("--log-format")) { - fullArgs.push("--log-output", this.policy.logOutput) + if (!hasFlag("--log-format")) { + const end = fullArgs.indexOf("--") + fullArgs.splice( + end < 0 ? fullArgs.length : end, + 0, + "--log-format", + this.policy.logOutput, + ) } return fullArgs } @@ -354,6 +398,8 @@ export class CliRunner { } async run(args: string[], options: CliInvocationOptions = {}): Promise { + assertParsedCommand(args) + const fullArgs = this.argsWithProtocol(args, true, options) const requestedFormat = requestedResultFormat(args) ?? this.policy.resultFormat if (requestedFormat !== "json") { @@ -364,7 +410,6 @@ export class CliRunner { await this.acquire() let released = false try { - const fullArgs = this.argsWithProtocol(args, true) const stdout = options.stdin === undefined ? ( @@ -397,68 +442,68 @@ export class CliRunner { } } - async runRaw( + async runText( args: string[], options: CliInvocationOptions = {}, ): Promise { + assertParsedCommand(args) + const fullArgs = this.argsWithProtocol(args, false, options) await this.acquire() let released = false try { if (options.stdin !== undefined) return await this.spawnWithStdin( - this.argsWithProtocol(args), + fullArgs, options.stdin, this.invocationEnv(args, options), ) - const { stdout } = await execFile( - this.execPath, - this.argsWithProtocol(args), - { env: this.invocationEnv(args, options) }, - ) + const { stdout } = await execFile(this.execPath, fullArgs, { + env: this.invocationEnv(args, options), + }) return stdout } catch (error: unknown) { const wrapped = this.wrapError(error, options) this.release() released = true - if (await this.unlockForRetry(args, wrapped, options)) { - return this.runRaw(args, { ...options, unlockRetried: true }) - } + if (await this.unlockForRetry(args, wrapped, options)) + return this.runText(args, { ...options, unlockRetried: true }) throw wrapped } finally { if (!released) this.release() } } - /** Writes `input` via stdin so secret values never appear in argv (e.g. `ps`). */ - async runRawStdin( + async runRaw( args: string[], - input: string, options: CliInvocationOptions = {}, ): Promise { + const fullArgs = this.argsWithProtocol(args, false, options) await this.acquire() - let released = false try { - return await this.spawnWithStdin( - this.argsWithProtocol(args), - input, - this.invocationEnv(args, options), - ) - } catch (error: unknown) { - const wrapped = this.wrapError(error, { ...options, stdin: input }) - this.release() - released = true - if (await this.unlockForRetry(args, wrapped, options)) { - return this.runRawStdin(args, input, { - ...options, - unlockRetried: true, - }) - } - throw wrapped + if (options.stdin !== undefined) + return await this.spawnWithStdin( + fullArgs, + options.stdin, + this.invocationEnv(args, options), + ) + const { stdout } = await execFile(this.execPath, fullArgs, { + env: this.invocationEnv(args, options), + }) + return stdout } finally { - if (!released) this.release() + this.release() } } + /** Writes `input` via stdin so secret values never appear in argv (e.g. `ps`). */ + async runRawStdin( + args: string[], + input: string, + options: CliInvocationOptions = {}, + ): Promise { + return this.runRaw(args, { ...options, stdin: input }) + } + // Uses spawn, not execFile: async execFile ignores { input } (Sync-only), which // would leave the child blocked reading stdin forever. private spawnWithStdin( @@ -485,7 +530,8 @@ export class CliRunner { } const err = new Error( `command failed with exit code ${code}`, - ) as Error & { stderr: string; code: number | null } + ) as Error & { stdout: string; stderr: string; code: number | null } + err.stdout = stdout err.stderr = stderr err.code = code reject(err) @@ -522,6 +568,8 @@ export class CliRunner { options: CliInvocationOptions = {}, retryCancellationGeneration?: number, ): Promise { + assertParsedCommand(args) + const fullArgs = this.argsWithProtocol(args, false, options) // A retry keeps its originating generation. A new call captures the // latest generation, so it remains valid after an older call is canceled. const cancellationGeneration = workspaceId @@ -547,7 +595,7 @@ export class CliRunner { (text, credential) => text.replaceAll(credential, "***"), value, ) - const child = spawn(this.execPath, this.argsWithProtocol(args), { + const child = spawn(this.execPath, fullArgs, { env: invocationEnv, }) @@ -570,18 +618,17 @@ export class CliRunner { rl.on("line", (line) => { if (suppressCallbacks) return line = redact(line) - const parsed = parseStderrLine(line) - const direct = cliErrorFromEnvelope(parsed) - const statusError = parsed?.error as - | { code?: string; message?: string } - | undefined + const envelope = parseCliEnvelope(line) + const direct = + envelope?.kind === "error" + ? cliErrorFromEnvelope(envelope) + : undefined + const statusError = + envelope?.kind === "status" ? envelope.error : undefined const cliError = direct ?? (statusError?.code === "unlock_required" - ? { - code: "unlock_required", - message: statusError.message ?? "Secret store unlock required", - } + ? { code: statusError.code, message: statusError.message } : undefined) if (cliError) lastCliError = cliError if ( @@ -604,11 +651,10 @@ export class CliRunner { if (suppressCallbacks) return line = redact(line) const parsed = parseStderrLine(line) - const direct = cliErrorFromEnvelope(parsed) - const legacy = cliErrorFromLegacy(parsed) - if (direct ?? legacy) lastCliError = direct ?? legacy + const direct = parsed ? undefined : extractCliErrorFromStderr(line) + if (direct) lastCliError = direct if ( - (direct ?? legacy)?.code === "unlock_required" && + direct?.code === "unlock_required" && !options.unlockRetried && this.commandNeedsSecret(args) && this.unlockHandler @@ -617,8 +663,8 @@ export class CliRunner { const meta: StreamLine = { raw: line, parsed, - cliError: direct ?? legacy, - level: normalizeLevel(parsed?.level), + cliError: direct, + level: parsed?.level, } applyBackpressure(onLine(line, "stderr", meta)) }) diff --git a/desktop/src/main/index.ts b/desktop/src/main/index.ts index fc3bba4337..59cf04b02c 100644 --- a/desktop/src/main/index.ts +++ b/desktop/src/main/index.ts @@ -28,7 +28,7 @@ import { updateDesktopDatabase, } from "./linux-desktop-integration.js" import { LogStore } from "./log-store.js" -import { mainLog, setMainLogLevel } from "./logging.js" +import { initializeMainLog, mainLog, setMainLogLevel } from "./logging.js" import { MachineDiagnosticsManager } from "./machine-diagnostics-manager.js" import { MachineDiagnosticsStore } from "./machine-diagnostics-store.js" import { ProviderJobs } from "./provider-jobs.js" @@ -155,7 +155,14 @@ app.whenReady().then(async () => { join(app.getPath("userData"), "app-settings.json"), ) appSettingsStore.load() - setMainLogLevel(appSettingsStore.get().desktopLogLevel) + try { + setMainLogLevel(appSettingsStore.get().desktopLogLevel) + initializeMainLog(app.getPath("logs")) + } catch { + console.error("Desktop logging configuration failed") + app.exit(1) + return + } initAnalytics() trackEvent("app_open") diff --git a/desktop/src/main/ipc.ts b/desktop/src/main/ipc.ts index cbe962b58a..9c5b82d044 100644 --- a/desktop/src/main/ipc.ts +++ b/desktop/src/main/ipc.ts @@ -8,7 +8,11 @@ import { promisify } from "node:util" import type { BrowserWindow } from "electron" import { app, dialog, ipcMain } from "electron" import { isAppNavigationRequest } from "../shared/app-route.js" -import type { CLIError, OperationStatus } from "../shared/cli-error.js" +import type { + CLIError, + CliLogLine, + OperationStatus, +} from "../shared/cli-error.js" import { normalizeOperationStatus, parseCliEnvelope, @@ -27,7 +31,7 @@ import { type WorkspacePresentationReply, type WorkspacePresentationRequest, } from "../shared/workspace-presentation.js" -import { hashWorkspaceRef, trackEvent } from "./analytics.js" +import { hashWorkspaceUid, trackEvent } from "./analytics.js" import type { AppNavigationController } from "./app-navigation.js" import { sanitizeAppSettingsPatch } from "./app-settings.js" import type { CliInvocationOptions, CliRunner, StreamLine } from "./cli.js" @@ -40,6 +44,7 @@ import type { MachineDiagnosticsStore } from "./machine-diagnostics-store.js" import { ProviderIconReader } from "./provider-icons.js" import type { ProviderActivity, ProviderJobs } from "./provider-jobs.js" import type { PtyManager } from "./pty.js" +import { createRendererErrorHandler } from "./renderer-error.js" import { sendRendererEvent } from "./renderer-events.js" import { isTrustedSecretIpcSender } from "./secret-ipc-policy.js" import { SecretSession } from "./secret-session.js" @@ -245,7 +250,7 @@ function displayCliLine(line: string, meta?: StreamLine): string { } interface ProgressSink { - line(formatted: string): boolean + line(formatted: string, diagnostic?: CliLogLine): boolean done( finalLine: string, extra?: { @@ -276,6 +281,23 @@ function redactSensitiveText(value: string): string { .replace(/(authorization\s*[:=]\s*(?:bearer|basic)\s+)[^\s,]+/gi, "$1***") } +function redactDiagnostic(value: CliLogLine): CliLogLine { + const redact = (input: unknown): unknown => { + if (typeof input === "string") return redactSensitiveText(input) + if (Array.isArray(input)) return input.map(redact) + if (input && typeof input === "object") { + return Object.fromEntries( + Object.entries(input).map(([key, item]) => [ + redactSensitiveText(key), + redact(item), + ]), + ) + } + return input + } + return redact(value) as CliLogLine +} + function redactCLIError(error: CLIError): CLIError { return { ...error, @@ -342,7 +364,7 @@ function createLogSink( done: boolean, extra?: { message?: string - level?: "info" | "warn" | "error" + level?: CliLogLine["level"] cliError?: CLIError success?: boolean }, @@ -373,13 +395,24 @@ function createLogSink( } return { - line(formatted) { + line(formatted, diagnostic) { if (finished) return true const safeLine = redactSensitiveText(formatted) const ok = appendLog?.(safeLine) ?? true - buf.push(safeLine) - if (buf.length >= MAX_BATCH) post(false) - else if (!timer) timer = setTimeout(() => post(false), FLUSH_MS) + if (diagnostic) { + post(false) + sendRendererEvent(getWin, "command-progress", { + commandId, + message: safeLine, + level: diagnostic.level, + diagnostic: redactDiagnostic(diagnostic), + done: false, + }) + } else { + buf.push(safeLine) + if (buf.length >= MAX_BATCH) post(false) + else if (!timer) timer = setTimeout(() => post(false), FLUSH_MS) + } return ok }, async done(finalLine, extra) { @@ -425,6 +458,51 @@ export function registerIpcHandlers(deps: IpcDependencies): { machineDiagnosticsManager, getMainWindow, } = deps + function workspaceIdentity( + workspaceId: string, + context?: string, + expectedUid?: string, + ): Record { + const entries = state + .workspaceList() + .filter((entry) => entry.id === workspaceId) + if (entries.length === 0) return {} + const scope = context || state.currentContext() + const workspace = entries.find((entry) => entry.context === scope) + const uid = workspace?.uid + if ( + typeof uid !== "string" || + !uid.trim() || + (expectedUid !== undefined && uid !== expectedUid) + ) + return {} + return { workspace_id: hashWorkspaceUid(uid) } + } + function workspaceProvider(name?: string): string | undefined { + if (!name) return undefined + const provider = state.providerList().find((entry) => entry.name === name) + const source = provider?.source + if ( + source && + typeof source === "object" && + "internal" in source && + source.internal === true && + "raw" in source && + typeof source.raw === "string" + ) { + return [ + "apple", + "docker", + "kubernetes", + "microsandbox", + "podman", + "pro", + ].includes(source.raw) + ? source.raw + : "custom" + } + return "custom" + } const secretSession = new SecretSession(deps.secretSessionTimeoutMs) const providerIcons = new ProviderIconReader(cli) let providerIconContextRevision = -1 @@ -479,6 +557,14 @@ export function registerIpcHandlers(deps: IpcDependencies): { !app.isPackaged && process.env.ELECTRON_RENDERER_URL ? process.env.ELECTRON_RENDERER_URL : pathToFileURL(join(__dirname, "../renderer/index.html")).href + ipcMain.on( + "renderer-error", + createRendererErrorHandler({ + getWindow: getMainWindow, + expectedDocumentURL: secretDocumentURL, + log: (summary) => mainLog.error("Renderer error", summary), + }), + ) const secretRequestDenied: SecretIpcFailure = { ok: false, message: "Secret operations require the main application window.", @@ -571,7 +657,7 @@ export function registerIpcHandlers(deps: IpcDependencies): { if (approvalFailure) return approvalFailure if (confirmation.response !== 1) return { ok: false, message: "Secret protection change canceled." } - await cli.runRaw(["secret", "protection", "remember"], { + await cli.runText(["secret", "protection", "remember"], { env: { DEVSY_SECRETS_PASSPHRASE: passphrase }, unlockRetried: true, }) @@ -810,14 +896,17 @@ export function registerIpcHandlers(deps: IpcDependencies): { ) if (approvalFailure) return approvalFailure if (changesPassphrase && typeof newPassphrase === "string") { - await cli.runRawStdin([...command, "--stdin"], newPassphrase, options) + await cli.runText([...command, "--stdin"], { + ...options, + stdin: newPassphrase, + }) updateProtectedSessionCredential( event, cacheGeneration, newPassphrase, ) } else { - await cli.runRaw(command, options) + await cli.runText(command, options) if (action === "remove-passphrase") updateProtectedSessionCredential(event, cacheGeneration, undefined) } @@ -1081,7 +1170,7 @@ export function registerIpcHandlers(deps: IpcDependencies): { try { const versions = await cli.run< Array<{ tag: string; current?: boolean }> - >(["provider", "versions", p.name, "--json", "--no-cache"]) + >(["provider", "versions", p.name, "--no-cache"]) const list = versions ?? [] const current = list.find((v) => v.current)?.tag ?? version const latest = list[0]?.tag ?? "" @@ -1163,7 +1252,7 @@ export function registerIpcHandlers(deps: IpcDependencies): { "workspace_rename", async (_event, args: { workspaceId: string; newWorkspaceId: string }) => { trackEvent("workspace_rename", { - workspace_ref: hashWorkspaceRef(args.workspaceId), + ...workspaceIdentity(args.workspaceId), }) await cli.runRaw([ "workspace", @@ -1183,7 +1272,11 @@ export function registerIpcHandlers(deps: IpcDependencies): { const invalid = validateWorkspacePresentationRequest(request) if (invalid) return { ok: false, ...invalid } trackEvent("workspace_edit", { - workspace_ref: hashWorkspaceRef(request.workspaceId), + ...workspaceIdentity( + request.workspaceId, + request.context, + request.expectedUid, + ), }) const context = request.context || state.workspaceContext(request.workspaceId) @@ -1239,7 +1332,7 @@ export function registerIpcHandlers(deps: IpcDependencies): { async (_event, args: { workspaceId: string; ide: string }) => { trackEvent("workspace_set_ide", { ide: args.ide, - workspace_ref: hashWorkspaceRef(args.workspaceId), + ...workspaceIdentity(args.workspaceId), }) await cli.runRaw(["workspace", "set-ide", args.workspaceId, args.ide]) }, @@ -1418,6 +1511,10 @@ export function registerIpcHandlers(deps: IpcDependencies): { commandId: cmdId, message: formatted, level: meta?.level, + diagnostic: + stream === "stderr" && meta?.parsed + ? redactDiagnostic(meta.parsed) + : undefined, done: false, }) }, @@ -1481,13 +1578,18 @@ export function registerIpcHandlers(deps: IpcDependencies): { const win = deps.getMainWindow() providerJobs.start(args.name, "updating") - const sendProgress = (message: string, level?: string) => { + const sendProgress = ( + message: string, + level?: CliLogLine["level"], + diagnostic?: CliLogLine, + ) => { const formatted = redactSensitiveText(formatLogLine(message)) providerJobs.appendLog(args.name, formatted) win?.webContents.send("command-progress", { commandId: cmdId, message: formatted, level, + diagnostic: diagnostic ? redactDiagnostic(diagnostic) : undefined, done: false, }) } @@ -1508,7 +1610,11 @@ export function registerIpcHandlers(deps: IpcDependencies): { return } } - sendProgress(line, meta?.level) + sendProgress( + line, + meta?.level, + stream === "stderr" ? meta?.parsed : undefined, + ) }, (code, cliError) => { if (code === 0) { @@ -1662,7 +1768,7 @@ export function registerIpcHandlers(deps: IpcDependencies): { ipcMain.handle( "provider_list_versions", async (_event, args: { name: string; noCache?: boolean }) => { - const cliArgs = ["provider", "versions", args.name, "--json"] + const cliArgs = ["provider", "versions", args.name] if (args.noCache) cliArgs.push("--no-cache") try { const versions = await cli.run(cliArgs) @@ -1883,7 +1989,7 @@ export function registerIpcHandlers(deps: IpcDependencies): { return secretRequestDenied trackEvent("secret_set") try { - await cli.runRawStdin( + await cli.runText( [ ...variableContextArgs(args.context), "secret", @@ -1891,7 +1997,7 @@ export function registerIpcHandlers(deps: IpcDependencies): { args.name, "--stdin", ], - args.value, + { stdin: args.value }, ) return { ok: true } as const } catch (err) { @@ -1909,7 +2015,7 @@ export function registerIpcHandlers(deps: IpcDependencies): { return secretRequestDenied trackEvent("secret_delete") try { - await cli.runRaw([ + await cli.runText([ ...variableContextArgs(args.context), "secret", "delete", @@ -1932,7 +2038,7 @@ export function registerIpcHandlers(deps: IpcDependencies): { trackEvent("secret_attach") try { if (!args.context) throw new Error("context is required") - await cli.runRaw([ + await cli.runText([ "--context", args.context, "secret", @@ -1956,7 +2062,7 @@ export function registerIpcHandlers(deps: IpcDependencies): { trackEvent("secret_detach") try { if (!args.context) throw new Error("context is required") - await cli.runRaw([ + await cli.runText([ "--context", args.context, "secret", @@ -1983,7 +2089,7 @@ export function registerIpcHandlers(deps: IpcDependencies): { async (_event, args: { name: string; value: string; context?: string }) => { trackEvent("env_set") try { - await cli.runRaw([ + await cli.runText([ ...variableContextArgs(args.context), "env", "set", @@ -2006,7 +2112,7 @@ export function registerIpcHandlers(deps: IpcDependencies): { trackEvent("env_delete") try { if (!args.context) throw new Error("context is required") - await cli.runRaw([ + await cli.runText([ "--context", args.context, "env", @@ -2028,7 +2134,7 @@ export function registerIpcHandlers(deps: IpcDependencies): { trackEvent("env_attach") try { if (!args.context) throw new Error("context is required") - await cli.runRaw([ + await cli.runText([ "--context", args.context, "env", @@ -2050,7 +2156,7 @@ export function registerIpcHandlers(deps: IpcDependencies): { trackEvent("env_detach") try { if (!args.context) throw new Error("context is required") - await cli.runRaw([ + await cli.runText([ "--context", args.context, "env", @@ -2182,10 +2288,8 @@ export function registerIpcHandlers(deps: IpcDependencies): { recovery?: boolean commandId?: string }): { commandId: string; completion: Promise } => { - trackEvent("workspace_create", { - provider: args.provider, - workspace_ref: hashWorkspaceRef(args.workspaceId ?? args.source), - }) + const provider = workspaceProvider(args.provider) + trackEvent("workspace_create", provider ? { provider } : {}) const cliArgs = ["workspace", "up", args.source] if (args.workspaceId) cliArgs.push("--id", args.workspaceId) cliArgs.push(...buildWorkspaceUpPresentationArgs(args)) @@ -2377,7 +2481,13 @@ export function registerIpcHandlers(deps: IpcDependencies): { return } - if (!sink.line(formatted)) return logStore.onDrain(logPath) + if ( + !sink.line( + formatted, + stream === "stderr" ? meta?.parsed : undefined, + ) + ) + return logStore.onDrain(logPath) }, (_code, _cliError) => { // No releaseTask: the follower dying says nothing about the @@ -2571,7 +2681,7 @@ export function registerIpcHandlers(deps: IpcDependencies): { ) trackEvent( `workspace_${{ stopping: "stop", deleting: "delete", rebuilding: "rebuild", resetting: "reset", starting: "up", creating: "create" }[activity]}`, - { workspace_ref: hashWorkspaceRef(args.workspaceId), source }, + { ...workspaceIdentity(args.workspaceId), source }, ) timing("accepted") const completion = (async () => { @@ -2613,7 +2723,12 @@ export function registerIpcHandlers(deps: IpcDependencies): { ) ) return - if (!progressSink.line(displayCliLine(line, meta))) + if ( + !progressSink.line( + displayCliLine(line, meta), + stream === "stderr" ? meta?.parsed : undefined, + ) + ) return logStore.onDrain(logPath) }, (code, cliError) => { @@ -2684,7 +2799,7 @@ export function registerIpcHandlers(deps: IpcDependencies): { commandId, ) trackEvent(`workspace_${activity === "rebuilding" ? "rebuild" : "reset"}`, { - workspace_ref: hashWorkspaceRef(args.workspaceId), + ...workspaceIdentity(args.workspaceId), source: "renderer", }) const completion = runDetachedUp({ @@ -3048,13 +3163,16 @@ export function registerIpcHandlers(deps: IpcDependencies): { args: { name: string; properties?: Record }, ) => { if ( - !args?.name || - typeof args.name !== "string" || - args.name.length > 64 - ) { + !["page_view", "session_start", "session_end", "engagement"].includes( + args?.name, + ) + ) return - } - trackEvent(args.name, sanitizeAnalyticsProperties(args.properties)) + const duration = args.properties?.duration_ms + trackEvent( + args.name, + typeof duration === "number" ? { duration_ms: duration } : undefined, + ) }, ) @@ -3091,16 +3209,3 @@ export function registerIpcHandlers(deps: IpcDependencies): { }, } } - -function sanitizeAnalyticsProperties( - input?: Record, -): Record | undefined { - if (!input || typeof input !== "object") return undefined - const entries = Object.entries(input).slice(0, 20) - const out: Record = {} - for (const [k, v] of entries) { - if (!k || k.length > 64) continue - out[k] = typeof v === "string" ? v.slice(0, 256) : v - } - return out -} diff --git a/desktop/src/main/logging.ts b/desktop/src/main/logging.ts index 15688a151a..ede6241fca 100644 --- a/desktop/src/main/logging.ts +++ b/desktop/src/main/logging.ts @@ -1,3 +1,12 @@ +import { + appendFileSync, + existsSync, + mkdirSync, + renameSync, + rmSync, + statSync, +} from "node:fs" +import { join } from "node:path" import type { LogLevel } from "../shared/app-settings.js" const rank: Record = { @@ -7,30 +16,196 @@ const rank: Record = { debug: 3, trace: 4, } +const sensitiveKey = + /(password|passwd|token|secret|api.?key|authorization|credential|private.?key|access.?key|telemetry.?distinct.?id)/i +const sensitiveLabel = new RegExp(`^(?:${sensitiveKey.source})$`, "i") +const maxFileBytes = 5 * 1024 * 1024 +const maxRecordBytes = 64 * 1024 let current: LogLevel = "info" +let logPath: string | undefined -function enabled(level: LogLevel): boolean { - return rank[current] >= rank[level] +function redactLabels(value: string): string { + const tokens = /[a-z0-9_.-]+/gi + let output = "" + let copied = 0 + for (let match = tokens.exec(value); match; match = tokens.exec(value)) { + const start = match.index + let end = tokens.lastIndex + let label = match[0] + let candidateEnd = end + for (let parts = 0; parts < 2; parts++) { + const suffix = /^[ \t]+[a-z0-9_.-]+/i.exec( + value.slice(candidateEnd, candidateEnd + 64), + ) + if (!suffix) break + candidateEnd += suffix[0].length + const candidate = value.slice(start, candidateEnd) + if (sensitiveLabel.test(candidate)) { + end = candidateEnd + label = candidate + } + } + let next = end + if (!sensitiveKey.test(label)) continue + if (value[next] === '"' || value[next] === "'") next++ + while (next < value.length && /\s/.test(value[next])) next++ + if (value[next] !== ":" && value[next] !== "=") continue + next++ + while (next < value.length && /\s/.test(value[next])) next++ + const secretStart = next + const scheme = value.slice(next, next + 6).toLowerCase() + const schemeLength = scheme.startsWith("bearer") + ? 6 + : scheme.startsWith("basic") + ? 5 + : 0 + if (schemeLength && /\s/.test(value[next + schemeLength] ?? "")) { + next += schemeLength + while (next < value.length && /\s/.test(value[next])) next++ + } + const quote = + value[next] === '"' || value[next] === "'" ? value[next++] : "" + if (quote) { + while (next < value.length) { + if (value[next] === "\\") { + next = Math.min(next + 2, value.length) + } else if (value[next++] === quote) { + break + } + } + } else { + while (next < value.length && !/[\s,;]/.test(value[next])) next++ + } + if (next === secretStart) continue + output += `${value.slice(copied, secretStart)}***` + copied = next + tokens.lastIndex = next + } + return output + value.slice(copied) } -export const mainLog = { - debug: (...args: unknown[]) => { - if (enabled("debug")) console.debug(...args) - }, - trace: (...args: unknown[]) => { - if (enabled("trace")) console.debug(...args) - }, - info: (...args: unknown[]) => { - if (enabled("info")) console.info(...args) - }, - warn: (...args: unknown[]) => { - if (enabled("warn")) console.warn(...args) - }, - error: (...args: unknown[]) => console.error(...args), +function redactText(value: string): string { + let result = value + const secrets = Object.entries(process.env) + .filter(([name, secret]) => sensitiveKey.test(name) && secret) + .map(([, secret]) => secret as string) + .sort((a, b) => b.length - a.length) + for (const secret of secrets) result = result.split(secret).join("***") + return redactLabels(result.replace(/(https?:\/\/)[^\s/@]+@/gi, "$1***@")) +} + +function safeValue( + value: unknown, + seen = new WeakSet(), + depth = 0, +): unknown { + if (typeof value === "string") return redactText(value) + if (typeof value === "bigint") return value.toString() + if (value === null || typeof value !== "object") return value + if (value instanceof Error) + return { name: redactText(value.name), message: redactText(value.message) } + if (depth >= 8 || seen.has(value)) return "[unavailable]" + seen.add(value) + if (Array.isArray(value)) + return value.map((item) => safeValue(item, seen, depth + 1)) + const result: Record = {} + for (const [key, item] of Object.entries(value)) { + result[redactText(key)] = sensitiveKey.test(key) + ? "***" + : safeValue(item, seen, depth + 1) + } + return result +} + +function appendRecord(record: string): void { + if (!logPath) return + try { + if ( + existsSync(logPath) && + statSync(logPath).size + Buffer.byteLength(record) > maxFileBytes + ) { + for (let i = 2; i >= 1; i--) { + const source = `${logPath}.${i}` + if (existsSync(source)) { + rmSync(`${logPath}.${i + 1}`, { force: true }) + renameSync(source, `${logPath}.${i + 1}`) + } + } + rmSync(`${logPath}.1`, { force: true }) + renameSync(logPath, `${logPath}.1`) + } + appendFileSync(logPath, record, { encoding: "utf8", mode: 0o600 }) + } catch { + logPath = undefined + } +} + +function emit( + level: LogLevel, + component: string | undefined, + args: unknown[], +): void { + if (rank[current] < rank[level]) return + let record: string + try { + const [first, ...rest] = args + const message = typeof first === "string" ? redactText(first) : "" + const attrs = rest.length ? safeValue(rest) : undefined + record = JSON.stringify({ + ts: new Date().toISOString(), + level, + msg: message, + ...(component ? { component: redactText(component) } : {}), + ...(typeof first !== "string" ? { value: safeValue(first) } : {}), + ...(attrs ? { args: attrs } : {}), + }) + if (Buffer.byteLength(record) + 1 > maxRecordBytes) { + record = JSON.stringify({ + ts: new Date().toISOString(), + level, + msg: `${message.slice(0, 4096)} [record truncated]`, + }) + } + } catch { + record = JSON.stringify({ + ts: new Date().toISOString(), + level, + msg: "[unavailable log record]", + }) + } + const sink = + level === "trace" || level === "debug" ? console.debug : console[level] + sink(record) + appendRecord(`${record}\n`) +} + +function logger(component?: string) { + return { + trace: (...args: unknown[]) => emit("trace", component, args), + debug: (...args: unknown[]) => emit("debug", component, args), + info: (...args: unknown[]) => emit("info", component, args), + warn: (...args: unknown[]) => emit("warn", component, args), + error: (...args: unknown[]) => emit("error", component, args), + child: (name: string) => logger(component ? `${component}.${name}` : name), + } +} + +export const mainLog = logger() + +export function initializeMainLog(directory: string): void { + mkdirSync(directory, { recursive: true, mode: 0o700 }) + logPath = join(directory, "main.log") } export function setMainLogLevel(level: LogLevel | undefined): void { - current = level && level in rank ? level : "info" + const env = process.env.DEVSY_LOG_LEVEL?.trim() + if (env && !Object.hasOwn(rank, env)) + throw new Error("Invalid DEVSY_LOG_LEVEL") + current = env + ? (env as LogLevel) + : level && Object.hasOwn(rank, level) + ? level + : "info" } export function getMainLogLevel(): LogLevel { diff --git a/desktop/src/main/machine-id.ts b/desktop/src/main/machine-id.ts index d42d93673d..7cb972e091 100644 --- a/desktop/src/main/machine-id.ts +++ b/desktop/src/main/machine-id.ts @@ -1,37 +1,65 @@ -import { execSync } from "node:child_process" -import { createHash } from "node:crypto" +import { execFileSync } from "node:child_process" +import { randomBytes } from "node:crypto" +import { readFileSync } from "node:fs" import { platform } from "node:os" -export function machineIdSync(): string { - try { - const os = platform() - let raw: string +let cached: string | undefined - if (os === "linux") { - raw = execSync("cat /etc/machine-id || cat /var/lib/dbus/machine-id", { - encoding: "utf-8", - timeout: 3000, - }).trim() - } else if (os === "darwin") { - const output = execSync( - "ioreg -rd1 -c IOPlatformExpertDevice | awk '/IOPlatformUUID/'", - { encoding: "utf-8", timeout: 3000 }, - ) - const match = output.match(/"([^"]+)"$/) - raw = match?.[1] ?? "unknown" - } else if (os === "win32") { - const output = execSync( - "reg query HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Cryptography /v MachineGuid", - { encoding: "utf-8", timeout: 3000 }, - ) - const match = output.match(/REG_SZ\s+(.+)/) - raw = match?.[1]?.trim() ?? "unknown" - } else { - raw = "unknown" - } +function valid(value: string): string { + const trimmed = value.trim() + return trimmed.toLowerCase() === "unknown" ? "" : trimmed +} - return createHash("sha256").update(raw).digest("hex") +export function machineIdSync(): string { + if (cached !== undefined) return cached + const os = platform() + if (os === "linux") { + for (const path of ["/var/lib/dbus/machine-id", "/etc/machine-id"]) { + try { + const id = readFileSync(path, "utf8").trim() + if (id) { + if (valid(id)) { + cached = id + return cached + } + break + } + } catch {} + } + } else if (os === "darwin" || os === "win32") { + try { + const output = + os === "darwin" + ? execFileSync("ioreg", ["-rd1", "-c", "IOPlatformExpertDevice"], { + encoding: "utf8", + timeout: 3000, + }) + : execFileSync( + "reg", + [ + "query", + "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Cryptography", + "/v", + "MachineGuid", + "/reg:64", + ], + { encoding: "utf8", timeout: 3000 }, + ) + const match = + os === "darwin" + ? output.match(/"IOPlatformUUID"\s*=\s*"([^"]+)"/) + : output.match(/MachineGuid\s+REG_SZ\s+([^\r\n]+)/i) + const id = valid(match?.[1] ?? "") + if (id) { + cached = id + return cached + } + } catch {} + } + try { + cached = randomBytes(32).toString("hex") } catch { - return "unknown" + cached = "" } + return cached } diff --git a/desktop/src/main/renderer-error.ts b/desktop/src/main/renderer-error.ts new file mode 100644 index 0000000000..ffdb8c87b7 --- /dev/null +++ b/desktop/src/main/renderer-error.ts @@ -0,0 +1,90 @@ +import type { BrowserWindow, IpcMainEvent, IpcMainInvokeEvent } from "electron" +import { + type RendererErrorSummary, + rendererErrorMessages, + rendererErrorNames, + sanitizeRendererErrorMessage, +} from "../shared/renderer-error.js" +import { isTrustedSecretIpcSender } from "./secret-ipc-policy.js" + +const MAX_PAYLOAD_BYTES = 512 +const MAX_REPORTS = 10 +const WINDOW_MS = 60_000 + +function parseSummary(payload: unknown): RendererErrorSummary | undefined { + try { + if (!payload || typeof payload !== "object" || Array.isArray(payload)) + return undefined + const keys = Object.keys(payload) + if ( + keys.length !== 3 || + !keys.includes("kind") || + !keys.includes("message") || + !keys.includes("name") + ) + return undefined + const { kind, message, name } = payload as Record + if ( + typeof kind !== "string" || + kind.length > 32 || + typeof message !== "string" || + message.length === 0 || + message.length > 128 || + typeof name !== "string" || + name.length > 32 + ) + return undefined + if ( + Buffer.byteLength(kind) + + Buffer.byteLength(message) + + Buffer.byteLength(name) > + MAX_PAYLOAD_BYTES + ) + return undefined + if (kind !== "error" && kind !== "unhandledrejection") return undefined + if (!rendererErrorNames.some((value) => value === name)) return undefined + return { + kind, + message: + sanitizeRendererErrorMessage(message) || rendererErrorMessages[kind], + name: name as RendererErrorSummary["name"], + } + } catch { + return undefined + } +} + +export function createRendererErrorHandler(options: { + getWindow: () => BrowserWindow | null + expectedDocumentURL: string + log: (summary: RendererErrorSummary) => void + now?: () => number +}): (event: IpcMainEvent, payload: unknown) => void { + let windowStart: number | undefined + let reports = 0 + const now = options.now ?? Date.now + return (event, payload) => { + if ( + !isTrustedSecretIpcSender( + event as unknown as IpcMainInvokeEvent, + options.getWindow(), + options.expectedDocumentURL, + ) + ) + return + const summary = parseSummary(payload) + if (!summary) return + const time = now() + if ( + windowStart === undefined || + time < windowStart || + time - windowStart >= WINDOW_MS + ) { + windowStart = time + reports = 0 + } + if (reports >= MAX_REPORTS) return + reports++ + options.log(summary) + } +} diff --git a/desktop/src/preload/index.test.ts b/desktop/src/preload/index.test.ts new file mode 100644 index 0000000000..dc2160cfac --- /dev/null +++ b/desktop/src/preload/index.test.ts @@ -0,0 +1,39 @@ +import { describe, expect, it, vi } from "vitest" +import "./index.js" + +const electron = vi.hoisted(() => ({ + exposeInMainWorld: vi.fn(), + send: vi.fn(), + invoke: vi.fn(), + on: vi.fn(), + removeListener: vi.fn(), +})) + +vi.mock("electron", () => ({ + contextBridge: { exposeInMainWorld: electron.exposeInMainWorld }, + ipcRenderer: { + send: electron.send, + invoke: electron.invoke, + on: electron.on, + removeListener: electron.removeListener, + }, +})) + +describe("preload renderer error bridge", () => { + it("sends the summary on the dedicated channel", () => { + expect(electron.exposeInMainWorld).toHaveBeenCalledWith( + "electronAPI", + expect.any(Object), + ) + const api = electron.exposeInMainWorld.mock.calls[0][1] as { + reportRendererError: (summary: unknown) => void + } + const summary = { + kind: "error", + message: "Uncaught renderer error", + name: "Error", + } + api.reportRendererError(summary) + expect(electron.send).toHaveBeenCalledWith("renderer-error", summary) + }) +}) diff --git a/desktop/src/preload/index.ts b/desktop/src/preload/index.ts index 1f7f409692..53adf88018 100644 --- a/desktop/src/preload/index.ts +++ b/desktop/src/preload/index.ts @@ -1,7 +1,12 @@ import type { IpcRendererEvent } from "electron" import { contextBridge, ipcRenderer } from "electron" +import type { RendererErrorSummary } from "../shared/renderer-error.js" contextBridge.exposeInMainWorld("electronAPI", { + reportRendererError: (summary: RendererErrorSummary): void => { + ipcRenderer.send("renderer-error", summary) + }, + invoke: (channel: string, args?: Record): Promise => ipcRenderer.invoke(channel, args), diff --git a/desktop/src/renderer/src/lib/components/provider/ProviderSheet.svelte b/desktop/src/renderer/src/lib/components/provider/ProviderSheet.svelte index de7162b989..e35f49e26e 100644 --- a/desktop/src/renderer/src/lib/components/provider/ProviderSheet.svelte +++ b/desktop/src/renderer/src/lib/components/provider/ProviderSheet.svelte @@ -43,7 +43,7 @@ import { normalizeProviderOptionEnums, providerOptionEnumHasValue, } from "$lib/utils/provider-option-enum.js" -import { isCommandSuccess } from "$lib/utils/log-parser.js" +import { isCommandSuccess, progressLogMessage } from "$lib/utils/log-parser.js" import { providerSourceReference } from "$lib/utils/provider-source.js" import { providerStatus } from "$lib/utils/provider-status.js" import type { @@ -139,8 +139,9 @@ let updatePhase = $derived.by(() => { function handleUpdateProgress(progress: CommandProgress) { const targetName = updateProviderName - if (progress.message && targetName === provider.name) { - updateLines = [...updateLines, progress.message] + const message = progressLogMessage(progress) + if (message && targetName === provider.name) { + updateLines = [...updateLines, message] } if (!progress.done) return updating = false diff --git a/desktop/src/renderer/src/lib/components/provider/ProviderWizard.svelte b/desktop/src/renderer/src/lib/components/provider/ProviderWizard.svelte index b23505da7d..c87a4d610f 100644 --- a/desktop/src/renderer/src/lib/components/provider/ProviderWizard.svelte +++ b/desktop/src/renderer/src/lib/components/provider/ProviderWizard.svelte @@ -28,7 +28,7 @@ import { onCommandProgress } from "$lib/ipc/events.js" import { providers } from "$lib/stores/providers.js" import { toasts } from "$lib/stores/toasts.js" import { extractErrorMessage } from "$lib/utils/error.js" -import { isCommandSuccess } from "$lib/utils/log-parser.js" +import { isCommandSuccess, progressLogMessage } from "$lib/utils/log-parser.js" import { initialProviderOptionValue, normalizeProviderOptionEnums, @@ -280,8 +280,9 @@ onMount(async () => { activeSession.commandId && progress.commandId === activeSession.commandId ) { - if (progress.message) { - initLines = [...initLines, progress.message] + const message = progressLogMessage(progress) + if (message) { + initLines = [...initLines, message] } if (progress.done) { initRunning = false diff --git a/desktop/src/renderer/src/lib/components/workspace/WorkspaceWizard.svelte b/desktop/src/renderer/src/lib/components/workspace/WorkspaceWizard.svelte index 3b9c8ac708..5163d46c2f 100644 --- a/desktop/src/renderer/src/lib/components/workspace/WorkspaceWizard.svelte +++ b/desktop/src/renderer/src/lib/components/workspace/WorkspaceWizard.svelte @@ -67,6 +67,7 @@ import { extractErrorMessage } from "$lib/utils/error.js" import { isRecoverableBuildFailure, isCommandSuccess, + progressLogMessage, stripAnsi, } from "$lib/utils/log-parser.js" import type { UnlistenFn } from "$lib/ipc/types.js" @@ -658,8 +659,8 @@ function flushLines() { } function queueProgressLines(progress: CommandProgress) { - const incoming = - progress.lines ?? (progress.message ? [progress.message] : []) + const message = progressLogMessage(progress) + const incoming = progress.lines ?? (message ? [message] : []) if (incoming.length === 0) return pendingLines.push(...incoming) if (flushHandle === null) { diff --git a/desktop/src/renderer/src/lib/ipc/bridge.ts b/desktop/src/renderer/src/lib/ipc/bridge.ts index a4e3be3970..ae41ba3df0 100644 --- a/desktop/src/renderer/src/lib/ipc/bridge.ts +++ b/desktop/src/renderer/src/lib/ipc/bridge.ts @@ -3,6 +3,7 @@ * falls back to mock implementations for browser-only development. */ +import type { RendererErrorSummary } from "$shared/renderer-error.js" import type { UnlistenFn } from "./types.js" function isElectron(): boolean { @@ -10,6 +11,7 @@ function isElectron(): boolean { } interface ElectronAPI { + reportRendererError: (summary: RendererErrorSummary) => void invoke: (channel: string, args?: Record) => Promise on: (channel: string, callback: (payload: unknown) => void) => () => void } diff --git a/desktop/src/renderer/src/lib/types/index.ts b/desktop/src/renderer/src/lib/types/index.ts index cd6f689249..9dec6ed42b 100644 --- a/desktop/src/renderer/src/lib/types/index.ts +++ b/desktop/src/renderer/src/lib/types/index.ts @@ -1,3 +1,5 @@ +import type { CLIError, CliLogLine } from "$shared/cli-error.js" + // Types matching the Rust daemon types (camelCase) export interface WorkspaceSource { @@ -243,8 +245,8 @@ export interface CommandProgress { commandId: string lines?: string[] message?: string - /** Optional log level; populated when the underlying stderr line was JSON. */ - level?: "info" | "warn" | "error" + level?: CliLogLine["level"] + diagnostic?: CliLogLine done: boolean /** * Whether the command succeeded. Set on the final (done: true) event by the @@ -252,11 +254,7 @@ export interface CommandProgress { * rather than pattern-matching the log text. */ success?: boolean - /** - * Structured CLI error. Present only on the final (done: true) event when the - * CLI emitted a `cliError` field on its zap JSON output. - */ - cliError?: import("$shared/cli-error.js").CLIError + cliError?: CLIError } /** A workspace phase transition, pushed as it happens. */ diff --git a/desktop/src/renderer/src/lib/utils/log-parser.test.ts b/desktop/src/renderer/src/lib/utils/log-parser.test.ts index 23634bf7b2..fa685381d3 100644 --- a/desktop/src/renderer/src/lib/utils/log-parser.test.ts +++ b/desktop/src/renderer/src/lib/utils/log-parser.test.ts @@ -5,9 +5,32 @@ import { isRecoverableBuildFailure, parseLogLine, parseRecoveryContainer, + progressLogMessage, } from "./log-parser.js" describe("parseLogLine", () => { + it("displays trace diagnostics with nested attributes intact", () => { + const diagnostic = { + ts: "2026-01-01T12:34:56Z", + level: "trace" as const, + msg: "building", + data: { count: 2, enabled: true }, + cliError: { code: "unlock_required" }, + } + const line = progressLogMessage({ + commandId: "one", + done: false, + diagnostic, + }) + expect(parseLogLine(line ?? "")).toEqual({ + time: "12:34:56", + level: "trace", + message: + 'building {"data":{"count":2,"enabled":true},"cliError":{"code":"unlock_required"}}', + source: "", + origin: "cli", + }) + }) it("does not interpret the removed legacy text format", () => { expect(parseLogLine("12:34:56 info old message source.go:42")).toEqual({ time: "", diff --git a/desktop/src/renderer/src/lib/utils/log-parser.ts b/desktop/src/renderer/src/lib/utils/log-parser.ts index d96d5ad99c..dcab5078d9 100644 --- a/desktop/src/renderer/src/lib/utils/log-parser.ts +++ b/desktop/src/renderer/src/lib/utils/log-parser.ts @@ -1,3 +1,14 @@ +import type { CommandProgress } from "$lib/types/index.js" +import { isCliDiagnostic } from "$shared/cli-error.js" + +export function progressLogMessage( + progress: CommandProgress, +): string | undefined { + return progress.diagnostic + ? JSON.stringify(progress.diagnostic) + : progress.message +} + // biome-ignore lint/suspicious/noControlCharactersInRegex: ANSI escape stripping requires matching ESC (0x1b) const ANSI_RE = /\x1b\[[0-9;]*m/g const BRACKET_RE = /\[0[;0-9]*m/g @@ -39,7 +50,7 @@ export function parseRecoveryContainer( export interface ParsedLogLine { time: string - level: "info" | "warn" | "fatal" | "debug" | "error" | "" + level: "trace" | "info" | "warn" | "fatal" | "debug" | "error" | "" message: string source: string origin: "cli" | "tunnel" | "" @@ -99,6 +110,33 @@ export function parseLogLine(raw: string): ParsedLogLine { function parseLogLineUncached(raw: string): ParsedLogLine { const clean = stripAnsi(raw) + if (clean.startsWith("{")) { + try { + const diagnostic: unknown = JSON.parse(clean) + if (isCliDiagnostic(diagnostic)) { + const { ts, level, msg, ...attrs } = diagnostic + const suffix = Object.keys(attrs).length + ? ` ${JSON.stringify(attrs)}` + : "" + return { + time: ts.match(/T(\d{2}:\d{2}:\d{2})/)?.[1] ?? ts, + level, + message: `${msg}${suffix}`, + source: "", + origin: "cli", + } + } + } catch { + return { + time: "", + level: "", + message: clean.trim(), + source: "", + origin: "", + } + } + } + // Zap console format (tab-separated): ISO8601\tLEVEL\tmessage\tsource.go:NNN const zapMatch = clean.match( /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}[^\t]*)\t(INFO|WARN|FATAL|DEBUG|ERROR)\t(.*?)(?:\t(\S+\.\w+:\d+))?\s*$/, diff --git a/desktop/src/renderer/src/lib/utils/renderer-error.test.ts b/desktop/src/renderer/src/lib/utils/renderer-error.test.ts new file mode 100644 index 0000000000..a40b7c04d9 --- /dev/null +++ b/desktop/src/renderer/src/lib/utils/renderer-error.test.ts @@ -0,0 +1,75 @@ +import { describe, expect, it, vi } from "vitest" +import { installRendererErrorReporting } from "./renderer-error.js" + +function emit( + target: EventTarget, + type: string, + field: string, + value: unknown, +) { + const event = new Event(type) + Object.defineProperty(event, field, { value }) + target.dispatchEvent(event) +} + +describe("renderer error reporting", () => { + it("preserves useful messages while removing secrets, stacks, paths, and URLs", () => { + const target = new EventTarget() + const report = vi.fn() + const dispose = installRendererErrorReporting( + target as unknown as Window, + report, + ) + const error = new TypeError( + "Workspace load failed token=secret https://example.test/?secret=123", + ) + error.stack = "/Users/private/file.ts:1" + emit(target, "error", "error", error) + emit( + target, + "unhandledrejection", + "reason", + "Fetch failed /path?token=value", + ) + const first = report.mock.calls[0][0] + const second = report.mock.calls[1][0] + expect(first.kind).toBe("error") + expect(first.name).toBe("TypeError") + expect(first.message).toContain("Workspace load failed") + expect(second.message).toContain("Fetch failed") + for (const secret of [ + "secret", + "example.test", + "123", + "/Users", + "/path", + "token=value", + ]) { + expect(JSON.stringify(report.mock.calls)).not.toContain(secret) + } + dispose() + emit(target, "error", "error", error) + expect(report).toHaveBeenCalledTimes(2) + }) + + it("does not inspect arbitrary thrown objects and tolerates a failed bridge", () => { + const target = new EventTarget() + const report = vi.fn(() => { + throw new Error("bridge unavailable") + }) + installRendererErrorReporting(target as unknown as Window, report) + const thrown = { + get message() { + throw new Error("must not inspect") + }, + } + expect(() => + emit(target, "unhandledrejection", "reason", thrown), + ).not.toThrow() + expect(report).toHaveBeenCalledWith({ + kind: "unhandledrejection", + message: "Unhandled renderer promise rejection", + name: "UnknownError", + }) + }) +}) diff --git a/desktop/src/renderer/src/lib/utils/renderer-error.ts b/desktop/src/renderer/src/lib/utils/renderer-error.ts new file mode 100644 index 0000000000..36b50f0604 --- /dev/null +++ b/desktop/src/renderer/src/lib/utils/renderer-error.ts @@ -0,0 +1,53 @@ +import { + type RendererErrorKind, + type RendererErrorName, + type RendererErrorSummary, + rendererErrorMessages, + rendererErrorNames, + sanitizeRendererErrorMessage, +} from "$shared/renderer-error.js" + +function errorName(value: unknown): RendererErrorName { + try { + if (value instanceof Error) { + const name = value.name + if (rendererErrorNames.some((allowed) => allowed === name)) + return name as RendererErrorName + } + } catch { + return "UnknownError" + } + return "UnknownError" +} + +export function installRendererErrorReporting( + target: Window, + report: (summary: RendererErrorSummary) => void, +): () => void { + const send = (kind: RendererErrorKind, value: unknown) => { + try { + let message = "" + if (typeof value === "string") message = value + else if (value instanceof Error) { + const candidate = value.message + if (typeof candidate === "string") message = candidate + } + report({ + kind, + message: + sanitizeRendererErrorMessage(message) || rendererErrorMessages[kind], + name: errorName(value), + }) + } catch {} + } + const onError = (event: ErrorEvent) => + send("error", event.error ?? event.message) + const onRejection = (event: PromiseRejectionEvent) => + send("unhandledrejection", event.reason) + target.addEventListener("error", onError) + target.addEventListener("unhandledrejection", onRejection) + return () => { + target.removeEventListener("error", onError) + target.removeEventListener("unhandledrejection", onRejection) + } +} diff --git a/desktop/src/renderer/src/main.ts b/desktop/src/renderer/src/main.ts index 1c2382f7f9..33b5fb26d5 100644 --- a/desktop/src/renderer/src/main.ts +++ b/desktop/src/renderer/src/main.ts @@ -1,5 +1,10 @@ import { mount } from "svelte" import App from "./App.svelte" +import { installRendererErrorReporting } from "./lib/utils/renderer-error.js" + +installRendererErrorReporting(window, (summary) => { + window.electronAPI?.reportRendererError(summary) +}) const target = document.getElementById("app") if (!target) throw new Error("App mount element not found") diff --git a/desktop/src/renderer/src/pages/WorkspaceDetailPage.svelte b/desktop/src/renderer/src/pages/WorkspaceDetailPage.svelte index 7cd2e3ac70..9bb0de2109 100644 --- a/desktop/src/renderer/src/pages/WorkspaceDetailPage.svelte +++ b/desktop/src/renderer/src/pages/WorkspaceDetailPage.svelte @@ -99,6 +99,7 @@ import { isRecoverableBuildFailure, isCommandSuccess, parseRecoveryContainer, + progressLogMessage, stripAnsi, } from "$lib/utils/log-parser.js" import { Skeleton } from "$lib/components/ui/skeleton/index.js" @@ -384,8 +385,8 @@ onMount(async () => { try { unlisten = await onCommandProgress((progress) => { if (commandId && progress.commandId === commandId) { - const incoming = - progress.lines ?? (progress.message ? [progress.message] : []) + const message = progressLogMessage(progress) + const incoming = progress.lines ?? (message ? [message] : []) if (incoming.length > 0) { pendingLines.push(...incoming) if (flushHandle === null) { diff --git a/desktop/src/shared/cli-error.ts b/desktop/src/shared/cli-error.ts index b7fc582fac..71db982154 100644 --- a/desktop/src/shared/cli-error.ts +++ b/desktop/src/shared/cli-error.ts @@ -6,13 +6,25 @@ export interface CLIError { } export interface CliLogLine { - level?: "debug" | "info" | "warn" | "error" | "panic" | "fatal" | string - ts?: string - msg?: string - cliError?: CLIError + level: "trace" | "debug" | "info" | "warn" | "error" | "fatal" + ts: string + msg: string [key: string]: unknown } +export function isCliDiagnostic(value: unknown): value is CliLogLine { + if (!value || typeof value !== "object" || Array.isArray(value)) return false + const candidate = value as Record + return ( + typeof candidate.ts === "string" && + typeof candidate.msg === "string" && + typeof candidate.level === "string" && + ["trace", "debug", "info", "warn", "error", "fatal"].includes( + candidate.level, + ) + ) +} + export type CliEnvelopeKind = "status" | "result" | "error" export interface CliStatusEnvelope { @@ -104,6 +116,15 @@ export function cliErrorFromEnvelope(value: unknown): CLIError | undefined { if (!value || typeof value !== "object" || Array.isArray(value)) return undefined const candidate = value as Record + if ( + Object.keys(candidate).some( + (key) => + !["kind", "outcome", "code", "message", "hint", "context"].includes( + key, + ), + ) + ) + return undefined if (candidate.kind !== "error" || candidate.outcome !== "error") return undefined if (typeof candidate.message !== "string" || candidate.message.length === 0) @@ -122,37 +143,6 @@ export function cliErrorFromEnvelope(value: unknown): CLIError | undefined { } } -export function cliErrorFromLegacy(value: unknown): CLIError | undefined { - if (!value || typeof value !== "object" || Array.isArray(value)) - return undefined - const candidate = value as Record - if ( - candidate.level !== "error" && - candidate.level !== "fatal" && - candidate.level !== "panic" - ) - return undefined - if (!isCLIError(candidate.cliError)) return undefined - // Legacy zap encoding flattens context to a string; drop it rather than discard the error. - const err = candidate.cliError - return isStringMap(err.context) || err.context === undefined - ? err - : { ...err, context: undefined } -} - -function isCLIError(value: unknown): value is CLIError { - if (!value || typeof value !== "object" || Array.isArray(value)) return false - const candidate = value as Record - return ( - typeof candidate.code === "string" && - typeof candidate.message === "string" && - (candidate.hint === undefined || typeof candidate.hint === "string") && - (candidate.context === undefined || - typeof candidate.context === "string" || - isStringMap(candidate.context)) - ) -} - function isStringMap(value: unknown): value is Record { return ( !!value && @@ -173,6 +163,7 @@ export function parseCliEnvelope(line: string): CliEnvelope | undefined { if (!trimmed.startsWith("{")) return undefined try { const obj = JSON.parse(trimmed) as unknown + if (isCliDiagnostic(obj)) return undefined if ( obj && typeof obj === "object" && @@ -190,6 +181,7 @@ export function parseCliEnvelope(line: string): CliEnvelope | undefined { !cliErrorFromEnvelope(obj) ) return undefined + if (obj.kind === "result" && !isResultEnvelope(obj)) return undefined return obj as CliEnvelope } } catch { @@ -198,6 +190,42 @@ export function parseCliEnvelope(line: string): CliEnvelope | undefined { return undefined } +function isResultEnvelope(value: object): value is CliResultEnvelope { + const candidate = value as Record + if ( + Object.keys(candidate).some( + (key) => + ![ + "kind", + "outcome", + "containerId", + "remoteUser", + "remoteWorkspaceFolder", + "url", + "warnings", + "recovery", + "runId", + ].includes(key), + ) + ) + return false + return ( + candidate.outcome === "success" && + typeof candidate.containerId === "string" && + typeof candidate.remoteUser === "string" && + typeof candidate.remoteWorkspaceFolder === "string" && + (candidate.url === undefined || typeof candidate.url === "string") && + (candidate.recovery === undefined || + typeof candidate.recovery === "boolean") && + (candidate.runId === undefined || + (typeof candidate.runId === "string" && + RUN_UUID.test(candidate.runId))) && + (candidate.warnings === undefined || + (Array.isArray(candidate.warnings) && + candidate.warnings.every((item) => typeof item === "string"))) + ) +} + function isCurrentStatusEnvelope(value: object): value is CliStatusEnvelope { if (!hasOnlyCurrentStatusFields(value)) return false const candidate = value as Record diff --git a/desktop/src/shared/renderer-error.ts b/desktop/src/shared/renderer-error.ts new file mode 100644 index 0000000000..231afc8fb0 --- /dev/null +++ b/desktop/src/shared/renderer-error.ts @@ -0,0 +1,50 @@ +export const rendererErrorMessages = { + error: "Uncaught renderer error", + unhandledrejection: "Unhandled renderer promise rejection", +} as const + +export const rendererErrorNames = [ + "Error", + "TypeError", + "RangeError", + "ReferenceError", + "SyntaxError", + "URIError", + "EvalError", + "AggregateError", + "UnknownError", +] as const + +export type RendererErrorName = (typeof rendererErrorNames)[number] +export type RendererErrorKind = keyof typeof rendererErrorMessages + +export interface RendererErrorSummary { + kind: RendererErrorKind + message: string + name: RendererErrorName +} + +export function sanitizeRendererErrorMessage(value: string): string { + return value + .slice(0, 4096) + .split(/[\r\n\u2028\u2029]/, 1)[0] + .replace( + /\b(?:authorization|password|passwd|token|secret|api[_-]?key|credential|private[_-]?key|access[_-]?key)\b\s*["']?\s*(?::|=|\bis\b)\s*(?:(?:bearer|basic)\s+)?(?:"[^"]*"|'[^']*'|[^\s,;]+)/gi, + "[redacted]", + ) + .replace(/\b(?:bearer|basic)\s+[a-z0-9._~+/=-]+/gi, "[redacted]") + .replace(/\beyJ[a-z0-9_-]+\.[a-z0-9_-]+\.[a-z0-9_-]+\b/gi, "[redacted]") + .replace(/\b[a-z][a-z0-9+.-]*:\/\/[^\s"'<>]+/gi, "[url]") + .replace(/(?:[a-z]:\\|\\\\|\/|~\/)(?:[^\s"'<>()[\]{};,]+)/gi, "[path]") + .replace(/\?[^\s"'<>]*/g, "[query]") + .replace( + /\{[^}]*\}|\[(?!redacted\]|url\]|path\]|query\]|details\])[^\]]*\]/g, + "[details]", + ) + .replace(/\p{Cc}/gu, (character) => { + const code = character.charCodeAt(0) + return code <= 31 || code === 127 ? " " : character + }) + .trim() + .slice(0, 128) +} diff --git a/e2e/framework/command.go b/e2e/framework/command.go index 1045af890a..33c82253c1 100644 --- a/e2e/framework/command.go +++ b/e2e/framework/command.go @@ -26,7 +26,7 @@ const ( var ( flagResultFormat = names.Flag(names.ResultFormat) flagIDE = names.Flag(names.IDE) - flagDebug = names.Flag(names.Debug) + flagDebug = "--log-level=debug" flagCommand = names.Flag(names.Command) ) diff --git a/e2e/tests/ci/ci.go b/e2e/tests/ci/ci.go index 4a5f397702..0ed099294c 100644 --- a/e2e/tests/ci/ci.go +++ b/e2e/tests/ci/ci.go @@ -115,11 +115,18 @@ var _ = ginkgo.Describe("devsy ci test suite", ginkgo.Label("ci"), ginkgo.Ordere tempDir, f := setupCI(initialDir) args := []string{ciCommand} args = append(args, flags...) - args = append(args, tempDir, "--", "sh", "-c", - "printf 'child-out:[RUN] {\"kind\":\"status\"}'; printf 'child-err' >&2") + args = append( + args, + tempDir, + "--", + "sh", + "-c", + `printf 'child-out:{"kind":"status"}{"kind":"result"}{"kind":"error"}{"kind":"unlock"}'; printf 'child-err' >&2`, + ) stdout, stderr, err := f.ExecCommandCapture(ctx, args) framework.ExpectNoError(err) - gomega.Expect(stdout).To(gomega.Equal(`child-out:[RUN] {"kind":"status"}`)) + gomega.Expect(stdout).To(gomega.Equal( + `child-out:{"kind":"status"}{"kind":"result"}{"kind":"error"}{"kind":"unlock"}`)) gomega.Expect(stderr).To(gomega.ContainSubstring("child-err")) if wantStatus { gomega.Expect(stderr).To(gomega.MatchRegexp(`\[RUN\]\s+ci:`)) @@ -145,8 +152,8 @@ var _ = ginkgo.Describe("devsy ci test suite", ginkgo.Label("ci"), ginkgo.Ordere ginkgo.Entry("disabled", []string{noStatusFlag, resultFormatPlainFlag}, false, false, ginkgo.SpecTimeout(framework.TimeoutShort())), ginkgo.Entry( - "quiet", - []string{noStatusFlag, "--quiet", resultFormatPlainFlag}, + "error level", + []string{noStatusFlag, "--log-level=error", resultFormatPlainFlag}, false, false, ginkgo.SpecTimeout(framework.TimeoutShort()), @@ -159,8 +166,8 @@ var _ = ginkgo.Describe("devsy ci test suite", ginkgo.Label("ci"), ginkgo.Ordere "debug", []string{ noStatusFlag, - "--debug", - "--log-output=json", + "--log-level=debug", + "--log-format=json", resultFormatPlainFlag, }, false, @@ -206,7 +213,7 @@ var _ = ginkgo.Describe("devsy ci test suite", ginkgo.Label("ci"), ginkgo.Ordere }, ginkgo.Entry("warning level", []string{"--log-level=warn"}, true, ginkgo.SpecTimeout(framework.TimeoutShort())), - ginkgo.Entry("quiet", []string{"--quiet"}, false, + ginkgo.Entry("error level", []string{"--log-level=error"}, false, ginkgo.SpecTimeout(framework.TimeoutShort())), ) @@ -247,7 +254,7 @@ var _ = ginkgo.Describe("devsy ci test suite", ginkgo.Label("ci"), ginkgo.Ordere func(ctx context.Context) { tempDir, f := setupCI(initialDir) _, stderr, err := f.ExecCommandCapture(ctx, []string{ - ciCommand, noStatusFlag, "--log-output=json", resultFormatPlainFlag, tempDir, + ciCommand, noStatusFlag, "--log-format=json", "--result-format=json", tempDir, "--", "sh", "-c", "printf 'machine-child-error' >&2; exit 7", }) var exitErr *exec.ExitError diff --git a/e2e/tests/ide/browser_returns.go b/e2e/tests/ide/browser_returns.go index 5c7cb0c804..c9389c2f0d 100644 --- a/e2e/tests/ide/browser_returns.go +++ b/e2e/tests/ide/browser_returns.go @@ -341,7 +341,7 @@ var _ = ginkgo.Describe( stdout, stderr, err := f.DevsyUpStreamsRaw(ctx, tempDir, "--ide=openvscode", "--ide-launch=headless", - names.Flag(names.SSHGPGForwarding), "--debug") + names.Flag(names.SSHGPGForwarding), "--log-level=debug") framework.ExpectNoError(err) combined := stdout + stderr @@ -416,7 +416,7 @@ var _ = ginkgo.Describe( ) stdout, stderr, err := f.DevsyUpStreamsRaw(ctx, tempDir, - "--ide=openvscode", "--ide-launch=headless", "--debug") + "--ide=openvscode", "--ide-launch=headless", "--log-level=debug") framework.ExpectNoError(err) combined := stdout + stderr gomega.Expect(combined). @@ -468,7 +468,7 @@ var _ = ginkgo.Describe( func(ctx context.Context) { f, tempDir := setupBrowserIDE(ctx, initialDir) stdout, stderr, err := f.DevsyUpStreamsRaw(ctx, tempDir, - "--ide=openvscode", "--ide-launch=headless", "--debug") + "--ide=openvscode", "--ide-launch=headless", "--log-level=debug") framework.ExpectNoError(err) combined := stdout + stderr diff --git a/e2e/tests/logs/logs.go b/e2e/tests/logs/logs.go index 738c3e4661..cc69bee823 100644 --- a/e2e/tests/logs/logs.go +++ b/e2e/tests/logs/logs.go @@ -45,7 +45,7 @@ var _ = ginkgo.Describe( framework.ExpectNoError(err) }) - err = f.DevsyUp(ctx, tempDir, "--debug") + err = f.DevsyUp(ctx, tempDir, "--log-level=debug") framework.ExpectNoError(err) status, err := f.DevsyStatus(ctx, tempDir, "--container-status=false") diff --git a/e2e/tests/machineprovider/machineprovider.go b/e2e/tests/machineprovider/machineprovider.go index 05041ccbd0..ac246d2f87 100644 --- a/e2e/tests/machineprovider/machineprovider.go +++ b/e2e/tests/machineprovider/machineprovider.go @@ -50,7 +50,7 @@ var _ = ginkgo.Describe( }) // wait for devsy workspace to come online (deadline: 30s) - err = f.DevsyUp(ctx, tempDir, "--debug") + err = f.DevsyUp(ctx, tempDir, "--log-level=debug") framework.ExpectNoError(err) // expect workspace @@ -121,7 +121,7 @@ var _ = ginkgo.Describe( }) // wait for devsy workspace to come online (deadline: 30s) - err = f.DevsyUp(ctx, tempDir, "--debug", "--daemon-interval=3s") + err = f.DevsyUp(ctx, tempDir, "--log-level=debug", "--daemon-interval=3s") framework.ExpectNoError(err) // check status @@ -194,7 +194,7 @@ var _ = ginkgo.Describe( }) // wait for devsy workspace to come online - err = f.DevsyUp(ctx, tempDir, "--debug", "--daemon-interval=3s") + err = f.DevsyUp(ctx, tempDir, "--log-level=debug", "--daemon-interval=3s") framework.ExpectNoError(err) // check initial status diff --git a/e2e/tests/snapshot/snapshot.go b/e2e/tests/snapshot/snapshot.go index 6113952b90..8656d9130c 100644 --- a/e2e/tests/snapshot/snapshot.go +++ b/e2e/tests/snapshot/snapshot.go @@ -16,7 +16,7 @@ import ( const ( registryFlag = "--registry" - debugFlag = "--debug" + debugFlag = "--log-level=debug" workspaceIDFlag = "--workspace-id" snapshotCmd = "snapshot" snapshotVerbCreate = "create" diff --git a/e2e/tests/ssh/detached_task.go b/e2e/tests/ssh/detached_task.go index 31ca9086bd..41c56a47cc 100644 --- a/e2e/tests/ssh/detached_task.go +++ b/e2e/tests/ssh/detached_task.go @@ -52,7 +52,7 @@ func startDetachedTunnelUp( ) (string, error) { args := []string{ cmdWorkspace, "up", - names.Flag(names.Debug), + "--log-level=debug", names.Flag(names.IDE), "none", names.Flag(names.SSHTunnel), names.Flag(names.Detach), diff --git a/e2e/tests/tunnel/tunnel.go b/e2e/tests/tunnel/tunnel.go index 0e51b80595..13a1105450 100644 --- a/e2e/tests/tunnel/tunnel.go +++ b/e2e/tests/tunnel/tunnel.go @@ -46,7 +46,7 @@ var _ = ginkgo.Describe( framework.ExpectNoError(err) }) - err = f.DevsyUp(ctx, tempDir, "--debug") + err = f.DevsyUp(ctx, tempDir, "--log-level=debug") framework.ExpectNoError(err) out, err := f.DevsySSH( @@ -90,7 +90,7 @@ var _ = ginkgo.Describe( framework.ExpectNoError(err) }) - err = f.DevsyUp(ctx, tempDir, "--debug") + err = f.DevsyUp(ctx, tempDir, "--log-level=debug") framework.ExpectNoError(err) out, err := f.DevsySSH(ctx, tempDir, "echo alive") diff --git a/e2e/tests/up-docker-compose/build.go b/e2e/tests/up-docker-compose/build.go index 746cc5d048..78deb57d60 100644 --- a/e2e/tests/up-docker-compose/build.go +++ b/e2e/tests/up-docker-compose/build.go @@ -54,7 +54,7 @@ var _ = ginkgo.Describe( framework.ExpectNoError(err) // Wait for devsy workspace to come online (deadline: 30s) - err = f.DevsyUp(ctx, tempDir, "--debug") + err = f.DevsyUp(ctx, tempDir, "--log-level=debug") framework.ExpectNoError(err) }, ginkgo.SpecTimeout(framework.TimeoutLong())) @@ -117,7 +117,7 @@ var _ = ginkgo.Describe( framework.ExpectNoError(err) ginkgo.By("Starting Devsy again with --recreate") - err = f.DevsyUp(ctx, tempDir, "--debug", names.Flag(names.Recreate)) + err = f.DevsyUp(ctx, tempDir, "--log-level=debug", names.Flag(names.Recreate)) framework.ExpectError(err) ginkgo.By("Should leave original container running") @@ -169,7 +169,7 @@ var _ = ginkgo.Describe( Should(gomega.Equal(1), "1 compose container to be created") ginkgo.By("Starting Devsy again with --recreate") - err = f.DevsyUp(ctx, tempDir, "--debug", names.Flag(names.Recreate)) + err = f.DevsyUp(ctx, tempDir, "--log-level=debug", names.Flag(names.Recreate)) framework.ExpectNoError(err) ginkgo.By("Should start a new docker-compose container on rebuild") diff --git a/e2e/tests/up-docker-compose/helper.go b/e2e/tests/up-docker-compose/helper.go index 3f1b776e09..45145b467c 100644 --- a/e2e/tests/up-docker-compose/helper.go +++ b/e2e/tests/up-docker-compose/helper.go @@ -28,7 +28,7 @@ const ( cmdSSH = "ssh" flagCommand = "--command" flagIDE = "--ide" - flagDebug = "--debug" + flagDebug = "--log-level=debug" ideNone = "none" ) diff --git a/e2e/tests/up-docker-compose/up_docker_compose.go b/e2e/tests/up-docker-compose/up_docker_compose.go index 02e5e2a571..5fd75a9cb6 100644 --- a/e2e/tests/up-docker-compose/up_docker_compose.go +++ b/e2e/tests/up-docker-compose/up_docker_compose.go @@ -346,7 +346,7 @@ var _ = ginkgo.Describe( tempDir, workspace, err := tc.setupAndStartWorkspace( ctx, "tests/up-docker-compose/testdata/docker-compose-mounts", - "--debug", + "--log-level=debug", ) framework.ExpectNoError(err) @@ -397,7 +397,7 @@ var _ = ginkgo.Describe( tempDir, workspace, err := tc.setupAndStartWorkspace( ctx, "tests/up-docker-compose/testdata/docker-compose-mounts-readonly", - "--debug", + "--log-level=debug", ) framework.ExpectNoError(err) @@ -467,7 +467,7 @@ var _ = ginkgo.Describe( _, workspace, err := tc.setupAndStartWorkspace( ctx, "tests/up-docker-compose/testdata/docker-compose-forward-ports", - "--debug", + "--log-level=debug", ) framework.ExpectNoError(err) @@ -530,7 +530,7 @@ var _ = ginkgo.Describe( _, workspace, err := tc.setupAndStartWorkspace( ctx, "tests/up-docker-compose/testdata/docker-compose-forward-ports", - "--debug", + "--log-level=debug", ) framework.ExpectNoError(err) @@ -598,7 +598,7 @@ var _ = ginkgo.Describe( tempDir, workspace, err := tc.setupAndStartWorkspace( ctx, "tests/up-docker-compose/testdata/docker-compose-features", - "--debug", + "--log-level=debug", ) framework.ExpectNoError(err) @@ -903,7 +903,7 @@ var _ = ginkgo.Describe( tempDir, workspace, err := tc.setupAndStartWorkspace( ctx, "tests/up-docker-compose/testdata/docker-compose-build-target-features", - "--debug", + "--log-level=debug", ) framework.ExpectNoError(err) @@ -970,7 +970,7 @@ var _ = ginkgo.Describe( tempDirA, _, err := tc.setupAndStartWorkspace( ctx, projectAPath, - "--debug", + "--log-level=debug", ) framework.ExpectNoError(err) @@ -1004,7 +1004,7 @@ var _ = ginkgo.Describe( tempDirB, _, err := tc.setupAndStartWorkspace( ctx, projectBPath, - "--debug", + "--log-level=debug", ) framework.ExpectNoError(err) @@ -1170,7 +1170,7 @@ var _ = ginkgo.Describe( _, ws, err := tc.setupAndStartWorkspace( ctx, "tests/up-docker-compose/testdata/docker-compose-v2-with-name", - "--debug", + "--log-level=debug", ) framework.ExpectNoError(err) @@ -1248,7 +1248,7 @@ var _ = ginkgo.Describe( tempDir, workspace, err := tc.setupAndStartWorkspace( ctx, "tests/up-docker-compose/testdata/docker-compose-dockerfile-args", - "--debug", + "--log-level=debug", ) framework.ExpectNoError(err) @@ -1268,7 +1268,7 @@ var _ = ginkgo.Describe( tempDir, workspace, err := tc.setupAndStartWorkspace( ctx, "tests/up-docker-compose/testdata/docker-compose-dockerfile-args-multistage", - "--debug", + "--log-level=debug", ) framework.ExpectNoError(err) diff --git a/e2e/tests/up-features/wsl.go b/e2e/tests/up-features/wsl.go index 1812a2017e..78fc4d50dd 100644 --- a/e2e/tests/up-features/wsl.go +++ b/e2e/tests/up-features/wsl.go @@ -96,7 +96,7 @@ var _ = ginkgo.Describe( ginkgo.DeferCleanup(f.DevsyWorkspaceDelete, workspaceName) // Wait for devsy workspace to come online (deadline: 30s) - err = f.DevsyUp(ctx, tempDir, "--debug") + err = f.DevsyUp(ctx, tempDir, "--log-level=debug") framework.ExpectNoError(err) }, ginkgo.SpecTimeout(framework.TimeoutLong()), diff --git a/e2e/tests/up/docker_wsl.go b/e2e/tests/up/docker_wsl.go index af7cf1dcd9..126ecd4089 100644 --- a/e2e/tests/up/docker_wsl.go +++ b/e2e/tests/up/docker_wsl.go @@ -40,7 +40,7 @@ var _ = ginkgo.Describe("testing up command for windows", ginkgo.Label("up-docke tempDir, err := setupWorkspace("tests/up/testdata/docker-mounts", initialDir, f) framework.ExpectNoError(err) - err = f.DevsyUp(ctx, tempDir, "--debug") + err = f.DevsyUp(ctx, tempDir, "--log-level=debug") framework.ExpectNoError(err) workspace, err := f.FindWorkspace(ctx, tempDir) diff --git a/e2e/tests/up/dockerfile_build.go b/e2e/tests/up/dockerfile_build.go index b5597214a0..548d586eaa 100644 --- a/e2e/tests/up/dockerfile_build.go +++ b/e2e/tests/up/dockerfile_build.go @@ -45,7 +45,7 @@ var _ = ginkgo.Describe( ) framework.ExpectNoError(err) - err = f.DevsyUp(ctx, tempDir, "--debug") + err = f.DevsyUp(ctx, tempDir, "--log-level=debug") framework.ExpectNoError(err) }, ginkgo.SpecTimeout(framework.TimeoutVeryLong())) @@ -59,7 +59,7 @@ var _ = ginkgo.Describe( ) framework.ExpectNoError(err) - err = f.DevsyUp(ctx, tempDir, "--debug") + err = f.DevsyUp(ctx, tempDir, "--log-level=debug") framework.ExpectNoError(err) }, ginkgo.SpecTimeout(framework.TimeoutLong()), @@ -96,7 +96,7 @@ var _ = ginkgo.Describe( framework.ExpectNoError(err) ginkgo.By("Starting Devsy again with --recreate") - err = f.DevsyUp(ctx, tempDir, "--debug", names.Flag(names.Recreate)) + err = f.DevsyUp(ctx, tempDir, "--log-level=debug", names.Flag(names.Recreate)) framework.ExpectNoError(err) container, err = dockerHelper.FindDevContainer(ctx, []string{ @@ -143,7 +143,7 @@ var _ = ginkgo.Describe( framework.ExpectNoError(err) ginkgo.By("Starting Devsy again with --recreate") - err = f.DevsyUp(ctx, tempDir, "--debug", names.Flag(names.Recreate)) + err = f.DevsyUp(ctx, tempDir, "--log-level=debug", names.Flag(names.Recreate)) framework.ExpectNoError(err) container, err = dockerHelper.FindDevContainer(ctx, []string{ diff --git a/e2e/tests/up/handles_errors.go b/e2e/tests/up/handles_errors.go index 2a45b80274..ebf586cca3 100644 --- a/e2e/tests/up/handles_errors.go +++ b/e2e/tests/up/handles_errors.go @@ -29,7 +29,7 @@ var _ = ginkgo.Describe( }) ginkgo.It( - "make sure devsy output is correct and log-output works correctly", + "reports workspace errors with JSON diagnostics", func(ctx context.Context) { f := framework.NewDefaultFramework(initialDir + "/bin") tempDir := framework.CopyTestdata("tests/up/testdata/docker", initialDir) @@ -51,7 +51,9 @@ var _ = ginkgo.Describe( framework.ExpectNoError(err) // Wait for devsy workspace to come online - stdout, stderr, err := f.DevsyUpStreams(ctx, tempDir, "--log-output=json") + stdout, stderr, err := f.DevsyUpStreams( + ctx, tempDir, "--log-format=json", "--result-format=json", + ) deleteErr := f.DevsyWorkspaceDelete(ctx, tempDir, "--force") framework.ExpectNoError(deleteErr) framework.ExpectError(err, "expected error") @@ -103,7 +105,7 @@ var _ = ginkgo.Describe( initialDir, ) - err = f.DevsyUp(ctx, tempDir, "--debug") + err = f.DevsyUp(ctx, tempDir, debugFlag) gomega.Expect(err).To(gomega.HaveOccurred()) gomega.Expect(err.Error()).To(gomega.ContainSubstring("devsy up failed")) @@ -143,7 +145,7 @@ var _ = ginkgo.Describe( _, _, err = f.ExecCommandCapture(ctx, []string{ cmdWorkspace, "up", - names.Flag(names.Debug), + debugFlag, names.Flag(names.IDE), "none", tempDir, }) diff --git a/e2e/tests/up/provider_docker.go b/e2e/tests/up/provider_docker.go index 3f2016e2ae..4d08d36bff 100644 --- a/e2e/tests/up/provider_docker.go +++ b/e2e/tests/up/provider_docker.go @@ -366,7 +366,11 @@ printf "PLAIN=%s\nONE_EQ=%s\nTWO_EQ=%s\nCOMMA_EQ=%s\nTRAILING_EQ=%s\nFILE_ONE_EQ ) ginkgo.It("mounts", func(ctx context.Context) { - tempDir, err := dtc.setupAndUp(ctx, "tests/up/testdata/docker-mounts", "--debug") + tempDir, err := dtc.setupAndUp( + ctx, + "tests/up/testdata/docker-mounts", + "--log-level=debug", + ) framework.ExpectNoError(err) workspace, err := dtc.f.FindWorkspace(ctx, tempDir) diff --git a/e2e/tests/up/provider_kubernetes_dockerless_path.go b/e2e/tests/up/provider_kubernetes_dockerless_path.go index 5c7a610b79..4788475d9b 100644 --- a/e2e/tests/up/provider_kubernetes_dockerless_path.go +++ b/e2e/tests/up/provider_kubernetes_dockerless_path.go @@ -123,7 +123,7 @@ func (fixture *dockerlessPathFixture) up( baseArgs := []string{ cmdWorkspace, "up", - names.Flag(names.Debug), + debugFlag, names.Flag(names.IDE), kubernetesIgnoreIDE, } diff --git a/e2e/tests/up/provider_kubernetes_ignore.go b/e2e/tests/up/provider_kubernetes_ignore.go index 404e604f0f..7eb30e4c36 100644 --- a/e2e/tests/up/provider_kubernetes_ignore.go +++ b/e2e/tests/up/provider_kubernetes_ignore.go @@ -145,7 +145,7 @@ var _ = ginkgo.Describe( []string{ "workspace", "up", - "--debug", + debugFlag, "--ide", kubernetesIgnoreIDE, workspace, diff --git a/e2e/tests/up/provider_kubernetes_ssh_agent.go b/e2e/tests/up/provider_kubernetes_ssh_agent.go index fb9101aaa9..9526745b28 100644 --- a/e2e/tests/up/provider_kubernetes_ssh_agent.go +++ b/e2e/tests/up/provider_kubernetes_ssh_agent.go @@ -101,7 +101,7 @@ var _ = ginkgo.Describe( defer cancel() // The clone override applies only to the current up invocation. baseArgs := []string{ - "workspace", "up", "--debug", "--ide", "none", + "workspace", "up", debugFlag, "--ide", "none", "--pull-from-inside-container=true", } stdout, stderr, err := f.ExecCommandCapture( diff --git a/e2e/tests/up/provider_microsandbox_dockerless.go b/e2e/tests/up/provider_microsandbox_dockerless.go index 3bfdd648a6..82e01e5e5d 100644 --- a/e2e/tests/up/provider_microsandbox_dockerless.go +++ b/e2e/tests/up/provider_microsandbox_dockerless.go @@ -326,7 +326,7 @@ func (fixture *microsandboxDockerlessFixtureState) upOutput( args := []string{ cmdWorkspace, "up", - names.Flag(names.Debug), + debugFlag, names.Flag(names.IDE), string(devsyconfig.IDENone), fixture.workspace, diff --git a/e2e/tests/up/provider_microsandbox_mounts.go b/e2e/tests/up/provider_microsandbox_mounts.go index eb90fbac2e..4dc3515941 100644 --- a/e2e/tests/up/provider_microsandbox_mounts.go +++ b/e2e/tests/up/provider_microsandbox_mounts.go @@ -342,7 +342,7 @@ func microsandboxSSHAsRootOnce( microsandboxRootUser, flagCommand, command, - names.Flag(names.Debug), + debugFlag, }) if err != nil { return "", fmt.Errorf("devsy ssh as root failed: %w (stderr: %s)", err, stderr) diff --git a/e2e/tests/up/provider_podman_rootful_features.go b/e2e/tests/up/provider_podman_rootful_features.go index 2c50609a34..93c07b6beb 100644 --- a/e2e/tests/up/provider_podman_rootful_features.go +++ b/e2e/tests/up/provider_podman_rootful_features.go @@ -35,7 +35,7 @@ var _ = ginkgo.Describe( ctx, f, workspaceSource{"tests/up/testdata/docker-mounts", initialDir}, - "--debug", + "--log-level=debug", ) framework.ExpectNoError(err) diff --git a/e2e/tests/up/provider_podman_rootless_features.go b/e2e/tests/up/provider_podman_rootless_features.go index d0e1227aa0..da784bc271 100644 --- a/e2e/tests/up/provider_podman_rootless_features.go +++ b/e2e/tests/up/provider_podman_rootless_features.go @@ -37,7 +37,7 @@ var _ = ginkgo.Describe( ctx, f, workspaceSource{"tests/up/testdata/docker-mounts", initialDir}, - "--debug", + "--log-level=debug", ) framework.ExpectNoError(err) diff --git a/e2e/tests/up/up.go b/e2e/tests/up/up.go index 161109a0f3..5f7ce66d1a 100644 --- a/e2e/tests/up/up.go +++ b/e2e/tests/up/up.go @@ -22,7 +22,7 @@ import ( const ( noStatusFlag = "--no-status" resultFormatFlag = "--result-format" - debugFlag = "--debug" + debugFlag = "--log-level=debug" eventsCommand = "events" ideNone = "none" ) diff --git a/hack/sign_commit/main_test.go b/hack/sign_commit/main_test.go index e66c718176..d5db77c094 100644 --- a/hack/sign_commit/main_test.go +++ b/hack/sign_commit/main_test.go @@ -330,8 +330,8 @@ func gitRun(t *testing.T, dir string, args ...string) { t.Helper() cmd := exec.Command("git", args...) cmd.Dir = dir - if err := cmd.Run(); err != nil { - t.Fatalf("git %v: %v", args, err) + if output, err := cmd.CombinedOutput(); err != nil { + t.Fatalf("git %v: %v\n%s", args, err, output) } } @@ -347,6 +347,7 @@ func TestChangedFilesDetectsWorkingTree(t *testing.T) { gitRun(t, dir, "init", "--quiet") gitRun(t, dir, "config", "user.email", "t@t.com") gitRun(t, dir, "config", "user.name", "test") + gitRun(t, dir, "config", "--local", "commit.gpgsign", "false") gitRun(t, dir, "checkout", "-b", testMainBranch) writeFile(t, filepath.Join(dir, "committed.txt"), "x") writeFile(t, filepath.Join(dir, "staged.txt"), "s") diff --git a/pkg/agent/agent.go b/pkg/agent/agent.go index 9b8e354d75..0b7a1f1a85 100644 --- a/pkg/agent/agent.go +++ b/pkg/agent/agent.go @@ -402,6 +402,7 @@ func rerunAsRoot(workspaceInfo *provider2.AgentWorkspaceInfo) (bool, error) { // call ourself args := []string{"--preserve-env", binary} + args = append(args, log.ForwardFlagArgs()...) args = append(args, os.Args[1:]...) log.Debugf("re-run as root: command=%s", strings.Join(args, " ")) //nolint:gosec // sudo args are built internally from fixed flags @@ -487,7 +488,7 @@ func Tunnel(ctx context.Context, opts TunnelOptions) error { return err } - command := sshServerCommand(remoteAgentPath, log.DebugEnabled()) + command := sshServerCommand(remoteAgentPath) user := opts.User if user == "" { user = "root" @@ -505,11 +506,9 @@ func Tunnel(ctx context.Context, opts TunnelOptions) error { // sshServerCommand builds the remote command that runs the ssh-server // subcommand at agentPath. -func sshServerCommand(agentPath string, debug bool) string { +func sshServerCommand(agentPath string) string { args := []string{agentPath, "internal", "ssh-server", "--stdio"} - if debug { - args = append(args, "--debug") - } + args = append(args, log.ForwardFlagArgs()...) return shellescape.QuoteCommand(args) } diff --git a/pkg/agent/agent_test.go b/pkg/agent/agent_test.go index 0df892ab7d..11b3e91296 100644 --- a/pkg/agent/agent_test.go +++ b/pkg/agent/agent_test.go @@ -6,13 +6,15 @@ import ( "path/filepath" "strings" "testing" + + "github.com/devsy-org/devsy/pkg/log" ) func TestSSHServerCommand_EscapesAgentPath(t *testing.T) { marker := filepath.Join(t.TempDir(), "pwned") malicious := "/tmp/devsy'; touch " + marker + "; echo 'still-quoted" - command := sshServerCommand(malicious, false) + command := sshServerCommand(malicious) // The built command names a nonexistent binary, so it's expected to // fail; only the absence of the marker file matters here. @@ -26,18 +28,21 @@ func TestSSHServerCommand_EscapesAgentPath(t *testing.T) { } } -func TestSSHServerCommand_AppendsDebugFlag(t *testing.T) { - command := sshServerCommand("/usr/local/bin/devsy", true) - - if !strings.HasSuffix(command, "--debug") { - t.Fatalf("expected trailing --debug flag, got: %s", command) - } -} - -func TestSSHServerCommand_OmitsDebugFlagWhenDisabled(t *testing.T) { - command := sshServerCommand("/usr/local/bin/devsy", false) - - if strings.Contains(command, "--debug") { - t.Fatalf("did not expect --debug flag, got: %s", command) +func TestSSHServerCommandForwardsEffectiveLevel(t *testing.T) { + for _, tc := range []struct { + level log.Level + want string + }{ + {log.SlogLevelWarn, "warn"}, + {log.SlogLevelInfo, "info"}, + {log.SlogLevelTrace, "trace"}, + } { + t.Run(tc.want, func(t *testing.T) { + log.InitTestObserved(t, tc.level) + command := sshServerCommand("/usr/local/bin/devsy") + if !strings.Contains(command, "--log-level "+tc.want) { + t.Fatalf("effective level missing from %q", command) + } + }) } } diff --git a/pkg/agent/delivery/exec_stream_cancellation_unix_test.go b/pkg/agent/delivery/exec_stream_cancellation_unix_test.go index cf6836fe09..36fbbba958 100644 --- a/pkg/agent/delivery/exec_stream_cancellation_unix_test.go +++ b/pkg/agent/delivery/exec_stream_cancellation_unix_test.go @@ -125,11 +125,43 @@ func cancellationDeliveryRuntime(t *testing.T, blockCompletion bool) driver.Argv return argvRuntime } +type cancellationDeliveryEvent struct { + phase string + start bool + at time.Time + err error +} + func cancellationDeliveryExecutor( t *testing.T, runtime driver.ArgvExecDriver, canceled chan<- error, ) func(context.Context, []string, driver.Streams) error { + events := make(chan cancellationDeliveryEvent, 16) + t.Cleanup(func() { + if !t.Failed() { + return + } + for { + select { + case event := <-events: + t.Logf( + "delivery phase=%s start=%t time=%s error=%v", + event.phase, event.start, event.at.Format(time.RFC3339Nano), event.err, + ) + default: + return + } + } + }) return func(ctx context.Context, argv []string, streams driver.Streams) error { + phase := "validation" + if streams.Stdin != nil { + phase = "stage" + } else if len(argv) > 2 && strings.HasPrefix(argv[2], "rm -f ") { + phase = "cleanup" + } + events <- cancellationDeliveryEvent{phase: phase, start: true, at: time.Now()} err := runtime.CommandContainerArgv(ctx, "owned-delivery-test", argv, streams) + events <- cancellationDeliveryEvent{phase: phase, at: time.Now(), err: err} if streams.Stdin != nil { if cause := context.Cause(ctx); cause != nil { select { diff --git a/pkg/agent/dockerless.go b/pkg/agent/dockerless.go index d3034e7640..412b16a047 100644 --- a/pkg/agent/dockerless.go +++ b/pkg/agent/dockerless.go @@ -268,7 +268,7 @@ func parseIgnorePaths(ignorePaths string) []string { } func runDockerlessBuild(ctx context.Context, args []string, debug bool) error { - errWriter := log.Writer(log.LevelInfo) + errWriter := log.Writer(log.SlogLevelInfo) defer func() { _ = errWriter.Close() }() var stderrBuf bytes.Buffer @@ -277,7 +277,7 @@ func runDockerlessBuild(ctx context.Context, args []string, debug bool) error { //nolint:gosec // command is built from the agent configuration by design cmd := exec.CommandContext(ctx, "/.dockerless/dockerless", args...) if debug { - debugWriter := log.Writer(log.LevelDebug) + debugWriter := log.Writer(log.SlogLevelDebug) defer func() { _ = debugWriter.Close() }() cmd.Stdout = debugWriter } diff --git a/pkg/client/client.go b/pkg/client/client.go index d216f84fef..9c86cc0bd0 100644 --- a/pkg/client/client.go +++ b/pkg/client/client.go @@ -9,6 +9,7 @@ import ( "github.com/devsy-org/api/pkg/devsy" "github.com/devsy-org/devsy/pkg/devcontainer/config" + "github.com/devsy-org/devsy/pkg/log" "github.com/devsy-org/devsy/pkg/provider" "github.com/devsy-org/devsy/pkg/status" "github.com/devsy-org/devsy/pkg/transport" @@ -184,10 +185,24 @@ type CommandTransportOptions struct { type UpOptions struct { provider.CLIOptions - Debug bool - Stdin io.Reader - Stdout io.Writer - Reporter status.Reporter + LogLevel string `json:"logLevel,omitempty"` + Stdin io.Reader `json:"-"` + Stdout io.Writer `json:"-"` + Reporter status.Reporter `json:"-"` +} + +func (o UpOptions) EffectiveLogLevel() (string, error) { + level := o.LogLevel + if level == "" { + level = log.LevelString() + } + if _, ok := log.LevelFromString(level); !ok { + return "", fmt.Errorf( + "invalid log level, expected one of: %s", + strings.Join(log.ValidLevels(), ", "), + ) + } + return level, nil } type SshOptions struct { diff --git a/pkg/client/clientimplementation/daemonclient/up.go b/pkg/client/clientimplementation/daemonclient/up.go index a1dfbc6122..d7f18a4e9e 100644 --- a/pkg/client/clientimplementation/daemonclient/up.go +++ b/pkg/client/clientimplementation/daemonclient/up.go @@ -28,6 +28,11 @@ import ( ) func (c *client) Up(ctx context.Context, opt clientpkg.UpOptions) (*config.Result, error) { + level, err := opt.EffectiveLogLevel() + if err != nil { + return nil, err + } + opt.LogLevel = level baseClient, err := c.initPlatformClient(ctx) if err != nil { return nil, err @@ -125,8 +130,10 @@ func startUpTask( instance *managementv1.DevsyWorkspaceInstance, opt clientpkg.UpOptions, ) (kube.Interface, string, error) { - // encode options - rawOptions, _ := json.Marshal(opt) + rawOptions, err := json.Marshal(opt) + if err != nil { + return nil, "", fmt.Errorf("encode up options: %w", err) + } managementClient, err := baseClient.Management() if err != nil { return nil, "", fmt.Errorf("error getting management client: %w", err) @@ -201,7 +208,6 @@ func createUpTask(ctx context.Context, params createUpTaskParams) (string, error DevsyWorkspaceInstances(params.instance.Namespace). Up(ctx, params.instance.Name, &managementv1.DevsyWorkspaceInstanceUp{ Spec: managementv1.DevsyWorkspaceInstanceUpSpec{ - Debug: params.opt.Debug, Options: params.rawOptions, }, }, metav1.CreateOptions{}) @@ -420,15 +426,19 @@ func newLogScanner(r io.Reader) *bufio.Scanner { // task logs, plus the status-sniffing writer wrapped around stdout. type logOutputStreams struct { stdoutStreamer io.WriteCloser - stdoutDone chan struct{} stderrStreamer io.WriteCloser - stderrDone chan struct{} statusWriter *statusSniffingWriter } func newLogOutputStreams(reporter status.Reporter) *logOutputStreams { - stdoutStreamer, stdoutDone := log.PipeJSONStream() - stderrStreamer, stderrDone := log.PipeJSONStream() + stdoutStreamer := log.NewJSONLogStreamer(log.StreamerOptions{ + FallbackLevel: log.SlogLevelInfo, + DetectLevelPrefixes: true, + }) + stderrStreamer := log.NewJSONLogStreamer(log.StreamerOptions{ + FallbackLevel: log.SlogLevelWarn, + DetectLevelPrefixes: true, + }) // The remote task runs the same devsy CLI, so its stdout carries the // same NDJSON status lines a local `up` does; sniff them out here. @@ -436,9 +446,7 @@ func newLogOutputStreams(reporter status.Reporter) *logOutputStreams { return &logOutputStreams{ stdoutStreamer: stdoutStreamer, - stdoutDone: stdoutDone, stderrStreamer: stderrStreamer, - stderrDone: stderrDone, statusWriter: statusWriter, } } @@ -447,8 +455,6 @@ func (s *logOutputStreams) Close() { _ = s.statusWriter.Close() _ = s.stdoutStreamer.Close() _ = s.stderrStreamer.Close() - <-s.stdoutDone - <-s.stderrDone } func (s *logOutputStreams) stdout() io.Writer { diff --git a/pkg/client/clientimplementation/machine_client.go b/pkg/client/clientimplementation/machine_client.go index f565b7a5ef..edbae9fdee 100644 --- a/pkg/client/clientimplementation/machine_client.go +++ b/pkg/client/clientimplementation/machine_client.go @@ -3,16 +3,21 @@ package clientimplementation import ( "bytes" "context" + "errors" "fmt" "io" + "log/slog" "strings" "time" "github.com/devsy-org/devsy/pkg/client" + "github.com/devsy-org/devsy/pkg/clierr" "github.com/devsy-org/devsy/pkg/config" "github.com/devsy-org/devsy/pkg/log" "github.com/devsy-org/devsy/pkg/options" "github.com/devsy-org/devsy/pkg/provider" + "github.com/devsy-org/devsy/pkg/status" + "github.com/devsy-org/devsy/pkg/telemetry" "github.com/devsy-org/devsy/pkg/transport" "github.com/devsy-org/devsy/pkg/types" ) @@ -63,12 +68,31 @@ type execConfig struct { stdin io.Reader closeInputOnExit io.Closer rawStdout bool + diagnostic bool withProgress bool startMsg string doneMsg string } -func (e *machineExecutor) execute(ctx context.Context, cfg execConfig) error { +func (e *machineExecutor) execute(ctx context.Context, cfg execConfig) (err error) { + started := time.Now() + defer func() { + code := "" + if err != nil { + code = string(clierr.Classify(err).Code) + } + telemetry.RecordProviderOperation(ctx, telemetry.ProviderOperation{ + ProviderType: telemetry.ProviderTypeMachineBinary, + Operation: cfg.name, + Duration: time.Since(started), + ErrorCode: code, + }) + }() + var streamer *log.JSONLogStreamer + if cfg.diagnostic { + streamer = machineDiagnosticStreamer(e.client, cfg.name) + cfg.stderr = streamer + } var done chan struct{} if cfg.withProgress { done = scheduleLogMessage("Devsy " + cfg.name + " operation is in progress") @@ -76,10 +100,14 @@ func (e *machineExecutor) execute(ctx context.Context, cfg execConfig) error { } if cfg.startMsg != "" { - log.Infof(cfg.startMsg) + log.InfoContext(ctx, "Machine operation started", + log.AttrProvider(e.client.config.Name), + log.AttrMachineID(e.client.machine.ID), + log.AttrOperation(cfg.name), + slog.String("description", cfg.startMsg)) } - err := RunCommandWithBinaries(ctx, WorkspaceCommandConfig{ + err = RunCommandWithBinaries(ctx, WorkspaceCommandConfig{ Command: cfg.command, WorkspaceContextName: e.client.machine.Context, Machine: e.client.machine, @@ -92,17 +120,47 @@ func (e *machineExecutor) execute(ctx context.Context, cfg execConfig) error { closeInputOnExit: cfg.closeInputOnExit, RawStdout: cfg.rawStdout, }) + err = finishMachineDiagnostics(streamer, err) if err != nil { return err } if cfg.doneMsg != "" { - log.Infof(cfg.doneMsg) + log.InfoContext(ctx, "Machine operation completed", + log.AttrProvider(e.client.config.Name), + log.AttrMachineID(e.client.machine.ID), + log.AttrOperation(cfg.name), + slog.String("description", cfg.doneMsg)) } return nil } +func machineDiagnosticStreamer(client *machineClient, name string) *log.JSONLogStreamer { + return log.NewJSONLogStreamer(log.StreamerOptions{ + FallbackLevel: log.SlogLevelInfo, + CaptureLines: 50, + CaptureBytes: 32 * 1024, + DefaultAttrs: []slog.Attr{ + log.AttrProvider(client.config.Name), + log.AttrMachineID(client.machine.ID), + log.AttrOperation(name), + }, + }) +} + +func finishMachineDiagnostics(streamer *log.JSONLogStreamer, err error) error { + if streamer == nil { + return err + } + _ = streamer.Close() + if err != nil && !errors.Is(err, context.Canceled) && + !errors.Is(err, context.DeadlineExceeded) { + return clierr.ProviderFailure(err, streamer.ErrorOutput(), clierr.CodeUnknown) + } + return err +} + // lifecycleCommand executes a standard lifecycle operation (create/start/stop). // lifecycleStep is one lifecycle command of a machine and its progress wording. type lifecycleStep struct { @@ -115,14 +173,14 @@ type lifecycleStep struct { func (e *machineExecutor) lifecycleCommand(ctx context.Context, step lifecycleStep) error { name, command := step.name, step.command verb, pastVerb := step.verb, step.pastVerb - writer := log.Writer(log.LevelInfo) + writer := log.Writer(log.SlogLevelInfo) defer func() { _ = writer.Close() }() return e.execute(ctx, execConfig{ name: name, command: command, stdout: writer, - stderr: writer, + diagnostic: true, withProgress: true, startMsg: verb + " machine", doneMsg: pastVerb + " machine", @@ -187,37 +245,43 @@ func (s *machineClient) Context() string { } func (s *machineClient) Create(ctx context.Context) error { - return s.executor.lifecycleCommand( + return status.RunStep( ctx, - lifecycleStep{ - name: "create", - command: s.config.Exec.Create, - verb: "creating", - pastVerb: "created", + status.PhaseMachineCreate, + "create machine", + func(ctx context.Context) error { + return s.executor.lifecycleCommand(ctx, lifecycleStep{ + name: "create", + command: s.config.Exec.Create, + verb: "creating", + pastVerb: "created", + }) }, ) } func (s *machineClient) Start(ctx context.Context) error { - return s.executor.lifecycleCommand( + return status.RunStep( ctx, - lifecycleStep{ - name: "start", - command: s.config.Exec.Start, - verb: "starting", - pastVerb: "started", + status.PhaseMachineStart, + "start machine", + func(ctx context.Context) error { + return s.executor.lifecycleCommand(ctx, lifecycleStep{ + name: "start", command: s.config.Exec.Start, verb: "starting", pastVerb: "started", + }) }, ) } func (s *machineClient) Stop(ctx context.Context, options client.StopOptions) error { - return s.executor.lifecycleCommand( + return status.RunStep( ctx, - lifecycleStep{ - name: "stop", - command: s.config.Exec.Stop, - verb: "stopping", - pastVerb: "stopped", + status.PhaseMachineStop, + "stop machine", + func(ctx context.Context) error { + return s.executor.lifecycleCommand(ctx, lifecycleStep{ + name: "stop", command: s.config.Exec.Stop, verb: "stopping", pastVerb: "stopped", + }) }, ) } @@ -267,53 +331,57 @@ func (s *machineClient) Status( ctx context.Context, options client.StatusOptions, ) (client.Status, error) { - stdout := &bytes.Buffer{} - stderr := &bytes.Buffer{} - - err := s.executor.execute(ctx, execConfig{ - name: "status", - command: s.config.Exec.Status, - stdout: stdout, - stderr: io.MultiWriter(stderr, log.Writer(log.LevelInfo)), - }) - if err != nil { - return client.StatusNotFound, fmt.Errorf( - "get status: %s%s", - strings.TrimSpace(stdout.String()), - strings.TrimSpace(stderr.String()), - ) - } - - parsedStatus, err := client.ParseStatus(stdout.String()) - if err != nil { - return client.StatusNotFound, err - } - - return parsedStatus, nil + result := client.Status(client.StatusNotFound) + err := status.RunStep( + ctx, + status.PhaseMachineStatus, + "get machine status", + func(ctx context.Context) error { + stdout := &bytes.Buffer{} + if err := s.executor.execute(ctx, execConfig{ + name: "status", + command: s.config.Exec.Status, + stdout: stdout, + diagnostic: true, + }); err != nil { + return fmt.Errorf("get status: %w", err) + } + var err error + result, err = client.ParseStatus(stdout.String()) + return err + }, + ) + return result, err } func (s *machineClient) Describe(ctx context.Context) (string, error) { stdout := &bytes.Buffer{} - stderr := &bytes.Buffer{} err := s.executor.execute(ctx, execConfig{ - name: "describe", - command: s.config.Exec.Describe, - stdout: stdout, - stderr: io.MultiWriter(stderr, log.Writer(log.LevelInfo)), + name: "describe", + command: s.config.Exec.Describe, + stdout: stdout, + diagnostic: true, }) if err != nil { - return client.DescriptionNotFound, fmt.Errorf( - "describe: %s%s", - strings.TrimSpace(stdout.String()), - strings.TrimSpace(stderr.String()), - ) + return client.DescriptionNotFound, fmt.Errorf("describe: %w", err) } return strings.TrimSpace(stdout.String()), nil } func (s *machineClient) Delete(ctx context.Context, options client.DeleteOptions) error { + return status.RunStep( + ctx, + status.PhaseMachineDelete, + "delete machine", + func(ctx context.Context) error { + return s.delete(ctx, options) + }, + ) +} + +func (s *machineClient) delete(ctx context.Context, options client.DeleteOptions) error { if options.GracePeriod != "" { if duration, err := time.ParseDuration(options.GracePeriod); err == nil { var cancel context.CancelFunc @@ -322,14 +390,14 @@ func (s *machineClient) Delete(ctx context.Context, options client.DeleteOptions } } - writer := log.Writer(log.LevelInfo) + writer := log.Writer(log.SlogLevelInfo) defer func() { _ = writer.Close() }() err := s.executor.execute(ctx, execConfig{ name: "delete", command: s.config.Exec.Delete, stdout: writer, - stderr: writer, + diagnostic: true, withProgress: true, startMsg: "deleting machine", doneMsg: "deleted machine", diff --git a/pkg/client/clientimplementation/machine_logging_test.go b/pkg/client/clientimplementation/machine_logging_test.go new file mode 100644 index 0000000000..0cac3e4e9e --- /dev/null +++ b/pkg/client/clientimplementation/machine_logging_test.go @@ -0,0 +1,86 @@ +package clientimplementation + +import ( + "context" + "errors" + "log/slog" + "os/exec" + "runtime" + "testing" + + "github.com/devsy-org/devsy/pkg/client" + "github.com/devsy-org/devsy/pkg/clierr" + "github.com/devsy-org/devsy/pkg/config" + "github.com/devsy-org/devsy/pkg/log" + "github.com/devsy-org/devsy/pkg/provider" + "github.com/devsy-org/devsy/pkg/status" + "github.com/devsy-org/devsy/pkg/telemetry" + "github.com/devsy-org/devsy/pkg/types" + "github.com/stretchr/testify/require" +) + +const testShellExitSuccess = "exit 0" + +func machineLoggingClient(t *testing.T, command string) client.MachineClient { + t.Helper() + if runtime.GOOS == "windows" { + t.Skip("requires a POSIX shell") + } + cfg := &provider.ProviderConfig{ + Name: testCancelProvider, + Exec: provider.ProviderCommands{ + Create: types.StrArray{"/bin/sh", "-c", testShellExitSuccess}, + Status: types.StrArray{"/bin/sh", "-c", command}, + }, + } + devsy := &config.Config{ + DefaultContext: testLocksContext, + Contexts: map[string]*config.ContextConfig{testLocksContext: {}}, + } + machine, err := NewMachineClient( + devsy, + cfg, + &provider.Machine{ID: "machine-canary", Context: testLocksContext}, + ) + require.NoError(t, err) + return machine +} + +func TestMachineStatusPreservesProtocolAndRecordsMetrics(t *testing.T) { + observed := log.InitTestObserved(t, log.SlogLevelInfo) + machine := machineLoggingClient( + t, + `printf 'Running'; printf '%s\n' '{"level":"info","msg":"diagnostic canary","custom":"value"}' >&2`, + ) + reporter := status.NewMemoryReporter() + metrics := telemetry.NewMetricsReporter() + ctx := telemetry.WithMetrics(status.WithReporter(context.Background(), reporter), metrics) + result, err := machine.Status(ctx, client.StatusOptions{}) + require.NoError(t, err) + require.Equal(t, client.Status(client.StatusRunning), result) + require.NotEmpty(t, observed.FilterMessage("diagnostic canary").All()) + require.Equal(t, status.PhaseMachineStatus, reporter.Events()[0].Phase) + snapshot := metrics.Finish(nil) + require.NotEmpty(t, snapshot.ProviderOperations) + require.Equal(t, "status", snapshot.ProviderOperations[0].Operation) +} + +func TestMachineStatusRedactsDiagnosticAndPreservesExit(t *testing.T) { + t.Setenv("MACHINE_TEST_TOKEN", "private-machine-secret") + observed := log.InitTestObserved(t, log.SlogLevelInfo) + machine := machineLoggingClient( + t, + `printf '%s\n' '{"level":"error","msg":"private-machine-secret",`+ + `"error_code":"aws_quota_exceeded"}' >&2; exit 7`, + ) + _, err := machine.Status(context.Background(), client.StatusOptions{}) + require.Error(t, err) + require.NotContains(t, err.Error(), "private-machine-secret") + var exit *exec.ExitError + require.True(t, errors.As(err, &exit)) + require.Equal(t, 7, exit.ExitCode()) + require.Equal(t, clierr.CodeUnknown, clierr.Classify(err).Code) + entries := observed.FilterAttr(slog.String("error_code", "aws_quota_exceeded")).All() + require.Len(t, entries, 1) + require.NotContains(t, entries[0].Message, "private-machine-secret") +} diff --git a/pkg/client/clientimplementation/proxy_client.go b/pkg/client/clientimplementation/proxy_client.go index c696250b36..34fe6e317a 100644 --- a/pkg/client/clientimplementation/proxy_client.go +++ b/pkg/client/clientimplementation/proxy_client.go @@ -4,8 +4,10 @@ import ( "bytes" "context" "encoding/json" + "errors" "fmt" "io" + "log/slog" "os" "strings" "sync" @@ -14,12 +16,15 @@ import ( "github.com/blang/semver/v4" "github.com/devsy-org/api/pkg/devsy" "github.com/devsy-org/devsy/pkg/client" + "github.com/devsy-org/devsy/pkg/clierr" "github.com/devsy-org/devsy/pkg/config" "github.com/devsy-org/devsy/pkg/log" "github.com/devsy-org/devsy/pkg/options" "github.com/devsy-org/devsy/pkg/options/resolver" platformclient "github.com/devsy-org/devsy/pkg/platform/client" "github.com/devsy-org/devsy/pkg/provider" + "github.com/devsy-org/devsy/pkg/secrets" + "github.com/devsy-org/devsy/pkg/telemetry" "github.com/devsy-org/devsy/pkg/terminal" "github.com/devsy-org/devsy/pkg/transport" "github.com/devsy-org/devsy/pkg/types" @@ -57,6 +62,7 @@ type proxyExecutor struct { } type execParams struct { + operation string command types.StrArray extraEnv map[string]string stdin io.Reader @@ -68,7 +74,11 @@ type execParams struct { // execute runs a proxy command with common settings. func (e *proxyExecutor) execute(ctx context.Context, params execParams) error { - return RunCommandWithBinaries(ctx, WorkspaceCommandConfig{ + var started time.Time + if telemetry.MetricsFromContext(ctx) != nil { + started = time.Now() + } + err := RunCommandWithBinaries(ctx, WorkspaceCommandConfig{ Command: params.command, WorkspaceContextName: e.client.workspace.Context, Workspace: e.client.workspace, @@ -81,17 +91,26 @@ func (e *proxyExecutor) execute(ctx context.Context, params execParams) error { Stderr: params.stderr, RawStdout: params.rawStdout, }) + if !started.IsZero() { + code := "" + if err != nil { + code = string(clierr.Classify(err).Code) + } + telemetry.RecordProviderOperation(ctx, telemetry.ProviderOperation{ + ProviderType: telemetry.ProviderTypeScriptProxy, + Operation: params.operation, + Duration: time.Since(started), + ErrorCode: code, + }) + } + return err } -// executeWithJSONLog runs a command with JSON log streaming. After the -// sub-process exits we close the pipe and block on the scanner goroutine -// so every buffered log line is forwarded through zap before the caller -// can observe completion. Without this drain, callers that propagate the -// error and exit (e.g. cmd/root.go calls os.Exit on failure) race the -// goroutine and can lose the tail of the sub-process stderr - which is -// where the actionable error message usually lives. func (e *proxyExecutor) executeWithJSONLog(ctx context.Context, params execParams) error { - writer, done := log.PipeJSONStream() + writer := log.NewJSONLogStreamer(log.StreamerOptions{ + FallbackLevel: log.SlogLevelWarn, + DetectLevelPrefixes: true, + }) if params.stderr == nil { params.stderr = writer } else { @@ -99,7 +118,6 @@ func (e *proxyExecutor) executeWithJSONLog(ctx context.Context, params execParam } err := e.execute(ctx, params) _ = writer.Close() - <-done return err } @@ -194,10 +212,11 @@ func (s *proxyClient) Create( stderr io.Writer, ) error { err := s.executor.execute(ctx, execParams{ - command: s.config.Exec.Proxy.Create.Workspace, - stdin: stdin, - stdout: stdout, - stderr: stderr, + operation: "create", + command: s.config.Exec.Proxy.Create.Workspace, + stdin: stdin, + stdout: stdout, + stderr: stderr, }) if err != nil { return fmt.Errorf("create remote workspace : %w", err) @@ -207,6 +226,7 @@ func (s *proxyClient) Create( func (s *proxyClient) Ssh(ctx context.Context, opt client.SshOptions) error { return s.executor.executeWithJSONLog(ctx, execParams{ + operation: "command", command: s.config.Exec.Proxy.Ssh, extraEnv: EncodeOptions(opt, config.EnvFlagsSSH), stdin: opt.Stdin, @@ -223,7 +243,8 @@ func (s *proxyClient) OpenSSHTransport( ctx, func(ctx context.Context, stdin io.Reader, stdout io.Writer) error { return s.executor.executeWithJSONLog(ctx, execParams{ - command: s.config.Exec.Proxy.Ssh, + operation: "command", + command: s.config.Exec.Proxy.Ssh, extraEnv: EncodeOptions( client.SshOptions{User: opt.User}, config.EnvFlagsSSH, @@ -246,16 +267,20 @@ func (s *proxyClient) Stop(ctx context.Context, opt client.StopOptions) error { defer s.m.Unlock() return s.executor.executeWithJSONLog(ctx, execParams{ - command: s.config.Exec.Proxy.Stop, - stdout: io.Discard, + operation: "stop", + command: s.config.Exec.Proxy.Stop, + stdout: io.Discard, }) } func (s *proxyClient) Up(ctx context.Context, opt client.UpOptions) error { - opts := EncodeOptions(opt.CLIOptions, config.EnvFlagsUp) - if opt.Debug { - opts["DEBUG"] = "true" + level, err := opt.EffectiveLogLevel() + if err != nil { + return err } + opts := EncodeOptions(opt.CLIOptions, config.EnvFlagsUp) + opts[config.EnvLogLevel] = level + opts["DEVSY_LOG_FORMAT"] = "json" providerOptions := s.devsyConfig.ProviderOptions(s.config.Name) if err := s.checkPlatformVersion(ctx, providerOptions); err != nil { @@ -263,6 +288,7 @@ func (s *proxyClient) Up(ctx context.Context, opt client.UpOptions) error { } return s.executor.executeWithJSONLog(ctx, execParams{ + operation: "start", command: s.config.Exec.Proxy.Up, extraEnv: opts, stdin: opt.Stdin, @@ -284,9 +310,10 @@ func (s *proxyClient) Delete(ctx context.Context, opt client.DeleteOptions) erro } err := s.executor.executeWithJSONLog(ctx, execParams{ - command: s.config.Exec.Proxy.Delete, - extraEnv: EncodeOptions(opt, config.EnvFlagsDelete), - stdout: io.Discard, + operation: "delete", + command: s.config.Exec.Proxy.Delete, + extraEnv: EncodeOptions(opt, config.EnvFlagsDelete), + stdout: io.Discard, }) if err != nil && !opt.Force { return fmt.Errorf("error deleting workspace: %w", err) @@ -311,40 +338,81 @@ func (s *proxyClient) Status( defer s.m.Unlock() stdout := &bytes.Buffer{} - buf := &bytes.Buffer{} - err := RunCommandWithBinaries(ctx, WorkspaceCommandConfig{ - Command: s.config.Exec.Proxy.Status, - WorkspaceContextName: s.workspace.Context, - Workspace: s.workspace, - Machine: nil, - Options: s.devsyConfig.ProviderOptions(s.config.Name), - Config: s.config, - ExtraEnv: EncodeOptions(options, config.EnvFlagsStatus), - Stdin: nil, - Stdout: io.MultiWriter(stdout, buf), - Stderr: buf, + providerOptions := s.devsyConfig.ProviderOptions(s.config.Name) + resolvedOptions := provider.CombineOptions(s.workspace, nil, providerOptions) + extraEnv := EncodeOptions(options, config.EnvFlagsStatus) + environment := provider.ToEnvironment(s.workspace, nil, providerOptions, extraEnv) + var protected []string + for _, definitions := range []config.OptionDefinitions{ + s.config.Options, + s.devsyConfig.DynamicProviderOptionDefinitions(s.config.Name), + } { + for name, definition := range definitions { + if definition != nil && (definition.Password || definition.Hidden) { + if value, ok := resolvedOptions[name]; ok { + protected = append(protected, name+"="+value.Value) + } + } + } + } + stderr := log.NewJSONLogStreamer(log.StreamerOptions{ + Redactor: secrets.Combine( + secrets.NewEnvironmentRedactor(environment), + secrets.NewRedactor(protected), + ), + FallbackLevel: log.SlogLevelError, + DetectLevelPrefixes: true, + CaptureLines: 50, + CaptureBytes: 32 * 1024, + DefaultAttrs: []slog.Attr{log.AttrProvider(s.config.Name)}, }) + defer func() { _ = stderr.Close() }() + err := s.executor.execute(ctx, execParams{ + operation: "status", + command: s.config.Exec.Proxy.Status, + extraEnv: extraEnv, + stdout: stdout, + stderr: stderr, + rawStdout: true, + }) + _ = stderr.Close() if err != nil { - return client.StatusNotFound, fmt.Errorf( - "error retrieving container status: %s%w", - buf.String(), - err, - ) + cause := fmt.Errorf("error retrieving container status: %w", err) + if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) { + return client.StatusNotFound, cause + } + message := "error retrieving container status" + if tail := stderr.ErrorOutput(); tail != "" { + message += ": " + tail + } + code := clierr.CodeUnknown + var classified *clierr.CLIError + if errors.As(err, &classified) && classified != nil { + code = classified.Code + } + return client.StatusNotFound, clierr.ProviderFailure(cause, message, code) } - log.ReadJSONStream(bytes.NewReader(buf.Bytes())) status := &client.WorkspaceStatus{} - err = json.Unmarshal(stdout.Bytes(), status) + if err := json.Unmarshal(stdout.Bytes(), status); err != nil { + cause := fmt.Errorf("error parsing proxy command response: %w", err) + if tail := stderr.ErrorOutput(); tail != "" { + return client.StatusNotFound, clierr.WithContext( + cause, + map[string]string{"stderr": tail}, + ) + } + return client.StatusNotFound, cause + } + parsed, err := client.ParseStatus(status.State) if err != nil { - return client.StatusNotFound, fmt.Errorf( - "error parsing proxy command response: %s%w", - stdout.String(), + return client.StatusNotFound, clierr.ProviderFailure( err, + "unrecognized proxy status", + clierr.CodeUnknown, ) } - - // parse status - return client.ParseStatus(status.State) + return parsed, nil } func (s *proxyClient) lockIDs() (string, string, string) { @@ -395,10 +463,11 @@ func (s *proxyClient) updateInstance(ctx context.Context) error { } return s.executor.execute(ctx, execParams{ - command: s.config.Exec.Proxy.Update.Workspace, - stdin: os.Stdin, - stdout: os.Stdout, - stderr: os.Stderr, + operation: "other", + command: s.config.Exec.Proxy.Update.Workspace, + stdin: os.Stdin, + stdout: os.Stdout, + stderr: os.Stderr, }) } diff --git a/pkg/client/clientimplementation/proxy_status_test.go b/pkg/client/clientimplementation/proxy_status_test.go new file mode 100644 index 0000000000..219a8de3fd --- /dev/null +++ b/pkg/client/clientimplementation/proxy_status_test.go @@ -0,0 +1,110 @@ +package clientimplementation + +import ( + "context" + "encoding/json" + "errors" + "os/exec" + "testing" + + "github.com/devsy-org/devsy/pkg/client" + "github.com/devsy-org/devsy/pkg/clierr" + "github.com/devsy-org/devsy/pkg/config" + "github.com/devsy-org/devsy/pkg/log" + "github.com/devsy-org/devsy/pkg/provider" + "github.com/devsy-org/devsy/pkg/types" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func proxyStatusFixture(t *testing.T, script string) *proxyClient { + t.Helper() + requirePOSIXShell(t) + config.ResetPathManager() + t.Cleanup(config.ResetPathManager) + t.Setenv(config.EnvHome, t.TempDir()) + t.Setenv("EXTERNAL_TOKEN", "status-host-secret-78231") + t.Setenv("STATE_TOKEN", "RUNNING") + const contextName = "default" + p := &proxyClient{ + devsyConfig: &config.Config{ + DefaultContext: contextName, + Contexts: map[string]*config.ContextConfig{ + contextName: {Providers: map[string]*config.ProviderConfig{ + "configured-alias": {Options: map[string]config.OptionValue{ + "OPAQUE": {Value: "status-option-secret-78232"}, + }}, + }}, + }, + }, + config: &provider.ProviderConfig{ + Name: "configured-alias", + Options: map[string]*types.Option{"OPAQUE": {Password: true}}, + Exec: provider.ProviderCommands{Proxy: &provider.ProxyCommands{ + Status: types.StrArray{binSh, "-c", script}, + }}, + }, + workspace: &provider.Workspace{ID: testProxyWorkspaceID, Context: contextName}, + } + p.executor = &proxyExecutor{client: p} + return p +} + +func TestProxyStatusSeparatesProtocolFromRedactedDiagnostics(t *testing.T) { + observed := log.InitTestObserved(t, log.SlogLevelInfo) + p := proxyStatusFixture( + t, + `printf '%s' '{"state":"RUNNING","level":"error","msg":"stdout-only-canary"}'; `+ + `printf '{"level":"info","msg":"stderr-canary %s %s","phase":"readiness"}' `+ + `"$OPAQUE" "$EXTERNAL_TOKEN" >&2`, + ) + got, err := p.Status(context.Background(), client.StatusOptions{}) + require.NoError(t, err) + require.Equal(t, client.Status(client.StatusRunning), got) + require.Zero(t, observed.FilterMessageSnippet("stdout-only-canary").Len()) + entries := observed.FilterMessageSnippet("stderr-canary").All() + require.Len(t, entries, 1) + assert.NotContains(t, entries[0].Message, "status-host-secret-78231") + assert.NotContains(t, entries[0].Message, "status-option-secret-78232") + assert.Contains(t, entries[0].Message, "***") + assert.Equal(t, "configured-alias", entries[0].AttrsMap()["provider"]) + assert.Equal(t, "readiness", entries[0].AttrsMap()["phase"]) +} + +func TestProxyStatusFailureRetainsOnlyRedactedStderrAndCause(t *testing.T) { + p := proxyStatusFixture( + t, + `printf 'stdout-private-canary'; printf 'stderr-canary %s %s' "$OPAQUE" "$EXTERNAL_TOKEN" >&2; exit 23`, + ) + _, err := p.Status(context.Background(), client.StatusOptions{}) + require.Error(t, err) + var exitErr *exec.ExitError + require.True(t, errors.As(err, &exitErr)) + assert.Equal(t, 23, exitErr.ExitCode()) + classified := clierr.Classify(err) + assert.Equal(t, clierr.CodeUnknown, classified.Code) + assert.Contains(t, classified.Message, "stderr-canary") + assert.Contains(t, classified.Message, "***") + assert.NotContains(t, classified.Message, "stdout-private-canary") + assert.NotContains(t, classified.Message, "status-host-secret-78231") + assert.NotContains(t, classified.Message, "status-option-secret-78232") +} + +func TestProxyStatusDecodeErrorDoesNotEchoProtocol(t *testing.T) { + p := proxyStatusFixture(t, `printf 'stdout-private-canary'; printf 'stderr-canary' >&2`) + _, err := p.Status(context.Background(), client.StatusOptions{}) + require.Error(t, err) + var syntaxErr *json.SyntaxError + require.True(t, errors.As(err, &syntaxErr)) + assert.NotContains(t, err.Error(), "stdout-private-canary") + assert.Contains(t, clierr.Classify(err).Context["stderr"], "stderr-canary") +} + +func TestProxyStatusCancellationKeepsCause(t *testing.T) { + p := proxyStatusFixture(t, testShellExitSuccess) + ctx, cancel := context.WithCancel(context.Background()) + cancel() + _, err := p.Status(ctx, client.StatusOptions{}) + require.ErrorIs(t, err, context.Canceled) + assert.Equal(t, clierr.CodeCanceled, clierr.Classify(err).Code) +} diff --git a/pkg/client/clientimplementation/workspace_client.go b/pkg/client/clientimplementation/workspace_client.go index 643e6bae7c..2d17191a19 100644 --- a/pkg/client/clientimplementation/workspace_client.go +++ b/pkg/client/clientimplementation/workspace_client.go @@ -7,6 +7,7 @@ import ( "errors" "fmt" "io" + "log/slog" "net" "os" "os/exec" @@ -76,6 +77,18 @@ func (s *workspaceClient) Provider() string { return s.providerConfig.Name } +func (s *workspaceClient) TelemetryProviderKind() string { + if s.providerConfig == nil || !s.providerConfig.Source.Internal { + return "custom" + } + switch s.providerConfig.Source.Raw { + case "apple", "docker", "kubernetes", "microsandbox", "podman", "pro": + return s.providerConfig.Source.Raw + default: + return "custom" + } +} + func (s *workspaceClient) Context() string { return s.providerWorkspace.Context } @@ -578,11 +591,11 @@ func (s *workspaceClient) deleteContainer(ctx context.Context, opt client.Delete return nil } - writer, done := log.PipeJSONStream() - defer func() { - _ = writer.Close() - <-done - }() + writer := log.NewJSONLogStreamer(log.StreamerOptions{ + FallbackLevel: log.SlogLevelInfo, + DetectLevelPrefixes: true, + }) + defer func() { _ = writer.Close() }() log.Debug("deleting workspace container") command, err := s.agentWorkspaceCommand("delete") @@ -619,11 +632,11 @@ func (s *workspaceClient) deleteMachine(ctx context.Context, opt client.DeleteOp } func (s *workspaceClient) stopContainer(ctx context.Context) error { - writer, done := log.PipeJSONStream() - defer func() { - _ = writer.Close() - <-done - }() + writer := log.NewJSONLogStreamer(log.StreamerOptions{ + FallbackLevel: log.SlogLevelInfo, + DetectLevelPrefixes: true, + }) + defer func() { _ = writer.Close() }() log.Debug("stopping container") command, err := s.agentWorkspaceCommand("stop") @@ -739,12 +752,14 @@ func (s *workspaceClient) agentWorkspaceCommand(subcommand string) (string, erro return "", fmt.Errorf("agent info: %w", err) } - return fmt.Sprintf( - "%s internal agent workspace %s --workspace-info %s", - shellescape.Quote(info.Agent.Path), - subcommand, - shellescape.Quote(compressed), - ), nil + var command strings.Builder + _, _ = fmt.Fprintf(&command, "%s internal agent workspace %s --workspace-info %s", + shellescape.Quote(info.Agent.Path), subcommand, shellescape.Quote(compressed)) + for _, arg := range log.ForwardFlagArgs() { + command.WriteByte(' ') + command.WriteString(shellescape.Quote(arg)) + } + return command.String(), nil } func (s *workspaceClient) runProviderCommand( @@ -865,9 +880,27 @@ func runCommandExecution(ctx context.Context, opts RunCommandOptions) (retErr er if len(opts.Command) == 0 { return nil } - - if log.DebugEnabled() { - opts.Environ = append(opts.Environ, config.EnvDebug+"="+config.BoolTrue) + if opts.Environ == nil { + opts.Environ = os.Environ() + } + var hasLevel, hasFormat bool + for _, entry := range opts.Environ { + key, _, ok := strings.Cut(entry, "=") + if !ok { + continue + } + switch key { + case config.EnvLogLevel: + hasLevel = true + case "DEVSY_LOG_FORMAT": + hasFormat = true + } + } + if !hasLevel { + opts.Environ = append(opts.Environ, config.EnvLogLevel+"="+log.LevelString()) + } + if !hasFormat { + opts.Environ = append(opts.Environ, "DEVSY_LOG_FORMAT=json") } redactor := secrets.NewEnvironmentRedactor(opts.Environ) @@ -1342,18 +1375,25 @@ func runProviderArgvCommand( cmd.Stdout = stdout cmd.Stderr = stderr cmd.Env = opts.Environ - if opts.Cancellation == provider.ProviderCancellationFile { + var err error + if opts.Cancellation == provider.ProviderCancellationFile && opts.closeInputOnExit != nil { cmd.WaitDelay = 2 * time.Second - if opts.closeInputOnExit != nil { - return runProviderArgvWithOwnedInput( - cmd, opts.Stdin, opts.closeInputOnExit, providerAction(opts.Environ), - ) + err = runProviderArgvWithOwnedInput( + cmd, opts.Stdin, opts.closeInputOnExit, providerAction(opts.Environ), + ) + } else { + if opts.Cancellation == provider.ProviderCancellationFile { + cmd.WaitDelay = 2 * time.Second + } + err = cmd.Run() + if err != nil { + err = fmt.Errorf("run provider %s: %w", providerAction(opts.Environ), err) } } - if err := cmd.Run(); err != nil { - return fmt.Errorf("run provider %s: %w", providerAction(opts.Environ), err) + if err != nil && ctx.Err() != nil { + return errors.Join(err, ctx.Err()) } - return nil + return err } func runProviderArgvWithOwnedInput( @@ -1662,16 +1702,21 @@ func buildAgentCommand( workspaceClient client.WorkspaceClient, agentCommand, workspaceInfo string, ) string { - command := fmt.Sprintf( + var command strings.Builder + _, _ = fmt.Fprintf( + &command, "%s internal agent workspace %s --workspace-info %s", - shellescape.Quote(workspaceClient.AgentPath()), + shellescape.Quote( + workspaceClient.AgentPath(), + ), agentCommand, shellescape.Quote(workspaceInfo), ) - if log.DebugEnabled() { - command += " --debug" + for _, arg := range log.ForwardFlagArgs() { + command.WriteByte(' ') + command.WriteString(shellescape.Quote(arg)) } - return command + return command.String() } type processIOPipes struct { @@ -1722,17 +1767,17 @@ type workspaceInjectionConfig struct { func runAgentInjection(ctx context.Context, cfg workspaceInjectionConfig) chan error { errChan := make(chan error, 1) go func() { + defer cfg.cancel() streamer := log.NewJSONLogStreamer(log.StreamerOptions{ - FallbackLevel: log.LevelInfo, + FallbackLevel: log.SlogLevelInfo, DetectLevelPrefixes: true, + DefaultAttrs: []slog.Attr{ + log.AttrComponent("agent"), + log.AttrProvider(cfg.workspaceClient.Provider()), + log.AttrWorkspaceID(cfg.workspaceClient.Workspace()), + }, }) - defer func() { - log.Debugf("up command completed") - cfg.cancel() - _ = streamer.Close() - }() - - errChan <- agent.InjectAgent(ctx, &agent.InjectOptions{ + err := agent.InjectAgent(ctx, &agent.InjectOptions{ Exec: func(ctx context.Context, command string, stdin io.Reader, stdout io.Writer, stderr io.Writer) error { return cfg.workspaceClient.Command(ctx, client.CommandOptions{ Command: command, @@ -1752,6 +1797,10 @@ func runAgentInjection(ctx context.Context, cfg workspaceInjectionConfig) chan e Stderr: streamer, Timeout: cfg.timeout, }) + cfg.cancel() + _ = streamer.Close() + log.Debugf("up command completed") + errChan <- err }() return errChan } diff --git a/pkg/client/clientimplementation/workspace_client_test.go b/pkg/client/clientimplementation/workspace_client_test.go index 145534ba4b..b36f20bcea 100644 --- a/pkg/client/clientimplementation/workspace_client_test.go +++ b/pkg/client/clientimplementation/workspace_client_test.go @@ -15,7 +15,9 @@ import ( "github.com/devsy-org/devsy/pkg/client" "github.com/devsy-org/devsy/pkg/config" + "github.com/devsy-org/devsy/pkg/log" "github.com/devsy-org/devsy/pkg/provider" + "github.com/devsy-org/devsy/pkg/telemetry" "github.com/devsy-org/devsy/pkg/types" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" @@ -23,7 +25,8 @@ import ( ) const ( - binSh = "/bin/sh" + binSh = "/bin/sh" + testProxyWorkspaceID = "workspace" ) func TestHandleForceError(t *testing.T) { @@ -143,6 +146,31 @@ func TestRunCommand(t *testing.T) { }) } +func TestRunCommandPreservesCancellationAndExit(t *testing.T) { + requirePOSIXShell(t) + ready := filepath.Join(t.TempDir(), "ready") + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + done := make(chan error, 1) + go func() { + done <- RunCommand(ctx, RunCommandOptions{ + Command: types.StrArray{binSh, "-c", `printf x > "$READY"; exec /bin/sleep 60`}, + Environ: []string{"READY=" + ready}, + Stdout: io.Discard, + Stderr: io.Discard, + }) + }() + require.Eventually(t, func() bool { + _, err := os.Stat(ready) + return err == nil + }, 5*time.Second, 10*time.Millisecond) + cancel() + err := <-done + require.ErrorIs(t, err, context.Canceled) + var exitErr *exec.ExitError + require.ErrorAs(t, err, &exitErr) +} + func TestMachineCommandErrorsRedactOpaquePayloadAndArguments(t *testing.T) { requirePOSIXShell(t) const payload = "private-command-payload-796412" @@ -450,3 +478,152 @@ func (f *fakeWorkspaceClient) Create(context.Context) error { f.createCalled = true return f.createErr } + +func TestTelemetryProviderKindUsesBuiltinProvenance(t *testing.T) { + const dockerProvider = "docker" + const customProvider = "custom" + for _, tc := range []struct { + name string + config *provider.ProviderConfig + want string + }{ + {"builtin alias", &provider.ProviderConfig{ + Name: "my-provider", Source: provider.ProviderSource{Internal: true, Raw: dockerProvider}, + }, dockerProvider}, + {"external with builtin alias", &provider.ProviderConfig{ + Name: dockerProvider, Source: provider.ProviderSource{Github: "example/provider"}, + }, customProvider}, + {"unknown internal", &provider.ProviderConfig{ + Source: provider.ProviderSource{Internal: true, Raw: "private-provider"}, + }, customProvider}, + {"missing config", nil, customProvider}, + } { + t.Run(tc.name, func(t *testing.T) { + c := &workspaceClient{providerConfig: tc.config} + assert.Equal(t, tc.want, c.TelemetryProviderKind()) + }) + } +} + +func TestProxyExecutionRecordsProviderMetric(t *testing.T) { + requirePOSIXShell(t) + config.ResetPathManager() + t.Cleanup(config.ResetPathManager) + t.Setenv(config.EnvHome, t.TempDir()) + const contextName = "default" + proxy := &proxyClient{ + devsyConfig: &config.Config{ + DefaultContext: contextName, + Contexts: map[string]*config.ContextConfig{contextName: {}}, + }, + config: &provider.ProviderConfig{Name: "proxy"}, + workspace: &provider.Workspace{ID: "private-workspace", Context: contextName}, + } + executor := &proxyExecutor{client: proxy} + metrics := telemetry.NewMetricsReporter() + ctx := telemetry.WithMetrics(context.Background(), metrics) + err := executor.execute(ctx, execParams{ + operation: "command", + command: types.StrArray{binSh, "-c", testShellExitSuccess}, + stdout: io.Discard, + stderr: io.Discard, + }) + require.NoError(t, err) + snapshot := metrics.Finish(nil) + require.Len(t, snapshot.ProviderOperations, 1) + assert.Equal(t, telemetry.ProviderTypeScriptProxy, snapshot.ProviderOperations[0].ProviderType) + assert.Equal(t, "command", snapshot.ProviderOperations[0].Operation) + assert.EqualValues(t, 1, snapshot.ProviderOperations[0].Count) +} + +func TestProxyUpForwardsRequestedLogLevel(t *testing.T) { + requirePOSIXShell(t) + config.ResetPathManager() + t.Cleanup(config.ResetPathManager) + t.Setenv(config.EnvHome, t.TempDir()) + log.InitTestObserved(t, log.SlogLevelDebug) + const contextName = "default" + for _, tc := range []struct{ level, want string }{ + {"warn", "warn"}, {"info", "info"}, {"trace", "trace"}, {"", "debug"}, + } { + t.Run(tc.want, func(t *testing.T) { + var stdout bytes.Buffer + proxy := &proxyClient{ + devsyConfig: &config.Config{ + DefaultContext: contextName, + Contexts: map[string]*config.ContextConfig{contextName: {}}, + }, + config: &provider.ProviderConfig{ + Name: "proxy", + Exec: provider.ProviderCommands{Proxy: &provider.ProxyCommands{ + Up: types.StrArray{ + binSh, + "-c", + `printf '%s|%s|%s|%s' "$DEVSY_LOG_LEVEL" "$DEVSY_LOG_FORMAT" "$#" "$1"`, + "provider", + "sentinel", + }, + }}, + }, + workspace: &provider.Workspace{ID: testProxyWorkspaceID, Context: contextName}, + } + proxy.executor = &proxyExecutor{client: proxy} + require.NoError( + t, + proxy.Up( + context.Background(), + client.UpOptions{LogLevel: tc.level, Stdout: &stdout}, + ), + ) + assert.Equal(t, tc.want+"|json|1|sentinel", stdout.String()) + }) + } +} + +func TestProxyUpRejectsInvalidLogLevelBeforeExecution(t *testing.T) { + proxy := &proxyClient{} + err := proxy.Up(context.Background(), client.UpOptions{LogLevel: "invalid"}) + require.ErrorContains(t, err, "invalid log level") +} + +func TestRunCommandLoggingEnvironmentDefaultsAndPrecedence(t *testing.T) { + requirePOSIXShell(t) + t.Setenv(config.EnvLogLevel, "warn") + t.Setenv("DEVSY_LOG_FORMAT", "text") + log.InitTestObserved(t, log.SlogLevelInfo) + const printEnvironment = `printf '%s|%s' "$DEVSY_LOG_LEVEL" "$DEVSY_LOG_FORMAT"` + for _, tc := range []struct { + name string + env []string + command types.StrArray + want string + }{ + {"inherited environment", nil, types.StrArray{binSh, "-c", printEnvironment}, "warn|text"}, + {"custom argv defaults", []string{}, types.StrArray{binSh, "-c", printEnvironment}, "info|json"}, + {"custom shell defaults", []string{}, types.StrArray{printEnvironment}, "info|json"}, + { + "explicit format", + []string{"DEVSY_LOG_FORMAT=plain"}, + types.StrArray{binSh, "-c", printEnvironment}, + "info|plain", + }, + {"last explicit values win", []string{ + "DEVSY_LOG_LEVEL=trace", "DEVSY_LOG_LEVEL=warn", "DEVSY_LOG_FORMAT=json", "DEVSY_LOG_FORMAT=logfmt", + }, types.StrArray{binSh, "-c", printEnvironment}, "warn|logfmt"}, + {"shell last explicit values win", []string{ + "DEVSY_LOG_LEVEL=trace", "DEVSY_LOG_LEVEL=warn", "DEVSY_LOG_FORMAT=json", "DEVSY_LOG_FORMAT=logfmt", + }, types.StrArray{printEnvironment}, "warn|logfmt"}, + } { + t.Run(tc.name, func(t *testing.T) { + var stdout bytes.Buffer + err := RunCommand(context.Background(), RunCommandOptions{ + Command: tc.command, + Environ: tc.env, + Stdout: &stdout, + Stderr: io.Discard, + }) + require.NoError(t, err) + assert.Equal(t, tc.want, stdout.String()) + }) + } +} diff --git a/pkg/client/proxycmd/proxycmd.go b/pkg/client/proxycmd/proxycmd.go index b5f27d4a25..e4bd59c354 100644 --- a/pkg/client/proxycmd/proxycmd.go +++ b/pkg/client/proxycmd/proxycmd.go @@ -45,7 +45,7 @@ func Run(ctx context.Context, cfg Options) ([]byte, error) { stderr := cfg.Stderr if stderr == nil { - stderr = log.Writer(log.LevelError) + stderr = log.Writer(log.SlogLevelError) } var stdout bytes.Buffer diff --git a/pkg/client/up_options_test.go b/pkg/client/up_options_test.go new file mode 100644 index 0000000000..e7172a25b2 --- /dev/null +++ b/pkg/client/up_options_test.go @@ -0,0 +1,64 @@ +package client + +import ( + "encoding/json" + "testing" + + "github.com/devsy-org/devsy/pkg/log" + "github.com/devsy-org/devsy/pkg/provider" + "github.com/devsy-org/devsy/pkg/status" + "github.com/stretchr/testify/require" +) + +type runtimeReporter struct { + Callback func() +} + +func (r runtimeReporter) Report(status.Event) { r.Callback() } + +type runtimeReader struct { + Callback func() +} + +func (r runtimeReader) Read([]byte) (int, error) { r.Callback(); return 0, nil } + +type runtimeWriter struct { + Callback func() +} + +func (w runtimeWriter) Write(p []byte) (int, error) { w.Callback(); return len(p), nil } + +func TestUpOptionsJSONPreservesLevelAndExcludesRuntimeFields(t *testing.T) { + for _, level := range []string{"warn", "info", "trace"} { + t.Run(level, func(t *testing.T) { + options := UpOptions{ + CLIOptions: provider.CLIOptions{SkipPostStart: true}, + LogLevel: level, + Stdin: runtimeReader{Callback: func() {}}, + Stdout: runtimeWriter{Callback: func() {}}, + Reporter: runtimeReporter{Callback: func() {}}, + } + encoded, err := json.Marshal(options) + require.NoError(t, err) + var decoded map[string]any + require.NoError(t, json.Unmarshal(encoded, &decoded)) + require.Equal(t, level, decoded["logLevel"]) + require.Equal(t, true, decoded["skipPostStart"]) + require.NotContains(t, decoded, "Stdin") + require.NotContains(t, decoded, "Stdout") + require.NotContains(t, decoded, "Reporter") + }) + } +} + +func TestUpOptionsEffectiveLogLevel(t *testing.T) { + log.InitTestObserved(t, log.SlogLevelTrace) + level, err := (UpOptions{}).EffectiveLogLevel() + require.NoError(t, err) + require.Equal(t, "trace", level) + const privateValue = "private-level-canary-82531" + _, err = (UpOptions{LogLevel: privateValue}).EffectiveLogLevel() + require.ErrorContains(t, err, "invalid log level") + require.ErrorContains(t, err, "trace") + require.NotContains(t, err.Error(), privateValue) +} diff --git a/pkg/clierr/errors.go b/pkg/clierr/errors.go index 3e2c3b3703..4de53bf772 100644 --- a/pkg/clierr/errors.go +++ b/pkg/clierr/errors.go @@ -6,11 +6,11 @@ import ( "encoding/json" "errors" "fmt" + "log/slog" "maps" "strings" "github.com/devsy-org/devsy/pkg/secrets" - "go.uber.org/zap/zapcore" ) type Code string @@ -48,6 +48,19 @@ func NewPanic(recovered any) *CLIError { } } +func ProviderFailure(err error, diagnostic string, code Code) error { + if err == nil { + return nil + } + if code == "" { + code = CodeUnknown + } + if diagnostic == "" { + diagnostic = "Provider operation failed." + } + return &CLIError{Code: code, Message: diagnostic, wrapped: err} +} + func (e *CLIError) Error() string { if e == nil { return "" @@ -71,19 +84,18 @@ func (e *CLIError) MarshalJSON() ([]byte, error) { }{Code: e.Code, Message: e.Message, Hint: e.Hint, Context: e.Context}) } -func (e *CLIError) MarshalLogObject(enc zapcore.ObjectEncoder) error { +func (e *CLIError) LogValue() slog.Value { if e == nil { - return nil + return slog.GroupValue() } - enc.AddString("code", string(e.Code)) - enc.AddString("message", e.Message) + attrs := []slog.Attr{slog.String("code", string(e.Code)), slog.String("message", e.Message)} if e.Hint != "" { - enc.AddString("hint", e.Hint) + attrs = append(attrs, slog.String("hint", e.Hint)) } if len(e.Context) > 0 { - enc.AddString("context", fmt.Sprint(e.Context)) + attrs = append(attrs, slog.Any("context", e.Context)) } - return nil + return slog.GroupValue(attrs...) } var ErrRateLimited = errors.New("rate limited") diff --git a/pkg/clierr/errors_test.go b/pkg/clierr/errors_test.go index 487a9e6c17..8ff7f8847f 100644 --- a/pkg/clierr/errors_test.go +++ b/pkg/clierr/errors_test.go @@ -6,8 +6,6 @@ import ( stderrs "errors" "fmt" "testing" - - "go.uber.org/zap/zapcore" ) func TestClassifyCancellation(t *testing.T) { @@ -90,6 +88,27 @@ func TestCLIError_UnwrapPreservesChain(t *testing.T) { } } +func TestProviderFailurePreservesCauseAndSafeMessage(t *testing.T) { + if got := ProviderFailure(nil, "diagnostic", CodeRateLimited); got != nil { + t.Fatalf("ProviderFailure(nil) = %v", got) + } + cause := stderrs.New("private cause") + wrapped := fmt.Errorf("operation: %w", cause) + err := ProviderFailure(wrapped, "redacted diagnostic", CodeRateLimited) + if !stderrs.Is(err, cause) { + t.Fatal("provider failure lost its original cause") + } + var classified *CLIError + if !stderrs.As(err, &classified) || classified.Code != CodeRateLimited || + err.Error() != "redacted diagnostic" { + t.Fatalf("unexpected provider failure: %#v", err) + } + fallback := ProviderFailure(cause, "", "") + if fallback.Error() != "Provider operation failed." || Classify(fallback).Code != CodeUnknown { + t.Fatalf("unexpected default provider failure: %#v", fallback) + } +} + func TestClassify_RecoverableBuildFailure(t *testing.T) { got := Classify(Recoverable(fmt.Errorf("build image: boom"))) if got.Code != CodeBuildFailedRecoverable { @@ -156,20 +175,21 @@ func TestCLIError_MarshalJSONIncludesHintAndContext(t *testing.T) { } } -func TestCLIError_LogObjectShape(t *testing.T) { - enc := zapcore.NewMapObjectEncoder() - e := &CLIError{Code: CodeRateLimited, Message: testRateLimited} - if err := e.MarshalLogObject(enc); err != nil { - t.Fatalf("MarshalLogObject: %v", err) - } - if len(enc.Fields) != 2 { - t.Fatalf("wire object must be exactly {code, message}, got %v", enc.Fields) - } - if enc.Fields["code"] != string(CodeRateLimited) { - t.Fatalf("code = %v, want %q", enc.Fields["code"], CodeRateLimited) - } - if enc.Fields["message"] != testRateLimited { - t.Fatalf("message = %v", enc.Fields["message"]) +func TestCLIErrorLogValue(t *testing.T) { + e := &CLIError{ + Code: CodeRateLimited, + Message: testRateLimited, + Hint: "retry", + Context: map[string]string{"provider": "example"}, + } + attrs := e.LogValue().Group() + if len(attrs) != 4 || attrs[0].Key != "code" || + attrs[0].Value.String() != string(CodeRateLimited) || + attrs[1].Key != "message" || + attrs[1].Value.String() != testRateLimited || + attrs[2].Key != "hint" || + attrs[3].Key != "context" { + t.Fatalf("unexpected error attributes: %v", attrs) } } diff --git a/pkg/clierr/ssh.go b/pkg/clierr/ssh.go new file mode 100644 index 0000000000..16ff850c23 --- /dev/null +++ b/pkg/clierr/ssh.go @@ -0,0 +1,76 @@ +package clierr + +import ( + "context" + "errors" + "net" + "strings" + + "golang.org/x/crypto/ssh/knownhosts" +) + +const ( + CodeSSHAuthFailed Code = "ssh_auth_failed" + CodeSSHHostKeyFailed Code = "ssh_host_key_failed" + CodeSSHUnreachable Code = "ssh_unreachable" + CodeSSHCommandFailed Code = "ssh_command_failed" +) + +type sshExitCoder interface { + ExitCode() int +} + +func ClassifySSHConnection(err error) error { + if preserveSSHError(err) { + return err + } + var keyErr *knownhosts.KeyError + var revokedErr *knownhosts.RevokedError + var netErr *net.OpError + var code Code + var message, hint string + switch { + case errors.As(err, &keyErr), errors.As(err, &revokedErr): + code = CodeSSHHostKeyFailed + message = "SSH host key verification failed." + hint = "Verify the server identity and update the trusted host key." + case errors.As(err, &netErr): + code = CodeSSHUnreachable + message = "SSH could not reach the remote host." + hint = "Check the host name, network, port, and SSH service." + case isSSHAuthenticationFailure(err): + code = CodeSSHAuthFailed + message = "SSH authentication failed." + hint = "Check the SSH user, key, and server authorization." + default: + code = CodeSSHCommandFailed + message = "SSH connection failed." + hint = "Check the SSH configuration and connection." + } + return &CLIError{Code: code, Message: message, Hint: hint, wrapped: err} +} + +func preserveSSHError(err error) bool { + if err == nil || errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) { + return true + } + _, ok := errors.AsType[*CLIError](err) + return ok || isSSHRemoteExit(err) +} + +func isSSHRemoteExit(err error) bool { + var exitCode sshExitCoder + var exitStatus interface{ ExitStatus() int } + return errors.As(err, &exitCode) || errors.As(err, &exitStatus) +} + +func isSSHAuthenticationFailure(err error) bool { + for current := err; current != nil; current = errors.Unwrap(current) { + text := current.Error() + if strings.HasPrefix(text, "ssh: unable to authenticate, attempted methods [") && + strings.HasSuffix(text, "], no supported methods remain") { + return true + } + } + return false +} diff --git a/pkg/clierr/ssh_test.go b/pkg/clierr/ssh_test.go new file mode 100644 index 0000000000..b0ad2b3875 --- /dev/null +++ b/pkg/clierr/ssh_test.go @@ -0,0 +1,67 @@ +package clierr + +import ( + "context" + "errors" + "fmt" + "net" + "testing" + + "github.com/stretchr/testify/require" + "golang.org/x/crypto/ssh/knownhosts" +) + +type fakeSSHExit struct{ code int } + +func (e fakeSSHExit) Error() string { return "remote process exited" } +func (e fakeSSHExit) ExitCode() int { return e.code } + +func TestClassifySSHConnection(t *testing.T) { + cause := errors.New("connection detail") + cases := []struct { + name string + err error + code Code + }{ + {"network", &net.OpError{Op: "dial", Net: "tcp", Err: cause}, CodeSSHUnreachable}, + {"host key", &knownhosts.KeyError{}, CodeSSHHostKeyFailed}, + {"revoked key", &knownhosts.RevokedError{}, CodeSSHHostKeyFailed}, + { + "authentication", + fmt.Errorf( + "ssh: handshake failed: %w", + errors.New( + "ssh: unable to authenticate, attempted methods [none publickey], no supported methods remain", + ), + ), + CodeSSHAuthFailed, + }, + {"untrusted text", errors.New("remote says unable to authenticate"), CodeSSHCommandFailed}, + {"other handshake", cause, CodeSSHCommandFailed}, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + err := ClassifySSHConnection(tc.err) + var classified *CLIError + require.ErrorAs(t, err, &classified) + require.Equal(t, tc.code, classified.Code) + require.NotEmpty(t, classified.Hint) + require.ErrorIs(t, err, tc.err) + }) + } +} + +func TestClassifySSHConnectionPreservesPriorErrors(t *testing.T) { + existing := &CLIError{Code: CodeRateLimited, Message: "existing"} + for _, err := range []error{ + nil, + context.Canceled, + fmt.Errorf("deadline: %w", context.DeadlineExceeded), + existing, + fmt.Errorf("wrapped: %w", existing), + fakeSSHExit{code: 7}, + fakeSSHExit{code: 255}, + } { + require.Equal(t, err, ClassifySSHConnection(err)) + } +} diff --git a/pkg/config/env.go b/pkg/config/env.go index 35a606303c..8d7ab0406a 100644 --- a/pkg/config/env.go +++ b/pkg/config/env.go @@ -24,9 +24,6 @@ const ( // EnvUI indicates the desktop UI is active. EnvUI = "DEVSY_UI" - // EnvDebug enables debug logging. - EnvDebug = "DEVSY_DEBUG" - // EnvInsecureTLS, when truthy, disables TLS certificate verification for the // shared HTTP client. Enabled by default. EnvInsecureTLS = "DEVSY_INSECURE_TLS" diff --git a/pkg/daemon/local/daemon.go b/pkg/daemon/local/daemon.go index 5762c96d1c..7ed838e794 100644 --- a/pkg/daemon/local/daemon.go +++ b/pkg/daemon/local/daemon.go @@ -71,6 +71,7 @@ func New(devsyConfig *config.Config) (*Daemon, error) { } func (d *Daemon) Run(ctx context.Context) error { + ctx = log.WithContext(ctx, log.AttrComponent("local_daemon"), log.AttrOperation("serve")) log.Infof("local daemon listening on %s", GetSocketPath()) errCh := make(chan error, 1) @@ -90,7 +91,7 @@ func (d *Daemon) Run(ctx context.Context) error { idle := time.Since(d.lastActivity) > idleTimeout d.mu.RUnlock() if idle { - log.Infof("idle timeout reached, shutting down") + log.InfoContext(ctx, "idle timeout reached, shutting down") return d.shutdown() } } diff --git a/pkg/daemon/platform/daemon.go b/pkg/daemon/platform/daemon.go index f3e52cbdf3..1920a2f295 100644 --- a/pkg/daemon/platform/daemon.go +++ b/pkg/daemon/platform/daemon.go @@ -36,6 +36,14 @@ type InitConfig struct { } func Init(ctx context.Context, config InitConfig) (*Daemon, error) { + ctx = log.WithContext( + ctx, + log.AttrComponent("platform_daemon"), + log.AttrOperation("initialize"), + ) + if config.ProviderName != "" { + ctx = log.WithContext(ctx, log.AttrProvider(config.ProviderName)) + } socketAddr := GetSocketAddr(config.ProviderName) log.Infof("Starting Daemon on address: %s", socketAddr) // listen to socket for early return in case it's already in use @@ -67,6 +75,7 @@ func Init(ctx context.Context, config InitConfig) (*Daemon, error) { } func (d *Daemon) Start(ctx context.Context) error { + ctx = log.WithContext(ctx, log.AttrComponent("platform_daemon"), log.AttrOperation("serve")) errChan := make(chan error, 1) go func() { @@ -74,16 +83,16 @@ func (d *Daemon) Start(ctx context.Context) error { errChan <- d.localServer.ListenAndServe() }() go func() { - log.Info("Start proxying connections") + log.InfoContext(ctx, "start proxying connections") errChan <- d.Listen(d.socketListener) }() go func() { - log.Info("Start netmap watcher") + log.InfoContext(ctx, "start netmap watcher") errChan <- d.watchNetmap(ctx) }() defer func() { - log.Info("Cleaning up daemon resources") + log.InfoContext(ctx, "cleaning up daemon resources") _ = d.tsServer.Close() _ = d.localServer.Close() _ = d.socketListener.Close() diff --git a/pkg/daemon/platform/local_server.go b/pkg/daemon/platform/local_server.go index 5942524599..7dcd5c4016 100644 --- a/pkg/daemon/platform/local_server.go +++ b/pkg/daemon/platform/local_server.go @@ -124,7 +124,7 @@ func newLocalServer( handlers.RecoveryLogger(panicLogger{}), handlers.PrintRecoveryStack(true), )(mux) - handler = handlers.LoggingHandler(log.Writer(log.LevelDebug), handler) + handler = handlers.LoggingHandler(log.Writer(log.SlogLevelDebug), handler) l.httpServer = &http.Server{Handler: handler, ReadHeaderTimeout: readHeaderTimeout} return l diff --git a/pkg/devcontainer/build_record_test.go b/pkg/devcontainer/build_record_test.go index fa074cf6ac..ccbd423228 100644 --- a/pkg/devcontainer/build_record_test.go +++ b/pkg/devcontainer/build_record_test.go @@ -21,7 +21,6 @@ import ( "github.com/google/go-containerregistry/pkg/v1/remote" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" - "go.uber.org/zap/zapcore" ) const ( @@ -95,7 +94,7 @@ func composeScript(t *testing.T, body string) *compose.ComposeHelper { } func TestRunComposeBuildRetainsOutputAtWarnLevel(t *testing.T) { - logs := log.InitTestObserved(t, zapcore.WarnLevel) + logs := log.InitTestObserved(t, log.SlogLevelWarn) ctx, store, runID := recordedContext(t) helper := composeScript(t, "echo 'compose out'; echo 'compose err' >&2") @@ -116,7 +115,7 @@ func TestRunComposeBuildRetainsOutputAtWarnLevel(t *testing.T) { } func TestRunComposeBuildFailureKeepsErrorAndExitCode(t *testing.T) { - log.InitTestObserved(t, zapcore.WarnLevel) + log.InitTestObserved(t, log.SlogLevelWarn) ctx, store, runID := recordedContext(t) helper := composeScript(t, "echo 'service failed' >&2; exit 4") @@ -136,7 +135,7 @@ func TestRunComposeBuildFailureKeepsErrorAndExitCode(t *testing.T) { } func TestRunComposeBuildCanceledIsRecorded(t *testing.T) { - log.InitTestObserved(t, zapcore.WarnLevel) + log.InitTestObserved(t, log.SlogLevelWarn) ctx, store, runID := recordedContext(t) ctx, cancel := context.WithCancel(ctx) cancel() @@ -150,7 +149,7 @@ func TestRunComposeBuildCanceledIsRecorded(t *testing.T) { } func TestRunComposeBuildWithoutRecorderLogsOnly(t *testing.T) { - logs := log.InitTestObserved(t, zapcore.InfoLevel) + logs := log.InitTestObserved(t, log.SlogLevelInfo) err := (&runner{}).runComposeBuild( t.Context(), composeScript(t, "echo plain"), testComposeArgs, @@ -162,7 +161,7 @@ func TestRunComposeBuildWithoutRecorderLogsOnly(t *testing.T) { } func TestBuildImageRecordsPrebuildReuseWithoutOutput(t *testing.T) { - log.InitTestObserved(t, zapcore.WarnLevel) + log.InitTestObserved(t, log.SlogLevelWarn) ctx, store, runID := recordedContext(t) server := httptest.NewServer(registry.New()) t.Cleanup(server.Close) diff --git a/pkg/devcontainer/buildkit/record_test.go b/pkg/devcontainer/buildkit/record_test.go index 5097f8c84b..0ec7e37442 100644 --- a/pkg/devcontainer/buildkit/record_test.go +++ b/pkg/devcontainer/buildkit/record_test.go @@ -15,7 +15,6 @@ import ( digest "github.com/opencontainers/go-digest" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" - "go.uber.org/zap/zapcore" ) func recordedContext(t *testing.T) (context.Context, *workspacelogs.Store, string) { @@ -72,9 +71,9 @@ func invocations(recs []workspacelogs.Record) []workspacelogs.Record { } func TestStepRetainsOutputBelowLogLevel(t *testing.T) { - logs := log.InitTestObserved(t, zapcore.WarnLevel) + logs := log.InitTestObserved(t, log.SlogLevelWarn) ctx, store, runID := recordedContext(t) - logWriter := log.Writer(log.LevelInfo) + logWriter := log.Writer(log.SlogLevelInfo) step := StartStep(ctx, "buildkit") w := step.Tee(logWriter, workspacelogs.StreamCombined) @@ -180,13 +179,16 @@ func TestRecordSkippedWritesReason(t *testing.T) { // The printer renders on its own goroutine, so the last status must be drained // before the recorder writer closes. func TestPrinterDrainKeepsFinalBytes(t *testing.T) { - logs := log.InitTestObserved(t, zapcore.WarnLevel) + logs := log.InitTestObserved(t, log.SlogLevelWarn) ctx, store, runID := recordedContext(t) step := StartStep(ctx, "buildkit-remote") dgst := digest.FromString("vertex") now := time.Now() - pw, err := NewPrinter(ctx, step.Tee(log.Writer(log.LevelInfo), workspacelogs.StreamCombined)) + pw, err := NewPrinter( + ctx, + step.Tee(log.Writer(log.SlogLevelInfo), workspacelogs.StreamCombined), + ) require.NoError(t, err) pw.Status() <- &client.SolveStatus{ Vertexes: []*client.Vertex{{Digest: dgst, Name: "RUN make", Started: &now}}, diff --git a/pkg/devcontainer/buildkit/remote.go b/pkg/devcontainer/buildkit/remote.go index a4ae9d7ec4..d8fee88235 100644 --- a/pkg/devcontainer/buildkit/remote.go +++ b/pkg/devcontainer/buildkit/remote.go @@ -494,7 +494,7 @@ func executeBuild(params executeBuildParams) error { } func runRemoteSolve(params executeBuildParams, step *Step) error { - writer := log.Writer(log.LevelInfo) + writer := log.Writer(log.SlogLevelInfo) defer func() { _ = writer.Close() }() pw, err := NewPrinter(params.Ctx, step.Tee(writer, workspacelogs.StreamCombined)) diff --git a/pkg/devcontainer/compose.go b/pkg/devcontainer/compose.go index 53f289cc95..e6310ed617 100644 --- a/pkg/devcontainer/compose.go +++ b/pkg/devcontainer/compose.go @@ -576,7 +576,7 @@ func (r *runner) updateContainerUserUID( if !ok { return nil } - writer := log.Writer(log.LevelInfo) + writer := log.Writer(log.SlogLevelInfo) defer func() { _ = writer.Close() }() if err := dockerDriver.UpdateContainerUserUID( ctx, @@ -676,7 +676,7 @@ func (r *runner) composeUpExistingProject( upArgs = append(upArgs, "up", "-d") upArgs = r.onlyRunServices(upArgs, params.parsedConfig) - writer := log.Writer(log.LevelInfo) + writer := log.Writer(log.SlogLevelInfo) if err := params.composeHelper.RunWithOutput( ctx, upArgs, @@ -1413,7 +1413,7 @@ func (r *runner) composeUpAndFindContainer( } upArgs = r.onlyRunServices(upArgs, params.parsedConfig) - writer := log.Writer(log.LevelInfo) + writer := log.Writer(log.SlogLevelInfo) if err := params.composeHelper.RunWithOutput( ctx, upArgs, diff --git a/pkg/devcontainer/compose_build.go b/pkg/devcontainer/compose_build.go index 24050b97b8..db756b17bc 100644 --- a/pkg/devcontainer/compose_build.go +++ b/pkg/devcontainer/compose_build.go @@ -328,7 +328,7 @@ func prepareComposeServiceImage( if !pull { return details, inspectErr } - writer := log.Writer(log.LevelInfo) + writer := log.Writer(log.SlogLevelInfo) defer func() { _ = writer.Close() }() if err := helper.Pull(ctx, docker.PullOptions{ Image: service.Image, Platform: platform, Stdout: writer, Stderr: writer, @@ -419,7 +419,7 @@ func (r *runner) runComposeBuild( composeHelper *compose.ComposeHelper, buildArgs []string, ) error { - logWriter := log.Writer(log.LevelInfo) + logWriter := log.Writer(log.SlogLevelInfo) step := buildkit.StartStep(ctx, "compose") writer := step.Tee(io.Discard, workspacelogs.StreamCombined) log.Debugf("Run %s %s", composeHelper.Command, strings.Join(buildArgs, " ")) diff --git a/pkg/devcontainer/compose_resume.go b/pkg/devcontainer/compose_resume.go index b0f0e5e0d1..50ab98c0f2 100644 --- a/pkg/devcontainer/compose_resume.go +++ b/pkg/devcontainer/compose_resume.go @@ -113,7 +113,7 @@ func (r *runner) startComposeInstance( return nil, err } args = r.onlyRunServices(append(args, "start"), params.runParams.parsedConfig) - writer := log.Writer(log.LevelInfo) + writer := log.Writer(log.SlogLevelInfo) if err := params.composeHelper.RunWithOutput( ctx, args, diff --git a/pkg/devcontainer/config/host_requirements.go b/pkg/devcontainer/config/host_requirements.go index cfb1fe53d0..8d2ed1ea89 100644 --- a/pkg/devcontainer/config/host_requirements.go +++ b/pkg/devcontainer/config/host_requirements.go @@ -1,8 +1,10 @@ package config import ( + "context" "errors" "fmt" + "log/slog" "regexp" "strconv" "strings" @@ -40,10 +42,10 @@ func ValidateHostRequirements( warnings = appendGPUWarning(warnings, reqs.GPU) for _, w := range warnings { - log.Warnw("hostRequirements not met", "warning", w) + log.WarnContext(context.Background(), "hostRequirements not met", slog.String("warning", w)) } for _, f := range hardFailures { - log.Warnw("hostRequirements not met", "error", f) + log.WarnContext(context.Background(), "hostRequirements not met", slog.String("error", f)) } if len(hardFailures) > 0 { diff --git a/pkg/devcontainer/delete_test.go b/pkg/devcontainer/delete_test.go index 8a75463ef4..f750b8e0c2 100644 --- a/pkg/devcontainer/delete_test.go +++ b/pkg/devcontainer/delete_test.go @@ -12,8 +12,6 @@ import ( "github.com/devsy-org/devsy/pkg/driver" "github.com/devsy-org/devsy/pkg/log" "github.com/devsy-org/devsy/pkg/provider" - "go.uber.org/zap/zapcore" - "go.uber.org/zap/zaptest/observer" ) const ( @@ -267,7 +265,7 @@ func TestDelete_NonLocalSource_KeepsNothingToClean(t *testing.T) { } func TestTeardown_DeliveryVolumeFailure_WarnsButSucceeds(t *testing.T) { - logs := log.InitTestObserved(t, zapcore.WarnLevel) + logs := log.InitTestObserved(t, log.SlogLevelWarn) r := newTestRunner(&mockDriver{}) r.workspaceConfig.Agent.Driver = provider.DockerDriver @@ -284,9 +282,9 @@ func TestTeardown_DeliveryVolumeFailure_WarnsButSucceeds(t *testing.T) { } } -func observedWarning(entries []observer.LoggedEntry, substr string) bool { +func observedWarning(entries []log.LoggedEntry, substr string) bool { for _, e := range entries { - if e.Level == zapcore.WarnLevel && searchString(e.Message, substr) { + if e.Level == log.SlogLevelWarn && searchString(e.Message, substr) { return true } } @@ -294,7 +292,7 @@ func observedWarning(entries []observer.LoggedEntry, substr string) bool { } func TestTeardown_ImportedMarkerFailure_WarnsButSucceeds(t *testing.T) { - logs := log.InitTestObserved(t, zapcore.WarnLevel) + logs := log.InitTestObserved(t, log.SlogLevelWarn) tmpDir := t.TempDir() notADir := filepath.Join(tmpDir, importedProfileParent) diff --git a/pkg/devcontainer/feature/options_secret_test.go b/pkg/devcontainer/feature/options_secret_test.go index 2fba7ceabe..c9de809169 100644 --- a/pkg/devcontainer/feature/options_secret_test.go +++ b/pkg/devcontainer/feature/options_secret_test.go @@ -9,7 +9,6 @@ import ( "github.com/devsy-org/devsy/pkg/devcontainer/config" "github.com/devsy-org/devsy/pkg/log" "github.com/stretchr/testify/suite" - "go.uber.org/zap/zapcore" ) type mockPrompter struct { @@ -381,7 +380,7 @@ func (s *SecretOptionsTestSuite) TestPrompterNotCalledWhenEnvVarSet() { } func (s *SecretOptionsTestSuite) TestTerminalPrompterNonInteractiveEmitsWarning() { - logs := log.InitTestObserved(s.T(), zapcore.WarnLevel) + logs := log.InitTestObserved(s.T(), log.SlogLevelWarn) prompter := &TerminalSecretPrompter{ IsTerminal: func() bool { return false }, @@ -393,7 +392,7 @@ func (s *SecretOptionsTestSuite) TestTerminalPrompterNonInteractiveEmitsWarning( s.Require().Equal(1, logs.Len()) entry := logs.All()[0] - s.Equal(zapcore.WarnLevel, entry.Level) + s.Equal(log.SlogLevelWarn, entry.Level) s.Contains(entry.Message, testFeatureID) s.Contains(entry.Message, testOptionToken) s.Contains(entry.Message, "stdin is not a terminal") diff --git a/pkg/devcontainer/initialize.go b/pkg/devcontainer/initialize.go index 9d6874962b..0e87b1e535 100644 --- a/pkg/devcontainer/initialize.go +++ b/pkg/devcontainer/initialize.go @@ -95,8 +95,8 @@ func (c *initializeCommand) run(ctx context.Context, name string, cmd []string) strings.Join(args, " "), ) - stdout := log.Writer(log.LevelInfo) - stderr := log.Writer(log.LevelError) + stdout := log.Writer(log.SlogLevelInfo) + stderr := log.Writer(log.SlogLevelError) defer func() { _ = stdout.Close() }() defer func() { _ = stderr.Close() }() diff --git a/pkg/devcontainer/initialize_record_test.go b/pkg/devcontainer/initialize_record_test.go index d69e0c027b..8297df9a07 100644 --- a/pkg/devcontainer/initialize_record_test.go +++ b/pkg/devcontainer/initialize_record_test.go @@ -11,7 +11,6 @@ import ( "github.com/devsy-org/devsy/pkg/workspacelogs" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" - "go.uber.org/zap/zapcore" ) func recordedInitContext(t *testing.T) (context.Context, func() []workspacelogs.Record) { @@ -83,7 +82,7 @@ func summarizeInit(recs []workspacelogs.Record) map[string]*initSummary { } func TestInitializeCommandRecordsOutputAtErrorLevel(t *testing.T) { - log.InitTestObserved(t, zapcore.ErrorLevel) + log.InitTestObserved(t, log.SlogLevelError) ctx, records := recordedInitContext(t) conf := initConf(map[string][]string{ "a": {"echo a-out; echo a-err >&2"}, diff --git a/pkg/devcontainer/setup.go b/pkg/devcontainer/setup.go index ec1e11336c..93bf592c8b 100644 --- a/pkg/devcontainer/setup.go +++ b/pkg/devcontainer/setup.go @@ -466,7 +466,7 @@ func (r *runner) addSetupFlags(args *[]string) { r.addPlatformFlags(args) r.addDotfilesFlags(args) r.addPrebuildFlag(args) - r.addDebugFlag(args) + *args = append(*args, log.ForwardFlagArgs()...) } func (r *runner) addChownFlag(args *[]string) { @@ -555,12 +555,6 @@ func (r *runner) addPrebuildFlag(args *[]string) { } } -func (r *runner) addDebugFlag(args *[]string) { - if r.isDebugMode() { - *args = append(*args, names.Flag(names.Debug)) - } -} - func (r *runner) isDebugMode() bool { return log.DebugEnabled() } @@ -687,9 +681,7 @@ func (r *runner) buildSSHTunnelArgv() []string { r.workspaceConfig.CLIOptions.SSHAuthSockID, ) } - if r.isDebugMode() { - args = append(args, names.Flag(names.Debug)) - } + args = append(args, log.ForwardFlagArgs()...) return args } diff --git a/pkg/devcontainer/setup/dotfiles.go b/pkg/devcontainer/setup/dotfiles.go index ea381dfe8f..35989223a9 100644 --- a/pkg/devcontainer/setup/dotfiles.go +++ b/pkg/devcontainer/setup/dotfiles.go @@ -192,7 +192,7 @@ func ensureDotfileExecutable(ctx context.Context, path string) error { } func execDotfilesCmd(ctx context.Context, script, remoteUser string) error { - writer := log.Writer(log.LevelInfo) + writer := log.Writer(log.SlogLevelInfo) currentUser, err := user.Current() if err != nil { diff --git a/pkg/devcontainer/setup/lifecycle_terminal_linux_test.go b/pkg/devcontainer/setup/lifecycle_terminal_linux_test.go index f4075b2f52..9842c218fe 100644 --- a/pkg/devcontainer/setup/lifecycle_terminal_linux_test.go +++ b/pkg/devcontainer/setup/lifecycle_terminal_linux_test.go @@ -24,7 +24,6 @@ import ( "github.com/devsy-org/devsy/pkg/types" "github.com/devsy-org/devsy/pkg/workspacelogs" "github.com/stretchr/testify/suite" - "go.uber.org/zap/zapcore" ) const ( @@ -424,7 +423,7 @@ func (s *terminalTestSuite) TestArgvAndLargeInput() { } func (s *terminalTestSuite) TestParentCancelAndExitAckSuccess() { - logs := log.InitTestObserved(s.T(), zapcore.WarnLevel) + logs := log.InitTestObserved(s.T(), log.SlogLevelWarn) a := newTestTerminal() ctx, cancel := context.WithCancel(context.Background()) p := s.params(ctx, a, `printf 'ready:'; exec sleep 30`) @@ -483,7 +482,7 @@ func (b *blockedTerminalOutput) Write(p []byte) (int, error) { } func (s *terminalTestSuite) TestBackgroundOutputDrain() { - logs := log.InitTestObserved(s.T(), zapcore.WarnLevel) + logs := log.InitTestObserved(s.T(), log.SlogLevelWarn) a := newTestTerminal() p := s.params( context.Background(), diff --git a/pkg/devcontainer/setup/lifecyclehooks_record_test.go b/pkg/devcontainer/setup/lifecyclehooks_record_test.go index 03c8d63869..fc5f47ab6f 100644 --- a/pkg/devcontainer/setup/lifecyclehooks_record_test.go +++ b/pkg/devcontainer/setup/lifecyclehooks_record_test.go @@ -16,7 +16,6 @@ import ( "github.com/devsy-org/devsy/pkg/workspacelogs" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" - "go.uber.org/zap/zapcore" ) type recordedRun struct { @@ -234,7 +233,7 @@ func TestRecordsSilentSuccessHasNoOutput(t *testing.T) { } func TestRecordsOutputAtQuietLogLevel(t *testing.T) { - log.InitTestObserved(t, zapcore.ErrorLevel) + log.InitTestObserved(t, log.SlogLevelError) run := newRecordedRun(t) p := testParams(t, run.ctx, types.LifecycleHook{"": {"echo kept"}}) diff --git a/pkg/devcontainer/setup/lifecyclehooks_test.go b/pkg/devcontainer/setup/lifecyclehooks_test.go index d9248aef42..2a7db803d9 100644 --- a/pkg/devcontainer/setup/lifecyclehooks_test.go +++ b/pkg/devcontainer/setup/lifecyclehooks_test.go @@ -15,7 +15,6 @@ import ( "github.com/devsy-org/devsy/pkg/types" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/suite" - "go.uber.org/zap/zapcore" ) const ( @@ -639,7 +638,7 @@ func (s *LifecycleHookTestSuite) TestPhaseHasCommandsTrueRunFunc() { func (s *LifecycleHookTestSuite) TestWaitForEmptyPhaseLogsWarning() { t := s.T() - logs := log.InitTestObserved(t, zapcore.DebugLevel) + logs := log.InitTestObserved(t, log.SlogLevelDebug) all := makeTestPhaseHooks() phase := PhaseUpdateContent diff --git a/pkg/devcontainer/setup/setup.go b/pkg/devcontainer/setup/setup.go index e448f7e70f..70dabb681f 100644 --- a/pkg/devcontainer/setup/setup.go +++ b/pkg/devcontainer/setup/setup.go @@ -6,10 +6,12 @@ import ( "encoding/json" "errors" "fmt" + "log/slog" "maps" "os" "os/exec" "path/filepath" + "slices" "sort" "strconv" "strings" @@ -67,6 +69,14 @@ func SetupContainerPreAttach( if err := validateContainerSetupConfig(cfg); err != nil { return DeferredHooks{}, err } + ctx = log.WithContext( + ctx, + log.AttrComponent("devcontainer_setup"), + log.AttrOperation("pre_attach"), + ) + if workspaceID := os.Getenv(pkgconfig.EnvWorkspaceID); workspaceID != "" { + ctx = log.WithContext(ctx, log.AttrWorkspaceID(workspaceID)) + } if cfg.Terminal != nil { if err := ValidateInteractivePostStart( @@ -85,7 +95,7 @@ func SetupContainerPreAttach( } if err := setupGitSafeDirectory(ctx, cfg.SetupInfo); err != nil { - log.Warnf("configure Git safe.directory: %v", err) + log.WarnContext(ctx, "configure Git safe.directory", slog.Any("error", err)) } if err := setupEnvironment(cfg); err != nil { @@ -98,7 +108,7 @@ func SetupContainerPreAttach( setupOptionalFeatures(ctx, cfg) - log.Debugf("running pre-attach lifecycle hooks") + log.DebugContext(ctx, "running pre-attach lifecycle hooks") deferred, err := RunPreAttachHooks(ctx, cfg.SetupInfo, PreAttachOptions{ Prebuild: cfg.Prebuild, Dotfiles: cfg.Dotfiles, @@ -116,14 +126,22 @@ func SetupContainerPreAttach( return DeferredHooks{}, fmt.Errorf("lifecycle hooks pre-attach: %w", err) } - log.Debugf("pre-attach setup completed") + log.DebugContext(ctx, "pre-attach setup completed") return deferred, nil } // SetupContainerPostAttach runs postAttachCommand only. // Called after the IDE has been opened. func SetupContainerPostAttach(ctx context.Context, cfg *ContainerSetupConfig) error { - log.Debugf("running post-attach lifecycle hooks") + ctx = log.WithContext( + ctx, + log.AttrComponent("devcontainer_setup"), + log.AttrOperation("post_attach"), + ) + if workspaceID := os.Getenv(pkgconfig.EnvWorkspaceID); workspaceID != "" { + ctx = log.WithContext(ctx, log.AttrWorkspaceID(workspaceID)) + } + log.DebugContext(ctx, "running post-attach lifecycle hooks") if err := RunPostAttachHooks(ctx, cfg.SetupInfo, PostAttachOptions{ SecretsEnv: cfg.SecretsEnv, SecretsMount: cfg.SecretsMount, @@ -132,7 +150,7 @@ func SetupContainerPostAttach(ctx context.Context, cfg *ContainerSetupConfig) er return fmt.Errorf("lifecycle hooks post-attach: %w", err) } - log.Debugf("devcontainer setup completed") + log.DebugContext(ctx, "devcontainer setup completed") return nil } @@ -483,12 +501,8 @@ func writeSecrets(cfg *ContainerSetupConfig) error { func setupEnvironment(cfg *ContainerSetupConfig) error { log.Debugf("patching etc environment") - if err := patchEtcEnvironment(cfg.SetupInfo.MergedConfig); err != nil { - return fmt.Errorf("patch etc environment: %w", err) - } - - if err := patchEtcEnvironmentFlags(cfg.ExtraWorkspaceEnv); err != nil { - return fmt.Errorf("patch etc environment from flags: %w", err) + if err := applySetupEnvironment(cfg, envfile.MergeAndApply, markerFileExists); err != nil { + return err } if err := patchEtcProfile(); err != nil { @@ -498,6 +512,31 @@ func setupEnvironment(cfg *ContainerSetupConfig) error { return nil } +func applySetupEnvironment( + cfg *ContainerSetupConfig, + merge func(map[string]string), + marker func(string, string) (bool, error), +) error { + preserveTelemetry := os.Getenv(pkgconfig.EnvDisableTelemetry) == pkgconfig.BoolTrue + if err := patchEtcEnvironment( + cfg.SetupInfo.MergedConfig, + preserveTelemetry, + merge, + marker, + ); err != nil { + return fmt.Errorf("patch etc environment: %w", err) + } + if err := patchEtcEnvironmentFlags( + cfg.ExtraWorkspaceEnv, + preserveTelemetry, + merge, + marker, + ); err != nil { + return fmt.Errorf("patch etc environment from flags: %w", err) + } + return nil +} + func setupOptionalFeatures(ctx context.Context, cfg *ContainerSetupConfig) { if err := setupKubeConfig(ctx, cfg.SetupInfo, cfg.TunnelClient); err != nil { log.Errorf("setup KubeConfig: %v", err) @@ -665,8 +704,13 @@ func patchEtcProfile() error { return nil } -func patchEtcEnvironmentFlags(workspaceEnv []string) error { - if len(workspaceEnv) == 0 { +func patchEtcEnvironmentFlags( + workspaceEnv []string, + preserveTelemetry bool, + merge func(map[string]string), + marker func(string, string) (bool, error), +) error { + if len(workspaceEnv) == 0 && !preserveTelemetry { return nil } @@ -674,15 +718,18 @@ func patchEtcEnvironmentFlags(workspaceEnv []string) error { if err != nil { return err } + if preserveTelemetry { + environment[pkgconfig.EnvDisableTelemetry] = pkgconfig.BoolTrue + } - exists, err := markerFileExists("patchEtcEnvironmentFlags", strings.Join(canonical, "\n")) + exists, err := marker("patchEtcEnvironmentFlags", strings.Join(canonical, "\n")) if err != nil { return err - } else if exists { + } else if exists && !preserveTelemetry { return nil } - envfile.MergeAndApply(environment) + merge(environment) return nil } @@ -711,22 +758,37 @@ func parseWorkspaceEnvironment(assignments []string) (map[string]string, []strin return environment, canonical, nil } -func patchEtcEnvironment(mergedConfig *config.MergedDevContainerConfig) error { - if len(mergedConfig.RemoteEnv) == 0 { +func patchEtcEnvironment( + mergedConfig *config.MergedDevContainerConfig, + preserveTelemetry bool, + merge func(map[string]string), + marker func(string, string) (bool, error), +) error { + if len(mergedConfig.RemoteEnv) == 0 && !preserveTelemetry { return nil } setEnvs, unsetKeys := splitRemoteEnv(mergedConfig.RemoteEnv) - marker := buildEnvMarker(setEnvs, unsetKeys) + if preserveTelemetry { + setEnvs[pkgconfig.EnvDisableTelemetry] = pkgconfig.BoolTrue + unsetKeys = slices.DeleteFunc(unsetKeys, func(key string) bool { + return key == pkgconfig.EnvDisableTelemetry + }) + } + markerText := buildEnvMarker(setEnvs, unsetKeys) - exists, err := markerFileExists("patchEtcEnvironment", marker) + exists, err := marker("patchEtcEnvironment", markerText) if err != nil { return err - } else if exists { + } else if exists && !preserveTelemetry { return nil } - envfile.MergeAndApply(setEnvs) + merge(setEnvs) + return unsetRemoteEnv(unsetKeys) +} + +func unsetRemoteEnv(unsetKeys []string) error { for _, k := range unsetKeys { if err := os.Unsetenv(k); err != nil { return fmt.Errorf("unset env %s: %w", k, err) diff --git a/pkg/devcontainer/setup/setup_test.go b/pkg/devcontainer/setup/setup_test.go index 5437ccebac..b875330586 100644 --- a/pkg/devcontainer/setup/setup_test.go +++ b/pkg/devcontainer/setup/setup_test.go @@ -3,6 +3,8 @@ package setup import ( "context" "errors" + "fmt" + "maps" "os" "os/exec" "path/filepath" @@ -16,7 +18,6 @@ import ( "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "github.com/stretchr/testify/suite" - "go.uber.org/zap/zapcore" "google.golang.org/grpc" ) @@ -77,7 +78,7 @@ func (f *fakeTunnelClient) KubeConfig( // e2e substring-absence check is brittle to log renames; this is the // direct guard for the demotion to Debug. func TestSetupKubeConfig_EmptyPayloadSuppressesInfoLog(t *testing.T) { - logs := log.InitTestObserved(t, zapcore.DebugLevel) + logs := log.InitTestObserved(t, log.SlogLevelDebug) client := &fakeTunnelClient{kubeConfigPayload: ""} if err := setupKubeConfig(context.Background(), nil, client); err != nil { @@ -85,7 +86,7 @@ func TestSetupKubeConfig_EmptyPayloadSuppressesInfoLog(t *testing.T) { } for _, entry := range logs.All() { - if entry.Level >= zapcore.InfoLevel { + if entry.Level >= log.SlogLevelInfo { // "setup KubeConfig" specifically must not appear at Info+. if entry.Message == "setup KubeConfig" { t.Errorf("expected no 'setup KubeConfig' log; got: %+v", entry) @@ -102,7 +103,7 @@ func TestSetupKubeConfig_EmptyPayloadSuppressesInfoLog(t *testing.T) { // kubeconfig payload. writeKubeConfig may fail in the test environment, but // the log is emitted BEFORE that call so we still expect to see it. func TestSetupKubeConfig_NonEmptyPayloadEmitsInfoLog(t *testing.T) { - logs := log.InitTestObserved(t, zapcore.DebugLevel) + logs := log.InitTestObserved(t, log.SlogLevelDebug) client := &fakeTunnelClient{ kubeConfigPayload: "apiVersion: v1\nclusters: []", @@ -206,10 +207,58 @@ func (s *WorkspaceEnvironmentTestSuite) TestParseCanonicalizesWithoutChangingInp func (s *WorkspaceEnvironmentTestSuite) TestPatchRejectsDuplicatesWithoutMutatingInput() { assignments := []string{"MODE=one", "MODE=two"} original := slices.Clone(assignments) - s.Require().Error(patchEtcEnvironmentFlags(assignments)) + s.Require().Error(patchEtcEnvironmentFlags(assignments, false, nil, nil)) s.Assert().Equal(original, assignments) } +func TestSetupEnvironmentPreservesInheritedTelemetryOptOut(t *testing.T) { + const falseValue = "false" + for _, inherited := range []bool{true, false} { + t.Run(fmt.Sprintf("inherited_%t", inherited), func(t *testing.T) { + incoming := falseValue + if inherited { + incoming = pkgconfig.BoolTrue + } + t.Setenv(pkgconfig.EnvDisableTelemetry, incoming) + t.Setenv("DEVSY_ENV_CANARY", "") + remoteDisabled := falseValue + remoteCanary := "remote" + remote := map[string]*string{ + pkgconfig.EnvDisableTelemetry: &remoteDisabled, + "DEVSY_ENV_CANARY": &remoteCanary, + } + cfg := &ContainerSetupConfig{ + SetupInfo: &config.Result{MergedConfig: &config.MergedDevContainerConfig{ + DevContainerConfigBase: config.DevContainerConfigBase{RemoteEnv: remote}, + }}, + ExtraWorkspaceEnv: []string{ + pkgconfig.EnvDisableTelemetry + "=false", + "DEVSY_ENV_CANARY=workspace", + }, + } + persisted := map[string]string{pkgconfig.EnvDisableTelemetry: falseValue} + merge := func(values map[string]string) { + maps.Copy(persisted, values) + for key, value := range persisted { + require.NoError(t, os.Setenv(key, value)) + } + } + marker := func(string, string) (bool, error) { return inherited, nil } + require.NoError(t, applySetupEnvironment(cfg, merge, marker)) + expected := falseValue + if inherited { + expected = pkgconfig.BoolTrue + } + require.Equal(t, expected, os.Getenv(pkgconfig.EnvDisableTelemetry)) + require.Equal(t, expected, persisted[pkgconfig.EnvDisableTelemetry]) + require.Equal(t, "workspace", os.Getenv("DEVSY_ENV_CANARY")) + require.Equal(t, "workspace", persisted["DEVSY_ENV_CANARY"]) + require.Equal(t, "false", *remote[pkgconfig.EnvDisableTelemetry]) + require.Equal(t, pkgconfig.EnvDisableTelemetry+"=false", cfg.ExtraWorkspaceEnv[0]) + }) + } +} + func TestWriteResultFileTo_WidensExistingRestrictiveMode(t *testing.T) { path := filepath.Join(t.TempDir(), "result.json") // #nosec G306 -- intentional: simulating a pre-fix file left at 0600 @@ -386,7 +435,7 @@ func TestChownWorkspaceIgnoresForeignMarkerWithoutWorkspaceID(t *testing.T) { t.Cleanup(func() { _ = os.Remove(filepath.Join(pkgconfig.ContainerDataDir, "chownWorkspace.marker")) }) - logs := log.InitTestObserved(t, zapcore.DebugLevel) + logs := log.InitTestObserved(t, log.SlogLevelDebug) result := &config.Result{ SubstitutionContext: &config.SubstitutionContext{ diff --git a/pkg/devcontainer/setup_test.go b/pkg/devcontainer/setup_test.go index 09c0d500e5..0ae6a68d2b 100644 --- a/pkg/devcontainer/setup_test.go +++ b/pkg/devcontainer/setup_test.go @@ -23,7 +23,6 @@ import ( "github.com/devsy-org/devsy/pkg/version" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" - "go.uber.org/zap/zapcore" ) const ( @@ -573,9 +572,9 @@ func setupSSHArgvRunner(d driver.Driver) *runner { func TestBuildSSHTunnelArgvPreservesLiteralArguments(t *testing.T) { for _, debug := range []bool{false, true} { - level := zapcore.InfoLevel + level := log.SlogLevelInfo if debug { - level = zapcore.DebugLevel + level = log.SlogLevelDebug } log.InitTestObserved(t, level) r := setupSSHArgvRunner(&mockDriver{}) @@ -583,15 +582,11 @@ func TestBuildSSHTunnelArgvPreservesLiteralArguments(t *testing.T) { r.agentContainerPath(), "internal", "ssh-server", "--stdio", "--reuse-ssh-auth-sock", r.workspaceConfig.CLIOptions.SSHAuthSockID, } - if debug { - want = append(want, "--debug") - } + want = append(want, log.ForwardFlagArgs()...) assert.Equal(t, want, r.buildSSHTunnelArgv()) r.workspaceConfig.Workspace.IDE.Name = none want = []string{r.agentContainerPath(), "internal", "ssh-server", "--stdio"} - if debug { - want = append(want, "--debug") - } + want = append(want, log.ForwardFlagArgs()...) assert.Equal(t, want, r.buildSSHTunnelArgv()) } } diff --git a/pkg/devcontainer/single.go b/pkg/devcontainer/single.go index 68ebb67591..22c8feaf41 100644 --- a/pkg/devcontainer/single.go +++ b/pkg/devcontainer/single.go @@ -995,7 +995,7 @@ func (r *runner) runContainer( runOptions.Labels = append(runOptions.Labels, key+"="+value) } runOptions.AllowRecreate = p.options.Recreate - runOptions.Env = r.addExtraEnvVars(runOptions.Env) + runOptions.Env = r.addExtraEnvVars(runOptions.Env, distinctid.Get) if r.needsCurrentContainerIdentity() { runOptions.Labels = append(runOptions.Labels, metadata.CreationConfigLabel+"="+stringTrue) } @@ -1349,7 +1349,10 @@ func secretsEnvironmentTmpfsMount(enabled, supported bool) (*config.Mount, error // add environment variables that signals that we are in a remote container // (vscode compatibility) and specifically that we are using devsy. -func (r *runner) addExtraEnvVars(env map[string]string) map[string]string { +func (r *runner) addExtraEnvVars( + env map[string]string, + getDistinctID func() string, +) map[string]string { if env == nil { env = make(map[string]string) } @@ -1358,10 +1361,15 @@ func (r *runner) addExtraEnvVars(env map[string]string) map[string]string { env[RemoteContainersExtraEnvVar] = stringTrue r.addWorkspaceEnvVars(env) - if os.Getenv(pkgconfig.EnvDisableTelemetry) == pkgconfig.BoolTrue { + if os.Getenv(pkgconfig.EnvDisableTelemetry) == pkgconfig.BoolTrue || + env[pkgconfig.EnvDisableTelemetry] == pkgconfig.BoolTrue { env[pkgconfig.EnvDisableTelemetry] = pkgconfig.BoolTrue + delete(env, pkgconfig.EnvTelemetryDistinctID) + } else if id := getDistinctID(); id != "" { + env[pkgconfig.EnvTelemetryDistinctID] = id } else { - env[pkgconfig.EnvTelemetryDistinctID] = distinctid.Get() + env[pkgconfig.EnvDisableTelemetry] = pkgconfig.BoolTrue + delete(env, pkgconfig.EnvTelemetryDistinctID) } return env diff --git a/pkg/devcontainer/single_delivery_test.go b/pkg/devcontainer/single_delivery_test.go index 8072bd2da5..550f91a460 100644 --- a/pkg/devcontainer/single_delivery_test.go +++ b/pkg/devcontainer/single_delivery_test.go @@ -18,7 +18,6 @@ import ( "github.com/devsy-org/devsy/pkg/version" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" - "go.uber.org/zap/zapcore" ) type failingArchitectureDriver struct { @@ -31,7 +30,7 @@ func (d *failingArchitectureDriver) TargetArchitecture(context.Context, string) } func TestAttemptPreStartDeliveryLogsPlannedPostStartPhase(t *testing.T) { - logs := log.InitTestObserved(t, zapcore.DebugLevel) + logs := log.InitTestObserved(t, log.SlogLevelDebug) r := newTestRunner(&mockDriver{}) // A nil configuration would fail if pre-start options were built. A @@ -47,7 +46,7 @@ func TestAttemptPreStartDeliveryLogsPlannedPostStartPhase(t *testing.T) { } func TestAttemptPreStartDeliveryLogsFailureAndContinues(t *testing.T) { - logs := log.InitTestObserved(t, zapcore.DebugLevel) + logs := log.InitTestObserved(t, log.SlogLevelDebug) failure := errors.New("architecture unavailable") r := newTestRunner(&failingArchitectureDriver{err: failure}) r.workspaceConfig.Agent.Driver = provider.DockerDriver diff --git a/pkg/devcontainer/single_test.go b/pkg/devcontainer/single_test.go index 7633164558..9a71290e62 100644 --- a/pkg/devcontainer/single_test.go +++ b/pkg/devcontainer/single_test.go @@ -634,3 +634,62 @@ func TestOwnerIndependentReuseRefreshesDeveloperIdentity(t *testing.T) { require.False(t, d.stopCalled) require.False(t, d.deleteCalled) } + +func TestChildTelemetryEnvironment(t *testing.T) { + const derivedIdentity = "derived-identity" + tests := []struct { + name string + hostDisabled string + childDisabled string + distinctID string + wantDisabled string + wantID string + wantLookup bool + }{ + { + name: "identity is propagated", + distinctID: derivedIdentity, + wantID: derivedIdentity, + wantLookup: true, + }, + { + name: "identity unavailable", + childDisabled: stringFalse, + wantDisabled: pkgconfig.BoolTrue, + wantLookup: true, + }, + { + name: "host disabled", hostDisabled: pkgconfig.BoolTrue, distinctID: derivedIdentity, + wantDisabled: pkgconfig.BoolTrue, + }, + { + name: "workspace disabled", + childDisabled: pkgconfig.BoolTrue, + distinctID: derivedIdentity, + wantDisabled: pkgconfig.BoolTrue, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + t.Setenv(pkgconfig.EnvDisableTelemetry, tt.hostDisabled) + env := map[string]string{ + pkgconfig.EnvDisableTelemetry: tt.childDisabled, + pkgconfig.EnvTelemetryDistinctID: "workspace-override", + "CANARY": "retained", + } + lookedUp := false + env = (&runner{}).addExtraEnvVars(env, func() string { + lookedUp = true + return tt.distinctID + }) + require.Equal(t, tt.wantLookup, lookedUp) + if tt.wantDisabled != "" { + require.Equal(t, tt.wantDisabled, env[pkgconfig.EnvDisableTelemetry]) + require.NotContains(t, env, pkgconfig.EnvTelemetryDistinctID) + } else { + require.Equal(t, tt.wantID, env[pkgconfig.EnvTelemetryDistinctID]) + } + require.Equal(t, "retained", env["CANARY"]) + }) + } +} diff --git a/pkg/devcontainer/sshtunnel/sshtunnel.go b/pkg/devcontainer/sshtunnel/sshtunnel.go index f0cf3d64e9..266b110719 100644 --- a/pkg/devcontainer/sshtunnel/sshtunnel.go +++ b/pkg/devcontainer/sshtunnel/sshtunnel.go @@ -264,7 +264,7 @@ func runCommandInSSHTunnel(ctx context.Context, p sshCommandParams, stdin, stdou func newSSHTunnelJSONLogStreamer() *log.JSONLogStreamer { return log.NewJSONLogStreamer(log.StreamerOptions{ - FallbackLevel: log.LevelDebug, + FallbackLevel: log.SlogLevelDebug, DetectLevelPrefixes: true, TreatUnknownJSONAsDebug: true, }) diff --git a/pkg/devcontainer/sshtunnel/sshtunnel_test.go b/pkg/devcontainer/sshtunnel/sshtunnel_test.go index b3c437967e..2c2f7e83b5 100644 --- a/pkg/devcontainer/sshtunnel/sshtunnel_test.go +++ b/pkg/devcontainer/sshtunnel/sshtunnel_test.go @@ -15,7 +15,6 @@ import ( "github.com/devsy-org/devsy/pkg/tunnel" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" - "go.uber.org/zap/zapcore" ) func TestExecuteSSHServerHelperPreservesStartupSilenceError(t *testing.T) { @@ -36,42 +35,42 @@ func TestLogLine_JSONPassthrough(t *testing.T) { name string input string wantMsg string - wantLevel zapcore.Level + wantLevel log.Level }{ { name: "json with message field", input: `{"level":"info","message":"agent started"}`, wantMsg: "agent started", - wantLevel: zapcore.InfoLevel, + wantLevel: log.SlogLevelInfo, }, { name: "json with msg field", input: `{"level":"warn","msg":"disk nearly full"}`, wantMsg: "disk nearly full", - wantLevel: zapcore.WarnLevel, + wantLevel: log.SlogLevelWarn, }, { name: "json error level", input: `{"level":"error","message":"connection lost"}`, wantMsg: "connection lost", - wantLevel: zapcore.ErrorLevel, + wantLevel: log.SlogLevelError, }, { name: "unknown JSON level keeps tunnel debug fallback", input: `{"level":"notice","msg":"legacy tunnel output"}`, wantMsg: "legacy tunnel output", - wantLevel: zapcore.DebugLevel, + wantLevel: log.SlogLevelDebug, }, { name: "json debug level", input: `{"level":"debug","message":"heartbeat sent"}`, wantMsg: "heartbeat sent", - wantLevel: zapcore.DebugLevel, + wantLevel: log.SlogLevelDebug, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - logs := log.InitTestObserved(t, zapcore.DebugLevel) + logs := log.InitTestObserved(t, log.SlogLevelDebug) streamer := newSSHTunnelJSONLogStreamer() defer func() { _ = streamer.Close() }() streamer.LogLine(tt.input) @@ -89,31 +88,31 @@ func TestLogLine_JSONLevelNormalization(t *testing.T) { name string input string wantMsg string - wantLevel zapcore.Level + wantLevel log.Level }{ { - name: "trace maps to debug", + name: "trace preserves trace", input: `{"level":"trace","message":"trace event"}`, wantMsg: "trace event", - wantLevel: zapcore.DebugLevel, + wantLevel: log.SlogLevelTrace, }, { name: "warning maps to warn", input: `{"level":"warning","message":"deprecated call"}`, wantMsg: "deprecated call", - wantLevel: zapcore.WarnLevel, + wantLevel: log.SlogLevelWarn, }, { - name: "fatal maps to error", + name: "fatal preserves fatal", input: `{"level":"fatal","message":"panic recovered"}`, wantMsg: "panic recovered", - wantLevel: zapcore.ErrorLevel, + wantLevel: log.SlogLevelFatal, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - logs := log.InitTestObserved(t, zapcore.DebugLevel) + logs := log.InitTestObserved(t, log.SlogLevelTrace) streamer := newSSHTunnelJSONLogStreamer() defer func() { _ = streamer.Close() }() streamer.LogLine(tt.input) @@ -131,25 +130,25 @@ func TestLogLine_PlainText(t *testing.T) { name string input string wantMsg string - wantLevel zapcore.Level + wantLevel log.Level }{ { name: "timestamped text with level", input: "2024-01-01T00:00:00Z info some message here", wantMsg: "2024-01-01T00:00:00Z info some message here", - wantLevel: zapcore.InfoLevel, + wantLevel: log.SlogLevelInfo, }, { name: "plain text without level falls back to debug", input: "just a plain line", wantMsg: "just a plain line", - wantLevel: zapcore.DebugLevel, + wantLevel: log.SlogLevelDebug, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - logs := log.InitTestObserved(t, zapcore.DebugLevel) + logs := log.InitTestObserved(t, log.SlogLevelDebug) streamer := newSSHTunnelJSONLogStreamer() defer func() { _ = streamer.Close() }() streamer.LogLine(tt.input) @@ -163,7 +162,7 @@ func TestLogLine_PlainText(t *testing.T) { } func TestLogLine_EmptyAndWhitespace(t *testing.T) { - logs := log.InitTestObserved(t, zapcore.DebugLevel) + logs := log.InitTestObserved(t, log.SlogLevelDebug) streamer := newSSHTunnelJSONLogStreamer() defer func() { _ = streamer.Close() }() @@ -175,7 +174,7 @@ func TestLogLine_EmptyAndWhitespace(t *testing.T) { } func TestLogLine_JSONWithoutMessage(t *testing.T) { - logs := log.InitTestObserved(t, zapcore.DebugLevel) + logs := log.InitTestObserved(t, log.SlogLevelDebug) streamer := newSSHTunnelJSONLogStreamer() defer func() { _ = streamer.Close() }() @@ -183,7 +182,7 @@ func TestLogLine_JSONWithoutMessage(t *testing.T) { entries := logs.All() require.Len(t, entries, 1) - assert.Equal(t, zapcore.DebugLevel, entries[0].Level) + assert.Equal(t, log.SlogLevelDebug, entries[0].Level) } func TestExecuteCommand_PipeBridgeIntegration(t *testing.T) { diff --git a/pkg/dotfiles/dotfiles.go b/pkg/dotfiles/dotfiles.go index cd568161f3..ed7ff3f39b 100644 --- a/pkg/dotfiles/dotfiles.go +++ b/pkg/dotfiles/dotfiles.go @@ -6,6 +6,7 @@ import ( "slices" "strings" + "al.essio.dev/pkg/shellescape" client2 "github.com/devsy-org/devsy/pkg/client" "github.com/devsy-org/devsy/pkg/config" config2 "github.com/devsy-org/devsy/pkg/devcontainer/config" @@ -62,13 +63,11 @@ func Setup(p SetupParams) error { if err != nil { return err } - if log.DebugEnabled() { - dotCmd.Args = append(dotCmd.Args, names.Flag(names.Debug)) - } + dotCmd.Args = append(dotCmd.Args, log.ForwardFlagArgs()...) log.Debugf("Running dotfiles setup command: %v", dotCmd.Args) - writer := log.Writer(log.LevelInfo) + writer := log.Writer(log.SlogLevelInfo) dotCmd.Stdout = writer dotCmd.Stderr = writer @@ -85,7 +84,7 @@ func Setup(p SetupParams) error { func buildDotCmdAgentArguments( dotfilesRepo, dotfilesScript string, - strictHostKey, debug bool, + strictHostKey bool, ) []string { agentArguments := []string{ cmdInternal, @@ -100,9 +99,7 @@ func buildDotCmdAgentArguments( agentArguments = append(agentArguments, names.Flag(names.StrictHostKeyChecking)) } - if debug { - agentArguments = append(agentArguments, names.Flag(names.Debug)) - } + agentArguments = append(agentArguments, log.ForwardFlagArgs()...) if dotfilesScript != "" { agentArguments = append( @@ -157,24 +154,25 @@ func buildDotCmd(p buildDotCmdParams) (*exec.Cmd, error) { strictHostKey := p.devsyConfig.ContextOption( config.ContextOptionSSHStrictHostKeyChecking, ) == config.BoolTrue - debug := log.DebugEnabled() agentArguments := buildDotCmdAgentArguments( - p.dotfilesRepo, p.dotfilesScript, strictHostKey, debug, + p.dotfilesRepo, p.dotfilesScript, strictHostKey, ) if p.dotfilesScript != "" { log.Infof("Dotfiles script %s specified", p.dotfilesScript) } - sshCmd = append(sshCmd, + sshCmd = append( + sshCmd, names.Flag(names.User), remoteUser, names.Flag(names.Context), p.client.Context(), p.client.Workspace(), - names.FlagValue(names.LogOutput, "raw"), names.Flag(names.Command), - config.ContainerDevsyHelperLocation+" "+strings.Join(agentArguments, " "), + shellescape.QuoteCommand( + append([]string{config.ContainerDevsyHelperLocation}, agentArguments...), + ), ) execPath, err := os.Executable() if err != nil { diff --git a/pkg/dotfiles/dotfiles_test.go b/pkg/dotfiles/dotfiles_test.go index 9f0340be3c..460089a50d 100644 --- a/pkg/dotfiles/dotfiles_test.go +++ b/pkg/dotfiles/dotfiles_test.go @@ -3,6 +3,7 @@ package dotfiles import ( "testing" + "github.com/devsy-org/devsy/pkg/log" "github.com/stretchr/testify/assert" ) @@ -73,12 +74,12 @@ func TestCollectDotfilesScriptEnvKeyValuePairs(t *testing.T) { } func TestBuildDotCmdAgentArguments(t *testing.T) { + const logLevelFlag = "--log-level" tests := []struct { name string dotfilesRepo string dotfilesScript string strictHostKey bool - debug bool expected []string }{ { @@ -87,6 +88,7 @@ func TestBuildDotCmdAgentArguments(t *testing.T) { expected: []string{ cmdInternal, cmdAgent, cmdWorkspace, cmdInstallDotfs, repository, httpsGithubComUserDotfiles, + logLevelFlag, log.LevelString(), }, }, { @@ -96,6 +98,7 @@ func TestBuildDotCmdAgentArguments(t *testing.T) { expected: []string{ cmdInternal, cmdAgent, cmdWorkspace, cmdInstallDotfs, repository, httpsGithubComUserDotfiles, + logLevelFlag, log.LevelString(), "--install-script", "install.sh", }, }, @@ -104,11 +107,10 @@ func TestBuildDotCmdAgentArguments(t *testing.T) { dotfilesRepo: httpsGithubComUserDotfiles, dotfilesScript: "setup.sh", strictHostKey: true, - debug: true, expected: []string{ cmdInternal, cmdAgent, cmdWorkspace, cmdInstallDotfs, repository, httpsGithubComUserDotfiles, - "--strict-host-key-checking", "--debug", + "--strict-host-key-checking", logLevelFlag, log.LevelString(), "--install-script", "setup.sh", }, }, @@ -120,7 +122,6 @@ func TestBuildDotCmdAgentArguments(t *testing.T) { tt.dotfilesRepo, tt.dotfilesScript, tt.strictHostKey, - tt.debug, ) assert.Equal(t, tt.expected, result) }) diff --git a/pkg/driver/apple/build.go b/pkg/driver/apple/build.go index 25808e2505..6c3a1b1f01 100644 --- a/pkg/driver/apple/build.go +++ b/pkg/driver/apple/build.go @@ -23,6 +23,7 @@ func (d *appleDriver) BuildDevContainer( ctx context.Context, req driver.BuildRequest, ) (*config.BuildInfo, error) { + ctx = appleLogContext(ctx, d.workspaceID) imageName := build.GetImageName(req.LocalWorkspaceFolder, req.PrebuildHash) if req.Options.ImageName != "" { imageName = req.Options.ImageName @@ -108,7 +109,7 @@ func (d *appleDriver) executeBuild( args := buildArgs(options, platform) log.Debugf("building image with: container %s", redactArgs(args)) - writer := log.Writer(log.LevelInfo) + writer := log.Writer(log.SlogLevelInfo) defer func() { _ = writer.Close() }() stderrBuf := &bytes.Buffer{} @@ -117,7 +118,9 @@ func (d *appleDriver) executeBuild( Stdout: run.tee(writer, workspacelogs.StreamStdout), Stderr: io.MultiWriter(run.tee(writer, workspacelogs.StreamStderr), stderrBuf), } + started := time.Now() err := d.Apple.Run(ctx, args, streams) + logAppleCommand(ctx, started, err) run.finish(ctx, err) if err != nil { if stderrBuf.Len() > 0 { diff --git a/pkg/driver/apple/build_record_test.go b/pkg/driver/apple/build_record_test.go index d3ddabdc20..ce884e57a1 100644 --- a/pkg/driver/apple/build_record_test.go +++ b/pkg/driver/apple/build_record_test.go @@ -14,7 +14,6 @@ import ( "github.com/devsy-org/devsy/pkg/workspacelogs" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" - "go.uber.org/zap/zapcore" ) type streamingClient struct { @@ -84,7 +83,7 @@ func invocationRecords(recs []workspacelogs.Record) []workspacelogs.Record { } func TestExecuteBuildRetainsOutputAtWarnLevel(t *testing.T) { - logs := log.InitTestObserved(t, zapcore.WarnLevel) + logs := log.InitTestObserved(t, log.SlogLevelWarn) ctx, store, runID := recordedContext(t) d := &appleDriver{Apple: &streamingClient{stdout: "built layer\n", stderr: "warning text"}} @@ -103,7 +102,7 @@ func TestExecuteBuildRetainsOutputAtWarnLevel(t *testing.T) { } func TestExecuteBuildFailureKeepsErrorTail(t *testing.T) { - log.InitTestObserved(t, zapcore.WarnLevel) + log.InitTestObserved(t, log.SlogLevelWarn) ctx, store, runID := recordedContext(t) cause := errors.New("exit status 2") d := &appleDriver{Apple: &streamingClient{stderr: "no space left\n", err: cause}} @@ -121,7 +120,7 @@ func TestExecuteBuildFailureKeepsErrorTail(t *testing.T) { } func TestExecuteBuildCanceledIsRecorded(t *testing.T) { - log.InitTestObserved(t, zapcore.WarnLevel) + log.InitTestObserved(t, log.SlogLevelWarn) ctx, store, runID := recordedContext(t) ctx, cancel := context.WithCancel(ctx) cancel() @@ -136,7 +135,7 @@ func TestExecuteBuildCanceledIsRecorded(t *testing.T) { } func TestExecuteBuildWithoutRecorderLogsOnly(t *testing.T) { - logs := log.InitTestObserved(t, zapcore.InfoLevel) + logs := log.InitTestObserved(t, log.SlogLevelInfo) d := &appleDriver{Apple: &streamingClient{stdout: "plain\n"}} require.NoError(t, d.executeBuild(t.Context(), &build.BuildOptions{}, "")) @@ -148,6 +147,22 @@ func TestExecuteBuildWithoutRecorderLogsOnly(t *testing.T) { assert.Equal(t, []string{"plain"}, messages) } +func TestExecuteBuildLogsRuntimeContext(t *testing.T) { + logs := log.InitTestObserved(t, log.SlogLevelDebug) + d := &appleDriver{Apple: &streamingClient{}, workspaceID: "workspace-1"} + ctx := appleLogContext(t.Context(), d.workspaceID) + + require.NoError(t, d.executeBuild(ctx, &build.BuildOptions{}, "")) + entries := logs.FilterMessage("apple runtime command completed").All() + require.Len(t, entries, 1) + attrs := entries[0].AttrsMap() + assert.Equal(t, "builtin-driver", attrs["component"]) + assert.Equal(t, "apple", attrs["provider"]) + assert.Equal(t, "workspace-1", attrs["workspace_id"]) + assert.EqualValues(t, 0, attrs["exit_code"]) + assert.Contains(t, attrs, "duration_ms") +} + func TestResolveExistingImageRecordsReuse(t *testing.T) { ctx, store, runID := recordedContext(t) d := &appleDriver{Apple: &mockClient{}} diff --git a/pkg/driver/apple/driver.go b/pkg/driver/apple/driver.go index 4fe81f8c6c..248385fd83 100644 --- a/pkg/driver/apple/driver.go +++ b/pkg/driver/apple/driver.go @@ -9,8 +9,10 @@ import ( "context" "errors" "fmt" + "log/slog" "os/exec" "runtime" + "time" "github.com/devsy-org/devsy/pkg/apple" "github.com/devsy-org/devsy/pkg/devcontainer/config" @@ -30,6 +32,7 @@ type appleDriver struct { Rosetta bool command string // binary path, retained for logging containerID string // set when the workspace source is an existing container + workspaceID string } var ( @@ -45,9 +48,14 @@ var ( // NewAppleDriver verifies the host is supported and constructs the driver; // Preflight validates the container system service. func NewAppleDriver( - _ context.Context, + ctx context.Context, workspaceInfo *provider.AgentWorkspaceInfo, ) (driver.ImageDriver, error) { + workspaceID := "" + if workspaceInfo.Workspace != nil { + workspaceID = workspaceInfo.Workspace.ID + } + ctx = appleLogContext(ctx, workspaceID) if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" { return nil, fmt.Errorf( "the apple provider requires an Apple silicon Mac (found %s/%s)", @@ -67,26 +75,33 @@ func NewAppleDriver( rosetta, err := workspaceInfo.Agent.Apple.Rosetta.Bool() if err != nil { - log.Warnf( - "invalid rosetta value %q, defaulting to false: %v", - workspaceInfo.Agent.Apple.Rosetta, err, + log.WarnContext( + ctx, + "invalid rosetta value, defaulting to false", + slog.String( + "value", + string(workspaceInfo.Agent.Apple.Rosetta), + ), + slog.String("error", err.Error()), ) rosetta = false } - log.Debugf("using apple container command: command=%s, rosetta=%t", command, rosetta) + log.DebugContext(ctx, "using apple container driver", slog.Bool("rosetta", rosetta)) return &appleDriver{ Apple: helper, IDLabels: workspaceInfo.CLIOptions.IDLabels, Rosetta: rosetta, command: command, containerID: workspaceInfo.Workspace.Source.Container, + workspaceID: workspaceID, }, nil } // Preflight checks the `container` binary is installed and the system service // running, starting it unless auto-start is disabled. func (d *appleDriver) Preflight(ctx context.Context, opts driver.PreflightOptions) error { + ctx = appleLogContext(ctx, d.workspaceID) if _, err := exec.LookPath(d.command); err != nil { return &driver.PreflightError{ Provider: provider.AppleDriver, @@ -127,6 +142,7 @@ func (d *appleDriver) FindDevContainer( ctx context.Context, workspaceID string, ) (*config.ContainerDetails, error) { + ctx = appleLogContext(ctx, workspaceID) var containerDetails *config.ContainerDetails var err error if d.containerID != "" { @@ -158,3 +174,20 @@ func (d *appleDriver) RequiresMountStreaming() bool { return false } func (d *appleDriver) RecreateMode() driver.RecreateMode { return driver.RecreateDelete } func (d *appleDriver) RequiresWorkspaceChown() bool { return false } + +func appleLogContext(ctx context.Context, workspaceID string) context.Context { + return log.WithContext(ctx, log.AttrComponent("builtin-driver"), + log.AttrProvider(provider.AppleDriver), log.AttrWorkspaceID(workspaceID)) +} + +func logAppleCommand(ctx context.Context, started time.Time, err error) { + attrs := []slog.Attr{log.AttrDurationMs(time.Since(started).Milliseconds())} + if err == nil { + attrs = append(attrs, slog.Int("exit_code", 0)) + } else { + if exitErr, ok := errors.AsType[*exec.ExitError](err); ok { + attrs = append(attrs, slog.Int("exit_code", exitErr.ExitCode())) + } + } + log.DebugContext(ctx, "apple runtime command completed", attrs...) +} diff --git a/pkg/driver/apple/lifecycle.go b/pkg/driver/apple/lifecycle.go index b0a1884e52..de78233817 100644 --- a/pkg/driver/apple/lifecycle.go +++ b/pkg/driver/apple/lifecycle.go @@ -4,6 +4,8 @@ import ( "context" "fmt" "io" + "log/slog" + "time" "github.com/devsy-org/devsy/pkg/apple" "github.com/devsy-org/devsy/pkg/devcontainer/config" @@ -16,6 +18,7 @@ func (d *appleDriver) CommandDevContainer( ctx context.Context, params *driver.CommandParams, ) error { + ctx = appleLogContext(ctx, params.WorkspaceID) container, err := d.FindDevContainer(ctx, params.WorkspaceID) if err != nil { return err @@ -39,9 +42,12 @@ func (d *appleDriver) CommandDevContainer( args = append(args, "-u", params.User) } args = append(args, container.ID, "sh", "-c", params.Command) - return d.Apple.Run(ctx, args, apple.Streams{ + started := time.Now() + err = d.Apple.Run(ctx, args, apple.Streams{ Stdin: params.Stdin, Stdout: params.Stdout, Stderr: params.Stderr, }) + logAppleCommand(ctx, started, err) + return err } // SupportsRequireRunning reports that CommandDevContainer honors RequireRunning. @@ -74,6 +80,7 @@ func (d *appleDriver) requireDevContainer( } func (d *appleDriver) StartDevContainer(ctx context.Context, workspaceID string) error { + ctx = appleLogContext(ctx, workspaceID) container, err := d.requireDevContainer(ctx, workspaceID) if err != nil { return err @@ -82,6 +89,7 @@ func (d *appleDriver) StartDevContainer(ctx context.Context, workspaceID string) } func (d *appleDriver) StopDevContainer(ctx context.Context, workspaceID string) error { + ctx = appleLogContext(ctx, workspaceID) container, err := d.requireDevContainer(ctx, workspaceID) if err != nil { return err @@ -90,6 +98,7 @@ func (d *appleDriver) StopDevContainer(ctx context.Context, workspaceID string) } func (d *appleDriver) DeleteDevContainer(ctx context.Context, workspaceID string) error { + ctx = appleLogContext(ctx, workspaceID) container, err := d.FindDevContainer(ctx, workspaceID) if err != nil { return err @@ -101,7 +110,7 @@ func (d *appleDriver) DeleteDevContainer(ctx context.Context, workspaceID string // container is genuinely still running). if container.State.Status == config.ContainerStatusRunning { if err := d.Apple.Stop(ctx, container.ID); err != nil { - log.Warnf("stop before delete failed for %s: %v", container.ID, err) + log.WarnContext(ctx, "stop before delete failed", slog.String("error", err.Error())) } } return d.Apple.Remove(ctx, container.ID) @@ -113,6 +122,7 @@ func (d *appleDriver) GetDevContainerLogs( stdout io.Writer, stderr io.Writer, ) error { + ctx = appleLogContext(ctx, workspaceID) container, err := d.requireDevContainer(ctx, workspaceID) if err != nil { return err @@ -132,7 +142,7 @@ func (d *appleDriver) GetImageTag(ctx context.Context, imageID string) (string, } func (d *appleDriver) PushDevContainer(ctx context.Context, image string) error { - writer := log.Writer(log.LevelInfo) + writer := log.Writer(log.SlogLevelInfo) defer func() { _ = writer.Close() }() if err := d.Apple.Push(ctx, image, writer, writer); err != nil { return fmt.Errorf("push image: %w", err) @@ -161,6 +171,7 @@ func (d *appleDriver) RunImageDevContainer( ctx context.Context, params *driver.RunImageDevContainerParams, ) error { + ctx = appleLogContext(ctx, params.WorkspaceID) if err := d.ValidateRunImageDevContainer(params); err != nil { return err } @@ -171,15 +182,17 @@ func (d *appleDriver) RunImageDevContainer( args := d.buildRunArgs(params) - writer := log.Writer(log.LevelInfo) + writer := log.Writer(log.SlogLevelInfo) defer func() { _ = writer.Close() }() log.Infof( "running apple container command: command=%s, args=%s", d.command, redactArgs(args), ) + started := time.Now() err := d.Apple.RunWithDir(ctx, params.LocalWorkspaceFolder, args, apple.Streams{Stdout: writer, Stderr: writer}) + logAppleCommand(ctx, started, err) if err != nil { return fmt.Errorf("failed to start dev container: %w", err) } @@ -199,7 +212,7 @@ func (d *appleDriver) EnsureImage(ctx context.Context, options *driver.RunOption } log.Debugf("image not found, pulling image: image=%s", options.Image) - writer := log.Writer(log.LevelDebug) + writer := log.Writer(log.SlogLevelDebug) defer func() { _ = writer.Close() }() return d.Apple.Pull(ctx, apple.PullOptions{ Image: options.Image, diff --git a/pkg/driver/custom/custom.go b/pkg/driver/custom/custom.go index 83bc4abc89..3094cdbbe7 100644 --- a/pkg/driver/custom/custom.go +++ b/pkg/driver/custom/custom.go @@ -6,8 +6,8 @@ import ( "encoding/json" "fmt" "io" + "log/slog" "strings" - "time" "github.com/devsy-org/devsy/pkg/agent" "github.com/devsy-org/devsy/pkg/client/clientimplementation" @@ -16,9 +16,8 @@ import ( "github.com/devsy-org/devsy/pkg/driver" "github.com/devsy-org/devsy/pkg/log" "github.com/devsy-org/devsy/pkg/provider" - "github.com/devsy-org/devsy/pkg/scanner" + "github.com/devsy-org/devsy/pkg/secrets" "github.com/devsy-org/devsy/pkg/types" - "go.uber.org/zap/zapcore" ) func NewCustomDriver(workspaceInfo *provider.AgentWorkspaceInfo) driver.Driver { @@ -42,24 +41,21 @@ func (c *customDriver) FindDevContainer( ctx context.Context, workspaceId string, ) (*config.ContainerDetails, error) { - writer := log.Writer(log.LevelInfo) - defer func() { _ = writer.Close() }() - stdout := &bytes.Buffer{} if err := c.runCommand(ctx, runCommandOptions{ - workspaceId: workspaceId, - name: "findDevContainer", - command: c.workspaceInfo.Agent.Custom.FindDevContainer, - stdout: stdout, - stderr: writer, + workspaceId: workspaceId, + name: "findDevContainer", + command: c.workspaceInfo.Agent.Custom.FindDevContainer, + stdout: stdout, + diagnosticStderr: true, }); err != nil { - return nil, fmt.Errorf("error finding devcontainer: %s%w", stdout.String(), err) + return nil, fmt.Errorf("error finding devcontainer: %w", err) } else if len(stdout.Bytes()) == 0 { return nil, nil } var containerDetails config.ContainerDetails if err := json.Unmarshal(stdout.Bytes(), &containerDetails); err != nil { - return nil, fmt.Errorf("error parsing devcontainer details: %s%w", stdout.String(), err) + return nil, fmt.Errorf("error parsing devcontainer details: %w", err) } return &containerDetails, nil @@ -91,26 +87,20 @@ func (c *customDriver) CommandDevContainer( // TargetArchitecture returns the architecture of the container runtime. e.g. amd64 or arm64. func (c *customDriver) TargetArchitecture(ctx context.Context, workspaceId string) (string, error) { - writer := log.Writer(log.LevelInfo) - defer func() { _ = writer.Close() }() - stdout := &bytes.Buffer{} if err := c.runCommand(ctx, runCommandOptions{ - workspaceId: workspaceId, - name: "getTargetArchitecture", - command: c.workspaceInfo.Agent.Custom.TargetArchitecture, - stdout: stdout, - stderr: writer, + workspaceId: workspaceId, + name: "getTargetArchitecture", + command: c.workspaceInfo.Agent.Custom.TargetArchitecture, + stdout: stdout, + diagnosticStderr: true, }); err != nil { - return "", fmt.Errorf("error getting target architecture: %s%w", stdout.String(), err) + return "", fmt.Errorf("error getting target architecture: %w", err) } targetArchitecture := strings.ToLower(strings.TrimSpace(stdout.String())) if targetArchitecture != "amd64" && targetArchitecture != "arm64" { - return "", fmt.Errorf( - "invalid target architecture %s, expected either arm64 or amd64", - targetArchitecture, - ) + return "", fmt.Errorf("invalid target architecture, expected either arm64 or amd64") } return targetArchitecture, nil @@ -118,17 +108,14 @@ func (c *customDriver) TargetArchitecture(ctx context.Context, workspaceId strin // DeleteDevContainer deletes the devcontainer. func (c *customDriver) DeleteDevContainer(ctx context.Context, workspaceId string) error { - writer := log.Writer(log.LevelInfo) - defer func() { _ = writer.Close() }() - if err := c.runCommand(ctx, runCommandOptions{ - workspaceId: workspaceId, - name: "deleteDevContainer", - command: c.workspaceInfo.Agent.Custom.DeleteDevContainer, - stdin: nil, - stdout: writer, - stderr: writer, - extraEnv: nil, + workspaceId: workspaceId, + name: "deleteDevContainer", + command: c.workspaceInfo.Agent.Custom.DeleteDevContainer, + stdin: nil, + diagnosticStdout: true, + diagnosticStderr: true, + extraEnv: nil, }); err != nil { return fmt.Errorf("error deleting devcontainer: %w", err) } @@ -137,15 +124,12 @@ func (c *customDriver) DeleteDevContainer(ctx context.Context, workspaceId strin // StartDevContainer starts the devcontainer. func (c *customDriver) StartDevContainer(ctx context.Context, workspaceId string) error { - writer := log.Writer(log.LevelInfo) - defer func() { _ = writer.Close() }() - if err := c.runCommand(ctx, runCommandOptions{ - workspaceId: workspaceId, - name: "startDevContainer", - command: c.workspaceInfo.Agent.Custom.StartDevContainer, - stdout: writer, - stderr: writer, + workspaceId: workspaceId, + name: "startDevContainer", + command: c.workspaceInfo.Agent.Custom.StartDevContainer, + diagnosticStdout: true, + diagnosticStderr: true, }); err != nil { return fmt.Errorf("error starting devcontainer: %w", err) } @@ -155,17 +139,14 @@ func (c *customDriver) StartDevContainer(ctx context.Context, workspaceId string // StopDevContainer stops the devcontainer. func (c *customDriver) StopDevContainer(ctx context.Context, workspaceId string) error { - writer := log.Writer(log.LevelInfo) - defer func() { _ = writer.Close() }() - if err := c.runCommand(ctx, runCommandOptions{ - workspaceId: workspaceId, - name: "stopDevContainer", - command: c.workspaceInfo.Agent.Custom.StopDevContainer, - stdin: nil, - stdout: writer, - stderr: writer, - extraEnv: nil, + workspaceId: workspaceId, + name: "stopDevContainer", + command: c.workspaceInfo.Agent.Custom.StopDevContainer, + stdin: nil, + diagnosticStdout: true, + diagnosticStderr: true, + extraEnv: nil, }); err != nil { return fmt.Errorf("error stopping devcontainer: %w", err) } @@ -184,33 +165,17 @@ func (c *customDriver) RunDevContainer( return fmt.Errorf("marshal run options: %w", err) } - done := make(chan struct{}) - reader, writer := io.Pipe() - defer func() { _ = writer.Close() }() - go func() { - scan := scanner.NewScanner(reader) - for scan.Scan() { - log.Info(scan.Text()) - } - done <- struct{}{} - }() - if err := c.runCommand(ctx, runCommandOptions{ - workspaceId: workspaceId, - name: "runDevContainer", - command: c.workspaceInfo.Agent.Custom.RunDevContainer, - stdin: nil, - stdout: writer, - stderr: writer, + workspaceId: workspaceId, + name: "runDevContainer", + command: c.workspaceInfo.Agent.Custom.RunDevContainer, + stdin: nil, + diagnosticStdout: true, + diagnosticStderr: true, extraEnv: []string{ "DEVCONTAINER_RUN_OPTIONS=" + string(out), }, }); err != nil { - _ = writer.Close() // close writer to unblock logging goroutine - select { - case <-done: - case <-time.After(1 * time.Second): // timeout to avoid hanging if logging goroutine is blocked - } return fmt.Errorf("error running devcontainer: %w", err) } @@ -243,14 +208,16 @@ func (c *customDriver) CanReprovision() bool { } type runCommandOptions struct { - workspaceId string - name string - command types.StrArray - stdin io.Reader - stdout io.Writer - stderr io.Writer - rawStdout bool - extraEnv []string + workspaceId string + name string + command types.StrArray + stdin io.Reader + stdout io.Writer + stderr io.Writer + rawStdout bool + extraEnv []string + diagnosticStdout bool + diagnosticStderr bool } func ToEnvironWithBinaries( @@ -302,7 +269,7 @@ func (c *customDriver) runCommand( return nil } - log.Debugf("run %s driver command: %s", runOpts.name, strings.Join(runOpts.command, " ")) + log.Debugf("run %s driver command", runOpts.name) environ, err := ToEnvironWithBinaries(ctx, c.workspaceInfo) if err != nil { return err @@ -310,11 +277,46 @@ func (c *customDriver) runCommand( environ = append(environ, pkgconfig.EnvDevcontainerID+"="+runOpts.workspaceId) environ = append(environ, runOpts.extraEnv...) - if log.Underlying().Core().Enabled(zapcore.DebugLevel) { - environ = append(environ, pkgconfig.EnvDebug+"="+pkgconfig.BoolTrue) + var stdoutStream, stderrStream *log.JSONLogStreamer + if runOpts.diagnosticStdout || runOpts.diagnosticStderr { + var optionEntries []string + for key, value := range provider.CombineOptions( + c.workspaceInfo.Workspace, c.workspaceInfo.Machine, c.workspaceInfo.Options, + ) { + optionEntries = append(optionEntries, key+"="+value.Value) + } + attrs := []slog.Attr{ + log.AttrComponent("custom-driver"), + log.AttrOperation(runOpts.name), + log.AttrWorkspaceID(runOpts.workspaceId), + } + if c.workspaceInfo.Workspace != nil { + attrs = append(attrs, log.AttrProvider(c.workspaceInfo.Workspace.Provider.Name)) + } + if c.workspaceInfo.Machine != nil { + attrs = append(attrs, log.AttrMachineID(c.workspaceInfo.Machine.ID)) + } + streamOptions := log.StreamerOptions{ + Redactor: secrets.Combine( + secrets.NewRedactor(optionEntries), + secrets.NewEnvironmentRedactor(environ), + ), + FallbackLevel: log.SlogLevelInfo, + DefaultAttrs: attrs, + } + if runOpts.diagnosticStdout { + stdoutStream = log.NewJSONLogStreamer(streamOptions) + runOpts.stdout = stdoutStream + } + if runOpts.diagnosticStderr { + streamOptions.CaptureLines = 50 + streamOptions.CaptureBytes = 32 * 1024 + stderrStream = log.NewJSONLogStreamer(streamOptions) + runOpts.stderr = stderrStream + } } - return clientimplementation.RunCommand(ctx, clientimplementation.RunCommandOptions{ + err = clientimplementation.RunCommand(ctx, clientimplementation.RunCommandOptions{ Command: runOpts.command, Environ: environ, Stdin: runOpts.stdin, @@ -322,4 +324,14 @@ func (c *customDriver) runCommand( Stderr: runOpts.stderr, RawStdout: runOpts.rawStdout, }) + if stdoutStream != nil { + _ = stdoutStream.Close() + } + if stderrStream != nil { + _ = stderrStream.Close() + if output := stderrStream.ErrorOutput(); err != nil && output != "" { + err = fmt.Errorf("%s: %w", output, err) + } + } + return err } diff --git a/pkg/driver/custom/custom_logging_test.go b/pkg/driver/custom/custom_logging_test.go new file mode 100644 index 0000000000..698da1a0f2 --- /dev/null +++ b/pkg/driver/custom/custom_logging_test.go @@ -0,0 +1,138 @@ +package custom + +import ( + "bytes" + "context" + "errors" + "os/exec" + "runtime" + "strings" + "testing" + + "github.com/devsy-org/devsy/pkg/config" + "github.com/devsy-org/devsy/pkg/log" + "github.com/devsy-org/devsy/pkg/provider" + "github.com/devsy-org/devsy/pkg/types" +) + +const ( + testWindows = "windows" + testShell = "/bin/sh" + testStartContainer = "startDevContainer" +) + +func TestCustomDiagnosticsRedactAndPreserveExit(t *testing.T) { + if runtime.GOOS == testWindows { + t.Skip("requires /bin/sh") + } + observed := log.InitTestObserved(t, log.SlogLevelDebug) + c := &customDriver{workspaceInfo: &provider.AgentWorkspaceInfo{ + Origin: t.TempDir(), + Workspace: &provider.Workspace{Provider: provider.WorkspaceProviderConfig{Name: "example"}}, + Options: map[string]config.OptionValue{"custom_value": {Value: "private-canary-value"}}, + }} + err := c.runCommand(context.Background(), runCommandOptions{ + workspaceId: "workspace-test", + name: testStartContainer, + command: types.StrArray{ + testShell, + "-c", + `printf '%s\n' '{"level":"error","msg":"private-canary-value"}' >&2; exit 7`, + }, + diagnosticStderr: true, + }) + var exitErr *exec.ExitError + if !errors.As(err, &exitErr) || exitErr.ExitCode() != 7 { + t.Fatalf("expected exit 7, got %v", err) + } + if strings.Contains(err.Error(), "private-canary-value") { + t.Fatalf("secret in error: %s", err) + } + entries := observed.FilterMessage("***").All() + if len(entries) != 1 || entries[0].AttrsMap()["provider"] != "example" || + entries[0].AttrsMap()["workspace_id"] != "workspace-test" { + t.Fatalf("unexpected records: %#v", entries) + } +} + +func TestCustomCommandPreservesRawUserStreams(t *testing.T) { + if runtime.GOOS == testWindows { + t.Skip("requires /bin/sh") + } + c := &customDriver{workspaceInfo: &provider.AgentWorkspaceInfo{Origin: t.TempDir()}} + var stdout, stderr bytes.Buffer + err := c.runCommand(context.Background(), runCommandOptions{ + name: "commandDevContainer", + command: types.StrArray{ + testShell, + "-c", + `printf '\001{"level":"info"}'; printf 'ordinary stderr' >&2`, + }, + stdout: &stdout, + stderr: &stderr, + rawStdout: true, + }) + if err != nil { + t.Fatal(err) + } + if stdout.String() != "\x01{\"level\":\"info\"}" || stderr.String() != "ordinary stderr" { + t.Fatalf("unexpected streams: stdout=%q stderr=%q", stdout.String(), stderr.String()) + } +} + +func TestCustomDiagnosticsBoundedAndDrained(t *testing.T) { + if runtime.GOOS == testWindows { + t.Skip("requires /bin/sh") + } + log.InitTestObserved(t, log.SlogLevelDebug) + c := &customDriver{workspaceInfo: &provider.AgentWorkspaceInfo{Origin: t.TempDir()}} + err := c.runCommand(context.Background(), runCommandOptions{ + name: testStartContainer, + command: types.StrArray{testShell, "-c", `printf 'old-marker\n' >&2; i=0; ` + + `while [ "$i" -lt 60 ]; do printf '%0700d\n' 0 >&2; i=$((i+1)); done; ` + + `printf 'last-marker' >&2; exit 7`}, + diagnosticStderr: true, + }) + if err == nil || len(err.Error()) > 32*1024+256 || + strings.Contains(err.Error(), "old-marker") || + !strings.Contains(err.Error(), "last-marker") { + t.Fatalf("unexpected diagnostic tail: %v", err) + } +} + +func TestCustomDiagnosticsPreserveCancellation(t *testing.T) { + if runtime.GOOS == testWindows { + t.Skip("requires /bin/sh") + } + log.InitTestObserved(t, log.SlogLevelDebug) + c := &customDriver{workspaceInfo: &provider.AgentWorkspaceInfo{Origin: t.TempDir()}} + ctx, cancel := context.WithCancel(context.Background()) + cancel() + err := c.runCommand(ctx, runCommandOptions{ + name: testStartContainer, + command: types.StrArray{testShell, "-c", "exit 0"}, + diagnosticStdout: true, + diagnosticStderr: true, + }) + if !errors.Is(err, context.Canceled) { + t.Fatalf("expected cancellation, got %v", err) + } +} + +func TestCustomFailureTailExcludesPresentationStdout(t *testing.T) { + if runtime.GOOS == testWindows { + t.Skip("requires /bin/sh") + } + c := &customDriver{workspaceInfo: &provider.AgentWorkspaceInfo{Origin: t.TempDir()}} + err := c.runCommand(context.Background(), runCommandOptions{ + command: types.StrArray{ + testShell, "-c", "printf 'stdout-canary\\n'; printf 'stderr-canary\\n' >&2; exit 7", + }, + diagnosticStdout: true, + diagnosticStderr: true, + }) + if err == nil || !strings.Contains(err.Error(), "stderr-canary") || + strings.Contains(err.Error(), "stdout-canary") { + t.Fatalf("unexpected diagnostic failure: %v", err) + } +} diff --git a/pkg/driver/docker/build.go b/pkg/driver/docker/build.go index 3e625d8e45..f865a1dece 100644 --- a/pkg/driver/docker/build.go +++ b/pkg/driver/docker/build.go @@ -24,6 +24,8 @@ func (d *dockerDriver) BuildDevContainer( ctx context.Context, req driver.BuildRequest, ) (*config.BuildInfo, error) { + ctx = d.logContext(ctx, "") + log.DebugContext(ctx, "building dev container") imageName := build.GetImageName(req.LocalWorkspaceFolder, req.PrebuildHash) if req.Options.ImageName != "" { imageName = req.Options.ImageName @@ -510,7 +512,7 @@ func (d *dockerDriver) executeBuild( ) error { log.Debugf("build with %s", strategy.name()) writer := log.NewJSONLogStreamer(log.StreamerOptions{ - FallbackLevel: log.LevelInfo, + FallbackLevel: log.SlogLevelInfo, }) defer func() { _ = writer.Close() }() diff --git a/pkg/driver/docker/build_record_test.go b/pkg/driver/docker/build_record_test.go index 8c7f914fb4..7dfca3d943 100644 --- a/pkg/driver/docker/build_record_test.go +++ b/pkg/driver/docker/build_record_test.go @@ -17,7 +17,6 @@ import ( "github.com/devsy-org/devsy/pkg/workspacelogs" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" - "go.uber.org/zap/zapcore" ) func recordedContext(t *testing.T) (context.Context, *workspacelogs.Store, string) { @@ -116,7 +115,7 @@ func (s streamedFake) buildStreamed( } func TestExecuteBuildRetainsOutputAtWarnLevel(t *testing.T) { - logs := log.InitTestObserved(t, zapcore.WarnLevel) + logs := log.InitTestObserved(t, log.SlogLevelWarn) ctx, store, runID := recordedContext(t) err := (&dockerDriver{}).executeBuild( @@ -142,7 +141,7 @@ func TestExecuteBuildRetainsOutputAtWarnLevel(t *testing.T) { } func TestExecuteBuildFailureKeepsErrorAndRecordsFailed(t *testing.T) { - log.InitTestObserved(t, zapcore.WarnLevel) + log.InitTestObserved(t, log.SlogLevelWarn) ctx, store, runID := recordedContext(t) cause := errors.New("solve exploded") @@ -161,7 +160,7 @@ func TestExecuteBuildFailureKeepsErrorAndRecordsFailed(t *testing.T) { } func TestExecuteBuildCanceledIsRecorded(t *testing.T) { - log.InitTestObserved(t, zapcore.WarnLevel) + log.InitTestObserved(t, log.SlogLevelWarn) ctx, store, runID := recordedContext(t) ctx, cancel := context.WithCancel(ctx) cancel() @@ -182,7 +181,7 @@ func TestExecuteBuildCanceledIsRecorded(t *testing.T) { } func TestExecuteBuildWithoutRecorderUsesLoggerOnly(t *testing.T) { - logs := log.InitTestObserved(t, zapcore.DebugLevel) + logs := log.InitTestObserved(t, log.SlogLevelDebug) err := (&dockerDriver{}).executeBuild( t.Context(), @@ -216,7 +215,7 @@ func writeBuildxScript(t *testing.T) string { } func TestBuildxKeepsStreamsSeparateAndErrorTail(t *testing.T) { - log.InitTestObserved(t, zapcore.WarnLevel) + log.InitTestObserved(t, log.SlogLevelWarn) ctx, store, runID := recordedContext(t) d := &dockerDriver{Docker: &docker.DockerHelper{DockerCommand: writeBuildxScript(t)}} diff --git a/pkg/driver/docker/build_test.go b/pkg/driver/docker/build_test.go index 6fd47e48b8..6b3bc22078 100644 --- a/pkg/driver/docker/build_test.go +++ b/pkg/driver/docker/build_test.go @@ -16,7 +16,6 @@ import ( "github.com/devsy-org/devsy/pkg/provider" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" - "go.uber.org/zap/zapcore" ) func writeHelperScript(t *testing.T, dir, name, output string) string { @@ -285,7 +284,7 @@ func (s testBuildStrategy) build( func (testBuildStrategy) name() string { return "test build" } func TestExecuteBuildDecodesStructuredOutput(t *testing.T) { - logs := log.InitTestObserved(t, zapcore.DebugLevel) + logs := log.InitTestObserved(t, log.SlogLevelDebug) driverUnderTest := &dockerDriver{} strategy := testBuildStrategy{ output: "build starting\n" + @@ -305,7 +304,7 @@ func TestExecuteBuildDecodesStructuredOutput(t *testing.T) { require.Len(t, entries, 4) assert.Equal(t, "build with test build", entries[0].Message) assert.Equal(t, "build starting", entries[1].Message) - assert.Equal(t, zapcore.DebugLevel, entries[2].Level) + assert.Equal(t, log.SlogLevelDebug, entries[2].Level) assert.Equal(t, "credential request received", entries[2].Message) assert.Equal(t, "build complete", entries[3].Message) assert.NotContains(t, entries[2].Message, `{"level":"debug"`) diff --git a/pkg/driver/docker/docker.go b/pkg/driver/docker/docker.go index 248dc3b80a..70219da43d 100644 --- a/pkg/driver/docker/docker.go +++ b/pkg/driver/docker/docker.go @@ -83,10 +83,21 @@ func NewDockerDriver( return nil, err } + workspaceID := "" + if workspaceInfo.Workspace != nil { + workspaceID = workspaceInfo.Workspace.ID + } + machineID := "" + if workspaceInfo.Machine != nil { + machineID = workspaceInfo.Machine.ID + } + return &dockerDriver{ Docker: dockerHelper, IDLabels: workspaceInfo.CLIOptions.IDLabels, UpdateRemoteUserUIDDefault: workspaceInfo.CLIOptions.UpdateRemoteUserUIDDefault, + workspaceID: workspaceID, + machineID: machineID, }, nil } @@ -95,6 +106,8 @@ type dockerDriver struct { Compose *compose.ComposeHelper IDLabels []string UpdateRemoteUserUIDDefault string + workspaceID string + machineID string } // The docker driver supports the full image, compose, docker-helper, and @@ -429,3 +442,21 @@ func (d *dockerDriver) RequiresMountStreaming() bool { return false } func (d *dockerDriver) RecreateMode() driver.RecreateMode { return driver.RecreateDelete } func (d *dockerDriver) RequiresWorkspaceChown() bool { return false } + +func (d *dockerDriver) logContext(ctx context.Context, workspaceID string) context.Context { + providerName := "docker" + if d.Docker != nil && d.Docker.Runtime != nil { + providerName = string(d.Docker.Runtime.Name()) + } + ctx = log.WithContext(ctx, log.AttrComponent("docker-driver"), log.AttrProvider(providerName)) + if workspaceID == "" { + workspaceID = d.workspaceID + } + if workspaceID != "" { + ctx = log.WithContext(ctx, log.AttrWorkspaceID(workspaceID)) + } + if d.machineID != "" { + ctx = log.WithContext(ctx, log.AttrMachineID(d.machineID)) + } + return ctx +} diff --git a/pkg/driver/docker/lifecycle.go b/pkg/driver/docker/lifecycle.go index c64009485b..b2b572ed51 100644 --- a/pkg/driver/docker/lifecycle.go +++ b/pkg/driver/docker/lifecycle.go @@ -5,6 +5,7 @@ import ( "errors" "fmt" "io" + "log/slog" "os" "strings" "time" @@ -43,6 +44,7 @@ func (d *dockerDriver) CommandDevContainer( ctx context.Context, params *driver.CommandParams, ) error { + ctx = d.logContext(ctx, params.WorkspaceID) container, err := d.requireDevContainer(ctx, params.WorkspaceID) if err != nil { return err @@ -61,11 +63,13 @@ func (d *dockerDriver) CommandDevContainer( args = append(args, "-i") } args = append(args, "-u", params.User, container.ID, "sh", "-c", params.Command) + started := time.Now() err = d.Docker.Run(ctx, args, docker.Streams{ Stdin: params.Stdin, Stdout: params.Stdout, Stderr: params.Stderr, }) + logDockerCommandResult(ctx, "exec", started, err) if err != nil { return fmt.Errorf("run command in container: %w", err) } @@ -199,7 +203,7 @@ func (d *dockerDriver) runLoggedDockerCommand( subcommand string, args []string, ) error { - writer := log.Writer(log.LevelInfo) + writer := log.Writer(log.SlogLevelInfo) defer func() { _ = writer.Close() }() log.Debugf( @@ -237,6 +241,7 @@ func (d *dockerDriver) TagDevContainer(ctx context.Context, image, tag string) e } func (d *dockerDriver) CommitContainer(ctx context.Context, workspaceID, tag string) error { + ctx = d.logContext(ctx, workspaceID) container, err := d.FindDevContainer(ctx, workspaceID) if err != nil { return err @@ -255,6 +260,7 @@ func (d *dockerDriver) CommitContainer(ctx context.Context, workspaceID, tag str // DeleteDevContainer stops a still-running container before removing it, // since podman/docker refuse to `rm` a running container. func (d *dockerDriver) DeleteDevContainer(ctx context.Context, workspaceId string) error { + ctx = d.logContext(ctx, workspaceId) container, err := d.FindDevContainer(ctx, workspaceId) if err != nil { return err @@ -272,6 +278,7 @@ func (d *dockerDriver) DeleteDevContainer(ctx context.Context, workspaceId strin } func (d *dockerDriver) StartDevContainer(ctx context.Context, workspaceId string) error { + ctx = d.logContext(ctx, workspaceId) container, err := d.requireDevContainer(ctx, workspaceId) if err != nil { return err @@ -281,6 +288,7 @@ func (d *dockerDriver) StartDevContainer(ctx context.Context, workspaceId string } func (d *dockerDriver) StopDevContainer(ctx context.Context, workspaceId string) error { + ctx = d.logContext(ctx, workspaceId) container, err := d.requireDevContainer(ctx, workspaceId) if err != nil { return err @@ -328,6 +336,7 @@ func (d *dockerDriver) RunImageDevContainer( ctx context.Context, params *driver.RunImageDevContainerParams, ) error { + ctx = d.logContext(ctx, params.WorkspaceID) if err := d.ValidateRunImageDevContainer(params); err != nil { return err } @@ -346,7 +355,7 @@ func (d *dockerDriver) RunImageDevContainer( return err } - writer := log.Writer(log.LevelInfo) + writer := log.Writer(log.SlogLevelInfo) defer func() { _ = writer.Close() }() if err := d.startContainer(ctx, params.LocalWorkspaceFolder, args, writer); err != nil { @@ -382,7 +391,7 @@ func (d *dockerDriver) EnsureImage( } log.Debugf("image not found, pulling image: image=%s", options.Image) - writer := log.Writer(log.LevelDebug) + writer := log.Writer(log.SlogLevelDebug) defer func() { _ = writer.Close() }() return d.Docker.Pull(ctx, docker.PullOptions{ @@ -450,12 +459,14 @@ func (d *dockerDriver) startContainer( stderr := subprocess.NewBuffer( secrets.NewEnvironmentRedactor(append(os.Environ(), d.Docker.Environment...)), ) + started := time.Now() err := d.Docker.RunWithDir( ctx, dir, args, docker.Streams{Stdout: writer, Stderr: io.MultiWriter(writer, stderr)}, ) + logDockerCommandResult(ctx, "run", started, err) if err != nil { log.Errorf( "docker container failed to start: error=%v, command=%s, args=%s, cwd=%s", @@ -471,3 +482,20 @@ func (d *dockerDriver) startContainer( } return nil } + +func logDockerCommandResult(ctx context.Context, operation string, started time.Time, err error) { + attrs := []slog.Attr{ + log.AttrOperation(operation), + log.AttrDurationMs(time.Since(started).Milliseconds()), + } + if err == nil { + attrs = append(attrs, slog.Int("exit_code", 0)) + log.DebugContext(ctx, "runtime command completed", attrs...) + return + } + var exitErr interface{ ExitCode() int } + if errors.As(err, &exitErr) { + attrs = append(attrs, slog.Int("exit_code", exitErr.ExitCode())) + } + log.DebugContext(ctx, "runtime command failed", attrs...) +} diff --git a/pkg/driver/docker/lifecycle_test.go b/pkg/driver/docker/lifecycle_test.go index 8eef4eba3e..549452732d 100644 --- a/pkg/driver/docker/lifecycle_test.go +++ b/pkg/driver/docker/lifecycle_test.go @@ -18,6 +18,7 @@ import ( "github.com/devsy-org/devsy/pkg/devcontainer/config" "github.com/devsy-org/devsy/pkg/docker" "github.com/devsy-org/devsy/pkg/driver" + "github.com/devsy-org/devsy/pkg/log" "github.com/devsy-org/devsy/pkg/subprocess" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" @@ -569,6 +570,7 @@ func TestStartContainerPreservesEngineError(t *testing.T) { if runtime.GOOS == "windows" { t.Skip("requires a POSIX shell") } + logs := log.InitTestObserved(t, log.SlogLevelDebug) source := filepath.Join(t.TempDir(), "missing.sock") bin := filepath.Join(t.TempDir(), "engine") require.NoError(t, os.WriteFile(bin, []byte(`#!/bin/sh @@ -587,7 +589,7 @@ fi } var streamed engineOutputBuffer err := d.startContainer( - context.Background(), + d.logContext(context.Background(), "workspace-canary"), t.TempDir(), []string{testRunArg, source}, &streamed, @@ -600,6 +602,15 @@ fi var exitErr *exec.ExitError require.True(t, errors.As(err, &exitErr)) assert.Equal(t, 17, exitErr.ExitCode()) + entries := logs.FilterMessage("runtime command failed").All() + require.Len(t, entries, 1) + attrs := entries[0].AttrsMap() + assert.Equal(t, "docker-driver", attrs["component"]) + assert.Equal(t, "docker", attrs["provider"]) + assert.Equal(t, "workspace-canary", attrs["workspace_id"]) + assert.Equal(t, "run", attrs["operation"]) + assert.Equal(t, int64(17), attrs["exit_code"]) + assert.Contains(t, attrs, "duration_ms") } func TestStartContainerBoundsEngineError(t *testing.T) { diff --git a/pkg/driver/external/exec_test.go b/pkg/driver/external/exec_test.go index db2466c883..5a8c601957 100644 --- a/pkg/driver/external/exec_test.go +++ b/pkg/driver/external/exec_test.go @@ -15,6 +15,7 @@ import ( "github.com/devsy-org/devsy-runtime-sdk/conformance/fake" "github.com/devsy-org/devsy-runtime-sdk/runtimev1" "github.com/devsy-org/devsy/pkg/driver" + "github.com/devsy-org/devsy/pkg/telemetry" "google.golang.org/grpc/codes" "google.golang.org/grpc/status" ) @@ -127,7 +128,9 @@ func (s *HostSuite) TestExecCancellationClosesInputAndReapsChild() { host := s.host("stream-block-child") input, producer := io.Pipe() defer func() { _ = producer.Close() }() - ctx, cancel := context.WithCancel(context.Background()) + metrics := telemetry.NewMetricsReporter() + parent := telemetry.WithMetrics(context.Background(), metrics) + ctx, cancel := context.WithCancel(parent) defer cancel() done := make(chan error, 1) go func() { @@ -139,6 +142,10 @@ func (s *HostSuite) TestExecCancellationClosesInputAndReapsChild() { select { case err := <-done: s.ErrorIs(err, context.Canceled) + snapshot := metrics.Finish(err) + s.Require().Len(snapshot.ProviderOperations, 1) + s.Equal("Exec", snapshot.ProviderOperations[0].Operation) + s.Equal("cancelled", snapshot.ProviderOperations[0].RuntimeErrorCode) case <-time.After(5 * time.Second): s.FailNow("Exec cancellation did not join its input pump") } diff --git a/pkg/driver/external/host.go b/pkg/driver/external/host.go index 65dcc53df0..831194f49c 100644 --- a/pkg/driver/external/host.go +++ b/pkg/driver/external/host.go @@ -27,6 +27,7 @@ type Host struct { binariesDir string supervisorBinary string supervisorArgs []string + providerName string environment []string idLabels []string redactor *secrets.Redactor @@ -55,8 +56,13 @@ func New(ctx context.Context, workspace *provider.AgentWorkspaceInfo) (*Host, er workspace.Options, nil, ) + providerName := "" + if workspace.Workspace != nil { + providerName = workspace.Workspace.Provider.Name + } return newHost(ctx, hostOptions{ config: workspace.Agent, + providerName: providerName, directory: binariesDir, supervisorBinary: executable, supervisorArgs: []string{ @@ -72,6 +78,7 @@ func New(ctx context.Context, workspace *provider.AgentWorkspaceInfo) (*Host, er type hostOptions struct { config provider.ProviderAgentConfig directory, supervisorBinary string + providerName string supervisorArgs, environment []string idLabels []string timeout time.Duration @@ -83,6 +90,7 @@ func newHost(ctx context.Context, options hostOptions) (*Host, error) { binariesDir: options.directory, supervisorBinary: options.supervisorBinary, supervisorArgs: slices.Clone(options.supervisorArgs), + providerName: options.providerName, environment: slices.Clone(options.environment), idLabels: slices.Clone(options.idLabels), timeout: options.timeout, diff --git a/pkg/driver/external/host_test.go b/pkg/driver/external/host_test.go index 80ec8dd4f1..3c71b88af7 100644 --- a/pkg/driver/external/host_test.go +++ b/pkg/driver/external/host_test.go @@ -6,6 +6,7 @@ import ( "crypto/sha256" "encoding/hex" "errors" + "fmt" "os" "os/exec" "path/filepath" @@ -24,7 +25,6 @@ import ( "github.com/devsy-org/devsy/pkg/secrets" "github.com/shirou/gopsutil/v4/process" "github.com/stretchr/testify/suite" - "go.uber.org/zap/zapcore" "google.golang.org/grpc/codes" "google.golang.org/grpc/status" ) @@ -102,10 +102,54 @@ func (s *HostSuite) TestNegotiationFailures() { func (s *HostSuite) TestCancellationDuringHandshake() { ctx, cancel := context.WithTimeout(context.Background(), 250*time.Millisecond) defer cancel() + expired := make(chan time.Time, 1) + stop := context.AfterFunc(ctx, func() { expired <- time.Now() }) + defer stop() started := time.Now() - _, err := s.newHost(ctx, delayedMode, startupTimeout) + directory := s.T().TempDir() + _, err := s.newHostInDirectory(ctx, delayedMode, startupTimeout, directory) + returned := time.Since(started) + deadlineEvent := "not observed" + select { + case at := <-expired: + deadlineEvent = at.Sub(started).String() + default: + } + s.T(). + Logf("handshake cancellation: deadline_callback=%s returned=%s context_deadline=%t "+ + "error_deadline=%t supervisor=%s plugin=%s", + deadlineEvent, returned, errors.Is(ctx.Err(), context.DeadlineExceeded), + errors.Is(err, context.DeadlineExceeded), + fixtureProcessSummary(directory, "supervisor"), + fixtureProcessSummary(directory, "plugin")) s.ErrorIs(err, context.DeadlineExceeded) - s.Less(time.Since(started), 5*time.Second) + s.Less(returned, 5*time.Second) +} + +func fixtureProcessSummary(directory, kind string) string { + data, err := os.ReadFile(filepath.Join(directory, kind+"-pids")) + if errors.Is(err, os.ErrNotExist) { + return "not recorded" + } + if err != nil { + return fmt.Sprintf("read error %T", err) + } + var alive, unknown int + records := strings.Fields(string(data)) + for _, value := range records { + pid, err := strconv.ParseInt(value, 10, 32) + if err != nil { + unknown++ + continue + } + exists, err := process.PidExists(int32(pid)) + if err != nil { + unknown++ + } else if exists { + alive++ + } + } + return fmt.Sprintf("records=%d alive=%d unknown=%d", len(records), alive, unknown) } func (s *HostSuite) TestStartupTimeout() { @@ -231,7 +275,7 @@ func (s *HostSuite) TestSplitDiagnosticRedaction() { func (s *HostSuite) TestWorkspaceEnvironmentRedactedFromRuntimeErrors() { host := s.host("env-error") - observed := log.InitTestObserved(s.T(), zapcore.DebugLevel) + observed := log.InitTestObserved(s.T(), log.SlogLevelDebug) err := host.RunImage(context.Background(), &runtimev1.RunImageRequest{ WorkspaceId: fixtureWorkspace, Image: "fixture", @@ -300,7 +344,15 @@ func (s *HostSuite) newHost( mode string, timeout time.Duration, ) (*Host, error) { - directory := s.T().TempDir() + return s.newHostInDirectory(ctx, mode, timeout, s.T().TempDir()) +} + +func (s *HostSuite) newHostInDirectory( + ctx context.Context, + mode string, + timeout time.Duration, + directory string, +) (*Host, error) { s.T().Cleanup(func() { s.assertReaped(directory) }) args := []string{"--mode", mode, "--state-dir", directory} if mode == delayedMode { diff --git a/pkg/driver/external/internal/testfixture/main.go b/pkg/driver/external/internal/testfixture/main.go index ab0e9110f1..bd053b7dc6 100644 --- a/pkg/driver/external/internal/testfixture/main.go +++ b/pkg/driver/external/internal/testfixture/main.go @@ -47,6 +47,15 @@ func serve(mode, state string, delay time.Duration, nonce string) { if mode == "stream-startup-stderr" { _, _ = fmt.Fprintln(os.Stderr, "runtime startup diagnostic "+os.Getenv("FIXTURE_TOKEN")) } + if mode == "stream-structured-stderr" { + _, _ = fmt.Fprint(os.Stderr, + `{"level":"warn","msg":"structured runtime canary","detail":{"credential":"`) + secret := os.Getenv("FIXTURE_TOKEN") + middle := len(secret) / 2 + _, _ = fmt.Fprint(os.Stderr, secret[:middle]) + _, _ = fmt.Fprint(os.Stderr, secret[middle:]) + _, _ = fmt.Fprintln(os.Stderr, `"}}`) + } if mode == fake.CrashBeforeHandshake { os.Exit(22) } diff --git a/pkg/driver/external/logs_test.go b/pkg/driver/external/logs_test.go index 7a5aabd9e4..8557f2560f 100644 --- a/pkg/driver/external/logs_test.go +++ b/pkg/driver/external/logs_test.go @@ -6,6 +6,7 @@ import ( "time" "github.com/devsy-org/devsy-runtime-sdk/conformance/fake" + "github.com/devsy-org/devsy/pkg/telemetry" "google.golang.org/grpc/codes" "google.golang.org/grpc/status" ) @@ -47,7 +48,9 @@ func (s *HostSuite) TestLogsWriterAndProtocolFailures() { func (s *HostSuite) TestLogsCancellationReapsProcess() { host := s.host("stream-logs-block") - ctx, cancel := context.WithCancel(context.Background()) + metrics := telemetry.NewMetricsReporter() + parent := telemetry.WithMetrics(context.Background(), metrics) + ctx, cancel := context.WithCancel(parent) defer cancel() done := make(chan error, 1) go func() { done <- host.GetDevContainerLogs(ctx, fixtureWorkspace, nil, nil) }() @@ -56,6 +59,10 @@ func (s *HostSuite) TestLogsCancellationReapsProcess() { select { case err := <-done: s.ErrorIs(err, context.Canceled) + snapshot := metrics.Finish(err) + s.Require().Len(snapshot.ProviderOperations, 1) + s.Equal("Logs", snapshot.ProviderOperations[0].Operation) + s.Equal("cancelled", snapshot.ProviderOperations[0].RuntimeErrorCode) case <-time.After(5 * time.Second): s.FailNow("Logs cancellation did not return") } diff --git a/pkg/driver/external/session.go b/pkg/driver/external/session.go index 0debee63a0..7f7d3b51ca 100644 --- a/pkg/driver/external/session.go +++ b/pkg/driver/external/session.go @@ -5,6 +5,7 @@ import ( "errors" "fmt" "io" + "log/slog" "os/exec" "slices" "sync" @@ -15,9 +16,11 @@ import ( "github.com/devsy-org/devsy-runtime-sdk/supervisor" "github.com/devsy-org/devsy/pkg/log" "github.com/devsy-org/devsy/pkg/secrets" + "github.com/devsy-org/devsy/pkg/telemetry" "github.com/hashicorp/go-hclog" hplugin "github.com/hashicorp/go-plugin" "github.com/hashicorp/go-plugin/runner" + "google.golang.org/grpc/status" ) func (h *Host) call( @@ -32,10 +35,33 @@ func (h *Host) call( if err != nil { return fmt.Errorf("external runtime %s: %w", operation, err) } - // Normalize after owned cleanup so caller deadlines win over transport - // cancellation reported just before the local context timer fires. - defer func() { err = h.operationError(ctx, operation, err) }() - output := log.Writer(log.LevelDebug) + var rpcDuration time.Duration + var called bool + defer func() { + metricErr := err + if err != nil && ctx.Err() != nil { + metricErr = ctx.Err() + } + code := runtimeMetricCode(metricErr) + err = h.operationError(ctx, operation, err) + if called { + telemetry.RecordProviderOperation(ctx, telemetry.ProviderOperation{ + ProviderType: telemetry.ProviderTypeExternalSDK, + Operation: operation, + Duration: rpcDuration, + ErrorCode: code, + }) + } + }() + attrs := []slog.Attr{log.AttrComponent("external-driver")} + if h.providerName != "" { + attrs = append(attrs, log.AttrProvider(h.providerName)) + } + output := log.NewJSONLogStreamer(log.StreamerOptions{ + Redactor: h.redactor, + FallbackLevel: log.SlogLevelDebug, + DefaultAttrs: attrs, + }) diagnostic := &diagnosticWriter{ writer: output, stream: secrets.NewStreamingRedactor(h.redactor), @@ -56,8 +82,73 @@ func (h *Host) call( if !ok { return errors.New("invalid gRPC client") } - log.Debugf("External runtime %s startup completed in %s", operation, time.Since(started)) - return rpc(runtimeClient) + log.DebugContext(ctx, "External runtime startup completed", + log.AttrOperation(operation), log.AttrDurationMs(time.Since(started).Milliseconds())) + called = true + rpcStart := time.Now() + err = rpc(runtimeClient) + rpcDuration = time.Since(rpcStart) + return err +} + +func runtimeMetricCode(err error) string { + if err == nil { + return "" + } + if errors.Is(err, context.Canceled) { + return "cancelled" + } + if errors.Is(err, context.DeadlineExceeded) { + return "timeout" + } + var category runtimev1.RuntimeErrorCode + if runtimeErr, ok := errors.AsType[*RuntimeError](err); ok { + category = runtimeErr.Category + } else if rpcStatus, ok := status.FromError(err); ok { + for _, detail := range rpcStatus.Details() { + if runtimeErr, ok := detail.(*runtimev1.RuntimeError); ok { + category = runtimeErr.Code + break + } + } + } + return runtimeCategoryMetricCode(category) +} + +func runtimeCategoryMetricCode(category runtimev1.RuntimeErrorCode) string { + switch category { + case runtimev1.RuntimeErrorCode_RUNTIME_ERROR_CODE_NOT_FOUND: + return "not_found" + case runtimev1.RuntimeErrorCode_RUNTIME_ERROR_CODE_ALREADY_EXISTS: + return "already_exists" + case runtimev1.RuntimeErrorCode_RUNTIME_ERROR_CODE_INVALID_ARGUMENT: + return "invalid_argument" + case runtimev1.RuntimeErrorCode_RUNTIME_ERROR_CODE_UNSUPPORTED: + return "unsupported" + case runtimev1.RuntimeErrorCode_RUNTIME_ERROR_CODE_UNAVAILABLE: + return "unavailable" + case runtimev1.RuntimeErrorCode_RUNTIME_ERROR_CODE_FAILED_PRECONDITION: + return "failed_precondition" + default: + return runtimeCategoryMetricCodeOther(category) + } +} + +func runtimeCategoryMetricCodeOther(category runtimev1.RuntimeErrorCode) string { + switch category { + case runtimev1.RuntimeErrorCode_RUNTIME_ERROR_CODE_PERMISSION_DENIED: + return "permission_denied" + case runtimev1.RuntimeErrorCode_RUNTIME_ERROR_CODE_TIMEOUT: + return "timeout" + case runtimev1.RuntimeErrorCode_RUNTIME_ERROR_CODE_CANCELLED: + return "cancelled" + case runtimev1.RuntimeErrorCode_RUNTIME_ERROR_CODE_RUNTIME_FAILURE: + return "runtime_failure" + case runtimev1.RuntimeErrorCode_RUNTIME_ERROR_CODE_INCOMPATIBLE_VERSION: + return "incompatible_version" + default: + return "unknown" + } } // go-plugin holds its client lock throughout handshake, so Client.Kill cannot diff --git a/pkg/driver/external/session_logging_test.go b/pkg/driver/external/session_logging_test.go index 50aca6f11a..1960324cb1 100644 --- a/pkg/driver/external/session_logging_test.go +++ b/pkg/driver/external/session_logging_test.go @@ -2,21 +2,24 @@ package external import ( "context" + "encoding/json" "time" "github.com/devsy-org/devsy-runtime-sdk/conformance/fake" + "github.com/devsy-org/devsy-runtime-sdk/runtimev1" + "github.com/devsy-org/devsy/pkg/driver" "github.com/devsy-org/devsy/pkg/log" - "go.uber.org/zap/zapcore" + "github.com/devsy-org/devsy/pkg/telemetry" ) func (s *HostSuite) TestDebugKeepsRuntimeDiagnosticsWithoutHelperShutdownNoise() { s.T().Setenv("FIXTURE_TOKEN", "private-startup-canary") - observed := log.InitTestObserved(s.T(), zapcore.DebugLevel) + observed := log.InitTestObserved(s.T(), log.SlogLevelDebug) host := s.host("stream-startup-stderr") s.NotEmpty(host.Info().RuntimeName) s.Positive(observed.FilterMessageSnippet("runtime startup diagnostic ***").Len()) - s.Positive(observed.FilterMessageSnippet("External runtime Info startup completed").Len()) + s.Positive(observed.FilterMessageSnippet("External runtime startup completed").Len()) s.Zero(observed.FilterMessageSnippet("received EOF, stopping recv loop").Len()) s.Zero(observed.FilterMessageSnippet("plugin process exited").Len()) for _, entry := range observed.All() { @@ -25,7 +28,7 @@ func (s *HostSuite) TestDebugKeepsRuntimeDiagnosticsWithoutHelperShutdownNoise() } func (s *HostSuite) TestTraceKeepsHelperLifecycleDiagnostics() { - observed := log.InitTestObserved(s.T(), zapcore.DebugLevel-1) + observed := log.InitTestObserved(s.T(), log.SlogLevelTrace) host := s.host(fake.Normal) s.NotEmpty(host.Info().RuntimeName) @@ -37,9 +40,48 @@ func (s *HostSuite) TestTraceKeepsHelperLifecycleDiagnostics() { } func (s *HostSuite) TestDebugKeepsUnexpectedHelperExitDiagnostics() { - observed := log.InitTestObserved(s.T(), zapcore.DebugLevel) + observed := log.InitTestObserved(s.T(), log.SlogLevelDebug) _, err := s.newHost(context.Background(), fake.CrashBeforeHandshake, startupTimeout) s.Require().Error(err) s.Positive(observed.FilterMessageSnippet("plugin process exited").Len()) s.Positive(observed.FilterMessageSnippet("exit status 22").Len()) } + +func (s *HostSuite) TestRuntimeOperationMetricsPreserveClassificationWithoutDiagnostics() { + host := s.host("env-error") + metrics := telemetry.NewMetricsReporter() + ctx := telemetry.WithMetrics(context.Background(), metrics) + err := host.RunImage(ctx, &runtimev1.RunImageRequest{ + WorkspaceId: fixtureWorkspace, + Image: fixtureImage, + Environment: map[string]string{"CUSTOM_VALUE": workspaceCanary}, + }) + s.Require().Error(err) + snapshot := metrics.Finish(err) + s.Require().Len(snapshot.ProviderOperations, 1) + s.Equal(telemetry.ProviderTypeExternalSDK, snapshot.ProviderOperations[0].ProviderType) + s.Equal("RunImage", snapshot.ProviderOperations[0].Operation) + s.Equal("unavailable", snapshot.ProviderOperations[0].RuntimeErrorCode) + encoded, marshalErr := json.Marshal(snapshot) + s.Require().NoError(marshalErr) + s.NotContains(string(encoded), workspaceCanary) +} + +func (s *HostSuite) TestRuntimeStructuredDiagnosticsKeepAttributesAndRedact() { + s.T().Setenv("FIXTURE_TOKEN", "private-structured-canary") + observed := log.InitTestObserved(s.T(), log.SlogLevelDebug) + host := s.host("stream-structured-stderr") + host.providerName = "provider-canary" + observed.TakeAll() + s.Require().NoError(host.Preflight(context.Background(), driver.PreflightOptions{})) + entries := observed.FilterMessage("structured runtime canary").All() + s.Require().NotEmpty(entries) + s.Equal(log.SlogLevelWarn, entries[0].Level) + attrs := entries[0].AttrsMap() + s.Equal("external-driver", attrs["component"]) + s.Equal("provider-canary", attrs["provider"]) + data, err := json.Marshal(attrs) + s.Require().NoError(err) + s.Contains(string(data), "***") + s.NotContains(string(data), "private-structured-canary") +} diff --git a/pkg/driver/kubernetes/client_test.go b/pkg/driver/kubernetes/client_test.go index 15c3d2ad67..b50dd25c34 100644 --- a/pkg/driver/kubernetes/client_test.go +++ b/pkg/driver/kubernetes/client_test.go @@ -6,6 +6,7 @@ import ( "testing" "time" + "github.com/devsy-org/devsy/pkg/log" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) @@ -77,3 +78,30 @@ func TestWaitForStream_PropagatesRealStreamErrorEvenAfterCancellation(t *testing require.ErrorIs(t, err, wantErr) } + +type testExitStatus int + +func (e testExitStatus) Error() string { return "command failed" } +func (e testExitStatus) ExitStatus() int { return int(e) } + +func TestExecResultLogging(t *testing.T) { + logs := log.InitTestObserved(t, log.SlogLevelDebug) + ctx := (&KubernetesDriver{}).logContext(context.Background(), "workspace-canary") + logExecResult(ctx, time.Now(), testExitStatus(7)) + logExecResult(ctx, time.Now(), context.Canceled) + logExecResult(ctx, time.Now(), nil) + + failed := logs.FilterMessage("runtime command failed").All() + require.Len(t, failed, 2) + attrs := failed[0].AttrsMap() + assert.Equal(t, "kubernetes-driver", attrs["component"]) + assert.Equal(t, "kubernetes", attrs["provider"]) + assert.Equal(t, "workspace-canary", attrs["workspace_id"]) + assert.Equal(t, "exec", attrs["operation"]) + assert.Equal(t, int64(7), attrs["exit_code"]) + assert.Contains(t, attrs, "duration_ms") + assert.NotContains(t, failed[1].AttrsMap(), "exit_code") + completed := logs.FilterMessage("runtime command completed").All() + require.Len(t, completed, 1) + assert.Equal(t, int64(0), completed[0].AttrsMap()["exit_code"]) +} diff --git a/pkg/driver/kubernetes/driver.go b/pkg/driver/kubernetes/driver.go index 0abd5503f8..34024129bf 100644 --- a/pkg/driver/kubernetes/driver.go +++ b/pkg/driver/kubernetes/driver.go @@ -3,8 +3,10 @@ package kubernetes import ( "context" "encoding/json" + "errors" "fmt" "io" + "log/slog" "time" "github.com/devsy-org/devsy/pkg/driver" @@ -39,12 +41,23 @@ func NewKubernetesDriver( } log.Debugf("Use Kubernetes Namespace %q", namespace) + workspaceID := "" + if workspaceInfo.Workspace != nil { + workspaceID = workspaceInfo.Workspace.ID + } + machineID := "" + if workspaceInfo.Machine != nil { + machineID = workspaceInfo.Machine.ID + } + return &KubernetesDriver{ client: client, namespace: namespace, options: &options, agentConfig: &workspaceInfo.Agent, disableDaemon: workspaceInfo.CLIOptions.DisableDaemon, + workspaceID: workspaceID, + machineID: machineID, }, nil } @@ -82,6 +95,25 @@ type KubernetesDriver struct { disableDaemon bool shutdownAction string hasShutdownAction bool + workspaceID string + machineID string +} + +func logExecResult(ctx context.Context, started time.Time, err error) { + attrs := []slog.Attr{ + log.AttrOperation("exec"), + log.AttrDurationMs(time.Since(started).Milliseconds()), + } + if err == nil { + attrs = append(attrs, slog.Int("exit_code", 0)) + log.DebugContext(ctx, "runtime command completed", attrs...) + return + } + var exitErr interface{ ExitStatus() int } + if errors.As(err, &exitErr) { + attrs = append(attrs, slog.Int("exit_code", exitErr.ExitStatus())) + } + log.DebugContext(ctx, "runtime command failed", attrs...) } func (k *KubernetesDriver) CanReprovision() bool { @@ -103,8 +135,9 @@ func (k *KubernetesDriver) SupportsMountType(mountType string) bool { } func (k *KubernetesDriver) StopDevContainer(ctx context.Context, workspaceId string) error { - log.Debugf("Stopping devcontainer for workspace %q", workspaceId) - defer log.Debugf("Done stopping devcontainer for workspace %q", workspaceId) + ctx = k.logContext(ctx, workspaceId) + log.DebugContext(ctx, "stopping dev container") + defer log.DebugContext(ctx, "done stopping dev container") workspaceId = getID(workspaceId) @@ -118,8 +151,9 @@ func (k *KubernetesDriver) StopDevContainer(ctx context.Context, workspaceId str } func (k *KubernetesDriver) DeleteDevContainer(ctx context.Context, workspaceId string) error { - log.Debugf("Deleting devcontainer for workspace %q", workspaceId) - defer log.Debugf("Done deleting devcontainer for workspace %q", workspaceId) + ctx = k.logContext(ctx, workspaceId) + log.DebugContext(ctx, "deleting dev container") + defer log.DebugContext(ctx, "done deleting dev container") workspaceId = getID(workspaceId) @@ -145,6 +179,7 @@ func (k *KubernetesDriver) CommandDevContainer( ctx context.Context, params *driver.CommandParams, ) error { + ctx = k.logContext(ctx, params.WorkspaceID) workspaceId := getID(params.WorkspaceID) var args []string @@ -154,7 +189,8 @@ func (k *KubernetesDriver) CommandDevContainer( args = []string{"sh", "-c", params.Command} } - return k.client.Exec(ctx, &ExecStreamOptions{ + started := time.Now() + err := k.client.Exec(ctx, &ExecStreamOptions{ Pod: workspaceId, Namespace: k.namespace, Container: DevContainerName, @@ -163,6 +199,8 @@ func (k *KubernetesDriver) CommandDevContainer( Stdout: params.Stdout, Stderr: params.Stderr, }) + logExecResult(ctx, started, err) + return err } // SupportsRequireRunning reports that CommandDevContainer honors RequireRunning. @@ -178,7 +216,9 @@ func (k *KubernetesDriver) CommandContainerArgv( argv []string, streams driver.Streams, ) error { - return k.client.Exec(ctx, &ExecStreamOptions{ + ctx = k.logContext(ctx, workspaceID) + started := time.Now() + err := k.client.Exec(ctx, &ExecStreamOptions{ Pod: getID(workspaceID), Namespace: k.namespace, Container: DevContainerName, @@ -187,6 +227,8 @@ func (k *KubernetesDriver) CommandContainerArgv( Stdout: streams.Stdout, Stderr: streams.Stderr, }) + logExecResult(ctx, started, err) + return err } func (k *KubernetesDriver) GetDevContainerLogs( @@ -220,6 +262,24 @@ func (d *KubernetesDriver) RecreateMode() driver.RecreateMode { return driver.Re func (d *KubernetesDriver) RequiresWorkspaceChown() bool { return true } +func (k *KubernetesDriver) logContext(ctx context.Context, workspaceID string) context.Context { + ctx = log.WithContext( + ctx, + log.AttrComponent("kubernetes-driver"), + log.AttrProvider("kubernetes"), + ) + if workspaceID == "" { + workspaceID = k.workspaceID + } + if workspaceID != "" { + ctx = log.WithContext(ctx, log.AttrWorkspaceID(workspaceID)) + } + if k.machineID != "" { + ctx = log.WithContext(ctx, log.AttrMachineID(k.machineID)) + } + return ctx +} + func (k *KubernetesDriver) getDevContainerPvc( ctx context.Context, id string, diff --git a/pkg/driver/kubernetes/find.go b/pkg/driver/kubernetes/find.go index f5b76c96f0..7143821786 100644 --- a/pkg/driver/kubernetes/find.go +++ b/pkg/driver/kubernetes/find.go @@ -13,8 +13,9 @@ func (k *KubernetesDriver) FindDevContainer( ctx context.Context, workspaceId string, ) (*config.ContainerDetails, error) { - log.Debugf("Finding devcontainer for workspace %q", workspaceId) - defer log.Debugf("Done finding devcontainer for workspace %q", workspaceId) + ctx = k.logContext(ctx, workspaceId) + log.DebugContext(ctx, "finding dev container") + defer log.DebugContext(ctx, "done finding dev container") workspaceId = getID(workspaceId) diff --git a/pkg/driver/kubernetes/run.go b/pkg/driver/kubernetes/run.go index 406c6a577b..1514d93dc3 100644 --- a/pkg/driver/kubernetes/run.go +++ b/pkg/driver/kubernetes/run.go @@ -48,7 +48,8 @@ func (k *KubernetesDriver) RunDevContainer( workspaceId string, options *driver.RunOptions, ) error { - log.Debugf("Running devcontainer for workspace %q", workspaceId) + ctx = k.logContext(ctx, workspaceId) + log.DebugContext(ctx, "running dev container") workspaceId = getID(workspaceId) initialize, options, err := k.ensureDevContainerPvc(ctx, workspaceId, options) diff --git a/pkg/driver/microsandbox/cliclient.go b/pkg/driver/microsandbox/cliclient.go index 2f32c041ff..932c56f34b 100644 --- a/pkg/driver/microsandbox/cliclient.go +++ b/pkg/driver/microsandbox/cliclient.go @@ -6,6 +6,7 @@ import ( "errors" "fmt" "io" + "log/slog" "os" "os/exec" "path/filepath" @@ -16,6 +17,7 @@ import ( "github.com/devsy-org/devsy/pkg/devcontainer/config" "github.com/devsy-org/devsy/pkg/driver" "github.com/devsy-org/devsy/pkg/flags/names" + "github.com/devsy-org/devsy/pkg/log" "github.com/google/go-containerregistry/pkg/name" v1 "github.com/google/go-containerregistry/pkg/v1" "github.com/google/go-containerregistry/pkg/v1/tarball" @@ -39,7 +41,9 @@ func (cliClient) EnsureInstalled(_ context.Context) error { ) } -func (cliClient) Version(ctx context.Context) (string, error) { +func (cliClient) Version(ctx context.Context) (_ string, resultErr error) { + started := time.Now() + defer func() { logMicrosandboxCommand(ctx, "version", started, resultErr) }() // #nosec G204 -- args are a resolved binary path and fixed version command out, err := exec.CommandContext(ctx, msbBinary(), "--version").CombinedOutput() if err != nil { @@ -85,9 +89,11 @@ func (c cliClient) Create(ctx context.Context, sandbox string, spec sandboxSpec) } func (cliClient) Find(ctx context.Context, sandbox string) (*sandboxInfo, error) { + started := time.Now() // #nosec G204 -- args are a resolved binary path and a derived sandbox name out, err := exec.CommandContext(ctx, msbBinary(), "inspect", sandbox, "--format", "json"). Output() + logMicrosandboxCommand(ctx, "inspect", started, err) if err != nil { if ctx.Err() != nil { return nil, fmt.Errorf("inspect microsandbox VM %q: %w", sandbox, ctx.Err()) @@ -155,7 +161,9 @@ func (cliClient) Remove(ctx context.Context, sandbox string) error { // injection and the SSH-over-stdio tunnel require it; a PTY stalls the tunnel. // Cancellation closes non-file ReadCloser input; Close must unblock Read. // File input and input after normal completion remain caller-owned. -func (cliClient) Exec(ctx context.Context, sandbox string, req execRequest) error { +func (cliClient) Exec(ctx context.Context, sandbox string, req execRequest) (resultErr error) { + started := time.Now() + defer func() { logMicrosandboxCommand(ctx, "exec", started, resultErr) }() args := []string{"exec", "--stream"} if req.User != "" { args = append(args, names.Flag(names.User), req.User) @@ -194,7 +202,9 @@ func (cliClient) Exec(ctx context.Context, sandbox string, req execRequest) erro return cmd.Wait() } -func (cliClient) Logs(ctx context.Context, sandbox string, w io.Writer) error { +func (cliClient) Logs(ctx context.Context, sandbox string, w io.Writer) (resultErr error) { + started := time.Now() + defer func() { logMicrosandboxCommand(ctx, "logs", started, resultErr) }() // #nosec G204 -- args are a resolved binary path and a derived sandbox name cmd := exec.CommandContext(ctx, msbBinary(), "logs", sandbox) cmd.Stdout = w @@ -312,7 +322,9 @@ func namedVolumes(mounts []volumeMount) []string { return vols } -func msbRun(ctx context.Context, args ...string) error { +func msbRun(ctx context.Context, args ...string) (resultErr error) { + started := time.Now() + defer func() { logMicrosandboxCommand(ctx, args[0], started, resultErr) }() // #nosec G204 -- args are a resolved binary path and controlled config values out, err := exec.CommandContext(ctx, msbBinary(), args...).CombinedOutput() if err != nil { @@ -326,6 +338,21 @@ func msbRun(ctx context.Context, args ...string) error { return nil } +func logMicrosandboxCommand(ctx context.Context, operation string, started time.Time, err error) { + attrs := []slog.Attr{ + log.AttrOperation(operation), + log.AttrDurationMs(time.Since(started).Milliseconds()), + } + if err == nil { + attrs = append(attrs, slog.Int("exit_code", 0)) + } else { + if exitErr, ok := errors.AsType[*exec.ExitError](err); ok { + attrs = append(attrs, slog.Int("exit_code", exitErr.ExitCode())) + } + } + log.DebugContext(ctx, "microsandbox runtime command completed", attrs...) +} + // redactArgs joins args for an error message while masking --env values, which // may carry secrets from the devcontainer configuration. func redactArgs(args []string) string { diff --git a/pkg/driver/microsandbox/cliclient_test.go b/pkg/driver/microsandbox/cliclient_test.go index 534a8c4fb6..98b8ae4396 100644 --- a/pkg/driver/microsandbox/cliclient_test.go +++ b/pkg/driver/microsandbox/cliclient_test.go @@ -10,6 +10,7 @@ import ( "github.com/devsy-org/devsy/pkg/devcontainer/config" "github.com/devsy-org/devsy/pkg/driver" "github.com/devsy-org/devsy/pkg/flags/names" + "github.com/devsy-org/devsy/pkg/log" "github.com/stretchr/testify/require" ) @@ -17,6 +18,22 @@ func runPrefix() []string { return []string{msbCmdRun, msbFlagDetach, names.Flag(names.Name), wsName} } +func TestRuntimeCommandLogContext(t *testing.T) { + logs := log.InitTestObserved(t, log.SlogLevelDebug) + ctx := microsandboxLogContext(t.Context(), "workspace-1") + logMicrosandboxCommand(ctx, "exec", time.Now(), nil) + + entries := logs.FilterMessage("microsandbox runtime command completed").All() + require.Len(t, entries, 1) + attrs := entries[0].AttrsMap() + require.Equal(t, "builtin-driver", attrs["component"]) + require.Equal(t, "microsandbox", attrs["provider"]) + require.Equal(t, "workspace-1", attrs["workspace_id"]) + require.Equal(t, "exec", attrs["operation"]) + require.EqualValues(t, 0, attrs["exit_code"]) + require.Contains(t, attrs, "duration_ms") +} + func TestRunArgsFull(t *testing.T) { spec := sandboxSpec{ Image: testImg, diff --git a/pkg/driver/microsandbox/exec_cancellation_unix_test.go b/pkg/driver/microsandbox/exec_cancellation_unix_test.go index 9dd09a88e8..fb3d4102ba 100644 --- a/pkg/driver/microsandbox/exec_cancellation_unix_test.go +++ b/pkg/driver/microsandbox/exec_cancellation_unix_test.go @@ -57,7 +57,9 @@ func cancellationMSB(t *testing.T, exitImmediately bool) string { t.Helper() dir := t.TempDir() ready := filepath.Join(dir, "ready") - script := "#!/bin/sh\nprintf '%s\\n' \"$$\" > \"$DEVSY_CANCEL_READY\"\n" + script := "#!/bin/sh\nprintf 'fixture:start\\n' >&2\n" + + "if ! printf '%s\\n' \"$$\" > \"$DEVSY_CANCEL_READY\"; then " + + "printf 'fixture:ready-write-failed\\n' >&2; exit 2; fi\nprintf 'fixture:ready-written\\n' >&2\n" if exitImmediately { script += "exit 0\n" } else { @@ -73,19 +75,35 @@ func cancellationMSB(t *testing.T, exitImmediately bool) string { func awaitCancellationPID(t *testing.T, path string) int { t.Helper() var pid int + started := time.Now() + var state atomic.Value + state.Store("not checked") + defer func() { t.Logf("child readiness: state=%s elapsed=%s", state.Load().(string), time.Since(started)) }() require.Eventually(t, func() bool { data, err := os.ReadFile(path) // #nosec G304 -- Only the test-owned readiness file is read. if err != nil { + if errors.Is(err, os.ErrNotExist) { + state.Store("missing") + } else { + state.Store("read error") + } return false } pid, err = strconv.Atoi(strings.TrimSpace(string(data))) - return err == nil && pid > 1 + if err != nil || pid <= 1 { + state.Store("invalid pid") + return false + } + state.Store("ready") + return true }, execCancellationTestBound, time.Millisecond, "child readiness absent") return pid } func awaitCancellationSignal(t *testing.T, signal <-chan struct{}, message string) { t.Helper() + started := time.Now() + defer func() { t.Logf("checkpoint %q elapsed=%s", message, time.Since(started)) }() select { case <-signal: case <-time.After(execCancellationTestBound): @@ -94,35 +112,87 @@ func awaitCancellationSignal(t *testing.T, signal <-chan struct{}, message strin } type cancellationCall struct { - cancel context.CancelFunc - done chan struct{} - err error + cancel context.CancelFunc + done chan struct{} + err error + started time.Time + capture *os.File } func startCancellationCall(t *testing.T, input io.Reader, cleanup func()) *cancellationCall { t.Helper() ctx, cancel := context.WithCancel(context.Background()) - call := &cancellationCall{cancel: cancel, done: make(chan struct{})} + capture, err := os.CreateTemp(t.TempDir(), "fixture-output") + require.NoError(t, err) + output := struct{ io.Writer }{capture} + call := &cancellationCall{ + cancel: cancel, + done: make(chan struct{}), + started: time.Now(), + capture: capture, + } t.Cleanup(func() { + call.logState(t, "before cleanup", input) cancel() if cleanup != nil { cleanup() } select { case <-call.done: + call.logState(t, "after cleanup", input) case <-time.After(execCancellationTestBound): + call.logState(t, "cleanup timeout", input) t.Error("Exec failed to join after explicit input cleanup") } + _ = capture.Close() }) go func() { defer close(call.done) call.err = (cliClient{}).Exec(ctx, "owned-cancellation-test", execRequest{ - Stdin: input, Stdout: io.Discard, Stderr: io.Discard, + Stdin: input, Stdout: output, Stderr: output, }) }() return call } +func (call *cancellationCall) logState(t *testing.T, phase string, input io.Reader) { + t.Helper() + done := false + var errType any + select { + case <-call.done: + done = true + errType = call.err + default: + } + var closes int32 + if tracked, ok := input.(*cancellationInput); ok { + closes = tracked.closes.Load() + } + t.Logf("fixture %s: elapsed=%s done=%t error_type=%T input_closes=%d output=%s", + phase, time.Since(call.started), done, errType, closes, fixtureOutput(call.capture)) +} + +func fixtureOutput(file *os.File) string { + data := make([]byte, 512) + n, err := file.ReadAt(data, 0) + if err != nil && !errors.Is(err, io.EOF) { + return "read error" + } + text := string(data[:n]) + if text == "" { + return "empty" + } + for line := range strings.SplitSeq(strings.TrimSuffix(text, "\n"), "\n") { + switch line { + case "fixture:start", "fixture:ready-written", "fixture:ready-write-failed", "complete": + default: + return "other output" + } + } + return text +} + func TestExecCancellationClosesBlockedInput(t *testing.T) { for _, testCase := range []struct { name string diff --git a/pkg/driver/microsandbox/microsandbox.go b/pkg/driver/microsandbox/microsandbox.go index 32524130d0..7f0ea579bd 100644 --- a/pkg/driver/microsandbox/microsandbox.go +++ b/pkg/driver/microsandbox/microsandbox.go @@ -46,6 +46,7 @@ type microsandboxDriver struct { defaults specDefaults workspaceMountPolicy workspaceMountPolicy userResolver imageUserResolver + workspaceID string } var ( @@ -89,6 +90,7 @@ func parseMicrosandboxVersion(output string) (semver.Version, error) { // Preflight verifies the runtime is installed. Provisioning compatibility is // checked when creating a sandbox so older runtimes can manage existing ones. func (d *microsandboxDriver) Preflight(ctx context.Context, _ driver.PreflightOptions) error { + ctx = microsandboxLogContext(ctx, d.workspaceID) if err := d.client.EnsureInstalled(ctx); err != nil { return &driver.PreflightError{Provider: provider.MicrosandboxDriver, Err: err} } @@ -102,9 +104,14 @@ func (d *microsandboxDriver) CanReprovision() bool { } func NewMicrosandboxDriver( - _ context.Context, + ctx context.Context, workspaceInfo *provider.AgentWorkspaceInfo, ) (driver.Driver, error) { + workspaceID := "" + if workspaceInfo.Workspace != nil { + workspaceID = workspaceInfo.Workspace.ID + } + ctx = microsandboxLogContext(ctx, workspaceID) client := cliClient{dockerPath: workspaceInfo.Agent.Docker.Path} cfg := workspaceInfo.Agent.Microsandbox @@ -123,11 +130,9 @@ func NewMicrosandboxDriver( return nil, err } - log.Debugf( - "using microsandbox driver: memory=%dMiB cpus=%d ephemeral=%t idleTimeout=%s", - defaults.memory, defaults.cpus, defaults.ephemeral, defaults.idleTimeout, - ) + log.DebugContext(ctx, "using microsandbox driver") d := newDriver(client, workspaceInfo.CLIOptions.IDLabels, defaults) + d.workspaceID = workspaceID d.workspaceMountPolicy = workspacePolicy d.dockerPath = workspaceInfo.Agent.Docker.Path d.userResolver = filesystemUserResolver{dockerPath: d.dockerPath} @@ -150,6 +155,7 @@ func (d *microsandboxDriver) RunDevContainer( workspaceID string, options *driver.RunOptions, ) error { + ctx = microsandboxLogContext(ctx, workspaceID) return d.runFromOptions(ctx, workspaceID, options, nil) } @@ -157,6 +163,7 @@ func (d *microsandboxDriver) RunImageDevContainer( ctx context.Context, params *driver.RunImageDevContainerParams, ) error { + ctx = microsandboxLogContext(ctx, params.WorkspaceID) if err := checkGPURequirement(params.ParsedConfig); err != nil { return err } @@ -191,6 +198,7 @@ func (d *microsandboxDriver) FindDevContainer( ctx context.Context, workspaceID string, ) (*config.ContainerDetails, error) { + ctx = microsandboxLogContext(ctx, workspaceID) info, err := d.client.Find(ctx, sandboxName(workspaceID)) if err != nil || info == nil { return nil, err @@ -202,6 +210,7 @@ func (d *microsandboxDriver) CommandDevContainer( ctx context.Context, params *driver.CommandParams, ) error { + ctx = microsandboxLogContext(ctx, params.WorkspaceID) return d.client.Exec(ctx, sandboxName(params.WorkspaceID), execRequest{ Command: params.Command, User: params.User, @@ -219,6 +228,7 @@ func (d *microsandboxDriver) CommandContainerArgv( argv []string, streams driver.Streams, ) error { + ctx = microsandboxLogContext(ctx, workspaceID) return d.client.Exec(ctx, sandboxName(workspaceID), execRequest{ Argv: argv, User: "root", @@ -286,6 +296,7 @@ func (d *microsandboxDriver) RequiresWorkspaceChown() bool { } func (d *microsandboxDriver) StartDevContainer(ctx context.Context, workspaceID string) error { + ctx = microsandboxLogContext(ctx, workspaceID) if err := d.client.Start(ctx, sandboxName(workspaceID)); err != nil { return fmt.Errorf("start microsandbox VM: %w", err) } @@ -293,6 +304,7 @@ func (d *microsandboxDriver) StartDevContainer(ctx context.Context, workspaceID } func (d *microsandboxDriver) StopDevContainer(ctx context.Context, workspaceID string) error { + ctx = microsandboxLogContext(ctx, workspaceID) if err := d.client.Stop(ctx, sandboxName(workspaceID)); err != nil { return fmt.Errorf("stop microsandbox VM: %w", err) } @@ -302,6 +314,7 @@ func (d *microsandboxDriver) StopDevContainer(ctx context.Context, workspaceID s // DeleteDevContainer stops before removing; the runtime only removes stopped // sandboxes. func (d *microsandboxDriver) DeleteDevContainer(ctx context.Context, workspaceID string) error { + ctx = microsandboxLogContext(ctx, workspaceID) name := sandboxName(workspaceID) info, err := d.client.Find(ctx, name) if err != nil { @@ -316,10 +329,17 @@ func (d *microsandboxDriver) GetDevContainerLogs( stdout io.Writer, stderr io.Writer, ) error { + ctx = microsandboxLogContext(ctx, workspaceID) return d.client.Logs(ctx, sandboxName(workspaceID), stdout) } +func microsandboxLogContext(ctx context.Context, workspaceID string) context.Context { + return log.WithContext(ctx, log.AttrComponent("builtin-driver"), + log.AttrProvider(provider.MicrosandboxDriver), log.AttrWorkspaceID(workspaceID)) +} + func (d *microsandboxDriver) ProvisioningPreflight(ctx context.Context) error { + ctx = microsandboxLogContext(ctx, d.workspaceID) if d.workspaceMountPolicy.StatVirtualization == statVirtOff { return nil } diff --git a/pkg/envfile/envfile.go b/pkg/envfile/envfile.go index a170196965..b43785785d 100644 --- a/pkg/envfile/envfile.go +++ b/pkg/envfile/envfile.go @@ -5,6 +5,7 @@ import ( "maps" "os" + "github.com/devsy-org/devsy/pkg/config" "github.com/devsy-org/devsy/pkg/log" ) @@ -20,6 +21,9 @@ func Apply() { if !ok { return } + if os.Getenv(config.EnvDisableTelemetry) == config.BoolTrue { + delete(envFile.Env, config.EnvDisableTelemetry) + } for k, v := range envFile.Env { _ = os.Setenv(k, v) @@ -58,6 +62,9 @@ func MergeAndApply(env map[string]string) { envFile.Env = map[string]string{} } maps.Copy(envFile.Env, env) + if os.Getenv(config.EnvDisableTelemetry) == config.BoolTrue { + envFile.Env[config.EnvDisableTelemetry] = config.BoolTrue + } out, err := json.Marshal(envFile) if err != nil { diff --git a/pkg/envfile/envfile_test.go b/pkg/envfile/envfile_test.go index a081bfbfbc..06cb016fd0 100644 --- a/pkg/envfile/envfile_test.go +++ b/pkg/envfile/envfile_test.go @@ -5,11 +5,14 @@ import ( "os" "path/filepath" "testing" + + "github.com/devsy-org/devsy/pkg/config" ) const ( - testEnvVal = "value" - testEnvNew = "new" + testEnvVal = "value" + testEnvNew = "new" + testRetained = "retained" ) func useTempLocation(t *testing.T) string { @@ -167,3 +170,60 @@ func TestMergeAndApplyMalformedFileIsNoOp(t *testing.T) { t.Fatalf("DEVSY_ENVFILE_TEST_MERGE = %q, want %q", got, "keep") } } + +func TestApplyPreservesInheritedTelemetryOptOut(t *testing.T) { + path := useTempLocation(t) + t.Setenv(config.EnvDisableTelemetry, config.BoolTrue) + t.Setenv("DEVSY_ENVFILE_TEST_CANARY", "") + original := `{"env":{"DEVSY_DISABLE_TELEMETRY":"false","DEVSY_ENVFILE_TEST_CANARY":"retained"}}` + writeFile(t, path, original) + + Apply() + + if got := os.Getenv(config.EnvDisableTelemetry); got != config.BoolTrue { + t.Fatalf("telemetry opt-out = %q, want true", got) + } + if got := os.Getenv("DEVSY_ENVFILE_TEST_CANARY"); got != testRetained { + t.Fatalf("canary = %q, want retained", got) + } + data, err := os.ReadFile(path) + if err != nil { + t.Fatal(err) + } + if string(data) != original { + t.Fatal("Apply changed the environment file") + } +} + +func TestMergeAndApplyPersistsInheritedTelemetryOptOut(t *testing.T) { + path := useTempLocation(t) + t.Setenv(config.EnvDisableTelemetry, config.BoolTrue) + t.Setenv("DEVSY_ENVFILE_TEST_CANARY", "") + writeFile(t, path, `{"env":{"DEVSY_DISABLE_TELEMETRY":"false"}}`) + input := map[string]string{ + config.EnvDisableTelemetry: "false", + "DEVSY_ENVFILE_TEST_CANARY": testRetained, + } + + MergeAndApply(input) + + data, err := os.ReadFile(path) + if err != nil { + t.Fatal(err) + } + var persisted EnvFile + if err := json.Unmarshal(data, &persisted); err != nil { + t.Fatal(err) + } + if persisted.Env[config.EnvDisableTelemetry] != config.BoolTrue || + os.Getenv(config.EnvDisableTelemetry) != config.BoolTrue { + t.Fatal("inherited telemetry opt-out was not preserved") + } + if persisted.Env["DEVSY_ENVFILE_TEST_CANARY"] != testRetained || + os.Getenv("DEVSY_ENVFILE_TEST_CANARY") != testRetained { + t.Fatal("unrelated environment was not preserved") + } + if input[config.EnvDisableTelemetry] != "false" { + t.Fatal("input was mutated") + } +} diff --git a/pkg/flags/env.go b/pkg/flags/env.go index 27da2062b1..25e405c1cc 100644 --- a/pkg/flags/env.go +++ b/pkg/flags/env.go @@ -26,13 +26,6 @@ const EnvAnnotation = "devsy_env" // immediately after the flag's *Var registration. If the env var is set, the // value is applied to the flag (Changed=true, satisfying MarkFlagRequired) and // the env var is recorded under [EnvAnnotation] for the help renderer. -// -// Failure modes are loud by design: -// - panics if the flag is not registered (programmer bug at startup); -// - log.Fatalf if the env value is rejected by the flag's type (operator bug; -// e.g. DEVSY_DEBUG=garbage on a bool flag). This matches the contract of -// the prior inheritFlagsFromEnvironment loop so misconfigured env vars are -// never silently ignored. func BindEnv(fs *pflag.FlagSet, flagName string) { f := fs.Lookup(flagName) if f == nil { @@ -48,7 +41,7 @@ func BindEnv(fs *pflag.FlagSet, flagName string) { return } if err := fs.Set(flagName, value); err != nil { - log.Fatalf("invalid value %q for %s (flag --%s): %v", value, envName, flagName, err) + log.Fatalf("invalid value for %s (flag --%s)", envName, flagName) } f.DefValue = value } diff --git a/pkg/flags/env_test.go b/pkg/flags/env_test.go index 9de76a2eeb..a7d0a47d22 100644 --- a/pkg/flags/env_test.go +++ b/pkg/flags/env_test.go @@ -14,7 +14,6 @@ import ( func TestEnvName_MatchesConfigConstants(t *testing.T) { cases := map[string]string{ "home": config.EnvHome, - "debug": config.EnvDebug, "agent-url": config.EnvAgentURL, "log-level": config.EnvLogLevel, } diff --git a/pkg/flags/names/names.go b/pkg/flags/names/names.go index a7526f8a0d..936fc66d7e 100644 --- a/pkg/flags/names/names.go +++ b/pkg/flags/names/names.go @@ -202,13 +202,11 @@ const ( // Miscellaneous. const ( - Debug = "debug" Command = "command" Context = "context" User = "user" Workdir = "workdir" Home = "home" - LogOutput = "log-output" LogLevel = "log-level" LogFormat = "log-format" ResultFormat = "result-format" @@ -221,8 +219,6 @@ const ( ShutdownAction = "shutdown-action" Timeout = "timeout" Flavor = "flavor" - Verbose = "verbose" - Quiet = "quiet" Owner = "owner" AgentDir = "agent-dir" StateRoot = "state-root" diff --git a/pkg/flags/names/names_test.go b/pkg/flags/names/names_test.go index 5fdf92598b..d563a137fe 100644 --- a/pkg/flags/names/names_test.go +++ b/pkg/flags/names/names_test.go @@ -133,13 +133,12 @@ var wireNames = []struct { {names.ForceInternalBuildKit, "force-internal-buildkit"}, {names.DaemonInterval, "daemon-interval"}, {names.ForceDockerless, "force-dockerless"}, - {names.Debug, "debug"}, {names.Command, "command"}, {names.Context, "context"}, {names.User, "user"}, {names.Workdir, "workdir"}, {names.Home, "home"}, - {names.LogOutput, "log-output"}, + {names.LogLevel, "log-level"}, {names.LogFormat, "log-format"}, {names.ResultFormat, "result-format"}, {names.NoStatus, "no-status"}, @@ -154,8 +153,6 @@ var wireNames = []struct { {names.ShutdownAction, "shutdown-action"}, {names.Timeout, "timeout"}, {names.Flavor, "flavor"}, - {names.Verbose, "verbose"}, - {names.Quiet, "quiet"}, {names.Owner, "owner"}, {names.AgentDir, "agent-dir"}, {names.StateRoot, "state-root"}, @@ -282,8 +279,8 @@ func TestFlagHelpers(t *testing.T) { if got := names.Flag("stdio"); got != "--stdio" { t.Errorf("Flag = %q, want --stdio", got) } - if got := names.FlagValue("log-output", "raw"); got != "--log-output=raw" { - t.Errorf("FlagValue = %q, want --log-output=raw", got) + if got := names.FlagValue("log-format", "json"); got != "--log-format=json" { + t.Errorf("FlagValue = %q, want --log-format=json", got) } if got := names.FlagTrue("agent-forwarding"); got != "--agent-forwarding=true" { t.Errorf("FlagTrue = %q, want --agent-forwarding=true", got) diff --git a/pkg/ghcredentials/host.go b/pkg/ghcredentials/host.go index 2c5fbc33ce..e2ce902587 100644 --- a/pkg/ghcredentials/host.go +++ b/pkg/ghcredentials/host.go @@ -4,6 +4,7 @@ import ( "context" "errors" "io" + "log/slog" "os" "os/exec" "path/filepath" @@ -67,7 +68,7 @@ func collectHostAccounts( ctx, cancel := context.WithTimeout(ctx, hostCollectionTimeout) defer cancel() result := HostResult{Status: hostNoActiveAccounts} - accounts, truncated := registeredHostAccounts(hosts) + accounts, truncated := registeredHostAccounts(ctx, hosts) if truncated { result.Status = "account_limit" } @@ -85,13 +86,13 @@ func collectHostAccounts( return result } -func registeredHostAccounts(hosts *yaml.Node) ([]Account, bool) { +func registeredHostAccounts(ctx context.Context, hosts *yaml.Node) ([]Account, bool) { var accounts []Account for i := 0; i+1 < len(hosts.Content); i += 2 { host := hosts.Content[i].Value u := get(hosts.Content[i+1], "user") if u == nil || u.Value == "" { - log.Debugw("gh relay: host account unavailable", "host", host) + log.DebugContext(ctx, "gh relay: host account unavailable", slog.String("host", host)) continue } if len(accounts) == maxHostAccounts { @@ -192,15 +193,12 @@ func (a Account) resolveHostToken( token, err := resolveToken(ctx, binary, a.Host, env) if err != nil { if noTokenResult(err) { - log.Debugw("gh relay: host account unavailable", "host", a.Host) + log.DebugContext(ctx, "gh relay: host account unavailable", slog.String("host", a.Host)) return Account{}, nil } - log.Warnw( - "gh relay: host token lookup failed", - "host", - a.Host, - "error_type", - errorKind(err), + log.WarnContext(ctx, "gh relay: host token lookup failed", + slog.String("host", a.Host), + slog.String("error_type", errorKind(err)), ) return Account{}, err } diff --git a/pkg/ghcredentials/install_test.go b/pkg/ghcredentials/install_test.go index 86a468ae24..17c8d7fb3b 100644 --- a/pkg/ghcredentials/install_test.go +++ b/pkg/ghcredentials/install_test.go @@ -4,6 +4,8 @@ package ghcredentials import ( "context" + "errors" + "io" "os" "os/exec" "path/filepath" @@ -53,6 +55,17 @@ func TestBackendDiscoveryToleratesLoginShellOutput(t *testing.T) { ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) defer cancel() result, err := discoverWithLoginShell(ctx, binary, "guest-user") + if err != nil && (!tc.invalid || errors.Is(err, context.DeadlineExceeded)) { + trace, openErr := os.Open(record + ".trace") + if openErr != nil { + t.Logf("fixture trace unavailable: %v", openErr) + } else { + data, readErr := io.ReadAll(io.LimitReader(trace, 4096)) + _ = trace.Close() + t.Logf("fixture trace: %q (read error: %v)", data, readErr) + } + } + require.NotErrorIs(t, err, context.DeadlineExceeded) if tc.invalid { require.Error(t, err) } else { @@ -71,14 +84,20 @@ func loginShellFixture(t *testing.T) (binary, record string) { dir := t.TempDir() record = filepath.Join(dir, "su-args") writeTestExecutable(t, filepath.Join(dir, "su"), []byte(`#!/bin/sh +printf '%s\n' 'su started' >> "$DEVSY_TEST_SU_ARGS.trace" printf '%s\n' "$@" > "$DEVSY_TEST_SU_ARGS" +printf '%s\n' 'su arguments recorded' >> "$DEVSY_TEST_SU_ARGS.trace" printf '%s' "$DEVSY_TEST_PROFILE_OUTPUT" +printf '%s\n' 'su profile written' >> "$DEVSY_TEST_SU_ARGS.trace" exec /bin/sh -c "$4" `)) binary = filepath.Join(dir, "agent's binary") writeTestExecutable(t, binary, []byte(`#!/bin/sh +printf '%s\n' 'agent started' >> "$DEVSY_TEST_SU_ARGS.trace" test "$#" = 2 && test "$1" = internal && test "$2" = gh-backend || exit 42 +printf '%s\n' 'agent arguments validated' >> "$DEVSY_TEST_SU_ARGS.trace" printf '%s\n' "$DEVSY_TEST_BACKEND_OUTPUT" +printf '%s\n' 'agent output written' >> "$DEVSY_TEST_SU_ARGS.trace" exit "${DEVSY_TEST_BACKEND_EXIT:-0}" `)) t.Setenv("PATH", dir) diff --git a/pkg/ghcredentials/process_unix.go b/pkg/ghcredentials/process_unix.go index a369413168..3b217e7323 100644 --- a/pkg/ghcredentials/process_unix.go +++ b/pkg/ghcredentials/process_unix.go @@ -3,6 +3,8 @@ package ghcredentials import ( + "context" + "log/slog" "os" "os/exec" "os/signal" @@ -22,7 +24,11 @@ func runGH(binary string, args, env []string, owner *os.File) int { signal.Notify(signals, os.Interrupt, syscall.SIGTERM, syscall.SIGHUP) defer signal.Stop(signals) if err := cmd.Start(); err != nil { - log.Errorw("gh relay: executable unavailable", "error_type", errorKind(err)) + log.ErrorContext( + context.Background(), + "gh relay: executable unavailable", + slog.String("error_type", errorKind(err)), + ) return 126 } done := make(chan struct{}) diff --git a/pkg/ghcredentials/process_windows.go b/pkg/ghcredentials/process_windows.go index 6c6b076340..ce15082324 100644 --- a/pkg/ghcredentials/process_windows.go +++ b/pkg/ghcredentials/process_windows.go @@ -1,6 +1,8 @@ package ghcredentials import ( + "context" + "log/slog" "os" "os/exec" @@ -33,7 +35,11 @@ func runGH(binary string, args, env []string, _ *os.File) int { if cmd.ProcessState != nil { return cmd.ProcessState.ExitCode() } - log.Errorw("gh relay: executable unavailable", "error_type", errorKind(err)) + log.ErrorContext( + context.Background(), + "gh relay: executable unavailable", + slog.String("error_type", errorKind(err)), + ) return 126 } return 0 diff --git a/pkg/ghcredentials/result.go b/pkg/ghcredentials/result.go index 566cd84677..ac0461d798 100644 --- a/pkg/ghcredentials/result.go +++ b/pkg/ghcredentials/result.go @@ -3,6 +3,7 @@ package ghcredentials import ( "context" "errors" + "log/slog" "os" "os/exec" "syscall" @@ -76,12 +77,32 @@ func describeError(name string, err error) (string, string) { return name, errorKind(err) } -func logFailure(message, operation string, err error, saving bool) { - operation, kind := describeError(operation, err) - if saving { - log.Errorw(message, "operation", operation, "error_type", kind) - } else { - log.Warnw(message, "operation", operation, "error_type", kind) +type failureKind uint8 + +const ( + recoveryPending failureKind = iota + recoveryUnavailable + forwardingFailure + writebackPending +) + +type failureLog struct { + kind failureKind + operation string +} + +func logFailure(ctx context.Context, err error, details failureLog) { + operation, kind := describeError(details.operation, err) + operationAttr, kindAttr := slog.String("operation", operation), slog.String("error_type", kind) + switch details.kind { + case recoveryPending: + log.ErrorContext(ctx, "gh relay: recovery pending", operationAttr, kindAttr) + case recoveryUnavailable: + log.WarnContext(ctx, "gh relay: recovery unavailable", operationAttr, kindAttr) + case forwardingFailure: + log.WarnContext(ctx, forwardingUnavailable, operationAttr, kindAttr) + case writebackPending: + log.ErrorContext(ctx, "gh relay: configuration writeback pending", operationAttr, kindAttr) } } diff --git a/pkg/ghcredentials/session.go b/pkg/ghcredentials/session.go index 67e51d4680..b67d0ecaae 100644 --- a/pkg/ghcredentials/session.go +++ b/pkg/ghcredentials/session.go @@ -8,6 +8,7 @@ import ( "errors" "fmt" "io/fs" + "log/slog" "os" "os/exec" "path/filepath" @@ -208,14 +209,14 @@ func (s *treeSnapshot) reserveBytes(size int64) error { func recoverSessions(ctx context.Context, root string) { entries, err := os.ReadDir(root) if err != nil { - logFailure("gh relay: recovery pending", "recovery.list", err, true) + logFailure(ctx, err, failureLog{recoveryPending, "recovery.list"}) return } for _, e := range entries { if e.IsDir() && strings.HasPrefix(e.Name(), "session-") { dir := filepath.Join(root, e.Name()) if err := recoverSession(ctx, dir); err != nil { - logFailure("gh relay: recovery pending", "recovery.writeback", err, true) + logFailure(ctx, err, failureLog{recoveryPending, "recovery.writeback"}) } } } @@ -400,7 +401,12 @@ func (s *session) overlay( } source := a.inject(ctx, binary, replaceEnv(env, "GH_CONFIG_DIR", probe), hosts) _ = os.RemoveAll(probe) - log.Debugw("gh relay: authentication source", "host", a.Host, "source", source) + log.DebugContext( + ctx, + "gh relay: authentication source", + slog.String("host", a.Host), + slog.String("source", source), + ) if source == "forwarded" { injected = append(injected, a) } @@ -625,14 +631,10 @@ func (a Account) inject( } token, err := resolveToken(ctx, binary, a.Host, env) if err != nil && !noTokenResult(err) { - log.Warnw( - "gh relay: forwarding unavailable", - "operation", - "local.token_lookup", - "host", - a.Host, - "error_type", - errorKind(err), + log.WarnContext(ctx, "gh relay: forwarding unavailable", + slog.String("operation", "local.token_lookup"), + slog.String("host", a.Host), + slog.String("error_type", errorKind(err)), ) return "local_lookup_failed" } diff --git a/pkg/ghcredentials/wrapper.go b/pkg/ghcredentials/wrapper.go index 311d4ce744..9a9f2424dd 100644 --- a/pkg/ghcredentials/wrapper.go +++ b/pkg/ghcredentials/wrapper.go @@ -4,6 +4,7 @@ import ( "context" "encoding/json" "io" + "log/slog" "net/http" "os" "os/exec" @@ -17,8 +18,9 @@ import ( ) const ( - sessionEnv = "DEVSY_GH_SESSION" - authProbeEnv = "DEVSY_GH_AUTH_PROBE" + sessionEnv = "DEVSY_GH_SESSION" + authProbeEnv = "DEVSY_GH_AUTH_PROBE" + forwardingUnavailable = "gh relay: forwarding unavailable" ) func Run(args []string) int { @@ -28,10 +30,18 @@ func Run(args []string) int { } binary, err := realBinary(args[0]) if err != nil { - log.Errorw("gh relay: executable unavailable", "error_type", errorKind(err)) + log.ErrorContext( + context.Background(), + "gh relay: executable unavailable", + slog.String("error_type", errorKind(err)), + ) return 127 } - log.Debugw("gh relay: executable selected", "binary", binary) + log.DebugContext( + context.Background(), + "gh relay: executable selected", + slog.String("binary", binary), + ) env := os.Environ() if _, explicit := os.LookupEnv("GH_PATH"); !explicit { env = replaceEnv(env, "GH_PATH", wrapperPath) @@ -63,12 +73,12 @@ type invocation struct { func (inv *invocation) recover(ctx context.Context) { root, err := sessionRoot() if err != nil { - logFailure("gh relay: recovery unavailable", "session.recover", err, false) + logFailure(ctx, err, failureLog{recoveryUnavailable, "session.recover"}) return } l, err := lock(ctx, filepath.Join(root, "sessions.lock")) if err != nil { - logFailure("gh relay: recovery unavailable", "session.recover_lock", err, false) + logFailure(ctx, err, failureLog{recoveryUnavailable, "session.recover_lock"}) return } defer func() { _ = l.Close() }() @@ -78,19 +88,16 @@ func (inv *invocation) recover(ctx context.Context) { func (inv *invocation) prepare(ctx context.Context) *session { result, err := fetch(ctx) if err != nil { - logFailure("gh relay: forwarding unavailable", "relay.fetch", err, false) + logFailure(ctx, err, failureLog{forwardingFailure, "relay.fetch"}) return nil } - log.Debugw("gh relay: host authentication", "status", result.Status) + log.DebugContext(ctx, "gh relay: host authentication", slog.String("status", result.Status)) switch result.Status { case stateAvailable, "gh_not_found", hostNoActiveAccounts, "rpc_denied": default: - log.Warnw( - "gh relay: forwarding unavailable", - "operation", - "host.resolve", - "status", - result.Status, + log.WarnContext(ctx, forwardingUnavailable, + slog.String("operation", "host.resolve"), + slog.String("status", result.Status), ) } if len(result.Accounts) == 0 { @@ -98,16 +105,16 @@ func (inv *invocation) prepare(ctx context.Context) *session { } original, err := ConfigDir() if err != nil { - logFailure("gh relay: forwarding unavailable", "config.path", err, false) + logFailure(ctx, err, failureLog{forwardingFailure, "config.path"}) return nil } s, err := startSession(ctx, original, result.Accounts) if err != nil { - logFailure("gh relay: forwarding unavailable", "session.snapshot", err, false) + logFailure(ctx, err, failureLog{forwardingFailure, "session.snapshot"}) return nil } if err := s.inject(ctx, inv.binary, inv.env); err != nil { - logFailure("gh relay: forwarding unavailable", "config.overlay", err, false) + logFailure(ctx, err, failureLog{forwardingFailure, "config.overlay"}) _ = os.RemoveAll(s.dir) _ = s.lock.Close() return nil @@ -122,7 +129,7 @@ func (inv *invocation) withSession(s *session) int { ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) defer cancel() if err := s.finish(ctx); err != nil { - logFailure("gh relay: configuration writeback pending", "config.writeback", err, true) + logFailure(ctx, err, failureLog{writebackPending, "config.writeback"}) } return code } diff --git a/pkg/git/installer.go b/pkg/git/installer.go index 94e16b84b4..2eff19db60 100644 --- a/pkg/git/installer.go +++ b/pkg/git/installer.go @@ -118,7 +118,7 @@ func (s *pkgManagerStrategy) usable() bool { func (s *pkgManagerStrategy) install(ctx context.Context, t tool) error { log.Debugf("installing %s with %s", t.pkg, s.manager) for _, args := range s.installArgs(t.pkg) { - w := log.Writer(log.LevelInfo) + w := log.Writer(log.SlogLevelInfo) if _, err := s.runner.Run(ctx, RunOptions{ Binary: s.manager, Args: args, diff --git a/pkg/git/progress_test.go b/pkg/git/progress_test.go index ab264be0ea..9ef8f8cb82 100644 --- a/pkg/git/progress_test.go +++ b/pkg/git/progress_test.go @@ -36,7 +36,7 @@ func TestProgressWriter_SplitsOnCarriageReturn(t *testing.T) { } func TestProgressWriter_ThinsIntermediatePercentages(t *testing.T) { - log.Init(log.Config{Verbosity: 2, Format: testLogFormatText}) + log.Init(log.Config{Level: log.LevelDebugName, Format: testLogFormatText}) var sink bytes.Buffer remove := log.AddSink(&sink) defer remove() @@ -69,7 +69,7 @@ func TestProgressWriter_ThinsIntermediatePercentages(t *testing.T) { } func TestProgressWriter_DropsExactDuplicateFrame(t *testing.T) { - log.Init(log.Config{Verbosity: 2, Format: testLogFormatText}) + log.Init(log.Config{Level: log.LevelDebugName, Format: testLogFormatText}) var sink bytes.Buffer remove := log.AddSink(&sink) defer remove() @@ -94,7 +94,7 @@ func TestProgressWriter_DropsExactDuplicateFrame(t *testing.T) { } func TestProgressWriter_TracksLabelsIndependently(t *testing.T) { - log.Init(log.Config{Verbosity: 2, Format: testLogFormatText}) + log.Init(log.Config{Level: log.LevelDebugName, Format: testLogFormatText}) var sink bytes.Buffer remove := log.AddSink(&sink) defer remove() diff --git a/pkg/git/repo.go b/pkg/git/repo.go index 73b31a4a10..4ae2da25c1 100644 --- a/pkg/git/repo.go +++ b/pkg/git/repo.go @@ -246,7 +246,7 @@ func (r *Repo) run(ctx context.Context, args ...string) (RunResult, error) { // runLogged executes a git subcommand streaming its output to the logs. func (r *Repo) runLogged(ctx context.Context, args ...string) error { - w := log.Writer(log.LevelInfo) + w := log.Writer(log.SlogLevelInfo) _, err := r.runner.Run(ctx, RunOptions{ Dir: r.path, @@ -260,7 +260,7 @@ func (r *Repo) runLogged(ctx context.Context, args ...string) error { } func (r *Repo) cloneWith(ctx context.Context, repository string, c cloneConfig) error { - w := log.Writer(log.LevelInfo) + w := log.Writer(log.SlogLevelInfo) pw := newProgressWriter(w) diff --git a/pkg/gitcredentials/credentials_server_test.go b/pkg/gitcredentials/credentials_server_test.go new file mode 100644 index 0000000000..718c2dc6d9 --- /dev/null +++ b/pkg/gitcredentials/credentials_server_test.go @@ -0,0 +1,85 @@ +package gitcredentials + +import ( + "context" + "encoding/json" + "io" + "os" + "path/filepath" + "testing" + + "github.com/devsy-org/devsy/pkg/log" + "github.com/stretchr/testify/require" +) + +type credentialChildRecord struct { + Args []string `json:"args"` + Input string `json:"input"` +} + +func TestMain(m *testing.M) { + if os.Getenv("DEVSY_TEST_CREDENTIAL_CHILD") == "1" && len(os.Args) > 1 && + os.Args[1] == "internal" { + input, err := io.ReadAll(os.Stdin) + if err != nil { + os.Exit(91) + } + record, err := json.Marshal(credentialChildRecord{Args: os.Args[1:], Input: string(input)}) + if err != nil { + os.Exit(92) + } + recordPath := os.Getenv("DEVSY_TEST_CREDENTIAL_RECORD") + if err := os.WriteFile(recordPath, record, 0o600); err != nil { + os.Exit(93) + } + if _, err := os.Stdout.WriteString( + "username=alice\npassword=credential-value\n", + ); err != nil { + os.Exit(94) + } + os.Exit(0) + } + os.Exit(m.Run()) +} + +func TestCredentialsViaServerForwardsEffectiveLevelAndProtocol(t *testing.T) { + for _, tc := range []struct { + level log.Level + want string + }{ + {log.SlogLevelWarn, "warn"}, + {log.SlogLevelInfo, "info"}, + {log.SlogLevelTrace, "trace"}, + } { + t.Run(tc.want, func(t *testing.T) { + log.InitTestObserved(t, tc.level) + recordPath := filepath.Join(t.TempDir(), "request.json") + t.Setenv("DEVSY_TEST_CREDENTIAL_CHILD", "1") + t.Setenv("DEVSY_TEST_CREDENTIAL_RECORD", recordPath) + request := &GitCredentials{Protocol: httpPathTestProtocol, Host: "example.com"} + got, err := credentialsViaServer(context.Background(), request, "8022") + require.NoError(t, err) + require.Equal(t, "alice", got.Username) + require.Equal(t, "credential-value", got.Password) + data, err := os.ReadFile(recordPath) + require.NoError(t, err) + var record credentialChildRecord + require.NoError(t, json.Unmarshal(data, &record)) + require.Equal( + t, + []string{ + "internal", + "agent", + "git-credentials", + "--port", + "8022", + "get", + "--log-level", + tc.want, + }, + record.Args, + ) + require.Equal(t, request.Encode(), record.Input) + }) + } +} diff --git a/pkg/gitcredentials/gitcredentials.go b/pkg/gitcredentials/gitcredentials.go index 62e10073de..b680851b55 100644 --- a/pkg/gitcredentials/gitcredentials.go +++ b/pkg/gitcredentials/gitcredentials.go @@ -13,6 +13,7 @@ import ( "github.com/devsy-org/devsy/pkg/config" "github.com/devsy-org/devsy/pkg/file" "github.com/devsy-org/devsy/pkg/git" + "github.com/devsy-org/devsy/pkg/log" ) // GitCredentials is the git credential-helper record. Its wire form is git's @@ -221,12 +222,9 @@ func credentialsViaServer( return nil, err } - //nolint:gosec // binaryPath is from os.Executable(), not user input - cmd := exec.CommandContext( - ctx, - binaryPath, - "internal", "agent", "git-credentials", "--port", port, "get", - ) + args := []string{"internal", "agent", "git-credentials", "--port", port, "get"} + args = append(args, log.ForwardFlagArgs()...) + cmd := exec.CommandContext(ctx, binaryPath, args...) cmd.Stdin = strings.NewReader(request.Encode()) stdout, err := cmd.Output() if err != nil { diff --git a/pkg/gpg/forward.go b/pkg/gpg/forward.go index 8f19d360f7..ff444ba8a8 100644 --- a/pkg/gpg/forward.go +++ b/pkg/gpg/forward.go @@ -158,7 +158,7 @@ func signalOnce(ready chan<- struct{}) { } func buildForwardArgs(user, context, workspace string) []string { - return []string{ + args := []string{ "workspace", "ssh", names.FlagTrue(names.SSHGPGForwarding), @@ -169,7 +169,7 @@ func buildForwardArgs(user, context, workspace string) []string { names.Flag(names.Context), context, workspace, - names.FlagValue(names.LogOutput, "raw"), names.Flag(names.Command), "sleep infinity", } + return append(args, log.ForwardFlagArgs()...) } diff --git a/pkg/gpg/forward_test.go b/pkg/gpg/forward_test.go index 22f229a78a..6a3382ae5c 100644 --- a/pkg/gpg/forward_test.go +++ b/pkg/gpg/forward_test.go @@ -8,6 +8,7 @@ import ( "testing" "time" + "github.com/devsy-org/devsy/pkg/log" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) @@ -25,8 +26,8 @@ func TestBuildForwardArgs(t *testing.T) { "--user", "root", "--context", "test-context", "test-workspace", - "--log-output=raw", "--command", "sleep infinity", + "--log-level", log.LevelString(), } assert.Equal(t, expected, got) } @@ -42,8 +43,8 @@ func TestBuildForwardArgs_NonRootUser(t *testing.T) { "--user", "vscode", "--context", "test-context", "test-workspace", - "--log-output=raw", "--command", "sleep infinity", + "--log-level", log.LevelString(), } assert.Equal(t, expected, got) } diff --git a/pkg/ide/internal/serverutil/serverutil.go b/pkg/ide/internal/serverutil/serverutil.go index c1431f02b0..aa7d9466e2 100644 --- a/pkg/ide/internal/serverutil/serverutil.go +++ b/pkg/ide/internal/serverutil/serverutil.go @@ -118,7 +118,7 @@ func (e ExtensionInstall) Run() error { quote = func(name string) string { return name } } - out := log.Writer(log.LevelInfo) + out := log.Writer(log.SlogLevelInfo) defer func() { _ = out.Close() }() var failed []string diff --git a/pkg/ide/opener/browser_preparation_test.go b/pkg/ide/opener/browser_preparation_test.go index f656052c5a..4a21b00ef3 100644 --- a/pkg/ide/opener/browser_preparation_test.go +++ b/pkg/ide/opener/browser_preparation_test.go @@ -8,7 +8,6 @@ import ( "github.com/devsy-org/devsy/pkg/log" "github.com/stretchr/testify/require" - "go.uber.org/zap/zapcore" ) func TestBrowserReuseWaitsForPreparedHelperIdentity(t *testing.T) { @@ -51,7 +50,7 @@ func TestBrowserReuseRejectsLegacyAndCanceledPreparation(t *testing.T) { func TestBrowserReuseReleasesLockWhilePreparationIsPending(t *testing.T) { setupTempHome(t) - logs := log.InitTestObserved(t, zapcore.InfoLevel) + logs := log.InitTestObserved(t, log.SlogLevelInfo) created, err := helperCreateTime(os.Getpid()) require.NoError(t, err) existing := TunnelState{PID: os.Getpid(), CreateTime: created, PreparationVersion: 1} diff --git a/pkg/ide/opener/browser_tunnel.go b/pkg/ide/opener/browser_tunnel.go index 62ed3e48d8..09cb4e4cdb 100644 --- a/pkg/ide/opener/browser_tunnel.go +++ b/pkg/ide/opener/browser_tunnel.go @@ -412,9 +412,7 @@ func buildHelperArgs( if openBrowser { args = append(args, names.Flag(names.OpenBrowser)) } - if pkglog.DebugEnabled() { - args = append(args, names.Flag(names.Debug)) - } + args = append(args, pkglog.ForwardFlagArgs()...) return args } diff --git a/pkg/ide/opener/opener.go b/pkg/ide/opener/opener.go index eee8277e8e..e2bd3aac9e 100644 --- a/pkg/ide/opener/opener.go +++ b/pkg/ide/opener/opener.go @@ -4,6 +4,7 @@ import ( "bytes" "context" "fmt" + "log/slog" "net" "net/url" "strconv" @@ -300,7 +301,11 @@ func makeDaemonStartFunc( GitSSHSigningKey: params.GitSSHSigningKey, }, func(status credentials.Readiness) { - pkglog.Debugw("browser credentials prepared", "status", status.GitHubState) + pkglog.DebugContext( + ctx, + "browser credentials prepared", + slog.String("status", status.GitHubState), + ) prepared() }, ) diff --git a/pkg/ide/vscode/open.go b/pkg/ide/vscode/open.go index 447f0a6131..fa3c026065 100644 --- a/pkg/ide/vscode/open.go +++ b/pkg/ide/vscode/open.go @@ -6,6 +6,7 @@ import ( "errors" "fmt" "io/fs" + "log/slog" "net/url" "os" "os/exec" @@ -273,28 +274,25 @@ func (l hostLauncher) open(ctx context.Context, params OpenParams) error { return newStageError(stageResolve, errors.New("unsupported editor flavor")) } redactor := secrets.NewEnvironmentRedactor(os.Environ()) - fields := []any{ - "operation", redactor.Redact(status.OperationID(ctx)), - "flavor", redactor.Redact(string(params.Flavor)), + fields := []slog.Attr{ + slog.String("operation", redactor.Redact(status.OperationID(ctx))), + slog.String("flavor", redactor.Redact(string(params.Flavor))), } cliErr := l.openViaCLI(ctx, params, fields) if cliErr != nil { - log.Warnw( - "editor CLI launch failed", - append( - fields, - "route", - routeCLI, - "stage", - stageOf(cliErr), - "class", - classOf(cliErr), - )..., - ) + log.WarnContext(ctx, "editor CLI launch failed", + append(fields, + slog.String("route", routeCLI), + slog.String("stage", stageOf(cliErr)), + slog.String("class", classOf(cliErr)), + )...) } if cliErr == nil { - log.Infow("launch request dispatched", append(fields, "route", routeCLI)...) + log.InfoContext( + ctx, + "launch request dispatched", + append(fields, slog.String("route", routeCLI))...) return nil } @@ -302,17 +300,18 @@ func (l hostLauncher) open(ctx context.Context, params OpenParams) error { return ctx.Err() } - log.Debugw("dispatching launch request", - append(fields, "route", routeURI, "stage", stageURIDispatch)...) + log.DebugContext(ctx, "dispatching launch request", + append(fields, slog.String("route", routeURI), slog.String("stage", stageURIDispatch))...) uriErr := l.openViaURI(params) if uriErr == nil { - log.Infow("launch request dispatched", - append(fields, "route", routeURI, "after_cli_failure", true)...) + log.InfoContext(ctx, "launch request dispatched", + append(fields, slog.String("route", routeURI), slog.Bool("after_cli_failure", true))...) return nil } - log.Warnw("URI launch failed", - append(fields, "route", routeURI, "stage", stageOf(uriErr), "class", classOf(uriErr))...) + log.WarnContext(ctx, "URI launch failed", + append(fields, slog.String("route", routeURI), slog.String("stage", stageOf(uriErr)), + slog.String("class", classOf(uriErr)))...) return errors.Join(cliErr, uriErr) } @@ -357,19 +356,25 @@ func (l hostLauncher) openViaURI(params OpenParams) error { return nil } -func (l hostLauncher) openViaCLI(ctx context.Context, params OpenParams, fields []any) error { +func (l hostLauncher) openViaCLI(ctx context.Context, params OpenParams, fields []slog.Attr) error { config, ok := openConfigs[params.Flavor] if !ok { return fmt.Errorf("unknown flavor %s", params.Flavor) } - cliPath, err := l.resolveCLI(config, fields) + cliPath, err := l.resolveCLI(ctx, config, fields) if err != nil { return err } - log.Debugw("enumerating editor extensions", - append(fields, "route", routeCLI, "stage", stageListExtensions)...) + log.DebugContext( + ctx, + "enumerating editor extensions", + append( + fields, + slog.String("route", routeCLI), + slog.String("stage", stageListExtensions), + )...) hasSSHExtension, hasContainersExtension, err := l.listInstalledExtensions( ctx, cliPath, @@ -380,16 +385,22 @@ func (l hostLauncher) openViaCLI(ctx context.Context, params OpenParams, fields } if !hasSSHExtension { - log.Debugw("installing editor SSH extension", - append(fields, "route", routeCLI, "stage", stageInstallSSHExt)...) + log.DebugContext( + ctx, + "installing editor SSH extension", + append( + fields, + slog.String("route", routeCLI), + slog.String("stage", stageInstallSSHExt), + )...) if err := l.ensureSSHExtension(ctx, cliPath, config.sshExtension); err != nil { return err } } args := buildOpenArgs(params.SSHHost, params.Folder, params.NewWindow, hasContainersExtension) - log.Debugw("dispatching launch request", - append(fields, "route", routeCLI, "stage", stageCLIDispatch)...) + log.DebugContext(ctx, "dispatching launch request", + append(fields, slog.String("route", routeCLI), slog.String("stage", stageCLIDispatch))...) if _, err := l.run(ctx, cliPath, args...); err != nil { return newStageError(stageCLIDispatch, err) } @@ -400,7 +411,11 @@ func (l hostLauncher) openViaCLI(ctx context.Context, params OpenParams, fields // resolveCLI finds the editor CLI. It logs only the file kind, not the path: on // Windows a .cmd wrapper and a native executable fail in different ways, while // the path itself usually contains the user's name. -func (l hostLauncher) resolveCLI(config openConfig, fields []any) (string, error) { +func (l hostLauncher) resolveCLI( + ctx context.Context, + config openConfig, + fields []slog.Attr, +) (string, error) { candidates := []string{config.cliName} if l.goos == "darwin" { candidates = append(candidates, config.macAppPath) @@ -415,16 +430,11 @@ func (l hostLauncher) resolveCLI(config openConfig, fields []any) (string, error lookupErrs = append(lookupErrs, err) continue } - log.Debugw( - "editor CLI resolved", - append( - fields, - "route", - routeCLI, - "stage", - stageResolve, - "cli_kind", - cliKind(path), + log.DebugContext(ctx, "editor CLI resolved", + append(fields, + slog.String("route", routeCLI), + slog.String("stage", stageResolve), + slog.String("cli_kind", cliKind(path)), )...) return path, nil } diff --git a/pkg/ide/vscode/open_test.go b/pkg/ide/vscode/open_test.go index 355f54b33e..a7c751f984 100644 --- a/pkg/ide/vscode/open_test.go +++ b/pkg/ide/vscode/open_test.go @@ -4,6 +4,7 @@ import ( "context" "errors" "fmt" + "log/slog" "os" "os/exec" "path/filepath" @@ -14,9 +15,6 @@ import ( "github.com/devsy-org/devsy/pkg/log" "github.com/devsy-org/devsy/pkg/status" "github.com/stretchr/testify/suite" - "go.uber.org/zap" - "go.uber.org/zap/zapcore" - "go.uber.org/zap/zaptest/observer" ) const ( @@ -35,7 +33,7 @@ func (c call) isListExtensions() bool { type OpenSuite struct { suite.Suite - logs *observer.ObservedLogs + logs *log.ObservedLogs calls []call uris []string launcher hostLauncher @@ -48,7 +46,7 @@ func TestOpenSuite(t *testing.T) { } func (s *OpenSuite) SetupTest() { - s.logs = log.InitTestObserved(s.T(), zapcore.DebugLevel) + s.logs = log.InitTestObserved(s.T(), log.SlogLevelDebug) s.calls = nil s.uris = nil s.uriErr = nil @@ -115,14 +113,14 @@ func (s *OpenSuite) TestCLISuccessDispatchesOnceWithCorrelation() { s.Require().NotEmpty(operationID) s.Len(s.calls, 2) s.Empty(s.uris) - dispatched := s.records(zapcore.InfoLevel) + dispatched := s.records(log.SlogLevelInfo) s.Require().Len(dispatched, 1) - s.Equal(operationID, dispatched[0].ContextMap()["operation"]) - s.Equal(string(FlavorCodium), dispatched[0].ContextMap()["flavor"]) - s.Equal(routeCLI, dispatched[0].ContextMap()["route"]) - resolved := s.logs.FilterField(zap.String("cli_kind", "no extension")).All() + s.Equal(operationID, dispatched[0].AttrsMap()["operation"]) + s.Equal(string(FlavorCodium), dispatched[0].AttrsMap()["flavor"]) + s.Equal(routeCLI, dispatched[0].AttrsMap()["route"]) + resolved := s.logs.FilterAttr(slog.String("cli_kind", "no extension")).All() s.Require().Len(resolved, 1) - s.Equal(stageResolve, resolved[0].ContextMap()["stage"]) + s.Equal(stageResolve, resolved[0].AttrsMap()["stage"]) } func (s *OpenSuite) TestCLIFailureFallsBackAndKeepsCauseAndCorrelation() { @@ -140,17 +138,17 @@ func (s *OpenSuite) TestCLIFailureFallsBackAndKeepsCauseAndCorrelation() { s.Require().Len(s.uris, 1) s.Contains(s.uris[0], "codium://vscode-remote/") - failed := s.records(zapcore.WarnLevel) + failed := s.records(log.SlogLevelWarn) s.Require().Len(failed, 1) - s.Equal(operationID, failed[0].ContextMap()["operation"]) - s.Equal(routeCLI, failed[0].ContextMap()["route"]) - s.Equal(stageCLIDispatch, failed[0].ContextMap()["stage"]) + s.Equal(operationID, failed[0].AttrsMap()["operation"]) + s.Equal(routeCLI, failed[0].AttrsMap()["route"]) + s.Equal(stageCLIDispatch, failed[0].AttrsMap()["stage"]) - dispatched := s.records(zapcore.InfoLevel) + dispatched := s.records(log.SlogLevelInfo) s.Require().Len(dispatched, 1) - s.Equal(operationID, dispatched[0].ContextMap()["operation"]) - s.Equal(routeURI, dispatched[0].ContextMap()["route"]) - s.Equal(true, dispatched[0].ContextMap()["after_cli_failure"]) + s.Equal(operationID, dispatched[0].AttrsMap()["operation"]) + s.Equal(routeURI, dispatched[0].AttrsMap()["route"]) + s.Equal(true, dispatched[0].AttrsMap()["after_cli_failure"]) } func (s *OpenSuite) TestBothRoutesFailingKeepsCausesAndLogsBothFailures() { @@ -164,14 +162,14 @@ func (s *OpenSuite) TestBothRoutesFailingKeepsCausesAndLogsBothFailures() { s.Require().Error(err) s.ErrorIs(err, cliCause) s.ErrorIs(err, uriCause) - failed := s.records(zapcore.WarnLevel) + failed := s.records(log.SlogLevelWarn) s.Require().Len(failed, 2) for _, entry := range failed { - s.Equal(operationID, entry.ContextMap()["operation"]) + s.Equal(operationID, entry.AttrsMap()["operation"]) } - s.Equal(stageListExtensions, failed[0].ContextMap()["stage"]) - s.Equal(stageURIDispatch, failed[1].ContextMap()["stage"]) - s.Empty(s.records(zapcore.InfoLevel)) + s.Equal(stageListExtensions, failed[0].AttrsMap()["stage"]) + s.Equal(stageURIDispatch, failed[1].AttrsMap()["stage"]) + s.Empty(s.records(log.SlogLevelInfo)) } func (s *OpenSuite) TestCancelledCLIDoesNotOpenURI() { @@ -195,9 +193,9 @@ func (s *OpenSuite) TestMissingCLIFallsBackToURI() { s.Require().NoError(err) s.Empty(s.calls) s.Len(s.uris, 1) - failed := s.records(zapcore.WarnLevel) + failed := s.records(log.SlogLevelWarn) s.Require().Len(failed, 1) - s.Equal(stageResolve, failed[0].ContextMap()["stage"]) + s.Equal(stageResolve, failed[0].AttrsMap()["stage"]) } func (s *OpenSuite) TestMissingSSHExtensionIsInstalledBeforeDispatch() { @@ -281,10 +279,10 @@ func (s *OpenSuite) TestLogsAndErrorsOmitEditorOutputPathsAndErrorText() { s.NotContains(logged, "Alice") s.NotContains(logged, "alice") s.ErrorIs(err, leaky) - failed := s.records(zapcore.WarnLevel) + failed := s.records(log.SlogLevelWarn) s.Require().Len(failed, 2) - s.Equal(failedStage, failed[0].ContextMap()["stage"]) - s.Equal(stageURIDispatch, failed[1].ContextMap()["stage"]) + s.Equal(failedStage, failed[0].AttrsMap()["stage"]) + s.Equal(stageURIDispatch, failed[1].AttrsMap()["stage"]) }) } } @@ -331,13 +329,13 @@ func (s *OpenSuite) TestMacAppPathIsCandidateOnlyOnDarwin() { } config := openConfigs[FlavorCodium] - _, err := s.launcher.resolveCLI(config, nil) + _, err := s.launcher.resolveCLI(context.Background(), config, nil) s.Require().Error(err) s.Equal([]string{"codium"}, looked) looked = nil s.launcher.goos = "darwin" - _, err = s.launcher.resolveCLI(config, nil) + _, err = s.launcher.resolveCLI(context.Background(), config, nil) s.Require().Error(err) s.Equal([]string{"codium", config.macAppPath}, looked) } @@ -408,7 +406,7 @@ printf '%s\n' "$@" > "$DEVSY_TEST_ARGV_FILE" s.Require().NoError(err) s.Equal("--disable-extension\nms-vscode-remote.remote-containers\n--new-window\n"+ "--folder-uri\nvscode-remote://ssh-remote+ws.devsy/workspaces/a%20b/%E9%9B%AA\n", string(argv)) - s.Empty(s.records(zapcore.WarnLevel)) + s.Empty(s.records(log.SlogLevelWarn)) } // openInOperation runs the launcher inside a real status operation, the way @@ -425,13 +423,13 @@ func (s *OpenSuite) openInOperation(params OpenParams) (operationID string, err ) s.Require().NotEmpty(operationID) for _, entry := range s.logs.AllUntimed() { - s.Equal(operationID, entry.ContextMap()["operation"]) - s.Equal(string(params.Flavor), entry.ContextMap()["flavor"]) + s.Equal(operationID, entry.AttrsMap()["operation"]) + s.Equal(string(params.Flavor), entry.AttrsMap()["flavor"]) } return operationID, err } -func (s *OpenSuite) records(level zapcore.Level) []observer.LoggedEntry { +func (s *OpenSuite) records(level log.Level) []log.LoggedEntry { return s.logs.FilterLevelExact(level).AllUntimed() } @@ -441,7 +439,7 @@ func (s *OpenSuite) everythingLogged() string { var b strings.Builder for _, entry := range s.logs.AllUntimed() { b.WriteString(entry.Message + "\n") - for key, value := range entry.ContextMap() { + for key, value := range entry.AttrsMap() { fmt.Fprintf(&b, "%s=%v\n", key, value) } } diff --git a/pkg/ide/vscode/vscode.go b/pkg/ide/vscode/vscode.go index b29622dbdb..b279cc7701 100644 --- a/pkg/ide/vscode/vscode.go +++ b/pkg/ide/vscode/vscode.go @@ -136,8 +136,8 @@ func (o *VsCodeServer) InstallExtensions() error { return fmt.Errorf("unable to locate server binary") } - writer := log.Writer(log.LevelInfo) - errWriter := log.Writer(log.LevelError) + writer := log.Writer(log.SlogLevelInfo) + errWriter := log.Writer(log.SlogLevelError) defer func() { _ = writer.Close() }() defer func() { _ = errWriter.Close() }() diff --git a/pkg/inject/inject_test.go b/pkg/inject/inject_test.go index 7f6cdc53b1..35fb64e7a2 100644 --- a/pkg/inject/inject_test.go +++ b/pkg/inject/inject_test.go @@ -21,7 +21,6 @@ import ( "github.com/devsy-org/devsy/pkg/util/goleaktest" "github.com/stretchr/testify/require" "github.com/stretchr/testify/suite" - "go.uber.org/zap/zapcore" ) // TestMain sets up the test environment and checks for goroutine leaks after tests. @@ -294,7 +293,7 @@ type InjectTimingLogTestSuite struct { } func (s *InjectTimingLogTestSuite) TestInject_TimingLogs() { - logs := log.InitTestObserved(s.T(), zapcore.DebugLevel) + logs := log.InitTestObserved(s.T(), log.SlogLevelDebug) ctx := context.Background() diff --git a/pkg/log/attrs.go b/pkg/log/attrs.go new file mode 100644 index 0000000000..d5fe401a30 --- /dev/null +++ b/pkg/log/attrs.go @@ -0,0 +1,114 @@ +package log + +import ( + "bytes" + "context" + "encoding/json" + "log/slog" + + "github.com/devsy-org/devsy/pkg/secrets" +) + +type redactHandler struct { + next slog.Handler + redactor *secrets.Redactor + grouped bool +} + +func (h *redactHandler) Enabled(ctx context.Context, level slog.Level) bool { + return h.next.Enabled(ctx, level) +} + +func (h *redactHandler) Handle(ctx context.Context, r slog.Record) error { + clean := slog.NewRecord(r.Time, r.Level, h.redactor.Redact(r.Message), r.PC) + r.Attrs(func(a slog.Attr) bool { clean.AddAttrs(h.cleanAttr(a, !h.grouped)); return true }) + return h.next.Handle(ctx, clean) +} + +func (h *redactHandler) WithAttrs(attrs []slog.Attr) slog.Handler { + clean := make([]slog.Attr, len(attrs)) + for i, a := range attrs { + clean[i] = h.cleanAttr(a, !h.grouped) + } + return &redactHandler{next: h.next.WithAttrs(clean), redactor: h.redactor, grouped: h.grouped} +} + +func (h *redactHandler) WithGroup(name string) slog.Handler { + return &redactHandler{ + next: h.next.WithGroup(h.redactor.Redact(name)), + redactor: h.redactor, + grouped: h.grouped || name != "", + } +} + +func (h *redactHandler) cleanAttr(a slog.Attr, root bool) slog.Attr { + a.Key = h.redactor.Redact(a.Key) + if root && isEnvelopeKey(a.Key) { + return slog.Attr{} + } + v := a.Value.Resolve() + switch v.Kind() { + case slog.KindString: + a.Value = slog.StringValue(h.redactor.Redact(v.String())) + case slog.KindGroup: + a.Value = h.cleanGroup(v.Group(), root && a.Key == "") + case slog.KindAny: + a.Value = h.cleanAny(v, a.Value) + default: + a.Value = v + } + return a +} + +func (h *redactHandler) cleanGroup(group []slog.Attr, root bool) slog.Value { + clean := make([]slog.Attr, len(group)) + for i := range group { + clean[i] = h.cleanAttr(group[i], root) + } + return slog.GroupValue(clean...) +} + +func isEnvelopeKey(key string) bool { + switch key { + case "ts", slog.TimeKey, slog.MessageKey, "message", slog.LevelKey: + return true + } + return false +} + +func (h *redactHandler) cleanAny(v, original slog.Value) slog.Value { + if err, ok := v.Any().(error); ok { + return slog.StringValue(h.redactor.Redact(err.Error())) + } + data, err := json.Marshal(v.Any()) + if err != nil { + return slog.StringValue(h.redactor.Redact(v.String())) + } + dec := json.NewDecoder(bytes.NewReader(data)) + dec.UseNumber() + var value any + if dec.Decode(&value) == nil { + return slog.AnyValue(h.cleanValue(value)) + } + return original +} + +func (h *redactHandler) cleanValue(v any) any { + switch value := v.(type) { + case string: + return h.redactor.Redact(value) + case []any: + clean := make([]any, len(value)) + for i := range value { + clean[i] = h.cleanValue(value[i]) + } + return clean + case map[string]any: + clean := make(map[string]any, len(value)) + for k, v := range value { + clean[h.redactor.Redact(k)] = h.cleanValue(v) + } + return clean + } + return v +} diff --git a/pkg/log/context.go b/pkg/log/context.go new file mode 100644 index 0000000000..8691c42897 --- /dev/null +++ b/pkg/log/context.go @@ -0,0 +1,69 @@ +package log + +import ( + "context" + "log/slog" +) + +type contextKey struct{} + +func Slog() *slog.Logger { return current.Load().logger } + +func WithAttrs(attrs ...slog.Attr) *slog.Logger { + return Slog().With(attrsToArgs(attrs)...) +} + +func WithContext(ctx context.Context, attrs ...slog.Attr) context.Context { + return context.WithValue(ctx, contextKey{}, FromContext(ctx).With(attrsToArgs(attrs)...)) +} + +func FromContext(ctx context.Context) *slog.Logger { + if ctx != nil { + if logger, ok := ctx.Value(contextKey{}).(*slog.Logger); ok { + return logger + } + } + return Slog() +} + +func attrsToArgs(attrs []slog.Attr) []any { + args := make([]any, len(attrs)) + for i := range attrs { + args[i] = attrs[i] + } + return args +} + +func logContext(ctx context.Context, level Level, msg string, attrs ...slog.Attr) { + logger := FromContext(ctx) + logger.LogAttrs(ctx, level, msg, attrs...) +} + +func TraceContext(ctx context.Context, msg string, attrs ...slog.Attr) { + logContext(ctx, SlogLevelTrace, msg, attrs...) +} + +func DebugContext(ctx context.Context, msg string, attrs ...slog.Attr) { + logContext(ctx, SlogLevelDebug, msg, attrs...) +} + +func InfoContext(ctx context.Context, msg string, attrs ...slog.Attr) { + logContext(ctx, SlogLevelInfo, msg, attrs...) +} + +func WarnContext(ctx context.Context, msg string, attrs ...slog.Attr) { + logContext(ctx, SlogLevelWarn, msg, attrs...) +} + +func ErrorContext(ctx context.Context, msg string, attrs ...slog.Attr) { + logContext(ctx, SlogLevelError, msg, attrs...) +} + +func AttrWorkspaceID(v string) slog.Attr { return slog.String("workspace_id", v) } +func AttrMachineID(v string) slog.Attr { return slog.String("machine_id", v) } +func AttrProvider(v string) slog.Attr { return slog.String("provider", v) } +func AttrComponent(v string) slog.Attr { return slog.String("component", v) } +func AttrOperation(v string) slog.Attr { return slog.String("operation", v) } +func AttrPhase(v string) slog.Attr { return slog.String("phase", v) } +func AttrDurationMs(v int64) slog.Attr { return slog.Int64("duration_ms", v) } +func AttrErrorCode(v string) slog.Attr { return slog.String("error_code", v) } diff --git a/pkg/log/jsonstream.go b/pkg/log/jsonstream.go index a7d6b20da3..94a012a09f 100644 --- a/pkg/log/jsonstream.go +++ b/pkg/log/jsonstream.go @@ -2,8 +2,10 @@ package log import ( "io" + "os" "github.com/devsy-org/devsy/pkg/scanner" + "github.com/devsy-org/devsy/pkg/secrets" ) func PipeJSONStream() (io.WriteCloser, chan struct{}) { @@ -50,6 +52,12 @@ func ReadJSONStream(reader io.Reader) { // A line that isn't valid JSON, or whose level isn't recognized, is written // to fallback verbatim if fallback is non-nil; otherwise it's dropped. func readJSONStreamWithFallback(reader io.Reader, fallback io.Writer) { + redactor := &JSONLogStreamer{ + redactor: secrets.Combine( + current.Load().redactor, + secrets.NewEnvironmentRedactor(os.Environ()), + ), + } scan := scanner.NewScanner(reader) for scan.Scan() { line := scan.Bytes() @@ -59,10 +67,10 @@ func readJSONStreamWithFallback(reader io.Reader, fallback io.Writer) { decoded, ok := decodeJSONLogLine(line) if !ok || !decoded.recognized { - writeFallbackLine(fallback, line) + writeFallbackLine(fallback, []byte(redactor.redactLine(string(line)))) continue } - logAtZapLevel(decoded.level, decoded.text) + emitRecord(decoded.level, decoded.timestamp, decoded.text, decoded.attrs) } } diff --git a/pkg/log/levels.go b/pkg/log/levels.go index 9231b01b83..7afb7b926d 100644 --- a/pkg/log/levels.go +++ b/pkg/log/levels.go @@ -1,6 +1,17 @@ package log -import "go.uber.org/zap/zapcore" +import "log/slog" + +type Level = slog.Level + +const ( + SlogLevelTrace Level = -8 + SlogLevelDebug Level = -4 + SlogLevelInfo Level = 0 + SlogLevelWarn Level = 4 + SlogLevelError Level = 8 + SlogLevelFatal Level = 12 +) const DefaultLevel = LevelWarnName @@ -20,73 +31,43 @@ var validLevels = [...]string{ LevelTraceName, } -func LevelFromString(value string) (zapcore.Level, bool) { +func LevelFromString(value string) (Level, bool) { switch value { case LevelErrorName: - return zapcore.ErrorLevel, true + return SlogLevelError, true case LevelWarnName: - return zapcore.WarnLevel, true + return SlogLevelWarn, true case LevelInfoName: - return zapcore.InfoLevel, true + return SlogLevelInfo, true case LevelDebugName: - return zapcore.DebugLevel, true + return SlogLevelDebug, true case LevelTraceName: - return zapcore.DebugLevel - 1, true + return SlogLevelTrace, true default: - return zapcore.ErrorLevel, false + return SlogLevelError, false } } func ValidLevels() []string { return append([]string(nil), validLevels[:]...) } -// Verbosity levels mapped from CLI flags. -const ( - LevelTrace = 3 - LevelDebug = 2 - LevelInfo = 1 - LevelWarn = 1 - LevelError = 0 - LevelFatal = 0 -) - -// DebugEnabled reports whether debug-level messages are currently logged. -func DebugEnabled() bool { - return sugar.Load().Desugar().Core().Enabled(zapcore.DebugLevel) -} - -// LevelString returns the lowest enabled log level as a lowercase string -// (e.g. "debug", "info", "warn", "error", "fatal"). -func LevelString() string { - core := sugar.Load().Desugar().Core() - if core.Enabled(zapcore.DebugLevel - 1) { - return LevelTraceName - } - for _, l := range []zapcore.Level{ - zapcore.DebugLevel, - zapcore.InfoLevel, - zapcore.WarnLevel, - zapcore.ErrorLevel, - zapcore.FatalLevel, - } { - if core.Enabled(l) { - return l.String() - } - } - return "info" -} - -// VerbosityToLevel converts a -v count (0-3) to a zapcore.Level. -// 0 = error+fatal only, 1 = +warn+info, 2 = +debug, 3 = trace (mapped to zap Debug-1). -func VerbosityToLevel(verbosity int) zapcore.Level { +func levelName(level Level) string { switch { - case verbosity >= 3: - // Trace: use a custom level below Debug - return zapcore.DebugLevel - 1 - case verbosity >= 2: - return zapcore.DebugLevel - case verbosity >= 1: - return zapcore.InfoLevel + case level >= SlogLevelFatal: + return "fatal" + case level >= SlogLevelError: + return LevelErrorName + case level >= SlogLevelWarn: + return LevelWarnName + case level >= SlogLevelInfo: + return LevelInfoName + case level >= SlogLevelDebug: + return LevelDebugName default: - return zapcore.ErrorLevel + return LevelTraceName } } + +func TraceEnabled() bool { return enabled(SlogLevelTrace) } +func DebugEnabled() bool { return enabled(SlogLevelDebug) } +func InfoEnabled() bool { return enabled(SlogLevelInfo) } +func LevelString() string { return levelName(current.Load().level) } diff --git a/pkg/log/logfmt.go b/pkg/log/logfmt.go deleted file mode 100644 index 756f4b1e4b..0000000000 --- a/pkg/log/logfmt.go +++ /dev/null @@ -1,162 +0,0 @@ -package log - -import ( - "fmt" - "sort" - "strings" - "time" - - "go.uber.org/zap" - "go.uber.org/zap/buffer" - "go.uber.org/zap/zapcore" -) - -var logfmtPool = buffer.NewPool() - -type logfmtEncoder struct { - buf *buffer.Buffer - fields []zapcore.Field -} - -func newLogfmtEncoder() zapcore.Encoder { - return &logfmtEncoder{buf: logfmtPool.Get()} -} - -func (e *logfmtEncoder) Clone() zapcore.Encoder { - clone := &logfmtEncoder{ - buf: logfmtPool.Get(), - fields: make([]zapcore.Field, len(e.fields)), - } - copy(clone.fields, e.fields) - return clone -} - -func (e *logfmtEncoder) EncodeEntry( - entry zapcore.Entry, - fields []zapcore.Field, -) (*buffer.Buffer, error) { - buf := logfmtPool.Get() - - buf.AppendString("level=") - buf.AppendString(entry.Level.String()) - - buf.AppendString(" ts=") - buf.AppendString(entry.Time.Format(time.RFC3339)) - - buf.AppendString(" msg=") - buf.AppendString(quoteLogfmt(entry.Message)) - - if entry.Caller.Defined { - buf.AppendString(" caller=") - buf.AppendString(entry.Caller.TrimmedPath()) - } - - // Merge With() fields and entry fields into a fresh slice. - allFields := make([]zapcore.Field, 0, len(e.fields)+len(fields)) - allFields = append(allFields, e.fields...) - allFields = append(allFields, fields...) - - enc := zapcore.NewMapObjectEncoder() - for _, f := range allFields { - f.AddTo(enc) - } - - keys := make([]string, 0, len(enc.Fields)) - for k := range enc.Fields { - keys = append(keys, k) - } - sort.Strings(keys) - - for _, k := range keys { - buf.AppendString(" ") - buf.AppendString(k) - buf.AppendString("=") - buf.AppendString(quoteLogfmt(fmt.Sprint(enc.Fields[k]))) - } - - buf.AppendString("\n") - return buf, nil -} - -func quoteLogfmt(s string) string { - if s == "" || strings.ContainsAny(s, " \t\n\"=") { - return fmt.Sprintf("%q", s) - } - return s -} - -// Required interface methods - delegate to buffer for simple types. -func (e *logfmtEncoder) AddArray(key string, arr zapcore.ArrayMarshaler) error { return nil } -func (e *logfmtEncoder) AddObject(key string, obj zapcore.ObjectMarshaler) error { return nil } -func (e *logfmtEncoder) AddBinary(key string, val []byte) {} -func (e *logfmtEncoder) AddByteString(key string, val []byte) {} - -func (e *logfmtEncoder) AddBool(key string, val bool) { - e.fields = append(e.fields, zapcore.Field{ - Key: key, Type: zapcore.BoolType, Integer: boolToInt(val), - }) -} - -func (e *logfmtEncoder) AddComplex128(key string, val complex128) {} -func (e *logfmtEncoder) AddComplex64(key string, val complex64) {} - -func (e *logfmtEncoder) AddDuration(key string, val time.Duration) { - e.fields = append(e.fields, zapcore.Field{ - Key: key, Type: zapcore.StringType, String: val.String(), - }) -} - -func (e *logfmtEncoder) AddFloat64(key string, val float64) { - e.fields = append(e.fields, zap.Float64(key, val)) -} - -func (e *logfmtEncoder) AddFloat32(key string, val float32) {} - -func (e *logfmtEncoder) AddInt(key string, val int) { e.AddInt64(key, int64(val)) } - -func (e *logfmtEncoder) AddInt64(key string, val int64) { - e.fields = append(e.fields, zapcore.Field{ - Key: key, Type: zapcore.Int64Type, Integer: val, - }) -} - -func (e *logfmtEncoder) AddInt32(key string, val int32) { e.AddInt64(key, int64(val)) } -func (e *logfmtEncoder) AddInt16(key string, val int16) { e.AddInt64(key, int64(val)) } -func (e *logfmtEncoder) AddInt8(key string, val int8) { e.AddInt64(key, int64(val)) } - -func (e *logfmtEncoder) AddString(key, val string) { - e.fields = append(e.fields, zapcore.Field{ - Key: key, Type: zapcore.StringType, String: val, - }) -} - -func (e *logfmtEncoder) AddTime(key string, val time.Time) { - e.AddString(key, val.Format(time.RFC3339)) -} - -func (e *logfmtEncoder) AddUint(key string, val uint) { - e.AddString(key, fmt.Sprintf("%d", val)) -} - -func (e *logfmtEncoder) AddUint64(key string, val uint64) { - e.AddString(key, fmt.Sprintf("%d", val)) -} - -func (e *logfmtEncoder) AddUint32(key string, val uint32) { e.AddInt64(key, int64(val)) } -func (e *logfmtEncoder) AddUint16(key string, val uint16) { e.AddInt64(key, int64(val)) } -func (e *logfmtEncoder) AddUint8(key string, val uint8) { e.AddInt64(key, int64(val)) } -func (e *logfmtEncoder) AddUintptr(key string, val uintptr) {} - -func (e *logfmtEncoder) AddReflected(key string, val any) error { - e.AddString(key, fmt.Sprint(val)) - return nil -} - -func (e *logfmtEncoder) OpenNamespace(key string) {} - -func boolToInt(b bool) int64 { - if b { - return 1 - } - return 0 -} diff --git a/pkg/log/logger.go b/pkg/log/logger.go index acd8160317..6f1fbc7d00 100644 --- a/pkg/log/logger.go +++ b/pkg/log/logger.go @@ -1,85 +1,124 @@ package log import ( + "context" + "errors" + "fmt" "io" + "log/slog" "os" + "strings" "sync" "sync/atomic" + "time" "github.com/devsy-org/devsy/pkg/secrets" - "go.uber.org/zap" - "go.uber.org/zap/zapcore" "golang.org/x/term" ) +type loggerState struct { + logger *slog.Logger + level Level + writer *redactingWriter + redactor *secrets.Redactor + previous *loggerState + removed bool +} + var ( - sugar atomic.Pointer[zap.SugaredLogger] - // extraSinks fans every log line out to writers added by AddSink. The - // stderr core remains the primary destination; sinks are additive. + current atomic.Pointer[loggerState] + stateMu sync.Mutex extraSinks = &writerFanout{} ) -func init() { - sugar.Store(zap.NewNop().Sugar()) -} +func init() { Init(Config{}) } -// Config holds logger configuration parsed from CLI flags. type Config struct { - Verbosity int // 0=error, 1=info+warn, 2=debug, 3=trace - Quiet bool // error only - Debug bool // backwards compat, equivalent to Verbosity=2 - Level string // explicit --log-level override - DefaultLevel string // persisted default when no explicit verbosity flag is set - VerbositySet bool - Format string // "text", "json", "logfmt" + Level string + DefaultLevel string + Format string Redactor *secrets.Redactor } -// Init configures the global logger. Called once in root command PersistentPreRunE. func Init(cfg Config) { - cfg.Redactor = secrets.Combine(cfg.Redactor, secrets.NewEnvironmentRedactor(os.Environ())) + redactor := secrets.Combine(cfg.Redactor, secrets.NewEnvironmentRedactor(os.Environ())) level := resolveLevel(cfg) - encoder := resolveEncoder(cfg.Format) - stderrWriter := zapcore.Lock(&redactingWriter{next: os.Stderr, redactor: cfg.Redactor}) - stderrCore := zapcore.NewCore(encoder, consoleWriter{next: stderrWriter}, level) - // A separate core writes to the fanout sink with the same level/encoder - // so AddSink consumers see the same output stderr does. - sinkCore := zapcore.NewCore( - resolveEncoder(cfg.Format), - &redactingWriter{next: extraSinks, redactor: cfg.Redactor}, - level, + writer := &redactingWriter{next: outputWriter{}, redactor: redactor} + var handler slog.Handler + opts := &slog.HandlerOptions{Level: level, ReplaceAttr: replaceEnvelope} + switch cfg.Format { + case "json": + handler = slog.NewJSONHandler(writer, opts) + case "logfmt": + handler = slog.NewTextHandler(writer, opts) + default: + color := colorEnabled() + opts.ReplaceAttr = func(groups []string, attr slog.Attr) slog.Attr { + if level, ok := attr.Value.Any().(slog.Level); len(groups) == 0 && + attr.Key == slog.LevelKey && + ok { + name := strings.ToUpper(levelName(level)) + if color { + code := "36" + if level >= SlogLevelError { + code = "31" + } else if level >= SlogLevelWarn { + code = "33" + } + name = "\x1b[" + code + "m" + name + "\x1b[0m" + } + return slog.String("level", name) + } + return replaceEnvelope(groups, attr) + } + handler = slog.NewTextHandler(writer, opts) + } + handler = &redactHandler{next: handler, redactor: redactor} + stateMu.Lock() + if old := current.Load(); old != nil && old.writer != nil { + _ = old.writer.Sync() + } + current.Store( + &loggerState{logger: slog.New(handler), level: level, writer: writer, redactor: redactor}, ) - core := zapcore.NewTee(stderrCore, sinkCore) - - logger := zap.New(core, zap.AddStacktrace(zapcore.FatalLevel)) - sugar.Store(logger.Sugar()) + stateMu.Unlock() } -var consoleOutput = struct { - sync.RWMutex - suppressed int -}{} +type outputWriter struct{} -type consoleWriter struct{ next zapcore.WriteSyncer } - -func (w consoleWriter) Write(p []byte) (int, error) { +func (outputWriter) Write(p []byte) (int, error) { consoleOutput.RLock() - defer consoleOutput.RUnlock() - if consoleOutput.suppressed > 0 { - return len(p), nil + if consoleOutput.suppressed == 0 { + _, _ = os.Stderr.Write(p) } - return w.next.Write(p) + consoleOutput.RUnlock() + return extraSinks.Write(p) } -func (w consoleWriter) Sync() error { - consoleOutput.RLock() - defer consoleOutput.RUnlock() - if consoleOutput.suppressed > 0 { - return nil +func replaceEnvelope(groups []string, a slog.Attr) slog.Attr { + if len(groups) != 0 { + return a } - return w.next.Sync() + switch a.Key { + case slog.TimeKey: + if a.Value.Kind() == slog.KindTime { + return slog.String("ts", a.Value.Time().Format("2006-01-02T15:04:05.000Z0700")) + } + case slog.LevelKey: + if level, ok := a.Value.Any().(slog.Level); ok { + return slog.String("level", levelName(level)) + } + } + return a } +var consoleOutput = struct { + sync.RWMutex + suppressed int +}{} + +func enabled(level Level) bool { return level >= current.Load().level } + func SuppressConsoleOutput() func() { consoleOutput.Lock() consoleOutput.suppressed++ @@ -145,18 +184,30 @@ func AddSink(w io.Writer) (remove func()) { return extraSinks.add(w) } -// writerFanout is a zapcore.WriteSyncer that dispatches every Write to a -// dynamic set of writers. Safe for concurrent use. +type sinkRegistration struct { + writer io.Writer +} + type writerFanout struct { mu sync.RWMutex - writers []io.Writer + writers []*sinkRegistration } func (f *writerFanout) Write(p []byte) (int, error) { f.mu.RLock() defer f.mu.RUnlock() - for _, w := range f.writers { - _, _ = w.Write(p) + var result error + for _, registration := range f.writers { + n, err := registration.writer.Write(p) + if err == nil && n != len(p) { + err = io.ErrShortWrite + } + if err != nil { + result = errors.Join(result, err) + } + } + if result != nil { + return 0, result } return len(p), nil } @@ -164,14 +215,15 @@ func (f *writerFanout) Write(p []byte) (int, error) { func (*writerFanout) Sync() error { return nil } func (f *writerFanout) add(w io.Writer) (remove func()) { + registration := &sinkRegistration{writer: w} f.mu.Lock() - f.writers = append(f.writers, w) + f.writers = append(f.writers, registration) f.mu.Unlock() return func() { f.mu.Lock() defer f.mu.Unlock() for i, x := range f.writers { - if x == w { + if x == registration { f.writers = append(f.writers[:i], f.writers[i+1:]...) return } @@ -179,110 +231,93 @@ func (f *writerFanout) add(w io.Writer) (remove func()) { } } -func resolveLevel(cfg Config) zapcore.Level { - if level, ok := resolveExplicitLevel(cfg); ok { +func resolveLevel(cfg Config) Level { + value := cfg.Level + if value == "" { + value = cfg.DefaultLevel + } + if level, ok := LevelFromString(value); ok { return level } - return VerbosityToLevel(cfg.Verbosity) + return SlogLevelWarn } -// Precedence: --quiet > --debug > explicitly supplied -v > --log-level > persisted default. -// This ordering is compatibility-sensitive: earlier flags must keep winning over -// later configuration, so do not reorder it. -func resolveExplicitLevel(cfg Config) (zapcore.Level, bool) { - if cfg.Quiet { - return zapcore.ErrorLevel, true - } - if cfg.Debug { - return zapcore.DebugLevel, true - } - if cfg.VerbositySet || cfg.Verbosity > 0 { - return VerbosityToLevel(cfg.Verbosity), true - } - return resolveConfiguredLevel(cfg.Level, cfg.DefaultLevel) +func colorEnabled() bool { + return os.Getenv("NO_COLOR") == "" && term.IsTerminal(int(os.Stderr.Fd())) } -func resolveConfiguredLevel(explicit, fallback string) (zapcore.Level, bool) { - if explicit != "" { - return LevelFromString(explicit) - } - if fallback != "" { - if level, ok := LevelFromString(fallback); ok { - return level, true - } +func Sync() error { + if writer := current.Load().writer; writer != nil { + return writer.Sync() } - level, _ := LevelFromString(DefaultLevel) - return level, true + return nil } -func resolveEncoder(format string) zapcore.Encoder { - switch format { - case "json": - return zapcore.NewJSONEncoder(jsonEncoderConfig()) - case "logfmt": - return newLogfmtEncoder() - default: - // "text" - use console encoder, with color if stderr is a terminal - if colorEnabled() { - return zapcore.NewConsoleEncoder(colorEncoderConfig()) - } - return zapcore.NewConsoleEncoder(plainEncoderConfig()) +func ForwardFlagArgs() []string { return []string{"--log-level", LevelString()} } + +func emit(level Level, message string) { + if enabled(level) { + Slog().Log(context.Background(), level, message) } } -func colorEnabled() bool { - if os.Getenv("NO_COLOR") != "" { - return false +func emitf(level Level, format string, args ...any) { + if enabled(level) { + emit(level, fmt.Sprintf(format, args...)) } - return term.IsTerminal(int(os.Stderr.Fd())) //nolint:gosec // fd fits in int } -func jsonEncoderConfig() zapcore.EncoderConfig { - cfg := zap.NewProductionEncoderConfig() - cfg.TimeKey = "ts" - cfg.EncodeTime = zapcore.ISO8601TimeEncoder - return cfg +func Tracef(format string, args ...any) { emitf(SlogLevelTrace, format, args...) } +func Debugf(format string, args ...any) { emitf(SlogLevelDebug, format, args...) } +func Infof(format string, args ...any) { emitf(SlogLevelInfo, format, args...) } +func Warnf(format string, args ...any) { emitf(SlogLevelWarn, format, args...) } +func Errorf(format string, args ...any) { emitf(SlogLevelError, format, args...) } +func Fatalf(format string, args ...any) { + emitf(SlogLevelFatal, format, args...) + _ = Sync() + os.Exit(1) } -func colorEncoderConfig() zapcore.EncoderConfig { - cfg := zap.NewDevelopmentEncoderConfig() - cfg.EncodeLevel = zapcore.CapitalColorLevelEncoder - cfg.EncodeTime = zapcore.ISO8601TimeEncoder - return cfg +func Trace(args ...any) { + if enabled(SlogLevelTrace) { + emit(SlogLevelTrace, fmt.Sprint(args...)) + } } -func plainEncoderConfig() zapcore.EncoderConfig { - cfg := zap.NewDevelopmentEncoderConfig() - cfg.EncodeLevel = zapcore.CapitalLevelEncoder - cfg.EncodeTime = zapcore.ISO8601TimeEncoder - return cfg +func Debug(args ...any) { + if enabled(SlogLevelDebug) { + emit(SlogLevelDebug, fmt.Sprint(args...)) + } } -// Underlying returns the raw *zap.Logger for advanced use cases. -func Underlying() *zap.Logger { - return sugar.Load().Desugar() +func Info(args ...any) { + if enabled(SlogLevelInfo) { + emit(SlogLevelInfo, fmt.Sprint(args...)) + } } -// Sync flushes any buffered log entries. Call before process exit. -func Sync() error { - return sugar.Load().Desugar().Sync() +func Warn(args ...any) { + if enabled(SlogLevelWarn) { + emit(SlogLevelWarn, fmt.Sprint(args...)) + } } -// --- Package-level logging functions --- - -func Debugf(format string, args ...any) { sugar.Load().Debugf(format, args...) } -func Infof(format string, args ...any) { sugar.Load().Infof(format, args...) } -func Warnf(format string, args ...any) { sugar.Load().Warnf(format, args...) } -func Errorf(format string, args ...any) { sugar.Load().Errorf(format, args...) } -func Fatalf(format string, args ...any) { sugar.Load().Fatalf(format, args...) } - -func Debug(args ...any) { sugar.Load().Debug(args...) } -func Info(args ...any) { sugar.Load().Info(args...) } -func Warn(args ...any) { sugar.Load().Warn(args...) } -func Error(args ...any) { sugar.Load().Error(args...) } -func Fatal(args ...any) { sugar.Load().Fatal(args...) } +func Error(args ...any) { + if enabled(SlogLevelError) { + emit(SlogLevelError, fmt.Sprint(args...)) + } +} +func Fatal(args ...any) { emit(SlogLevelFatal, fmt.Sprint(args...)); _ = Sync(); os.Exit(1) } -func Debugw(msg string, keysAndValues ...any) { sugar.Load().Debugw(msg, keysAndValues...) } -func Infow(msg string, keysAndValues ...any) { sugar.Load().Infow(msg, keysAndValues...) } -func Warnw(msg string, keysAndValues ...any) { sugar.Load().Warnw(msg, keysAndValues...) } -func Errorw(msg string, keysAndValues ...any) { sugar.Load().Errorw(msg, keysAndValues...) } +func emitRecord(level Level, timestamp time.Time, message string, attrs []slog.Attr) { + logger := Slog() + if !logger.Enabled(context.Background(), level) { + return + } + if timestamp.IsZero() { + timestamp = time.Now() + } + record := slog.NewRecord(timestamp, level, message, 0) + record.AddAttrs(attrs...) + _ = logger.Handler().Handle(context.Background(), record) +} diff --git a/pkg/log/logger_test.go b/pkg/log/logger_test.go index 3664d3572e..e3a0c5061f 100644 --- a/pkg/log/logger_test.go +++ b/pkg/log/logger_test.go @@ -28,124 +28,17 @@ func TestColorEnabledHonorsNoColor(t *testing.T) { func TestResolveLevelPrecedence(t *testing.T) { tests := []struct { - name string cfg Config - want string + want Level }{ - {name: "persisted default", cfg: Config{DefaultLevel: LevelWarnName}, want: LevelWarnName}, - { - name: "explicit log level", - cfg: Config{Level: LevelDebugName, DefaultLevel: LevelWarnName}, want: LevelDebugName, - }, - { - name: "verbosity beats log level", - cfg: Config{ - Verbosity: 1, - VerbositySet: true, - Level: LevelDebugName, - }, - want: LevelInfoName, - }, - { - name: "debug beats verbosity", - cfg: Config{Verbosity: 1, VerbositySet: true, Debug: true}, want: LevelDebugName, - }, - { - name: "quiet beats debug", - cfg: Config{Debug: true, Quiet: true}, want: LevelErrorName, - }, - { - name: "log level beats persisted default", - cfg: Config{Level: LevelWarnName, DefaultLevel: LevelInfoName}, want: LevelWarnName, - }, - { - name: "explicit verbosity beats log level", - cfg: Config{ - Verbosity: 1, - VerbositySet: true, - Level: LevelErrorName, - }, - want: LevelInfoName, - }, - { - name: "debug beats log level", - cfg: Config{Debug: true, Level: LevelErrorName}, want: LevelDebugName, - }, - { - name: "quiet beats log level", - cfg: Config{Quiet: true, Level: LevelTraceName}, want: LevelErrorName, - }, + {Config{DefaultLevel: LevelWarnName}, SlogLevelWarn}, + {Config{Level: LevelDebugName, DefaultLevel: LevelWarnName}, SlogLevelDebug}, + {Config{DefaultLevel: "invalid"}, SlogLevelWarn}, } for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - if got := resolveLevel(tt.cfg).String(); got != tt.want { - t.Fatalf("resolveLevel() = %q, want %q", got, tt.want) - } - }) - } -} - -func TestResolveLevelExplicitFalseValues(t *testing.T) { - tests := []struct { - name string - cfg Config - want string - }{ - { - name: "explicit debug=false falls through to log level", - cfg: Config{ - Debug: false, - Level: LevelDebugName, - DefaultLevel: LevelWarnName, - }, - want: LevelDebugName, - }, - { - name: "explicit quiet=false falls through to log level", - cfg: Config{ - Quiet: false, - Level: LevelInfoName, - DefaultLevel: LevelWarnName, - }, - want: LevelInfoName, - }, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - if got := resolveLevel(tt.cfg).String(); got != tt.want { - t.Fatalf("resolveLevel() = %q, want %q", got, tt.want) - } - }) - } -} - -func TestResolveLevelDefaultsToWarn(t *testing.T) { - if got := resolveLevel(Config{DefaultLevel: DefaultLevel}).String(); got != LevelWarnName { - t.Fatalf("resolveLevel() = %q, want %q", got, LevelWarnName) - } -} - -func TestResolveLevelInvalidPersistedDefaultFallsBackToWarn(t *testing.T) { - if got := resolveLevel(Config{DefaultLevel: "verbose"}).String(); got != LevelWarnName { - t.Fatalf("resolveLevel() = %q, want %q", got, LevelWarnName) - } -} - -func TestQuietKeepsErrorsVisible(t *testing.T) { - Init(Config{Quiet: true}) - var sink syncBuffer - remove := AddSink(&sink) - defer remove() - - Warn("hidden warning") - Error("visible error") - _ = Sync() - - if got := sink.String(); strings.Contains(got, "hidden warning") { - t.Fatalf("quiet logger emitted warning: %q", got) - } - if got := sink.String(); !strings.Contains(got, "visible error") { - t.Fatalf("quiet logger hid error: %q", got) + if got := resolveLevel(tt.cfg); got != tt.want { + t.Fatalf("resolveLevel(%+v) = %v, want %v", tt.cfg, got, tt.want) + } } } @@ -161,7 +54,7 @@ func TestLevelFromString(t *testing.T) { } func TestAddSink_ForwardsLogLines(t *testing.T) { - Init(Config{Verbosity: 2}) // info+ + Init(Config{Level: LevelDebugName}) var sink bytes.Buffer remove := AddSink(&sink) @@ -176,7 +69,7 @@ func TestAddSink_ForwardsLogLines(t *testing.T) { } func TestAddSink_RemoveStopsForwarding(t *testing.T) { - Init(Config{Verbosity: 2}) + Init(Config{Level: LevelDebugName}) var sink bytes.Buffer remove := AddSink(&sink) @@ -197,7 +90,7 @@ func TestAddSink_RemoveStopsForwarding(t *testing.T) { } func TestAddSink_ConcurrentSinksAreIndependent(t *testing.T) { - Init(Config{Verbosity: 2}) + Init(Config{Level: LevelDebugName}) // Production callers (the MCP layer's io.Pipe writer) are thread-safe; // AddSink doesn't serialize the per-sink Write. Wrap bytes.Buffer for the test. @@ -223,8 +116,8 @@ func TestAddSink_ConcurrentSinksAreIndependent(t *testing.T) { func TestInitRedactsSecretsBeforeWritingSinks(t *testing.T) { Init( Config{ - Verbosity: 2, - Redactor: secrets.NewRedactor([]string{"TOKEN=DEVSY_SECRET_TEST_846297"}), + Level: LevelDebugName, + Redactor: secrets.NewRedactor([]string{"TOKEN=DEVSY_SECRET_TEST_846297"}), }, ) @@ -246,7 +139,7 @@ func TestInitRedactsSecretsBeforeWritingSinks(t *testing.T) { func TestInitDefaultsToEnvironmentRedaction(t *testing.T) { t.Setenv("DEVSY_LOG_DEFAULT_SECRET", "default-secret-846297") - Init(Config{Verbosity: 2}) + Init(Config{Level: LevelDebugName}) var sink syncBuffer remove := AddSink(&sink) @@ -295,14 +188,16 @@ func (s *syncBuffer) String() string { } func TestSuppressConsoleOutput(t *testing.T) { - previous := sugar.Load() + previous := current.Load() oldStderr := os.Stderr r, w, err := os.Pipe() if err != nil { t.Fatal(err) } os.Stderr = w - t.Cleanup(func() { os.Stderr = oldStderr; sugar.Store(previous); _ = r.Close(); _ = w.Close() }) + t.Cleanup( + func() { os.Stderr = oldStderr; current.Store(previous); _ = r.Close(); _ = w.Close() }, + ) Init(Config{}) var sink syncBuffer remove := AddSink(&sink) @@ -331,3 +226,30 @@ func TestSuppressConsoleOutput(t *testing.T) { t.Fatal("suppressed sink output") } } + +type sliceSink []*syncBuffer + +func (s sliceSink) Write(p []byte) (int, error) { return s[0].Write(p) } + +func TestAddSinkRemovesNonComparableRegistrationsIndependently(t *testing.T) { + var output syncBuffer + sink := sliceSink{&output} + removeFirst := AddSink(sink) + removeSecond := AddSink(sink) + defer removeSecond() + removeFirst() + removeFirst() + if _, err := extraSinks.Write([]byte("one")); err != nil { + t.Fatal(err) + } + if got := output.String(); got != "one" { + t.Fatalf("got %q", got) + } + removeSecond() + if _, err := extraSinks.Write([]byte("two")); err != nil { + t.Fatal(err) + } + if got := output.String(); got != "one" { + t.Fatalf("got %q", got) + } +} diff --git a/pkg/log/logr.go b/pkg/log/logr.go index 0d929ec434..4eeeab9009 100644 --- a/pkg/log/logr.go +++ b/pkg/log/logr.go @@ -1,11 +1,7 @@ package log -import ( - "github.com/go-logr/logr" - "github.com/go-logr/zapr" -) +import "github.com/go-logr/logr" -// LogrSink returns a logr.LogSink for Kubernetes client-go compatibility. func LogrSink() logr.LogSink { - return zapr.NewLogger(Underlying()).GetSink() + return logr.FromSlogHandler(Slog().Handler()).GetSink() } diff --git a/pkg/log/streamer.go b/pkg/log/streamer.go index 29abfc406e..86e3dafae5 100644 --- a/pkg/log/streamer.go +++ b/pkg/log/streamer.go @@ -2,14 +2,18 @@ package log import ( "bufio" + "bytes" "encoding/json" "io" + "log/slog" "os" + "reflect" + "sort" "strings" "sync" + "time" "github.com/devsy-org/devsy/pkg/secrets" - "go.uber.org/zap/zapcore" ) // StreamerOptions configures a JSON-aware subprocess log streamer. @@ -18,7 +22,7 @@ type StreamerOptions struct { // When omitted, sensitive values from the current environment are masked. Redactor *secrets.Redactor // FallbackLevel is used for non-structured subprocess output. - FallbackLevel int + FallbackLevel Level // CaptureLines retains this many raw lines for ErrorOutput. CaptureLines int // CaptureBytes bounds the total raw bytes retained for ErrorOutput, @@ -29,6 +33,7 @@ type StreamerOptions struct { // TreatUnknownJSONAsDebug preserves the historical tunnel behavior for // JSON messages whose level is absent or unrecognized. TreatUnknownJSONAsDebug bool + DefaultAttrs []slog.Attr } // JSONLogStreamer consumes line-oriented subprocess output. Devsy structured @@ -38,12 +43,14 @@ type JSONLogStreamer struct { pw *io.PipeWriter done chan struct{} - fallbackLevel zapcore.Level + fallbackLevel Level detectLevelPrefixes bool treatUnknownJSONAsDebug bool captureLines int captureBytes int redactor *secrets.Redactor + defaultAttrs []slog.Attr + errorCode string mu sync.Mutex lastLines []string @@ -59,17 +66,24 @@ func NewJSONLogStreamer(options StreamerOptions) *JSONLogStreamer { streamer := &JSONLogStreamer{ pw: pw, done: make(chan struct{}), - fallbackLevel: verbosityConstToZapLevel(options.FallbackLevel), + fallbackLevel: options.FallbackLevel, detectLevelPrefixes: options.DetectLevelPrefixes, treatUnknownJSONAsDebug: options.TreatUnknownJSONAsDebug, captureLines: options.CaptureLines, captureBytes: options.CaptureBytes, redactor: options.Redactor, + defaultAttrs: append([]slog.Attr(nil), options.DefaultAttrs...), } streamer.redactor = secrets.Combine( streamer.redactor, secrets.NewEnvironmentRedactor(os.Environ()), ) + for i := range streamer.defaultAttrs { + streamer.defaultAttrs[i] = (&redactHandler{redactor: streamer.redactor}).cleanAttr( + streamer.defaultAttrs[i], + true, + ) + } if options.CaptureLines > 0 { streamer.lastLines = make([]string, 0, options.CaptureLines) } @@ -100,45 +114,158 @@ func (s *JSONLogStreamer) ErrorOutput() string { return strings.Join(s.lastLines, "\n") } -// LogLine processes one line. It is exported for callers that need to feed a -// line directly, while Write remains the normal subprocess boundary API. func (s *JSONLogStreamer) LogLine(line string) { - line = strings.TrimSpace(line) - line = strings.ReplaceAll(line, "\r", "") + line = strings.TrimSpace(strings.ReplaceAll(line, "\r", "")) if line == "" { return } - - if decoded, ok := decodeJSONLogLine([]byte(line)); ok && + s.mu.Lock() + s.errorCode = "" + s.mu.Unlock() + if decoded, ok := decodeJSONLogLine( + []byte(line), + ); ok && (decoded.recognized || s.treatUnknownJSONAsDebug) { - logAtZapLevel(decoded.level, decoded.text) - } else if s.detectLevelPrefixes { - if matched, level := extractLevelPrefix(line); matched { - logAtZapLevel(level, line) - } else { - logAtZapLevel(s.fallbackLevel, line) + s.emitDecodedLine(decoded) + return + } + line = s.redactLine(line) + level := s.fallbackLevel + if s.detectLevelPrefixes { + if matched, found := extractLevelPrefix(line); matched { + level = found + } + } + emitRecord(level, time.Time{}, line, s.defaultAttrs) +} + +func (s *JSONLogStreamer) ErrorCode() string { + s.mu.Lock() + defer s.mu.Unlock() + return s.errorCode +} + +func (s *JSONLogStreamer) emitDecodedLine(decoded decodedJSONLogLine) { + decoded.text = s.redactor.Redact(decoded.text) + for i := range decoded.attrs { + decoded.attrs[i] = (&redactHandler{redactor: s.redactor}).cleanAttr(decoded.attrs[i], true) + } + if decoded.recognized && decoded.level >= SlogLevelError { + s.captureErrorCode(decoded.attrs) + } + emitRecord( + decoded.level, + decoded.timestamp, + decoded.text, + mergeAttrs(s.defaultAttrs, decoded.attrs), + ) +} + +func (s *JSONLogStreamer) captureErrorCode(attrs []slog.Attr) { + var code string + for _, attr := range attrs { + if attr.Key != "error_code" { + continue } - } else { - logAtZapLevel(s.fallbackLevel, line) + switch value := attr.Value.Any().(type) { + case string: + code = value + case json.Number: + code = value.String() + case bool: + if value { + code = "true" + } else { + code = "false" + } + } + } + if len(code) > 128 { + code = code[:128] + } + s.mu.Lock() + s.errorCode = code + s.mu.Unlock() +} + +func (s *JSONLogStreamer) redactLine(line string) string { + dec := json.NewDecoder(strings.NewReader(line)) + dec.UseNumber() + var value any + if dec.Decode(&value) != nil { + return s.redactor.Redact(line) } + var extra any + if dec.Decode(&extra) != io.EOF { + return s.redactor.Redact(line) + } + clean := (&redactHandler{redactor: s.redactor}).cleanValue(value) + if reflect.DeepEqual(value, clean) { + return line + } + if data, err := json.Marshal(clean); err == nil { + return string(data) + } + return s.redactor.Redact(line) } +const maxStructuredLine = 1024 * 1024 + func (s *JSONLogStreamer) process(reader io.Reader) { defer close(s.done) - scanner := bufio.NewScanner(reader) - buf := make([]byte, 0, 64*1024) - scanner.Buffer(buf, 1024*1024) + if closer, ok := reader.(io.Closer); ok { + defer func() { _ = closer.Close() }() + } + input := bufio.NewReaderSize(reader, 64*1024) + var line []byte + oversized := false + for { + chunk, err := input.ReadSlice('\n') + complete := err == nil + if complete { + chunk = chunk[:len(chunk)-1] + } + line, oversized = appendStructuredChunk(line, chunk, oversized) + end := err != nil && err != bufio.ErrBufferFull + if complete || end { + s.processLine(line, oversized) + line, oversized = nil, false + } + if end { + logStreamReadError(err) + return + } + } +} - for scanner.Scan() { - line := s.redactor.Redact(scanner.Text()) - s.LogLine(line) - s.capture(line) +func appendStructuredChunk(line, chunk []byte, oversized bool) ([]byte, bool) { + if oversized { + return line, true } - if err := scanner.Err(); err != nil { - Debugf("error reading subprocess output: %v", err) + if len(line)+len(chunk) <= maxStructuredLine { + return append(line, chunk...), false } - if closer, ok := reader.(io.Closer); ok { - _ = closer.Close() + return nil, true +} + +func (s *JSONLogStreamer) processLine(line []byte, oversized bool) { + if oversized { + s.mu.Lock() + s.errorCode = "" + s.mu.Unlock() + message := "[oversized subprocess output truncated]" + emitRecord(s.fallbackLevel, time.Time{}, message, s.defaultAttrs) + s.capture(message) + } else if len(line) > 0 { + text := strings.TrimSuffix(string(line), "\r") + s.LogLine(text) + s.capture(s.redactLine(text)) + } +} + +func logStreamReadError(err error) { + if err != io.EOF { + Debugf("error reading subprocess output: %v", err) } } @@ -190,79 +317,110 @@ func (s *JSONLogStreamer) dropOldestLine() { s.lastLines = s.lastLines[1:] } -type jsonLine struct { - Message string `json:"message,omitempty"` - Msg string `json:"msg,omitempty"` - Level string `json:"level,omitempty"` -} - -func (l *jsonLine) text() string { - if l.Message != "" { - return l.Message - } - return l.Msg -} - type decodedJSONLogLine struct { text string - level zapcore.Level + level Level recognized bool + timestamp time.Time + attrs []slog.Attr } func decodeJSONLogLine(line []byte) (decodedJSONLogLine, bool) { - var obj jsonLine - if err := json.Unmarshal(line, &obj); err != nil || obj.text() == "" { + decoder := json.NewDecoder(bytes.NewReader(line)) + decoder.UseNumber() + var obj map[string]any + if decoder.Decode(&obj) != nil || obj == nil { return decodedJSONLogLine{}, false } - level, recognized := normalizeZapLevel(obj.Level) + var extra any + if decoder.Decode(&extra) != io.EOF { + return decodedJSONLogLine{}, false + } + text, ok := obj[slog.MessageKey].(string) + if !ok || text == "" { + text, _ = obj["message"].(string) + } + if text == "" { + return decodedJSONLogLine{}, false + } + rawLevel, _ := obj["level"].(string) + level, recognized := normalizeLevel(rawLevel) + var timestamp time.Time + for _, key := range []string{"ts", slog.TimeKey} { + rawTime, _ := obj[key].(string) + var err error + timestamp, err = time.Parse(time.RFC3339Nano, rawTime) + if err != nil { + timestamp, err = time.Parse("2006-01-02T15:04:05.000Z0700", rawTime) + } + if err == nil { + break + } + } + delete(obj, slog.MessageKey) + delete(obj, "message") + delete(obj, "level") + delete(obj, "ts") + delete(obj, slog.TimeKey) + attrs := make([]slog.Attr, 0, len(obj)) + for k, v := range obj { + attrs = append(attrs, slog.Any(k, v)) + } + sort.Slice(attrs, func(i, j int) bool { return attrs[i].Key < attrs[j].Key }) return decodedJSONLogLine{ - text: obj.text(), + text: text, level: level, recognized: recognized, + timestamp: timestamp, + attrs: attrs, }, true } -const infoLevelName = "info" - -func normalizeZapLevel(raw string) (zapcore.Level, bool) { +func normalizeLevel(raw string) (Level, bool) { switch strings.ToLower(raw) { - case LevelTraceName, LevelDebugName: - return zapcore.DebugLevel, true - case infoLevelName: - return zapcore.InfoLevel, true + case "trace": + return SlogLevelTrace, true + case "debug": + return SlogLevelDebug, true + case "info": + return SlogLevelInfo, true case "warning", "warn": - return zapcore.WarnLevel, true - case "error", "panic", "fatal": - return zapcore.ErrorLevel, true + return SlogLevelWarn, true + case "error", "panic": + return SlogLevelError, true + case "fatal": + return SlogLevelFatal, true default: - return zapcore.DebugLevel, false + return SlogLevelDebug, false } } -func extractLevelPrefix(line string) (bool, zapcore.Level) { +func extractLevelPrefix(line string) (bool, Level) { parts := strings.Fields(line) if len(parts) < 2 || !strings.Contains(parts[0], ":") { return false, 0 } + level, ok := normalizeLevel(parts[1]) + return ok, level +} - level, recognized := normalizeZapLevel(parts[1]) - if !recognized { - return false, 0 +func mergeAttrs(defaults, explicit []slog.Attr) []slog.Attr { + attrs := make([]slog.Attr, 0, len(defaults)+len(explicit)) + for _, attr := range defaults { + if isEnvelopeKey(attr.Key) || containsAttr(explicit, attr.Key) || + containsAttr(attrs, attr.Key) { + continue + } + attrs = append(attrs, attr) } - return true, level + return append(attrs, explicit...) } -func logAtZapLevel(level zapcore.Level, message string) { - switch level { - case zapcore.DebugLevel: - Debug(message) - case zapcore.InfoLevel: - Info(message) - case zapcore.WarnLevel: - Warn(message) - case zapcore.ErrorLevel: - Error(message) - default: - Debug(message) +func containsAttr(attrs []slog.Attr, key string) bool { + for _, attr := range attrs { + if attr.Key == key { + return true + } } + return false } diff --git a/pkg/log/streamer_test.go b/pkg/log/streamer_test.go index b28c8f29af..2902cf9998 100644 --- a/pkg/log/streamer_test.go +++ b/pkg/log/streamer_test.go @@ -2,19 +2,26 @@ package log import ( "bytes" + "context" + "os" + "os/exec" "strings" "testing" + "time" "github.com/devsy-org/devsy/pkg/secrets" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" - "go.uber.org/zap" - "go.uber.org/zap/zapcore" +) + +const ( + streamNextMode = "next" + streamHelperSelector = "-test.run=^TestJSONLogStreamerDrainsOversizedHelper$" ) func TestJSONLogStreamerRedactsCapturedLines(t *testing.T) { streamer := NewJSONLogStreamer(StreamerOptions{ - FallbackLevel: LevelInfo, + FallbackLevel: SlogLevelInfo, CaptureLines: 2, Redactor: secrets.NewRedactor([]string{"TOKEN=DEVSY_STREAM_SECRET_846297"}), }) @@ -30,7 +37,7 @@ func TestJSONLogStreamerRedactsCapturedLines(t *testing.T) { func TestJSONLogStreamerCombinesConfiguredAndEnvironmentRedaction(t *testing.T) { t.Setenv("DEVSY_STREAM_ENV_SECRET", "stream-env-secret-846299") streamer := NewJSONLogStreamer(StreamerOptions{ - FallbackLevel: LevelInfo, + FallbackLevel: SlogLevelInfo, CaptureLines: 1, Redactor: secrets.NewRedactor([]string{"TOKEN=stream-config-secret-846300"}), }) @@ -49,7 +56,7 @@ func TestJSONLogStreamerCombinesConfiguredAndEnvironmentRedaction(t *testing.T) func streamTestOutput(t *testing.T, input string, options StreamerOptions) []observerEntry { t.Helper() - logs := InitTestObserved(t, zapcore.DebugLevel) + logs := InitTestObserved(t, SlogLevelDebug) streamer := NewJSONLogStreamer(options) _, err := streamer.Write([]byte(input)) require.NoError(t, err) @@ -64,7 +71,7 @@ func streamTestOutput(t *testing.T, input string, options StreamerOptions) []obs } type observerEntry struct { - Level zapcore.Level + Level Level Message string } @@ -72,10 +79,10 @@ func TestJSONLogStreamerStructuredLogPreservesLevel(t *testing.T) { entries := streamTestOutput( t, `{"level":"debug","ts":"2026-09-01T08:27:30.002Z","msg":"received docker credentials post data: bytes=23"}`+"\n", - StreamerOptions{FallbackLevel: LevelInfo}, + StreamerOptions{FallbackLevel: SlogLevelInfo}, ) require.Len(t, entries, 1) - assert.Equal(t, zapcore.DebugLevel, entries[0].Level) + assert.Equal(t, SlogLevelDebug, entries[0].Level) assert.Equal(t, "received docker credentials post data: bytes=23", entries[0].Message) assert.NotContains(t, entries[0].Message, `{"level":"debug"`) } @@ -85,12 +92,12 @@ func TestJSONLogStreamerSupportsMessageField(t *testing.T) { t, `{"level":"warn","message":"example warning"}`+"\n", StreamerOptions{ - FallbackLevel: LevelInfo, + FallbackLevel: SlogLevelInfo, }, ) require.Len(t, entries, 1) - assert.Equal(t, zapcore.WarnLevel, entries[0].Level) + assert.Equal(t, SlogLevelWarn, entries[0].Level) assert.Equal(t, "example warning", entries[0].Message) } @@ -99,11 +106,11 @@ func TestJSONLogStreamerUnknownLevelUsesFallback(t *testing.T) { entries := streamTestOutput( t, line+"\n", - StreamerOptions{FallbackLevel: LevelInfo}, + StreamerOptions{FallbackLevel: SlogLevelInfo}, ) require.Len(t, entries, 1) - assert.Equal(t, zapcore.InfoLevel, entries[0].Level) + assert.Equal(t, SlogLevelInfo, entries[0].Level) assert.Equal(t, line, entries[0].Message) } @@ -112,11 +119,11 @@ func TestJSONLogStreamerPlainTextUsesFallbackLevel(t *testing.T) { t, "#12 [4/8] RUN apt-get update\n", StreamerOptions{ - FallbackLevel: LevelInfo, + FallbackLevel: SlogLevelInfo, }, ) require.Len(t, entries, 1) - assert.Equal(t, zapcore.InfoLevel, entries[0].Level) + assert.Equal(t, SlogLevelInfo, entries[0].Level) assert.Equal(t, "#12 [4/8] RUN apt-get update", entries[0].Message) } @@ -125,11 +132,11 @@ func TestJSONLogStreamerMalformedJSONUsesFallbackLevel(t *testing.T) { entries := streamTestOutput( t, line+"\n", - StreamerOptions{FallbackLevel: LevelInfo}, + StreamerOptions{FallbackLevel: SlogLevelInfo}, ) require.Len(t, entries, 1) - assert.Equal(t, zapcore.InfoLevel, entries[0].Level) + assert.Equal(t, SlogLevelInfo, entries[0].Level) assert.Equal(t, line, entries[0].Message) } @@ -142,15 +149,15 @@ func TestJSONLogStreamerMixedStream(t *testing.T) { "#2 building image", "", }, "\n"), - StreamerOptions{FallbackLevel: LevelInfo}, + StreamerOptions{FallbackLevel: SlogLevelInfo}, ) require.Len(t, entries, 3) - assert.Equal(t, zapcore.InfoLevel, entries[0].Level) + assert.Equal(t, SlogLevelInfo, entries[0].Level) assert.Equal(t, "#1 loading build definition", entries[0].Message) - assert.Equal(t, zapcore.DebugLevel, entries[1].Level) + assert.Equal(t, SlogLevelDebug, entries[1].Level) assert.Equal(t, "received docker credentials post data: bytes=23", entries[1].Message) - assert.Equal(t, zapcore.InfoLevel, entries[2].Level) + assert.Equal(t, SlogLevelInfo, entries[2].Level) assert.Equal(t, "#2 building image", entries[2].Message) } @@ -159,12 +166,12 @@ func TestJSONLogStreamerNoDoubleWrappedStructuredOutput(t *testing.T) { t, `{"level":"debug","msg":"credential request received"}`+"\n", StreamerOptions{ - FallbackLevel: LevelInfo, + FallbackLevel: SlogLevelInfo, }, ) require.Len(t, entries, 1) - assert.Equal(t, zapcore.DebugLevel, entries[0].Level) + assert.Equal(t, SlogLevelDebug, entries[0].Level) assert.NotContains(t, entries[0].Message, `{"level":"debug"`) } @@ -173,13 +180,13 @@ func TestJSONLogStreamerTabDelimitedLevelPrefix(t *testing.T) { t, "2026-09-01T08:27:30.002Z\tDEBUG\tcredential request received\n", StreamerOptions{ - FallbackLevel: LevelInfo, + FallbackLevel: SlogLevelInfo, DetectLevelPrefixes: true, }, ) require.Len(t, entries, 1) - assert.Equal(t, zapcore.DebugLevel, entries[0].Level) + assert.Equal(t, SlogLevelDebug, entries[0].Level) assert.Equal( t, "2026-09-01T08:27:30.002Z\tDEBUG\tcredential request received", @@ -188,9 +195,9 @@ func TestJSONLogStreamerTabDelimitedLevelPrefix(t *testing.T) { } func TestJSONLogStreamerCaptureLinesIsBounded(t *testing.T) { - logs := InitTestObserved(t, zapcore.DebugLevel) + logs := InitTestObserved(t, SlogLevelDebug) streamer := NewJSONLogStreamer(StreamerOptions{ - FallbackLevel: LevelInfo, + FallbackLevel: SlogLevelInfo, CaptureLines: 1, }) _, err := streamer.Write([]byte("first\nsecond\n")) @@ -226,23 +233,88 @@ func TestJSONLogStreamerCaptureBytesTruncatesOversizedLine(t *testing.T) { } func TestJSONLogStreamerFormattedOutputHasNoNestedEnvelope(t *testing.T) { + Init(Config{Level: LevelDebugName, Format: testFormatJSON}) var output bytes.Buffer - previous := sugar.Load() - encoderConfig := zap.NewDevelopmentEncoderConfig() - encoderConfig.EncodeLevel = zapcore.CapitalLevelEncoder - core := zapcore.NewCore( - zapcore.NewConsoleEncoder(encoderConfig), - zapcore.AddSync(&output), - zapcore.DebugLevel, - ) - sugar.Store(zap.New(core).Sugar()) - t.Cleanup(func() { sugar.Store(previous) }) - - streamer := NewJSONLogStreamer(StreamerOptions{FallbackLevel: LevelInfo}) + remove := AddSink(&output) + defer remove() + streamer := NewJSONLogStreamer(StreamerOptions{FallbackLevel: SlogLevelInfo}) _, err := streamer.Write([]byte(`{"level":"debug","msg":"credential request received"}` + "\n")) require.NoError(t, err) require.NoError(t, streamer.Close()) + require.NoError(t, Sync()) + assert.Contains(t, output.String(), `"msg":"credential request received"`) +} + +func TestJSONLogStreamerDrainsOversizedHelper(t *testing.T) { + if mode := os.Getenv("DEVSY_STREAM_HELPER_MODE"); mode != "" { + writeOversizedHelper(mode) + return + } + for _, mode := range []string{streamNextMode, "eof"} { + t.Run(mode, func(t *testing.T) { + logs := InitTestObserved(t, SlogLevelDebug) + streamer := NewJSONLogStreamer(StreamerOptions{ + FallbackLevel: SlogLevelInfo, + CaptureLines: 2, + CaptureBytes: 256, + Redactor: secrets.NewRedactor([]string{"TOKEN=stream-boundary-secret"}), + }) + streamer.LogLine(`{"level":"error","msg":"old","error_code":"old-code"}`) + ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second) + defer cancel() + cmd := exec.CommandContext(ctx, os.Args[0], streamHelperSelector) + cmd.Env = append(os.Environ(), "DEVSY_STREAM_HELPER_MODE="+mode) + cmd.Stderr = streamer + err := cmd.Run() + closeErr := streamer.Close() + require.NoError(t, err) + require.NoError(t, closeErr) + require.Empty(t, streamer.ErrorCode()) + entries := logs.All() + require.GreaterOrEqual(t, len(entries), 2) + require.Equal(t, "[oversized subprocess output truncated]", entries[1].Message) + require.NotContains(t, entries[1].Message, "stream-boundary-") + require.LessOrEqual(t, len(streamer.ErrorOutput()), 256) + require.NotContains(t, streamer.ErrorOutput(), "stream-boundary-secret") + require.NotContains(t, streamer.ErrorOutput(), "stream-boundary-") + if mode == streamNextMode { + require.Len(t, entries, 3) + require.Equal(t, "next record", entries[2].Message) + require.Equal(t, "canary", entries[2].AttrsMap()["component"]) + require.Equal(t, "***", entries[2].AttrsMap()["sensitive"]) + } + }) + } +} - assert.NotContains(t, output.String(), `INFO {"level":"debug"`) - assert.Contains(t, output.String(), "DEBUG\tcredential request received") +func writeOversizedHelper(mode string) { + chunk := strings.Repeat("x", 64*1024) + for range 20 { + if _, err := os.Stderr.WriteString(chunk); err != nil { + os.Exit(2) + } + } + for _, part := range []string{"stream-boundary-", "secret canary"} { + if _, err := os.Stderr.WriteString(part); err != nil { + os.Exit(2) + } + } + if mode == streamNextMode { + if _, err := os.Stderr.WriteString("\n" + `{"level":"info","msg":"next record",` + + `"component":"canary","sensitive":"stream-boundary-secret"}` + "\n"); err != nil { + os.Exit(2) + } + } +} + +func TestJSONLogStreamerDrainsNormalUnterminatedRecord(t *testing.T) { + logs := InitTestObserved(t, SlogLevelInfo) + streamer := NewJSONLogStreamer(StreamerOptions{FallbackLevel: SlogLevelInfo, CaptureLines: 1}) + _, err := streamer.Write([]byte(`{"level":"info","msg":"unterminated","component":"canary"}`)) + require.NoError(t, err) + require.NoError(t, streamer.Close()) + entries := logs.All() + require.Len(t, entries, 1) + require.Equal(t, "unterminated", entries[0].Message) + require.Equal(t, "canary", entries[0].AttrsMap()["component"]) } diff --git a/pkg/log/structured_test.go b/pkg/log/structured_test.go new file mode 100644 index 0000000000..9c218c8c20 --- /dev/null +++ b/pkg/log/structured_test.go @@ -0,0 +1,280 @@ +package log + +import ( + "context" + "encoding/json" + "log/slog" + "strings" + "testing" + "time" + + "github.com/devsy-org/devsy/pkg/secrets" +) + +const testCanary = "canary" + +func TestStructuredLoggingRedactsResolvedNestedValues(t *testing.T) { + const secret = "private\"token\nvalue" + Init( + Config{ + Level: LevelTraceName, + Format: testFormatJSON, + Redactor: secrets.NewRedactor([]string{"TOKEN=" + secret}), + }, + ) + var output syncBuffer + remove := AddSink(&output) + defer remove() + ctx := WithContext(context.Background(), slog.String("component", testCanary)) + InfoContext( + ctx, + "hello "+secret, + slog.Any("nested", map[string]any{"value": []any{secret, "visible"}}), + ) + if err := Sync(); err != nil { + t.Fatal(err) + } + var record map[string]any + if err := json.Unmarshal([]byte(output.String()), &record); err != nil { + t.Fatal(err) + } + if record["component"] != testCanary || !strings.Contains(output.String(), "visible") || + strings.Contains(output.String(), "private") { + t.Fatalf("unexpected record %q", output.String()) + } +} + +func TestStreamerPreservesStructuredDataAndRedactsCapture(t *testing.T) { + logs := InitTestObserved(t, SlogLevelTrace) + secret := "private\"token" + stream := NewJSONLogStreamer(StreamerOptions{ + FallbackLevel: SlogLevelInfo, + CaptureLines: 1, + CaptureBytes: 1024, + Redactor: secrets.NewRedactor([]string{"TOKEN=" + secret}), + DefaultAttrs: []slog.Attr{ + slog.String("provider", "default"), + slog.String("component", testCanary), + }, + }) + line := `{"level":"error","ts":"2026-01-02T03:04:05.123Z","msg":"failure",` + + `"provider":"explicit","error_code":"unavailable","nested":{"number":9007199254740993,"secret":"private\"token"}}` + if _, err := stream.Write([]byte(line + "\n")); err != nil { + t.Fatal(err) + } + if err := stream.Close(); err != nil { + t.Fatal(err) + } + entries := logs.All() + assertStructuredStream(t, entries, stream) +} + +func assertStructuredStream(t *testing.T, entries []LoggedEntry, stream *JSONLogStreamer) { + t.Helper() + if len(entries) != 1 || entries[0].Level != SlogLevelError || + entries[0].AttrsMap()["provider"] != "explicit" || + entries[0].AttrsMap()["component"] != testCanary || + stream.ErrorCode() != "unavailable" { + t.Fatalf("unexpected record: %#v code=%q", entries, stream.ErrorCode()) + } + if strings.Contains(stream.ErrorOutput(), "private") || + !strings.Contains(stream.ErrorOutput(), "9007199254740993") { + t.Fatalf("unexpected captured output %q", stream.ErrorOutput()) + } +} + +func TestStreamerCleansRootDefaultsAndKeepsNestedFields(t *testing.T) { + logs := InitTestObserved(t, SlogLevelTrace) + stream := NewJSONLogStreamer(StreamerOptions{ + FallbackLevel: SlogLevelInfo, + DefaultAttrs: []slog.Attr{ + slog.String("level", "forged"), + slog.String("provider", "default"), + slog.String("component", testCanary), + slog.Group("", slog.String(slog.MessageKey, "forged")), + slog.Group("nested", slog.String("level", "nested")), + }, + }) + if _, err := stream.Write( + []byte(`{"level":"info","msg":"actual","provider":"explicit"}` + "\n"), + ); err != nil { + t.Fatal(err) + } + if err := stream.Close(); err != nil { + t.Fatal(err) + } + entries := logs.All() + if len(entries) != 1 { + t.Fatalf("unexpected entries: %#v", entries) + } + assertCleanStreamAttrs(t, entries[0]) +} + +func assertCleanStreamAttrs(t *testing.T, entry LoggedEntry) { + t.Helper() + attrs := entry.AttrsMap() + if entry.Message != "actual" || attrs["provider"] != "explicit" || + attrs["component"] != testCanary || + attrs["level"] != nil || + attrs[slog.MessageKey] != nil { + t.Fatalf("unexpected entry: %#v attrs=%#v", entry, attrs) + } + nested, ok := attrs["nested"].(map[string]any) + if !ok || nested["level"] != "nested" { + t.Fatalf("unexpected nested attrs: %#v", attrs) + } +} + +type countedStringer struct{ calls *int } + +func (s countedStringer) String() string { *s.calls++; return "formatted" } + +func TestDisabledFormattedLogDoesNotFormat(t *testing.T) { + Init(Config{Level: LevelWarnName}) + calls := 0 + Debugf("%s", countedStringer{calls: &calls}) + if calls != 0 { + t.Fatalf("disabled message formatted %d times", calls) + } +} + +func TestObservedGroupsAndFiltering(t *testing.T) { + logs := InitTestObserved(t, SlogLevelTrace) + logger := Slog().With(slog.String("component", testCanary)). + WithGroup("outer").With(slog.Int("count", 3)).WithGroup("inner") + logger.LogAttrs(context.Background(), SlogLevelTrace, "event", slog.String("phase", "ready")) + entries := logs.FilterAttr(slog.String("component", testCanary)). + FilterLevelExact(SlogLevelTrace). + All() + if len(entries) != 1 { + t.Fatalf("unexpected entries: %#v", entries) + } + outer, ok := entries[0].AttrsMap()["outer"].(map[string]any) + if !ok || outer["count"] != int64(3) { + t.Fatalf("unexpected groups: %#v", entries[0].AttrsMap()) + } + inner, ok := outer["inner"].(map[string]any) + if !ok || inner["phase"] != "ready" { + t.Fatalf("unexpected inner group: %#v", outer) + } +} + +func TestWriterRedactsSecretAcrossPendingLimit(t *testing.T) { + secret := "stream-boundary-secret" + Init( + Config{ + Level: LevelInfoName, + Format: testFormatJSON, + Redactor: secrets.NewRedactor([]string{"TOKEN=" + secret}), + }, + ) + var output syncBuffer + remove := AddSink(&output) + defer remove() + writer := Writer(SlogLevelInfo) + if _, err := writer.Write( + []byte(strings.Repeat("x", maxPendingLine) + "stream-boundary-"), + ); err != nil { + t.Fatal(err) + } + if _, err := writer.Write([]byte("secret canary\n")); err != nil { + t.Fatal(err) + } + if err := writer.Close(); err != nil { + t.Fatal(err) + } + if err := Sync(); err != nil { + t.Fatal(err) + } + if strings.Contains(output.String(), secret) || + strings.Contains(output.String(), "stream-boundary-") || + !strings.Contains(output.String(), "canary") { + t.Fatalf("unexpected output: %q", output.String()) + } +} + +func TestStreamerPreservesEmittedAndRFC3339Timestamps(t *testing.T) { + want := time.Date(2026, 1, 2, 3, 4, 5, 123000000, time.FixedZone("offset", -7*60*60)) + Init(Config{Level: LevelTraceName, Format: "json"}) + var output syncBuffer + remove := AddSink(&output) + emitRecord(SlogLevelInfo, want, "round trip", nil) + if err := Sync(); err != nil { + t.Fatal(err) + } + remove() + + logs := InitTestObserved(t, SlogLevelTrace) + stream := NewJSONLogStreamer(StreamerOptions{FallbackLevel: SlogLevelInfo}) + if _, err := stream.Write([]byte(output.String())); err != nil { + t.Fatal(err) + } + if _, err := stream.Write([]byte(`{"level":"info","ts":"2026-01-02T03:04:05.123-07:00",` + + `"msg":"standard"}` + "\n")); err != nil { + t.Fatal(err) + } + if err := stream.Close(); err != nil { + t.Fatal(err) + } + entries := logs.All() + if len(entries) != 2 { + t.Fatalf("unexpected entries: %#v", entries) + } + for _, entry := range entries { + if !entry.Time.Equal(want) { + t.Fatalf("timestamp %v, want %v", entry.Time, want) + } + } +} + +func TestStructuredLoggingProtectsEnvelope(t *testing.T) { + Init(Config{Level: LevelTraceName, Format: testFormatJSON}) + var output syncBuffer + remove := AddSink(&output) + defer remove() + ctx := WithContext( + context.Background(), + slog.String("component", "context"), + slog.String("level", "debug"), + ) + FromContext( + ctx, + ).With(slog.String(slog.MessageKey, "forged")). + LogAttrs(ctx, SlogLevelInfo, "actual", + slog.String("ts", "forged"), + slog.String(slog.TimeKey, "forged"), slog.String("message", "forged"), + slog.Group("", slog.String("level", "forged")), + slog.Group("nested", slog.String("level", "nested"))) + if err := Sync(); err != nil { + t.Fatal(err) + } + line := output.String() + var record map[string]any + if err := json.Unmarshal([]byte(line), &record); err != nil { + t.Fatal(err) + } + assertProtectedEnvelope(t, record, line) +} + +func assertProtectedEnvelope(t *testing.T, record map[string]any, line string) { + t.Helper() + if record["level"] != "info" || record[slog.MessageKey] != "actual" || + record["component"] != "context" || + record[slog.TimeKey] != nil || + record["message"] != nil { + t.Fatalf("unexpected record %s", line) + } + assertEnvelopeCounts(t, line) + nested, ok := record["nested"].(map[string]any) + if !ok || nested["level"] != "nested" { + t.Fatalf("unexpected nested fields %s", line) + } +} + +func assertEnvelopeCounts(t *testing.T, line string) { + t.Helper() + if strings.Count(line, `"level":`) != 2 || strings.Count(line, `"msg":`) != 1 || + strings.Count(line, `"ts":`) != 1 { + t.Fatalf("unexpected envelope %s", line) + } +} diff --git a/pkg/log/testing.go b/pkg/log/testing.go index 8624a1a686..8f1357a04f 100644 --- a/pkg/log/testing.go +++ b/pkg/log/testing.go @@ -1,32 +1,249 @@ package log import ( + "context" + "log/slog" + "maps" + "os" + "reflect" + "strings" + "sync" "testing" + "time" - "go.uber.org/zap" - "go.uber.org/zap/zapcore" - "go.uber.org/zap/zaptest" - "go.uber.org/zap/zaptest/observer" + "github.com/devsy-org/devsy/pkg/secrets" ) -// InitTest replaces the package-level logger with a test logger. -// Log output is captured by t.Log() and only shown on test failure. +type LoggedEntry struct { + Level Level + Message string + Time time.Time + attrs map[string]any +} + +func (e LoggedEntry) AttrsMap() map[string]any { + out := make(map[string]any, len(e.attrs)) + maps.Copy(out, e.attrs) + return out +} + +type observedStore struct { + mu sync.Mutex + entries []LoggedEntry +} + +type ObservedLogs struct { + store *observedStore + predicates []func(LoggedEntry) bool +} + +func (o *ObservedLogs) All() []LoggedEntry { + o.store.mu.Lock() + defer o.store.mu.Unlock() + return o.filtered(o.store.entries) +} + +func (o *ObservedLogs) AllUntimed() []LoggedEntry { + entries := o.All() + for i := range entries { + entries[i].Time = time.Time{} + } + return entries +} + +func (o *ObservedLogs) TakeAll() []LoggedEntry { + o.store.mu.Lock() + defer o.store.mu.Unlock() + result := o.filtered(o.store.entries) + remaining := make([]LoggedEntry, 0, len(o.store.entries)-len(result)) + for _, entry := range o.store.entries { + if len(o.filtered([]LoggedEntry{entry})) == 0 { + remaining = append(remaining, entry) + } + } + o.store.entries = remaining + return result +} +func (o *ObservedLogs) Len() int { return len(o.All()) } +func (o *ObservedLogs) FilterMessage(message string) *ObservedLogs { + return o.filter(func(e LoggedEntry) bool { return e.Message == message }) +} + +func (o *ObservedLogs) FilterMessageSnippet(part string) *ObservedLogs { + return o.filter(func(e LoggedEntry) bool { return strings.Contains(e.Message, part) }) +} + +func (o *ObservedLogs) FilterLevelExact(level Level) *ObservedLogs { + return o.filter(func(e LoggedEntry) bool { return e.Level == level }) +} + +func (o *ObservedLogs) FilterAttr(attr slog.Attr) *ObservedLogs { + return o.filter( + func(e LoggedEntry) bool { return reflect.DeepEqual(e.attrs[attr.Key], attr.Value.Resolve().Any()) }, + ) +} + +func (o *ObservedLogs) filtered(entries []LoggedEntry) []LoggedEntry { + out := make([]LoggedEntry, 0, len(entries)) + for _, e := range entries { + match := true + for _, predicate := range o.predicates { + if !predicate(e) { + match = false + break + } + } + if match { + out = append(out, e) + } + } + return out +} + +func (o *ObservedLogs) filter(fn func(LoggedEntry) bool) *ObservedLogs { + predicates := append([]func(LoggedEntry) bool(nil), o.predicates...) + return &ObservedLogs{store: o.store, predicates: append(predicates, fn)} +} + +type observedAttr struct { + groups []string + attr slog.Attr +} +type observedHandler struct { + store *observedStore + level Level + attrs []observedAttr + groups []string +} + +func (h *observedHandler) Enabled( + _ context.Context, + level slog.Level, +) bool { + return level >= h.level +} + +func (h *observedHandler) WithAttrs(attrs []slog.Attr) slog.Handler { + next := *h + next.attrs = append([]observedAttr(nil), h.attrs...) + for _, attr := range attrs { + next.attrs = append( + next.attrs, + observedAttr{groups: append([]string(nil), h.groups...), attr: attr}, + ) + } + return &next +} + +func (h *observedHandler) WithGroup(name string) slog.Handler { + if name == "" { + return h + } + next := *h + next.groups = append(append([]string(nil), h.groups...), name) + return &next +} + +func addObservedAttr(dst map[string]any, groups []string, attr slog.Attr) { + for _, name := range groups { + child, ok := dst[name].(map[string]any) + if !ok { + child = make(map[string]any) + dst[name] = child + } + dst = child + } + value := attr.Value.Resolve() + if value.Kind() == slog.KindGroup { + target := dst + if attr.Key != "" { + target = make(map[string]any) + dst[attr.Key] = target + } + for _, item := range value.Group() { + addObservedAttr(target, nil, item) + } + } else if attr.Key != "" { + dst[attr.Key] = value.Any() + } +} + +func (h *observedHandler) Handle(_ context.Context, record slog.Record) error { + attrs := make(map[string]any) + for _, item := range h.attrs { + addObservedAttr(attrs, item.groups, item.attr) + } + record.Attrs(func(attr slog.Attr) bool { addObservedAttr(attrs, h.groups, attr); return true }) + h.store.mu.Lock() + h.store.entries = append( + h.store.entries, + LoggedEntry{Level: record.Level, Message: record.Message, Time: record.Time, attrs: attrs}, + ) + h.store.mu.Unlock() + return nil +} + +type testWriter struct{ t testing.TB } + +func (w testWriter) Write(p []byte) (int, error) { + w.t.Log(strings.TrimSuffix(string(p), "\n")) + return len(p), nil +} + func InitTest(t testing.TB) { t.Helper() - prev := sugar.Load() - logger := zaptest.NewLogger(t) - sugar.Store(logger.Sugar()) - t.Cleanup(func() { sugar.Store(prev) }) + redactor := secrets.NewEnvironmentRedactor(os.Environ()) + writer := &redactingWriter{next: testWriter{t}, redactor: redactor} + handler := &redactHandler{ + next: slog.NewTextHandler( + writer, + &slog.HandlerOptions{Level: SlogLevelDebug, ReplaceAttr: replaceEnvelope}, + ), + redactor: redactor, + } + state := &loggerState{ + logger: slog.New(handler), + level: SlogLevelDebug, + writer: writer, + redactor: redactor, + } + installTestState(t, state) } -// InitTestObserved replaces the package-level logger with an observable -// logger at the given level. The returned ObservedLogs can be used to -// assert that specific log messages were emitted. -func InitTestObserved(t testing.TB, level zapcore.Level) *observer.ObservedLogs { +func InitTestObserved(t testing.TB, level Level) *ObservedLogs { t.Helper() - prev := sugar.Load() - core, logs := observer.New(level) - sugar.Store(zap.New(core).Sugar()) - t.Cleanup(func() { sugar.Store(prev) }) - return logs + store := &observedStore{} + redactor := secrets.NewEnvironmentRedactor(os.Environ()) + handler := &redactHandler{ + next: &observedHandler{store: store, level: level}, + redactor: redactor, + } + state := &loggerState{logger: slog.New(handler), level: level, redactor: redactor} + installTestState(t, state) + return &ObservedLogs{store: store} +} + +func installTestState(t testing.TB, state *loggerState) { + stateMu.Lock() + state.previous = current.Load() + current.Store(state) + stateMu.Unlock() + t.Cleanup(func() { + if state.writer != nil { + _ = state.writer.Sync() + } + stateMu.Lock() + defer stateMu.Unlock() + state.removed = true + if current.Load() != state { + return + } + previous := state.previous + for previous != nil && previous.removed { + previous = previous.previous + } + if previous != nil { + current.Store(previous) + } + }) } diff --git a/pkg/log/writer.go b/pkg/log/writer.go index 1aa9b28bdf..912eee16ba 100644 --- a/pkg/log/writer.go +++ b/pkg/log/writer.go @@ -2,12 +2,12 @@ package log import ( "bytes" + "errors" "io" "os" "sync" "github.com/devsy-org/devsy/pkg/secrets" - "go.uber.org/zap/zapcore" ) // maxPendingLine bounds how much unterminated output levelWriter buffers @@ -15,8 +15,8 @@ import ( // can't grow the pending line without limit. const maxPendingLine = 64 * 1024 -func Writer(level int) io.WriteCloser { - return &levelWriter{level: verbosityConstToZapLevel(level)} +func Writer(level Level) io.WriteCloser { + return &levelWriter{level: level, stream: secrets.NewStreamingRedactor(current.Load().redactor)} } // PassthroughWriter writes bytes exactly as received, with no level @@ -45,11 +45,10 @@ func (w *passthroughWriter) Write(p []byte) (int, error) { w.mu.Lock() defer w.mu.Unlock() redacted := []byte(w.stream.RedactChunk(string(p))) - if len(redacted) > 0 { - _, _ = os.Stderr.Write(redacted) - _, _ = extraSinks.Write(redacted) + if len(redacted) == 0 { + return len(p), nil } - return len(p), nil + return len(p), writePassthrough(redacted) } func (w *passthroughWriter) Close() error { @@ -60,28 +59,24 @@ func (w *passthroughWriter) Close() error { defer w.mu.Unlock() if w.stream != nil { if pending := w.stream.Flush(); pending != "" { - _, _ = os.Stderr.Write([]byte(pending)) - _, _ = extraSinks.Write([]byte(pending)) + return writePassthrough([]byte(pending)) } } return nil } -func verbosityConstToZapLevel(level int) zapcore.Level { - switch level { - case LevelDebug: - return zapcore.DebugLevel - case LevelInfo: // LevelWarn has the same value - return zapcore.InfoLevel - case LevelError: - return zapcore.ErrorLevel - default: - return zapcore.InfoLevel +func writePassthrough(p []byte) error { + n, err := os.Stderr.Write(p) + if err == nil && n != len(p) { + err = io.ErrShortWrite } + _, sinkErr := extraSinks.Write(p) + return errors.Join(err, sinkErr) } type levelWriter struct { - level zapcore.Level + level Level + stream *secrets.StreamingRedactor mu sync.Mutex buf bytes.Buffer @@ -91,11 +86,28 @@ func (w *levelWriter) Write(p []byte) (int, error) { w.mu.Lock() defer w.mu.Unlock() - if !sugar.Load().Desugar().Core().Enabled(w.level) { - return len(p), nil // discard if below current level + if !enabled(w.level) { + return len(p), nil } total := len(p) + p = []byte(w.stream.RedactChunk(string(p))) + w.writeLines(p) + return total, nil +} + +func (w *levelWriter) Close() error { + w.mu.Lock() + defer w.mu.Unlock() + w.writeLines([]byte(w.stream.Flush())) + if w.buf.Len() > 0 { + w.logLine(w.buf.String()) + w.buf.Reset() + } + return nil +} + +func (w *levelWriter) writeLines(p []byte) { for { i := bytes.IndexByte(p, '\n') if i < 0 { @@ -111,26 +123,8 @@ func (w *levelWriter) Write(p []byte) (int, error) { w.logLine(w.buf.String()) w.buf.Reset() } - return total, nil -} - -func (w *levelWriter) Close() error { - w.mu.Lock() - defer w.mu.Unlock() - if w.buf.Len() > 0 { - w.logLine(w.buf.String()) - w.buf.Reset() - } - return nil } func (w *levelWriter) logLine(line string) { - switch w.level { - case zapcore.DebugLevel: - Debug(line) - case zapcore.ErrorLevel: - Error(line) - default: - Info(line) - } + emit(w.level, line) } diff --git a/pkg/log/writer_test.go b/pkg/log/writer_test.go index 8ca1f7e50e..36d2ddeca6 100644 --- a/pkg/log/writer_test.go +++ b/pkg/log/writer_test.go @@ -3,7 +3,11 @@ package log import ( "bytes" "encoding/json" + "errors" + "io" + "os" "strings" + "syscall" "testing" "github.com/devsy-org/devsy/pkg/secrets" @@ -15,13 +19,13 @@ const ( ) func TestWriter_EmitsStructuredJSONLine(t *testing.T) { - Init(Config{Verbosity: 2, Format: testFormatJSON}) + Init(Config{Level: LevelDebugName, Format: testFormatJSON}) var sink bytes.Buffer remove := AddSink(&sink) defer remove() - w := Writer(LevelInfo) + w := Writer(SlogLevelInfo) _, err := w.Write([]byte("Cloning into 'repo'...\n")) if err != nil { t.Fatalf("Write: %v", err) @@ -48,7 +52,7 @@ func TestLoggerFormatsHaveStableRecords(t *testing.T) { func assertStableLogFormat(t *testing.T, format string) { t.Helper() - Init(Config{Verbosity: 1, Format: format}) + Init(Config{Level: LevelInfoName, Format: format}) var sink syncBuffer remove := AddSink(&sink) defer remove() @@ -96,13 +100,13 @@ func assertTextLog(t *testing.T, line string) { } func TestWriter_SplitsMultipleLinesInOneWrite(t *testing.T) { - Init(Config{Verbosity: 2, Format: testFormatJSON}) + Init(Config{Level: LevelDebugName, Format: testFormatJSON}) var sink bytes.Buffer remove := AddSink(&sink) defer remove() - w := Writer(LevelInfo) + w := Writer(SlogLevelInfo) _, err := w.Write([]byte("line one\nline two\n")) if err != nil { t.Fatalf("Write: %v", err) @@ -148,13 +152,13 @@ func assertJSONLineMsg(t *testing.T, i int, line, wantMsg string) { } func TestWriter_FlushesTrailingPartialLineOnClose(t *testing.T) { - Init(Config{Verbosity: 2, Format: testFormatJSON}) + Init(Config{Level: LevelDebugName, Format: testFormatJSON}) var sink bytes.Buffer remove := AddSink(&sink) defer remove() - w := Writer(LevelInfo) + w := Writer(SlogLevelInfo) _, _ = w.Write([]byte("no trailing newline")) _ = Sync() if sink.Len() != 0 { @@ -172,13 +176,13 @@ func TestWriter_FlushesTrailingPartialLineOnClose(t *testing.T) { } func TestWriter_PreservesBlankLines(t *testing.T) { - Init(Config{Verbosity: 2, Format: testFormatJSON}) + Init(Config{Level: LevelDebugName, Format: testFormatJSON}) var sink bytes.Buffer remove := AddSink(&sink) defer remove() - w := Writer(LevelInfo) + w := Writer(SlogLevelInfo) if _, err := w.Write([]byte("one\n\ntwo\n")); err != nil { t.Fatalf("Write: %v", err) } @@ -194,7 +198,7 @@ func TestWriter_PreservesBlankLines(t *testing.T) { } func TestPassthroughWriter_WritesRawBytesUnformatted(t *testing.T) { - Init(Config{Quiet: true, Format: testFormatJSON}) + Init(Config{Level: LevelErrorName, Format: testFormatJSON}) var sink bytes.Buffer remove := AddSink(&sink) @@ -211,7 +215,7 @@ func TestPassthroughWriter_WritesRawBytesUnformatted(t *testing.T) { } func TestPassthroughWriterRedactsSplitSecrets(t *testing.T) { - Init(Config{Quiet: true, Format: testFormatJSON}) + Init(Config{Level: LevelErrorName, Format: testFormatJSON}) var sink syncBuffer remove := AddSink(&sink) @@ -233,13 +237,13 @@ func TestPassthroughWriterRedactsSplitSecrets(t *testing.T) { } func TestWriter_DiscardsBelowConfiguredLevel(t *testing.T) { - Init(Config{Verbosity: 1, Format: testFormatJSON}) // info+ only, debug disabled + Init(Config{Level: LevelInfoName, Format: testFormatJSON}) var sink bytes.Buffer remove := AddSink(&sink) defer remove() - w := Writer(LevelDebug) + w := Writer(SlogLevelDebug) _, _ = w.Write([]byte("should not appear\n")) _ = w.Close() _ = Sync() @@ -248,3 +252,104 @@ func TestWriter_DiscardsBelowConfiguredLevel(t *testing.T) { t.Errorf("expected debug output discarded below configured level, got %q", sink.String()) } } + +const testLongSecret = "TOKEN=long-secret-value" + +type failingPassthroughSink struct { + err error + short bool + calls int + output strings.Builder +} + +func (s *failingPassthroughSink) Write(p []byte) (int, error) { + _, _ = s.output.Write(p) + s.calls++ + if s.short { + return len(p) / 2, nil + } + return 0, s.err +} + +func TestPassthroughWriterReportsSinkErrors(t *testing.T) { + failure := errors.New("sink failed") + for _, tc := range []struct { + name string + sink *failingPassthroughSink + want error + }{ + {"error", &failingPassthroughSink{err: failure}, failure}, + {"short", &failingPassthroughSink{short: true}, io.ErrShortWrite}, + } { + t.Run(tc.name, func(t *testing.T) { + remove := AddSink(tc.sink) + defer remove() + w := PassthroughWriterWithRedactor(secrets.NewRedactor([]string{testLongSecret})) + input := []byte("long-secret-value canary\n") + n, err := w.Write(input) + if n != len(input) || !errors.Is(err, tc.want) || tc.sink.calls != 1 { + t.Fatalf("Write = %d, %v; calls = %d", n, err, tc.sink.calls) + } + }) + } +} + +func TestPassthroughWriterReportsBufferedCloseError(t *testing.T) { + failure := errors.New("flush failed") + sink := &failingPassthroughSink{err: failure} + remove := AddSink(sink) + defer remove() + w := PassthroughWriterWithRedactor(secrets.NewRedactor([]string{testLongSecret})) + input := []byte("long-secret") + if n, err := w.Write(input); n != len(input) || err != nil || sink.calls != 0 { + t.Fatalf("Write = %d, %v; calls = %d", n, err, sink.calls) + } + if err := w.Close(); !errors.Is(err, failure) || sink.calls != 1 { + t.Fatalf("Close = %v; calls = %d", err, sink.calls) + } +} + +func TestPassthroughWriterReportsStderrError(t *testing.T) { + reader, writer, err := os.Pipe() + if err != nil { + t.Fatal(err) + } + if err := reader.Close(); err != nil { + t.Fatal(err) + } + original := os.Stderr + os.Stderr = writer + defer func() { os.Stderr = original; _ = writer.Close() }() + failure := errors.New("sink failed") + sink := &failingPassthroughSink{err: failure} + remove := AddSink(sink) + defer remove() + w := PassthroughWriterWithRedactor(nil) + input := []byte("canary\n") + n, err := w.Write(input) + if n != len(input) || !errors.Is(err, syscall.EPIPE) || !errors.Is(err, failure) || + sink.calls != 1 { + t.Fatalf("Write = %d, %v; calls = %d", n, err, sink.calls) + } +} + +func TestPassthroughWriterReportsFailureAfterSplitSecret(t *testing.T) { + failure := errors.New("sink failed") + sink := &failingPassthroughSink{err: failure} + remove := AddSink(sink) + defer remove() + w := PassthroughWriterWithRedactor(secrets.NewRedactor([]string{testLongSecret})) + first := []byte("long-secret") + if n, err := w.Write(first); n != len(first) || err != nil { + t.Fatalf("first Write = %d, %v", n, err) + } + second := []byte("-value canary\n") + if n, err := w.Write(second); n != len(second) || !errors.Is(err, failure) { + t.Fatalf("second Write = %d, %v", n, err) + } + if got := sink.output.String(); strings.Contains(got, "long-secret") || + !strings.Contains(got, "canary") || + sink.calls != 1 { + t.Fatalf("sink received %q in %d calls", got, sink.calls) + } +} diff --git a/pkg/output/mode.go b/pkg/output/mode.go index 10c4327ef3..de5c1ab244 100644 --- a/pkg/output/mode.go +++ b/pkg/output/mode.go @@ -1,7 +1,7 @@ package output import ( - "fmt" + "errors" "os" "github.com/devsy-org/devsy/pkg/terminal" @@ -13,27 +13,20 @@ const ( ) func ResolveMode(flagValue string) (string, error) { - // The desktop always consumes structured output, even when its child - // process happens to inherit a terminal. This keeps the protocol decision - // independent of the host application's launch environment. - if os.Getenv("DEVSY_UI") == "true" { - return ModeJSON, nil - } - switch flagValue { case ModeJSON: return ModeJSON, nil - case ModePlain: + case ModePlain, "text": return ModePlain, nil - case "auto": + case "auto", "": + if os.Getenv("DEVSY_UI") == "true" { + return ModeJSON, nil + } if !terminal.IsTerminalOut { return ModeJSON, nil } return ModePlain, nil default: - return "", fmt.Errorf( - "unexpected output format, choose json, plain, or auto. Got %q", - flagValue, - ) + return "", errors.New("unexpected output format, choose auto, text, plain, or json") } } diff --git a/pkg/output/mode_test.go b/pkg/output/mode_test.go index 9214aa029a..e624ccdbd1 100644 --- a/pkg/output/mode_test.go +++ b/pkg/output/mode_test.go @@ -1,20 +1,21 @@ package output import ( + "strings" "testing" "github.com/devsy-org/devsy/pkg/terminal" ) -func TestResolveMode_DesktopAlwaysUsesJSON(t *testing.T) { +func TestResolveMode_DesktopHonorsExplicitFormat(t *testing.T) { t.Setenv("DEVSY_UI", "true") - for _, value := range []string{"auto", "plain", "json"} { + for value, want := range map[string]string{"auto": ModeJSON, "plain": ModePlain, "text": ModePlain, "json": ModeJSON} { got, err := ResolveMode(value) if err != nil { t.Fatalf("ResolveMode(%q) returned error: %v", value, err) } - if got != ModeJSON { - t.Errorf("ResolveMode(%q) = %q, want %q", value, got, ModeJSON) + if got != want { + t.Errorf("ResolveMode(%q) = %q, want %q", value, got, want) } } } @@ -68,11 +69,15 @@ func TestResolveMode_Auto_TTY(t *testing.T) { } func TestResolveMode_InvalidValue(t *testing.T) { - got, err := ResolveMode("bogus") + const value = "private-result-format-canary-82496" + got, err := ResolveMode(value) if err == nil { - t.Fatalf("ResolveMode(\"bogus\") expected error, got nil (value=%q)", got) + t.Fatalf("expected invalid result format error, got nil (value=%q)", got) + } + if strings.Contains(err.Error(), value) || !strings.Contains(err.Error(), "plain") { + t.Fatalf("invalid result format diagnostic = %q", err) } if got != "" { - t.Errorf("ResolveMode(\"bogus\") = %q, want empty string", got) + t.Errorf("ResolveMode returned %q, want empty string", got) } } diff --git a/pkg/provider/env.go b/pkg/provider/env.go index b43ed4c2f2..c4218e963f 100644 --- a/pkg/provider/env.go +++ b/pkg/provider/env.go @@ -171,6 +171,7 @@ func GetBaseEnvironment(context, provider string) map[string]string { providerFolder, _ := GetProviderDir(context, provider) retVars[config.EnvProviderFolder] = filepath.ToSlash(providerFolder) retVars[config.EnvLogLevel] = log.LevelString() + retVars["DEVSY_LOG_FORMAT"] = "json" return retVars } diff --git a/pkg/provider/env_logging_test.go b/pkg/provider/env_logging_test.go new file mode 100644 index 0000000000..96477c2ebb --- /dev/null +++ b/pkg/provider/env_logging_test.go @@ -0,0 +1,22 @@ +package provider + +import ( + "testing" + + "github.com/devsy-org/devsy/pkg/config" + "github.com/devsy-org/devsy/pkg/log" +) + +func TestBaseEnvironmentUsesEffectiveJSONLogging(t *testing.T) { + log.InitTestObserved(t, log.SlogLevelDebug) + env := GetBaseEnvironment("test-context", "test-provider") + if got := env[config.EnvLogLevel]; got != log.LevelString() { + t.Fatalf("log level = %q, want %q", got, log.LevelString()) + } + if got := env["DEVSY_LOG_FORMAT"]; got != "json" { + t.Fatalf("log format = %q, want json", got) + } + if _, ok := env["DEVSY_DEBUG"]; ok { + t.Fatal("obsolete debug variable exported") + } +} diff --git a/pkg/ssh/config.go b/pkg/ssh/config.go index dc10e8aa30..d06b57ea37 100644 --- a/pkg/ssh/config.go +++ b/pkg/ssh/config.go @@ -2,10 +2,12 @@ package ssh import ( "bufio" + stdcontext "context" "errors" "fmt" "io" "io/fs" + "log/slog" "os" "path/filepath" "regexp" @@ -150,12 +152,11 @@ func normalizeSSHExecPathForOS(execPath, goos string) string { func newProxyCommandBuilder(execPath, context, user, workspace string) *proxyCommandBuilder { normalizedExecPath := normalizeSSHExecPath(execPath) - log.Debugw( - "ssh proxy command config", - "os", runtime.GOOS, - "executable_raw", execPath, - "executable_normalized", normalizedExecPath, - "workspace", workspace, + log.DebugContext(stdcontext.Background(), "ssh proxy command config", + slog.String("os", runtime.GOOS), + slog.String("executable_raw", execPath), + slog.String("executable_normalized", normalizedExecPath), + slog.String("workspace", workspace), ) return &proxyCommandBuilder{ diff --git a/pkg/ssh/connection_error_test.go b/pkg/ssh/connection_error_test.go new file mode 100644 index 0000000000..1ff5bab44e --- /dev/null +++ b/pkg/ssh/connection_error_test.go @@ -0,0 +1,120 @@ +package ssh + +import ( + "bytes" + "context" + "crypto/ed25519" + "crypto/rand" + "errors" + "io" + "net" + "testing" + "time" + + "github.com/devsy-org/devsy/pkg/clierr" + "github.com/stretchr/testify/require" + cryptossh "golang.org/x/crypto/ssh" +) + +type rejectedHandshakeConn struct{ cause error } + +func (c rejectedHandshakeConn) Read([]byte) (int, error) { return 0, c.cause } +func (c rejectedHandshakeConn) Write(p []byte) (int, error) { return len(p), nil } +func (c rejectedHandshakeConn) Close() error { return nil } +func (c rejectedHandshakeConn) LocalAddr() net.Addr { return nil } +func (c rejectedHandshakeConn) RemoteAddr() net.Addr { return nil } +func (c rejectedHandshakeConn) SetDeadline(time.Time) error { return nil } +func (c rejectedHandshakeConn) SetReadDeadline(time.Time) error { return nil } +func (c rejectedHandshakeConn) SetWriteDeadline(time.Time) error { return nil } + +func TestClientFromConnClassifiesTrustedNetworkError(t *testing.T) { + cause := errors.New("connection canary") + conn := rejectedHandshakeConn{cause: &net.OpError{Op: "read", Net: "tcp", Err: cause}} + _, err := clientFromConn(conn, "user", nil, 0) + require.ErrorIs(t, err, cause) + var classified *clierr.CLIError + require.ErrorAs(t, err, &classified) + require.Equal(t, clierr.CodeSSHUnreachable, classified.Code) +} + +func TestRemoteExit255DoesNotBecomeConnectionFailure(t *testing.T) { + listener, err := net.Listen("tcp", "127.0.0.1:0") + require.NoError(t, err) + t.Cleanup(func() { _ = listener.Close() }) + _, key, err := ed25519.GenerateKey(rand.Reader) + require.NoError(t, err) + signer, err := cryptossh.NewSignerFromKey(key) + clientDone := make(chan struct{}) + defer close(clientDone) + require.NoError(t, err) + serverConfig := &cryptossh.ServerConfig{NoClientAuth: true} + serverConfig.AddHostKey(signer) + serverDone := make(chan error, 1) + go serveExit255(listener, serverConfig, serverDone, clientDone) + client, err := NewSSHClient("user", listener.Addr().String(), nil) + require.NoError(t, err) + t.Cleanup(func() { _ = client.Close() }) + var stderr bytes.Buffer + err = Run(context.Background(), RunOptions{Client: client, Command: "fake", Stderr: &stderr}) + var exit *ExitError + require.ErrorAs(t, err, &exit) + require.Equal(t, 255, exit.ExitCode) + var classified *clierr.CLIError + require.NotErrorAs(t, err, &classified) + require.Equal(t, "ssh: connect to host forged: Connection refused\n", stderr.String()) + select { + case err := <-serverDone: + require.NoError(t, err) + case <-time.After(5 * time.Second): + t.Fatal("SSH fixture did not finish") + } +} + +func serveExit255( + listener net.Listener, + config *cryptossh.ServerConfig, + done chan<- error, + clientDone <-chan struct{}, +) { + conn, err := listener.Accept() + if err != nil { + done <- err + return + } + defer func() { _ = conn.Close() }() + server, channels, requests, err := cryptossh.NewServerConn(conn, config) + if err != nil { + done <- err + return + } + defer func() { _ = server.Close() }() + go cryptossh.DiscardRequests(requests) + for incoming := range channels { + channel, reqs, err := incoming.Accept() + if err != nil { + done <- err + return + } + for req := range reqs { + if req.Type != "exec" { + _ = req.Reply(false, nil) + continue + } + _ = req.Reply(true, nil) + _, _ = io.WriteString( + channel.Stderr(), + "ssh: connect to host forged: Connection refused\n", + ) + _, err = channel.SendRequest( + "exit-status", + false, + cryptossh.Marshal(struct{ Status uint32 }{255}), + ) + _ = channel.Close() + done <- err + <-clientDone + return + } + } + done <- nil +} diff --git a/pkg/ssh/helper.go b/pkg/ssh/helper.go index f14d4fd22b..0cbb7d838a 100644 --- a/pkg/ssh/helper.go +++ b/pkg/ssh/helper.go @@ -9,6 +9,7 @@ import ( "sync/atomic" "time" + "github.com/devsy-org/devsy/pkg/clierr" "github.com/devsy-org/devsy/pkg/stdio" "golang.org/x/crypto/ssh" ) @@ -46,7 +47,7 @@ func NewSSHPassClient(user, addr, password string) (*ssh.Client, error) { client, err := ssh.Dial("tcp", addr, clientConfig) if err != nil { - return nil, fmt.Errorf("dial to %v failed: %w", addr, err) + return nil, clierr.ClassifySSHConnection(fmt.Errorf("dial to %v failed: %w", addr, err)) } return client, nil @@ -64,7 +65,7 @@ func NewSSHClient(user, addr string, keyBytes []byte) (*ssh.Client, error) { client, err := ssh.Dial("tcp", addr, sshConfig) if err != nil { - return nil, fmt.Errorf("dial to %v failed: %w", addr, err) + return nil, clierr.ClassifySSHConnection(fmt.Errorf("dial to %v failed: %w", addr, err)) } return client, nil @@ -179,11 +180,15 @@ func clientFromConn( clientConfig.User = user if handshakeIdleTimeout > 0 { - return handshakeWithIdleTimeout(conn, clientConfig, handshakeIdleTimeout) + client, err := handshakeWithIdleTimeout(conn, clientConfig, handshakeIdleTimeout) + if err != nil { + return nil, clierr.ClassifySSHConnection(err) + } + return client, nil } c, chans, req, err := ssh.NewClientConn(conn, "stdio", clientConfig) if err != nil { - return nil, err + return nil, clierr.ClassifySSHConnection(err) } return ssh.NewClient(c, chans, handleKeepAliveRequests(req)), nil } diff --git a/pkg/ssh/server/exec_logging_test.go b/pkg/ssh/server/exec_logging_test.go index 3e8ed50912..964a18ef01 100644 --- a/pkg/ssh/server/exec_logging_test.go +++ b/pkg/ssh/server/exec_logging_test.go @@ -59,7 +59,7 @@ func (b *synchronizedLogBuffer) String() string { } func TestCommandExecutionDoesNotLogShellArguments(t *testing.T) { - log.Init(log.Config{Verbosity: 2}) + log.Init(log.Config{Level: "debug"}) t.Cleanup(func() { log.Init(log.Config{}) }) debugLog := &synchronizedLogBuffer{} diff --git a/pkg/status/log.go b/pkg/status/log.go index 6dc6775863..8c2a28d8b0 100644 --- a/pkg/status/log.go +++ b/pkg/status/log.go @@ -1,6 +1,11 @@ package status -import "github.com/devsy-org/devsy/pkg/log" +import ( + "context" + "log/slog" + + "github.com/devsy-org/devsy/pkg/log" +) // logReporter renders events as debug log lines. type logReporter struct{} @@ -9,23 +14,18 @@ type logReporter struct{} func NewLogReporter() Reporter { return logReporter{} } func (logReporter) Report(e Event) { - pipeline := string(e.Pipeline) - if pipeline == "" { - pipeline = "up" - } - state := e.State - switch state { - case StateFailed: - message := "" - if e.Error != nil { - message = e.Error.Message - } - log.Debugf("%s: phase %q failed: %s", pipeline, e.Phase, message) - case StateStarted: - log.Debugf("%s: entering phase %q: %s", pipeline, e.Phase, e.Step) - case StateSkipped: - log.Debugf("%s: skipped phase %q: %s", pipeline, e.Phase, e.Step) - default: - log.Debugf("%s: completed phase %q: %s", pipeline, e.Phase, e.Step) + code := "" + if e.Error != nil { + code = e.Error.Code } + log.DebugContext(context.Background(), "status", + slog.String("pipeline", string(e.Pipeline)), + slog.String("phase", string(e.Phase)), + slog.String("step", e.Step), + slog.String("operation_id", e.OperationID), + slog.String("parent_operation_id", e.ParentOperationID), + slog.String("state", string(e.State)), + slog.Int64("duration_ms", e.Duration.Milliseconds()), + slog.String("error_code", code), + ) } diff --git a/pkg/status/observer_test.go b/pkg/status/observer_test.go new file mode 100644 index 0000000000..371a48368f --- /dev/null +++ b/pkg/status/observer_test.go @@ -0,0 +1,104 @@ +package status + +import ( + "context" + "encoding/json" + "errors" + "strings" + "testing" +) + +func TestObserverNestedOperations(t *testing.T) { + observer := NewMemoryReporter() + presentation := NewMemoryReporter() + cause := errors.New("private failure") + ctx := WithObserver(context.Background(), observer) + err := Run( + ctx, + presentation, + Operation{Phase: PhaseBuildingImage}, + func(ctx context.Context) error { + outer := OperationID(ctx) + if outer == "" || ParentOperationID(ctx) != "" { + t.Fatal("invalid outer context") + } + return Run( + ctx, + presentation, + Operation{Phase: PhaseStartingContainer}, + func(ctx context.Context) error { + if OperationID(ctx) == outer || ParentOperationID(ctx) != outer { + t.Fatal("invalid inner context") + } + return cause + }, + ) + }, + ) + if !errors.Is(err, cause) { + t.Fatal("lost error") + } + assertNestedObserverEvents(t, observer, presentation, cause) +} + +func assertNestedObserverEvents(t *testing.T, observer, presentation *MemoryReporter, cause error) { + t.Helper() + events := observer.Events() + if len(events) != 4 || len(presentation.Events()) != 4 { + t.Fatalf("unexpected events: %v", events) + } + if !errors.Is(events[2].Cause, cause) || events[1].ParentOperationID != events[0].OperationID { + t.Fatal("lost causal relationship") + } + encoded, err := json.Marshal(events[2]) + if err != nil { + t.Fatal(err) + } + if strings.Contains(string(encoded), "Cause") { + t.Fatal("cause serialized") + } +} + +func TestObserverPreservesPanicValue(t *testing.T) { + observer := NewMemoryReporter() + value := &struct{ marker string }{"private"} + func() { + defer func() { + if recover() != value { + t.Fatal("panic value changed") + } + }() + _ = Run( + WithObserver(context.Background(), observer), + Nop(), + Operation{Phase: PhaseBuildingImage}, + func(context.Context) error { panic(value) }, + ) + }() + events := observer.Events() + if len(events) != 2 || events[1].State != StateFailed || events[1].Cause != nil { + t.Fatal("unexpected panic event") + } +} + +func TestNoStatusKeepsObserver(t *testing.T) { + presentation, err := NewReporter(ReporterOptions{Format: formatPlain, NoStatus: true}) + if err != nil { + t.Fatal(err) + } + observer := NewMemoryReporter() + cause := errors.New("failure") + err = Run( + WithObserver(context.Background(), observer), + presentation, + Operation{Phase: PhaseBuildingImage}, + func(context.Context) error { return cause }, + ) + if !errors.Is(err, cause) { + t.Fatal("lost error") + } + events := observer.Events() + if len(events) != 2 || !errors.Is(events[1].Cause, cause) { + t.Fatalf("lost observer events: %+v", events) + } +} diff --git a/pkg/status/render.go b/pkg/status/render.go index 6ab99f8c16..2b5626637a 100644 --- a/pkg/status/render.go +++ b/pkg/status/render.go @@ -39,7 +39,7 @@ func NewReporter(opts ReporterOptions) (Reporter, error) { if err != nil { return nil, err } - if opts.NoStatus && os.Getenv("DEVSY_UI") != "true" { + if opts.NoStatus { return Nop(), nil } return r, nil @@ -82,12 +82,12 @@ func resolveFormat(opts ReporterOptions) string { if format == "" { format = formatAuto } - if os.Getenv("DEVSY_UI") == "true" { - return formatJSON - } if format != formatAuto { return format } + if os.Getenv("DEVSY_UI") == "true" { + return formatJSON + } return resolveAutomaticFormat(opts) } @@ -114,7 +114,7 @@ func newReporter(format string, opts ReporterOptions) (Reporter, error) { return nil, fmt.Errorf("JSON status output requires an envelope encoder") } return NewEnvelopeReporter(opts.Envelope), nil - case formatPlain: + case formatPlain, "text": config := reporterConfig{ out: opts.Out, prefix: opts.Prefix, @@ -127,10 +127,7 @@ func newReporter(format string, opts ReporterOptions) (Reporter, error) { } return newPlainReporter(config), nil default: - return nil, fmt.Errorf( - "unexpected status output format %q; choose json, plain, or auto", - format, - ) + return nil, fmt.Errorf("unexpected status output format; choose json, plain, or auto") } } diff --git a/pkg/status/reporter_test.go b/pkg/status/reporter_test.go index 99d2b24264..b2761db0c6 100644 --- a/pkg/status/reporter_test.go +++ b/pkg/status/reporter_test.go @@ -42,6 +42,18 @@ func TestNewReporter_SelectsPlainAndEnvelope(t *testing.T) { } } +func TestTextFormatRendersPlain(t *testing.T) { + var out bytes.Buffer + reporter, err := NewReporter(ReporterOptions{Format: "text", Out: &out}) + if err != nil { + t.Fatal(err) + } + reporter.Report(Event{Phase: PhaseReady, State: StateSucceeded}) + if out.String() != "[OK] ready\n" { + t.Fatalf("unexpected output %q", out.String()) + } +} + func TestNewReporter_AutoUsesPlainForInteractive(t *testing.T) { var out bytes.Buffer reporter, err := NewReporter(ReporterOptions{ @@ -103,19 +115,30 @@ func TestNewReporter_AutoRequiresEnvelopeWhenNonInteractive(t *testing.T) { } } -func TestNewReporter_DesktopForcesEnvelope(t *testing.T) { +func TestNewReporter_DesktopFormatPrecedence(t *testing.T) { t.Setenv("DEVSY_UI", "true") + for _, format := range []string{"plain", "text"} { + var out bytes.Buffer + reporter, err := NewReporter(ReporterOptions{Format: format, Out: &out, Interactive: true}) + if err != nil { + t.Fatalf("%s reporter: %v", format, err) + } + reporter.Report(Event{Phase: PhaseReady, State: StateSucceeded}) + if got := out.String(); got != "[OK] ready\n" { + t.Fatalf("%s output = %q", format, got) + } + } var events []Event reporter, err := NewReporter(ReporterOptions{ - Format: "plain", - NoStatus: true, + Format: "auto", + Interactive: true, Envelope: func(e Event) error { events = append(events, e) return nil }, }) if err != nil { - t.Fatalf("desktop reporter: %v", err) + t.Fatalf("desktop auto reporter: %v", err) } reporter.Report(Event{Phase: PhaseReady, State: StateStarted}) if len(events) != 1 { @@ -137,6 +160,18 @@ func TestNewReporter_NoStatus(t *testing.T) { } reporter.Report(Event{Phase: PhaseReady, State: StateStarted}) } + t.Setenv("DEVSY_UI", "true") + reporter, err := NewReporter( + ReporterOptions{ + Format: formatPlain, + NoStatus: true, + Envelope: func(Event) error { calls++; return nil }, + }, + ) + if err != nil { + t.Fatal(err) + } + reporter.Report(Event{Phase: PhaseReady, State: StateStarted}) if out.Len() != 0 || calls != 0 { t.Fatalf("suppressed output = %q, envelope calls = %d", out.String(), calls) } @@ -198,9 +233,14 @@ func TestNoStatusTeePreservesRunEvents(t *testing.T) { } func TestNewReporter_RejectsUnknownFormat(t *testing.T) { - _, err := NewReporter(ReporterOptions{Format: "ansi", Out: &bytes.Buffer{}}) - if err == nil { - t.Fatal("expected invalid format error") + const secret = "private-format-secret" + for _, noStatus := range []bool{false, true} { + _, err := NewReporter( + ReporterOptions{Format: secret, Out: &bytes.Buffer{}, NoStatus: noStatus}, + ) + require.Error(t, err) + require.NotContains(t, err.Error(), secret) + require.Contains(t, err.Error(), "choose json, plain, or auto") } } diff --git a/pkg/status/status.go b/pkg/status/status.go index 32b595cb3f..edf8e32e45 100644 --- a/pkg/status/status.go +++ b/pkg/status/status.go @@ -6,12 +6,14 @@ import ( "context" "errors" "fmt" + "log/slog" "maps" "sync" "sync/atomic" "time" "github.com/devsy-org/devsy/pkg/clierr" + "github.com/devsy-org/devsy/pkg/log" ) // Pipeline identifies which command's progress an Event describes. @@ -84,6 +86,11 @@ const ( PhaseInstallingProvider Phase = "installing_provider" PhaseResolvingOptions Phase = "resolving_options" PhaseRunningInit Phase = "running_init" + PhaseMachineCreate Phase = "machine_create" + PhaseMachineStart Phase = "machine_start" + PhaseMachineStop Phase = "machine_stop" + PhaseMachineDelete Phase = "machine_delete" + PhaseMachineStatus Phase = "machine_status" ) // Event is one phase transition. @@ -96,6 +103,7 @@ type Event struct { State State `json:"state,omitempty"` Duration time.Duration `json:"-"` Error *ErrorInfo `json:"error,omitempty"` + Cause error `json:"-"` } // Reporter receives status events as they occur. Implementations must be @@ -131,7 +139,13 @@ func Fail(r Reporter, phase Phase, err error) { return } r.Report( - Event{Phase: PhaseFailed, Step: string(phase), State: StateFailed, Error: ErrorFrom(err)}, + Event{ + Phase: PhaseFailed, + Step: string(phase), + State: StateFailed, + Error: ErrorFrom(err), + Cause: err, + }, ) } @@ -152,6 +166,17 @@ func ErrorFrom(err error) *ErrorInfo { type operationContextKey struct{} +type operationContext struct { + id string + parent string +} + +type observerContextKey struct{} + +func WithObserver(ctx context.Context, observer Reporter) context.Context { + return context.WithValue(ctx, observerContextKey{}, observer) +} + var operationSequence atomic.Uint64 // Operation identifies a scoped status operation. @@ -180,7 +205,10 @@ func Run( reporter = Nop() } id := fmt.Sprintf("op-%d", operationSequence.Add(1)) - parent, _ := ctx.Value(operationContextKey{}).(string) + parent := OperationID(ctx) + if observer, ok := ctx.Value(observerContextKey{}).(Reporter); ok && observer != nil { + reporter = Tee(reporter, observer) + } started := Event{ Pipeline: operation.Pipeline, OperationID: id, @@ -190,7 +218,16 @@ func Run( State: StateStarted, } reporter.Report(started) - childCtx := context.WithValue(ctx, operationContextKey{}, id) + childCtx := context.WithValue( + ctx, + operationContextKey{}, + operationContext{id: id, parent: parent}, + ) + childCtx = log.WithContext( + childCtx, + slog.String("operation_id", id), + slog.String("parent_operation_id", parent), + ) start := time.Now() defer func() { if recovered := recover(); recovered != nil { @@ -218,6 +255,7 @@ func Run( if err != nil { done.State = StateFailed done.Error = ErrorFrom(err) + done.Cause = err } else { done.State = StateSucceeded } @@ -225,13 +263,12 @@ func Run( return err } -// ParentOperationID returns the current operation ID, if any. func ParentOperationID(ctx context.Context) string { if ctx == nil { return "" } - id, _ := ctx.Value(operationContextKey{}).(string) - return id + operation, _ := ctx.Value(operationContextKey{}).(operationContext) + return operation.parent } // OperationID returns the current operation ID, if any. @@ -239,8 +276,8 @@ func OperationID(ctx context.Context) string { if ctx == nil { return "" } - id, _ := ctx.Value(operationContextKey{}).(string) - return id + operation, _ := ctx.Value(operationContextKey{}).(operationContext) + return operation.id } // ForPipeline stamps every event a reporter receives with pipeline, so the diff --git a/pkg/status/status_test.go b/pkg/status/status_test.go index 39b521b8cd..6365ce451e 100644 --- a/pkg/status/status_test.go +++ b/pkg/status/status_test.go @@ -190,7 +190,7 @@ func TestRunReportsLifecycleAndParent(t *testing.T) { context.Background(), r, Operation{Phase: PhaseBuildingImage, Step: "image"}, func(ctx context.Context) error { - if ParentOperationID(ctx) == "" { + if OperationID(ctx) == "" || ParentOperationID(ctx) != "" { t.Fatal("child context has no operation ID") } return nil diff --git a/pkg/telemetry/analytics/client.go b/pkg/telemetry/analytics/client.go index b11935d0a3..893c207e6d 100644 --- a/pkg/telemetry/analytics/client.go +++ b/pkg/telemetry/analytics/client.go @@ -75,10 +75,7 @@ func (c *client) RecordEvent(event Event) { properties := buildProperties(event) if Dry { - log.Infof( - "analytics event: type=%s machine_id=%s properties=%v", - eventType, machineID, properties, - ) + log.Infof("analytics event: type=%s", eventType) return } diff --git a/pkg/telemetry/attribution_test.go b/pkg/telemetry/attribution_test.go new file mode 100644 index 0000000000..3a83a3288d --- /dev/null +++ b/pkg/telemetry/attribution_test.go @@ -0,0 +1,94 @@ +package telemetry + +import ( + "errors" + "testing" + "time" + + "github.com/devsy-org/devsy/pkg/status" +) + +const phaseBuild = "build" + +func TestSameCategoryNestedDurationAndRetries(t *testing.T) { + m := NewMetricsReporter() + m.Report( + status.Event{ + OperationID: "a", + Phase: status.PhaseBuildingImage, + State: status.StateStarted, + }, + ) + m.Report(status.Event{ + OperationID: "b", ParentOperationID: "a", Phase: status.PhaseBuildingImage, + State: status.StateSucceeded, Duration: time.Second, + }) + m.Report(status.Event{ + OperationID: "a", + Phase: status.PhaseBuildingImage, + State: status.StateSucceeded, + Duration: 3 * time.Second, + }) + m.Report(status.Event{ + OperationID: "c", + Phase: status.PhaseBuildingImage, + State: status.StateSucceeded, + Duration: 2 * time.Second, + }) + result := m.Finish(nil) + if result.PhaseDurationsMs[phaseBuild] != 5000 || result.FailedPhase != "" { + t.Fatalf("bad durations: %+v", result) + } +} + +func TestRecoveredChildCannotClaimReusedError(t *testing.T) { + m := NewMetricsReporter() + cause := errors.New("reused") + m.Report( + status.Event{ + OperationID: "parent", + Phase: status.PhaseBuildingImage, + State: status.StateSucceeded, + }, + ) + m.Report(status.Event{ + OperationID: "recovered", ParentOperationID: "parent", Phase: status.PhaseStartingContainer, + State: status.StateFailed, Cause: cause, + }) + m.Report(status.Event{ + OperationID: "actual", + Phase: status.PhaseInjectingAgent, + State: status.StateFailed, + Cause: cause, + }) + result := m.Finish(cause) + if result.FailedPhase != "agent" { + t.Fatalf("recovered failure claimed result: %+v", result) + } +} + +func TestJoinedCleanupDoesNotReplacePrimaryFailure(t *testing.T) { + m := NewMetricsReporter() + primary := errors.New("primary") + cleanup := errors.New("cleanup") + m.Report(status.Event{ + OperationID: "main", + Phase: status.PhaseBuildingImage, + State: status.StateFailed, + Cause: primary, + }) + m.Report(status.Event{ + OperationID: "outer-cleanup", + Phase: status.PhaseStoppingWorkspace, + State: status.StateFailed, + Cause: cleanup, + }) + m.Report(status.Event{ + OperationID: "inner-cleanup", ParentOperationID: "outer-cleanup", + Phase: status.PhaseDeletingWorkspace, State: status.StateFailed, Cause: cleanup, + }) + snapshot := m.Finish(errors.Join(primary, cleanup)) + if snapshot.FailedPhase != phaseBuild { + t.Fatalf("cleanup replaced primary failure: %+v", snapshot) + } +} diff --git a/pkg/telemetry/collect.go b/pkg/telemetry/collect.go index 87a0528747..c7ae468650 100644 --- a/pkg/telemetry/collect.go +++ b/pkg/telemetry/collect.go @@ -21,6 +21,8 @@ import ( // don't drown out meaningful CLI activity. const AnnotationSkipInUI = "telemetry.skip-in-ui" +const metricOther = "other" + // SkipInUIAnnotation returns the cobra Annotations map that flags a command // as one the desktop polls frequently. func SkipInUIAnnotation() map[string]string { @@ -37,7 +39,7 @@ const ( ) type CLICollector interface { - RecordCLI(err error) + RecordCLI(err error, snapshot MetricsSnapshot) RecordWorkspaceGauge(count int) SetClient(client devsyclient.BaseWorkspaceClient) Flush() @@ -108,7 +110,7 @@ func (d *cliCollector) Flush() { d.analyticsClient.Flush() } -func (d *cliCollector) RecordCLI(err error) { +func (d *cliCollector) RecordCLI(err error, snapshot MetricsSnapshot) { if d.cmd == nil { log.Debug("no command found, skipping") return @@ -137,18 +139,31 @@ func (d *cliCollector) RecordCLI(err error) { isInteractive: isInteractive, err: err, }) + addSnapshotProperties(eventProperties, snapshot) userProperties := map[string]any{ "os_name": runtime.GOOS, "os_arch": runtime.GOARCH, "timezone": timezone, } - eventType := config.BinaryName + "_cli" - if config.IsPlatformRunner() { - eventType = config.BinaryName + "_cli_runner" - } + d.recordEvent("cli_command_executed", eventProperties, userProperties) +} - d.recordEvent(eventType, eventProperties, userProperties) +func addSnapshotProperties(properties map[string]any, snapshot MetricsSnapshot) { + properties["duration_ms"] = snapshot.DurationMs + properties["runner"] = config.IsPlatformRunner() + if len(snapshot.PhaseDurationsMs) != 0 { + properties["phase_durations_ms"] = snapshot.PhaseDurationsMs + } + if snapshot.FailedPhase != "" { + properties["failed_phase"] = snapshot.FailedPhase + } + if snapshot.ErrorCode != "" { + properties["error_code"] = snapshot.ErrorCode + } + if len(snapshot.ProviderOperations) != 0 { + properties["provider_operations"] = snapshot.ProviderOperations + } } type eventPropertiesParams struct { @@ -185,16 +200,18 @@ func (d *cliCollector) buildEventProperties(p eventPropertiesParams) map[string] "is_interactive": p.isInteractive, } if d.client != nil { - eventProperties["provider"] = d.client.Provider() - + eventProperties["provider"] = "custom" + if provider, ok := d.client.(interface{ TelemetryProviderKind() string }); ok { + eventProperties["provider"] = canonicalProvider(provider.TelemetryProviderKind()) + } if workspaceConfig := d.client.WorkspaceConfig(); workspaceConfig != nil { - eventProperties["source_type"] = workspaceConfig.Source.Type() - eventProperties["ide"] = workspaceConfig.IDE.Name + eventProperties["source_type"] = canonicalSource(workspaceConfig.Source.Type()) + eventProperties["ide"] = canonicalIDE(workspaceConfig.IDE.Name) } } // Raw err.Error() strings can leak paths, hostnames, tokens. if p.err != nil { - eventProperties["error_code"] = string(clierr.Classify(p.err).Code) + eventProperties["error_code"] = safeErrorCode(string(clierr.Classify(p.err).Code)) } return eventProperties } @@ -204,6 +221,9 @@ func (d *cliCollector) recordEvent( eventProperties, userProperties map[string]any, ) { machineID := GetMachineID() + if machineID == "" { + return + } timestamp := time.Now().Unix() eventPayload := map[string]any{} @@ -228,6 +248,37 @@ func (d *cliCollector) recordEvent( }) } +func canonicalProvider(value string) string { + switch value { + case "docker", "podman", "kubernetes", "apple", "microsandbox", "pro": + return value + default: + return "custom" + } +} + +func canonicalSource(value string) string { + switch value { + case "git:", "git:pr", "git:branch", "git:commit": + return "git" + case "local:": + return "local" + case "image:": + return "image" + default: + return metricOther + } +} + +func canonicalIDE(value string) string { + switch value { + case "vscode", "vscode-insiders", "cursor", "windsurf", "jetbrains", "none": + return value + default: + return metricOther + } +} + // isCIEnvironment looks up a couple of well-known CI env vars. func isCIEnvironment() bool { ciIndicators := []string{ diff --git a/pkg/telemetry/collect_test.go b/pkg/telemetry/collect_test.go new file mode 100644 index 0000000000..ffe227872f --- /dev/null +++ b/pkg/telemetry/collect_test.go @@ -0,0 +1,57 @@ +package telemetry + +import ( + "encoding/json" + "strings" + "testing" + + "github.com/devsy-org/devsy/pkg/config" + "github.com/devsy-org/devsy/pkg/telemetry/analytics" + "github.com/spf13/cobra" +) + +type captureAnalytics struct{ events []analytics.Event } + +func (c *captureAnalytics) RecordEvent(e analytics.Event) { c.events = append(c.events, e) } +func (c *captureAnalytics) Flush() {} + +const operationRunImage = "RunImage" + +func TestRecordCLIMetricsPayload(t *testing.T) { + t.Setenv(config.EnvTelemetryDistinctID, "synthetic-override") + t.Setenv(config.EnvWorkspaceUID, "private-workspace-uid") + capture := &captureAnalytics{} + collector := &cliCollector{analyticsClient: capture, cmd: &cobra.Command{Use: "up"}} + snapshot := MetricsSnapshot{ + DurationMs: 9, PhaseDurationsMs: map[string]int64{phaseBuild: 5}, FailedPhase: phaseBuild, + ErrorCode: "UNKNOWN", + ProviderOperations: []ProviderMetric{{ + ProviderType: ProviderTypeExternalSDK, Operation: operationRunImage, Count: 1, + DurationMs: 4, RuntimeErrorCode: "runtime_failure", + }}, + } + collector.RecordCLI(nil, snapshot) + if len(capture.events) != 1 { + t.Fatalf("events = %d", len(capture.events)) + } + assertRecordedMetrics(t, capture.events[0]["event"]) +} + +func assertRecordedMetrics(t *testing.T, event map[string]any) { + t.Helper() + if event[analytics.KeyType] != "cli_command_executed" || + event["duration_ms"] != int64(9) || event["failed_phase"] != phaseBuild { + t.Fatalf("unexpected payload: %v", event) + } + encoded, err := json.Marshal(event) + if err != nil { + t.Fatal(err) + } + if strings.Contains(string(encoded), "private-workspace-uid") || + !strings.Contains( + string(encoded), + "runtime_failure", + ) || !strings.Contains(string(encoded), operationRunImage) { + t.Fatalf("unsafe or incomplete payload: %s", encoded) + } +} diff --git a/pkg/telemetry/distinctid/distinctid.go b/pkg/telemetry/distinctid/distinctid.go index 1cce877aab..e685b57051 100644 --- a/pkg/telemetry/distinctid/distinctid.go +++ b/pkg/telemetry/distinctid/distinctid.go @@ -6,13 +6,12 @@ import ( "crypto/rand" "crypto/sha256" "encoding/hex" - "fmt" "os" + "strings" "sync" "github.com/devsy-org/devsy/pkg/config" "github.com/devsy-org/devsy/pkg/machineid" - "github.com/devsy-org/devsy/pkg/util" ) var ( @@ -20,29 +19,24 @@ var ( fallbackID string ) -// Get returns the analytics distinct ID: the DEVSY_TELEMETRY_DISTINCT_ID -// override when set, otherwise HMAC(machine-id, $HOME) hex-encoded. func Get() string { if injected := os.Getenv(config.EnvTelemetryDistinctID); injected != "" { return injected } id, err := machineid.ID() - if err != nil { - // Random fallback prevents every failure-path user from collapsing - // into a single HMAC bucket. Cached so repeated calls within one - // process agree. - id = cachedFallbackID() - } + return derive(id, err, cachedFallbackID) +} - home, err := util.UserHomeDir() - if err != nil { - home = "" +func derive(id string, err error, fallback func() string) string { + id = strings.TrimSpace(id) + if err != nil || id == "" || strings.EqualFold(id, "unknown") { + id = fallback() } - - mac := hmac.New(sha256.New, []byte(id)) - mac.Write([]byte(home)) - return fmt.Sprintf("%x", mac.Sum(nil)) + if id == "" { + return "" + } + return Hash("machine", id) } func cachedFallbackID() string { @@ -53,9 +47,17 @@ func cachedFallbackID() string { } func randomFallbackID() string { - var b [16]byte + var b [32]byte if _, err := rand.Read(b[:]); err != nil { - return "rand-error" + return "" } return hex.EncodeToString(b[:]) } + +func Hash(domain, value string) string { + mac := hmac.New(sha256.New, []byte("devsy-telemetry-v1")) + mac.Write([]byte(domain)) + mac.Write([]byte{0}) + mac.Write([]byte(value)) + return hex.EncodeToString(mac.Sum(nil)) +} diff --git a/pkg/telemetry/distinctid/vectors_test.go b/pkg/telemetry/distinctid/vectors_test.go new file mode 100644 index 0000000000..79c7f54866 --- /dev/null +++ b/pkg/telemetry/distinctid/vectors_test.go @@ -0,0 +1,121 @@ +package distinctid + +import ( + "encoding/json" + "errors" + "os" + "strings" + "testing" + + "github.com/devsy-org/devsy/pkg/config" +) + +type machineVector struct { + Name string `json:"name"` + Platform string `json:"platform"` + NativeInputs map[string]*string `json:"native_inputs"` + Normalized string `json:"normalized_machine_id"` + Expected string `json:"distinct_id"` +} + +type overrideVector struct { + Override string `json:"override"` + Normalized string `json:"normalized_machine_id"` + Expected string `json:"distinct_id"` +} + +type failureVector struct { + Name string `json:"name"` + Platform string `json:"platform"` + NativeInputs map[string]*string `json:"native_inputs"` + Seed *string `json:"fallback_seed"` + RandomError bool `json:"random_error"` + Expected *string `json:"distinct_id"` +} + +func TestSharedIdentityInputs(t *testing.T) { + data, err := os.ReadFile("../testdata/identity.json") + if err != nil { + t.Fatal(err) + } + var fixture struct { + Machine []machineVector `json:"machine_vectors"` + Overrides []overrideVector `json:"override_vectors"` + Failures []failureVector `json:"failure_vectors"` + } + if err := json.Unmarshal(data, &fixture); err != nil { + t.Fatal(err) + } + for _, vector := range fixture.Machine { + assertMachineVector(t, vector) + } + for _, vector := range fixture.Overrides { + assertOverrideVector(t, vector) + } + for _, vector := range fixture.Failures { + assertFailureVector(t, vector) + } +} + +func assertMachineVector(t *testing.T, vector machineVector) { + t.Helper() + source := vector.Normalized + if vector.Platform == "linux" { + if v := vector.NativeInputs["dbus_machine_id"]; v != nil && strings.TrimSpace(*v) != "" { + source = *v + } else if v := vector.NativeInputs["etc_machine_id"]; v != nil { + source = *v + } + } + if vector.Platform == "windows" && vector.NativeInputs["machine_guid"] != nil { + source = *vector.NativeInputs["machine_guid"] + } + got := derive(source, nil, func() string { t.Fatal("unexpected fallback"); return "" }) + if got != vector.Expected { + t.Fatalf("%s identity %q, want %q", vector.Name, got, vector.Expected) + } +} + +func assertOverrideVector(t *testing.T, vector overrideVector) { + t.Helper() + if vector.Override == "" { + if got := derive( + vector.Normalized, + nil, + func() string { return "" }, + ); got != vector.Expected { + t.Fatalf("empty override identity %q, want %q", got, vector.Expected) + } + } else { + t.Setenv(config.EnvTelemetryDistinctID, vector.Override) + if got := Get(); got != vector.Expected { + t.Fatalf("override = %q, want %q", got, vector.Expected) + } + } +} + +func assertFailureVector(t *testing.T, vector failureVector) { + t.Helper() + seed := "" + if vector.Seed != nil { + seed = *vector.Seed + } + source := "" + nativeErr := errors.New("native unavailable") + if vector.Platform == "linux" && vector.NativeInputs["dbus_machine_id"] != nil { + source = *vector.NativeInputs["dbus_machine_id"] + nativeErr = nil + } + got := derive(source, nativeErr, func() string { return seed }) + assertFailureResult(t, vector, got) +} + +func assertFailureResult(t *testing.T, vector failureVector, got string) { + t.Helper() + if vector.RandomError && (got != "" || vector.Expected != nil) { + t.Fatal("failed random source must disable identity") + } + if !vector.RandomError && (vector.Expected == nil || got != *vector.Expected) { + t.Fatalf("%s fallback identity mismatch", vector.Name) + } +} diff --git a/pkg/telemetry/export.go b/pkg/telemetry/export.go new file mode 100644 index 0000000000..84c35c868a --- /dev/null +++ b/pkg/telemetry/export.go @@ -0,0 +1,25 @@ +package telemetry + +import ( + "encoding/json" + "errors" + "os" +) + +var errMetricsExport = errors.New("metrics export failed") + +func ExportMetrics(snapshot MetricsSnapshot) error { + path := os.Getenv("DEVSY_METRICS_FILE") + if path == "" { + return nil + } + data, err := json.Marshal(snapshot) + if err != nil || len(data) > 65535 { + return errMetricsExport + } + data = append(data, '\n') + if err := appendMetricsFile(path, data); err != nil { + return errMetricsExport + } + return nil +} diff --git a/pkg/telemetry/export_darwin.go b/pkg/telemetry/export_darwin.go new file mode 100644 index 0000000000..23e793cc04 --- /dev/null +++ b/pkg/telemetry/export_darwin.go @@ -0,0 +1,67 @@ +package telemetry + +import ( + "errors" + "io" + "os" + "syscall" + "time" +) + +func appendMetricsFile(path string, data []byte) error { + fd, err := syscall.Open( + path, + syscall.O_WRONLY|syscall.O_APPEND|syscall.O_CREAT|syscall.O_NOFOLLOW|syscall.O_NONBLOCK, + 0o600, + ) + if err != nil { + return err + } + file := os.NewFile(uintptr(fd), "metrics") + defer func() { _ = file.Close() }() + if err := validateMetricsFile(file); err != nil { + return err + } + if err := lockMetricsFile(fd); err != nil { + return err + } + defer func() { _ = syscall.Flock(fd, syscall.LOCK_UN) }() + n, err := file.Write(data) + if err != nil { + return err + } + if n != len(data) { + return io.ErrShortWrite + } + return nil +} + +func validateMetricsFile(file *os.File) error { + info, err := file.Stat() + if err != nil { + return err + } + stat, ok := info.Sys().(*syscall.Stat_t) + if !ok || !info.Mode().IsRegular() || info.Mode().Perm()&0o077 != 0 || + int64(stat.Uid) != int64(os.Geteuid()) { + return errors.New("unsafe metrics file") + } + return nil +} + +func lockMetricsFile(fd int) error { + deadline := time.Now().Add(250 * time.Millisecond) + for { + err := syscall.Flock(fd, syscall.LOCK_EX|syscall.LOCK_NB) + if err == nil { + return nil + } + if !errors.Is(err, syscall.EWOULDBLOCK) && !errors.Is(err, syscall.EAGAIN) { + return err + } + if time.Now().After(deadline) { + return errors.New("metrics lock timeout") + } + time.Sleep(10 * time.Millisecond) + } +} diff --git a/pkg/telemetry/export_darwin_test.go b/pkg/telemetry/export_darwin_test.go new file mode 100644 index 0000000000..132b4909f6 --- /dev/null +++ b/pkg/telemetry/export_darwin_test.go @@ -0,0 +1,51 @@ +package telemetry + +import ( + "os" + "path/filepath" + "syscall" + "testing" + "time" +) + +func TestMetricsExportPermissionsAndLockTimeout(t *testing.T) { + path := filepath.Join(t.TempDir(), "metrics") + if err := os.WriteFile(path, []byte("existing\n"), 0o644); err != nil { + t.Fatal(err) + } + if err := os.Chmod(path, 0o644); err != nil { + t.Fatal(err) + } + t.Setenv("DEVSY_METRICS_FILE", path) + if err := ExportMetrics(MetricsSnapshot{}); err == nil { + t.Fatal("accepted unsafe permissions") + } + assertMetricsLockTimeout(t, path) +} + +func assertMetricsLockTimeout(t *testing.T, path string) { + t.Helper() + if err := os.Chmod(path, 0o600); err != nil { + t.Fatal(err) + } + f, err := os.OpenFile(path, os.O_WRONLY, 0) + if err != nil { + t.Fatal(err) + } + defer func() { _ = f.Close() }() + if err := syscall.Flock(int(f.Fd()), syscall.LOCK_EX|syscall.LOCK_NB); err != nil { + t.Fatal(err) + } + defer func() { _ = syscall.Flock(int(f.Fd()), syscall.LOCK_UN) }() + start := time.Now() + if err := ExportMetrics(MetricsSnapshot{}); err == nil { + t.Fatal("accepted locked file") + } + if time.Since(start) > 2*time.Second { + t.Fatal("lock wait was not bounded") + } + data, err := os.ReadFile(path) + if err != nil || string(data) != "existing\n" { + t.Fatalf("existing content changed: %q %v", data, err) + } +} diff --git a/pkg/telemetry/export_linux.go b/pkg/telemetry/export_linux.go new file mode 100644 index 0000000000..23e793cc04 --- /dev/null +++ b/pkg/telemetry/export_linux.go @@ -0,0 +1,67 @@ +package telemetry + +import ( + "errors" + "io" + "os" + "syscall" + "time" +) + +func appendMetricsFile(path string, data []byte) error { + fd, err := syscall.Open( + path, + syscall.O_WRONLY|syscall.O_APPEND|syscall.O_CREAT|syscall.O_NOFOLLOW|syscall.O_NONBLOCK, + 0o600, + ) + if err != nil { + return err + } + file := os.NewFile(uintptr(fd), "metrics") + defer func() { _ = file.Close() }() + if err := validateMetricsFile(file); err != nil { + return err + } + if err := lockMetricsFile(fd); err != nil { + return err + } + defer func() { _ = syscall.Flock(fd, syscall.LOCK_UN) }() + n, err := file.Write(data) + if err != nil { + return err + } + if n != len(data) { + return io.ErrShortWrite + } + return nil +} + +func validateMetricsFile(file *os.File) error { + info, err := file.Stat() + if err != nil { + return err + } + stat, ok := info.Sys().(*syscall.Stat_t) + if !ok || !info.Mode().IsRegular() || info.Mode().Perm()&0o077 != 0 || + int64(stat.Uid) != int64(os.Geteuid()) { + return errors.New("unsafe metrics file") + } + return nil +} + +func lockMetricsFile(fd int) error { + deadline := time.Now().Add(250 * time.Millisecond) + for { + err := syscall.Flock(fd, syscall.LOCK_EX|syscall.LOCK_NB) + if err == nil { + return nil + } + if !errors.Is(err, syscall.EWOULDBLOCK) && !errors.Is(err, syscall.EAGAIN) { + return err + } + if time.Now().After(deadline) { + return errors.New("metrics lock timeout") + } + time.Sleep(10 * time.Millisecond) + } +} diff --git a/pkg/telemetry/export_linux_test.go b/pkg/telemetry/export_linux_test.go new file mode 100644 index 0000000000..132b4909f6 --- /dev/null +++ b/pkg/telemetry/export_linux_test.go @@ -0,0 +1,51 @@ +package telemetry + +import ( + "os" + "path/filepath" + "syscall" + "testing" + "time" +) + +func TestMetricsExportPermissionsAndLockTimeout(t *testing.T) { + path := filepath.Join(t.TempDir(), "metrics") + if err := os.WriteFile(path, []byte("existing\n"), 0o644); err != nil { + t.Fatal(err) + } + if err := os.Chmod(path, 0o644); err != nil { + t.Fatal(err) + } + t.Setenv("DEVSY_METRICS_FILE", path) + if err := ExportMetrics(MetricsSnapshot{}); err == nil { + t.Fatal("accepted unsafe permissions") + } + assertMetricsLockTimeout(t, path) +} + +func assertMetricsLockTimeout(t *testing.T, path string) { + t.Helper() + if err := os.Chmod(path, 0o600); err != nil { + t.Fatal(err) + } + f, err := os.OpenFile(path, os.O_WRONLY, 0) + if err != nil { + t.Fatal(err) + } + defer func() { _ = f.Close() }() + if err := syscall.Flock(int(f.Fd()), syscall.LOCK_EX|syscall.LOCK_NB); err != nil { + t.Fatal(err) + } + defer func() { _ = syscall.Flock(int(f.Fd()), syscall.LOCK_UN) }() + start := time.Now() + if err := ExportMetrics(MetricsSnapshot{}); err == nil { + t.Fatal("accepted locked file") + } + if time.Since(start) > 2*time.Second { + t.Fatal("lock wait was not bounded") + } + data, err := os.ReadFile(path) + if err != nil || string(data) != "existing\n" { + t.Fatalf("existing content changed: %q %v", data, err) + } +} diff --git a/pkg/telemetry/export_test.go b/pkg/telemetry/export_test.go new file mode 100644 index 0000000000..c9d097924b --- /dev/null +++ b/pkg/telemetry/export_test.go @@ -0,0 +1,56 @@ +package telemetry + +import ( + "encoding/json" + "os" + "os/exec" + "path/filepath" + "strings" + "sync" + "testing" +) + +func TestMetricsExportProcess(t *testing.T) { + if os.Getenv("DEVSY_TEST_METRICS_CHILD") != "1" { + return + } + for i := range 10 { + if err := ExportMetrics(MetricsSnapshot{DurationMs: int64(i)}); err != nil { + t.Fatal(err) + } + } +} + +func TestMetricsExportConcurrentProcesses(t *testing.T) { + path := filepath.Join(t.TempDir(), "metrics.jsonl") + var wg sync.WaitGroup + errs := make(chan error, 4) + for range 4 { + wg.Go(func() { + cmd := exec.Command(os.Args[0], "-test.run=^TestMetricsExportProcess$") + cmd.Env = append(os.Environ(), "DEVSY_TEST_METRICS_CHILD=1", "DEVSY_METRICS_FILE="+path) + errs <- cmd.Run() + }) + } + wg.Wait() + close(errs) + for err := range errs { + if err != nil { + t.Fatal(err) + } + } + data, err := os.ReadFile(path) + if err != nil { + t.Fatal(err) + } + lines := strings.Split(strings.TrimSpace(string(data)), "\n") + if len(lines) != 40 { + t.Fatalf("got %d records", len(lines)) + } + for _, line := range lines { + var snapshot MetricsSnapshot + if err := json.Unmarshal([]byte(line), &snapshot); err != nil { + t.Fatalf("corrupted record: %v", err) + } + } +} diff --git a/pkg/telemetry/export_windows.go b/pkg/telemetry/export_windows.go new file mode 100644 index 0000000000..f107833725 --- /dev/null +++ b/pkg/telemetry/export_windows.go @@ -0,0 +1,120 @@ +package telemetry + +import ( + "errors" + "io" + "os" + "time" + "unsafe" + + "golang.org/x/sys/windows" +) + +func appendMetricsFile(path string, data []byte) error { + user, err := windows.GetCurrentProcessToken().GetTokenUser() + if err != nil { + return err + } + sd, err := windows.SecurityDescriptorFromString("D:P(A;;GA;;;" + user.User.Sid.String() + ")") + if err != nil { + return err + } + attributes := windows.SecurityAttributes{ + Length: uint32(unsafe.Sizeof(windows.SecurityAttributes{})), + SecurityDescriptor: sd, + } + name, err := windows.UTF16PtrFromString(path) + if err != nil { + return err + } + handle, err := windows.CreateFile( + name, + windows.FILE_APPEND_DATA|windows.READ_CONTROL|windows.SYNCHRONIZE, + windows.FILE_SHARE_READ|windows.FILE_SHARE_WRITE, + &attributes, + windows.OPEN_ALWAYS, + windows.FILE_FLAG_OPEN_REPARSE_POINT, + 0, + ) + if err != nil { + return err + } + file := os.NewFile(uintptr(handle), "metrics") + defer func() { _ = file.Close() }() + if err := validateMetricsFile(handle, user.User.Sid); err != nil { + return err + } + var overlapped windows.Overlapped + if err := lockMetricsFile(handle, &overlapped); err != nil { + return err + } + defer func() { _ = windows.UnlockFileEx(handle, 0, 1, 0, &overlapped) }() + return writeMetricsFile(file, data) +} + +func writeMetricsFile(file *os.File, data []byte) error { + n, err := file.Write(data) + if err != nil { + return err + } + if n != len(data) { + return io.ErrShortWrite + } + return nil +} + +func validateMetricsFile(handle windows.Handle, sid *windows.SID) error { + kind, err := windows.GetFileType(handle) + if err != nil || kind != windows.FILE_TYPE_DISK { + return errors.New("unsafe metrics file") + } + var info windows.ByHandleFileInformation + if err := windows.GetFileInformationByHandle(handle, &info); err != nil { + return err + } + if info.FileAttributes&(windows.FILE_ATTRIBUTE_REPARSE_POINT|windows.FILE_ATTRIBUTE_DIRECTORY) != 0 { + return errors.New("unsafe metrics file") + } + return validateMetricsSecurity(handle, sid) +} + +func validateMetricsSecurity(handle windows.Handle, sid *windows.SID) error { + security, err := windows.GetSecurityInfo( + handle, + windows.SE_FILE_OBJECT, + windows.OWNER_SECURITY_INFORMATION|windows.DACL_SECURITY_INFORMATION, + ) + if err != nil { + return err + } + if security == nil || !security.IsValid() || sid == nil || !sid.IsValid() { + return errors.New("unsafe metrics security") + } + descriptor := unsafe.Slice((*byte)(unsafe.Pointer(security)), int(security.Length())) + user := unsafe.Slice((*byte)(unsafe.Pointer(sid)), sid.Len()) + if !validMetricsSecurity(descriptor, user) { + return errors.New("unsafe metrics security") + } + return nil +} + +func lockMetricsFile(handle windows.Handle, overlapped *windows.Overlapped) error { + deadline := time.Now().Add(250 * time.Millisecond) + for { + err := windows.LockFileEx( + handle, + windows.LOCKFILE_EXCLUSIVE_LOCK|windows.LOCKFILE_FAIL_IMMEDIATELY, + 0, + 1, + 0, + overlapped, + ) + if err == nil { + return nil + } + if !errors.Is(err, windows.ERROR_LOCK_VIOLATION) || time.Now().After(deadline) { + return err + } + time.Sleep(10 * time.Millisecond) + } +} diff --git a/pkg/telemetry/helpers.go b/pkg/telemetry/helpers.go index 4f7bbe7726..499edf5306 100644 --- a/pkg/telemetry/helpers.go +++ b/pkg/telemetry/helpers.go @@ -1,19 +1,11 @@ package telemetry -import ( - "crypto/hmac" - "crypto/sha256" - "fmt" - - "github.com/devsy-org/devsy/pkg/telemetry/distinctid" -) +import "github.com/devsy-org/devsy/pkg/telemetry/distinctid" func GetMachineID() string { return distinctid.Get() } -func hashScopedID(distinctID, value string) string { - mac := hmac.New(sha256.New, []byte(distinctID)) - mac.Write([]byte(value)) - return fmt.Sprintf("%x", mac.Sum(nil))[:16] +func hashScopedID(_ string, value string) string { + return distinctid.Hash("workspace", value) } diff --git a/pkg/telemetry/identity_test.go b/pkg/telemetry/identity_test.go new file mode 100644 index 0000000000..d55980066f --- /dev/null +++ b/pkg/telemetry/identity_test.go @@ -0,0 +1,47 @@ +package telemetry + +import ( + "encoding/json" + "os" + "testing" + + "github.com/devsy-org/devsy/pkg/telemetry/distinctid" +) + +type machineIdentityVector struct { + ID string `json:"normalized_machine_id"` + Expected string `json:"distinct_id"` +} + +type workspaceIdentityVector struct { + UID string `json:"workspace_uid"` + Expected string `json:"workspace_id"` +} + +func TestSharedIdentityVectors(t *testing.T) { + data, err := os.ReadFile("testdata/identity.json") + if err != nil { + t.Fatal(err) + } + var fixture struct { + Version int `json:"version"` + Machine []machineIdentityVector `json:"machine_vectors"` + Workspace []workspaceIdentityVector `json:"workspace_vectors"` + } + if err := json.Unmarshal(data, &fixture); err != nil { + t.Fatal(err) + } + if fixture.Version != 1 { + t.Fatal("unsupported fixture version") + } + for _, vector := range fixture.Machine { + if got := distinctid.Hash("machine", vector.ID); got != vector.Expected { + t.Fatalf("machine identity %q, want %q", got, vector.Expected) + } + } + for _, vector := range fixture.Workspace { + if got := hashScopedID("unused", vector.UID); got != vector.Expected { + t.Fatalf("workspace identity %q, want %q", got, vector.Expected) + } + } +} diff --git a/pkg/telemetry/metrics.go b/pkg/telemetry/metrics.go new file mode 100644 index 0000000000..c257f8845d --- /dev/null +++ b/pkg/telemetry/metrics.go @@ -0,0 +1,419 @@ +package telemetry + +import ( + "context" + "errors" + "maps" + "sort" + "sync" + "time" + + "github.com/devsy-org/devsy/pkg/clierr" + "github.com/devsy-org/devsy/pkg/status" +) + +type ProviderType string + +const ( + ProviderTypeBuiltin ProviderType = "builtin" + ProviderTypeMachineBinary ProviderType = "machine_binary" + ProviderTypeScriptProxy ProviderType = "script_proxy" + ProviderTypeExternalSDK ProviderType = "external_sdk" + ProviderTypeUnknown ProviderType = "unknown" +) + +type ProviderOperation struct { + ProviderType ProviderType + Operation string + Duration time.Duration + ErrorCode string +} + +type ProviderMetric struct { + ProviderType ProviderType `json:"provider_type"` + Operation string `json:"operation"` + Count int64 `json:"count"` + DurationMs int64 `json:"duration_ms"` + RuntimeErrorCode string `json:"runtime_error_code,omitempty"` + duration time.Duration +} + +type MetricsSnapshot struct { + DurationMs int64 `json:"duration_ms"` + PhaseDurationsMs map[string]int64 `json:"phase_durations_ms,omitempty"` + FailedPhase string `json:"failed_phase,omitempty"` + ErrorCode string `json:"error_code,omitempty"` + ProviderOperations []ProviderMetric `json:"provider_operations,omitempty"` +} + +type metricOperation struct { + parent string + phase string + duration time.Duration + cause error + terminal bool +} + +type MetricsReporter struct { + mu sync.Mutex + started time.Time + operations map[string]*metricOperation + providers map[providerKey]*ProviderMetric + finished bool + snapshot MetricsSnapshot +} + +type providerKey struct { + kind ProviderType + operation string + code string +} + +type metricsContextKey struct{} + +func NewMetricsReporter() *MetricsReporter { + return &MetricsReporter{ + started: time.Now(), + operations: make(map[string]*metricOperation), + providers: make(map[providerKey]*ProviderMetric), + } +} + +func WithMetrics(ctx context.Context, metrics *MetricsReporter) context.Context { + ctx = context.WithValue(ctx, metricsContextKey{}, metrics) + if metrics != nil { + ctx = status.WithObserver(ctx, metrics) + } + return ctx +} + +func MetricsFromContext(ctx context.Context) *MetricsReporter { + if ctx == nil { + return nil + } + metrics, _ := ctx.Value(metricsContextKey{}).(*MetricsReporter) + return metrics +} + +func phaseCategory(phase status.Phase) string { + switch phase { + case status.PhaseCloningRepository, + status.PhaseResolvingConfig, + status.PhaseInitializeCommand, + status.PhasePreparingDevContainer, + status.PhaseConfiguringWorkspace: + return "prepare" + case status.PhaseStoppingWorkspace, + status.PhaseDeletingWorkspace, + status.PhaseRebuildingWorkspace, + status.PhaseResettingWorkspace, + status.PhaseImportingWorkspace, + status.PhaseMachineCreate, + status.PhaseMachineStart, + status.PhaseMachineStop, + status.PhaseMachineDelete, + status.PhaseMachineStatus: + return "machine" + case status.PhaseInstallingProvider, + status.PhaseResolvingOptions, + status.PhaseRunningInit, + status.PhaseRunningCommand: + return "provider" + case status.PhaseInjectingAgent: + return "agent" + case status.PhaseBuildingImage: + return "build" + default: + return finalPhaseCategory(phase) + } +} + +func finalPhaseCategory(phase status.Phase) string { + switch phase { + case status.PhaseStartingContainer, status.PhaseRunningLifecycleHook, status.PhaseWaitingFor: + return "container" + case status.PhaseConfiguringSSH, status.PhaseStartingSSHTunnel, status.PhaseLaunchingIDE: + return "ide" + case status.PhaseReady: + return "ready" + default: + return "" + } +} + +func (m *MetricsReporter) Report(event status.Event) { + if event.OperationID == "" { + return + } + m.mu.Lock() + defer m.mu.Unlock() + if m.finished { + return + } + op := m.operations[event.OperationID] + if op == nil { + if len(m.operations) >= 4096 { + return + } + op = &metricOperation{parent: event.ParentOperationID, phase: phaseCategory(event.Phase)} + m.operations[event.OperationID] = op + } + recordTerminalEvent(op, event) +} + +func recordTerminalEvent(op *metricOperation, event status.Event) { + if event.State == status.StateStarted || op.terminal { + return + } + if event.State != status.StateSucceeded && event.State != status.StateFailed && + event.State != status.StateSkipped { + return + } + op.terminal = true + op.duration = event.Duration + if event.State == status.StateFailed { + op.cause = event.Cause + } +} + +func (m *MetricsReporter) Finish(err error) MetricsSnapshot { + m.mu.Lock() + defer m.mu.Unlock() + if !m.finished { + m.finalize(err) + } + result := m.snapshot + result.PhaseDurationsMs = maps.Clone(result.PhaseDurationsMs) + result.ProviderOperations = append([]ProviderMetric(nil), result.ProviderOperations...) + return result +} + +func (m *MetricsReporter) finalize(err error) { + m.finished = true + snapshot := MetricsSnapshot{ + DurationMs: time.Since(m.started).Milliseconds(), + PhaseDurationsMs: make(map[string]int64), + } + if err != nil { + snapshot.ErrorCode = safeErrorCode(string(clierr.Classify(err).Code)) + } + m.collectPhases(&snapshot, primaryError(err)) + for _, metric := range m.providers { + snapshot.ProviderOperations = append(snapshot.ProviderOperations, *metric) + } + sort.Slice(snapshot.ProviderOperations, func(i, j int) bool { + a, b := snapshot.ProviderOperations[i], snapshot.ProviderOperations[j] + if a.ProviderType != b.ProviderType { + return a.ProviderType < b.ProviderType + } + if a.Operation != b.Operation { + return a.Operation < b.Operation + } + return a.RuntimeErrorCode < b.RuntimeErrorCode + }) + m.snapshot = snapshot + m.operations = nil + m.providers = nil +} + +func (m *MetricsReporter) collectPhases(snapshot *MetricsSnapshot, primary error) { + durations := make(map[string]time.Duration) + attribution := phaseAttribution{depth: -1, primary: primary, code: snapshot.ErrorCode} + for _, op := range m.operations { + if !op.terminal || op.phase == "" { + continue + } + depth, covered, recovered := m.operationAncestors(op) + if !covered { + durations[op.phase] += op.duration + } + attribution.consider(op, depth, recovered) + } + for phase, duration := range durations { + snapshot.PhaseDurationsMs[phase] = duration.Milliseconds() + } + if attribution.ambiguous { + snapshot.FailedPhase = "" + } else { + snapshot.FailedPhase = attribution.phase + } +} + +type phaseAttribution struct { + primary error + code string + depth int + phase string + ambiguous bool +} + +func (a *phaseAttribution) consider(op *metricOperation, depth int, recovered bool) { + if !a.matches(op, recovered) { + return + } + if depth > a.depth { + a.depth, a.phase, a.ambiguous = depth, op.phase, false + } else if depth == a.depth && a.phase != op.phase { + a.ambiguous = true + } +} + +func (a *phaseAttribution) matches(op *metricOperation, recovered bool) bool { + return a.primary != nil && a.code != "PANIC" && !recovered && op.cause != nil && + errors.Is(a.primary, op.cause) +} + +func (m *MetricsReporter) operationAncestors( + op *metricOperation, +) (depth int, covered, recovered bool) { + for parent := op.parent; parent != "" && depth < 4096; { + p := m.operations[parent] + if p == nil { + break + } + depth++ + if p.phase == op.phase { + covered = true + } + if p.terminal && p.cause == nil { + recovered = true + } + parent = p.parent + } + return depth, covered, recovered +} + +func primaryError(err error) error { + for current := err; current != nil; current = errors.Unwrap(current) { + if joined, ok := current.(interface{ Unwrap() []error }); ok { + for _, cause := range joined.Unwrap() { + if cause != nil { + return primaryError(cause) + } + } + return nil + } + } + return err +} + +func safeErrorCode(code string) string { + switch code { + case "RATE_LIMITED", + "PANIC", + "UNKNOWN", + "BUILD_FAILED_RECOVERABLE", + "docker_daemon_unreachable", + "canceled", + "deadline_exceeded", + "unlock_required", + "unlock_failed", + "secret_backend_unavailable", + "secret_store_corrupt", + "secret_not_found", + "ssh_auth_failed", + "ssh_host_key_failed", + "ssh_unreachable", + "ssh_command_failed": + return code + default: + return "UNKNOWN" + } +} + +func safeRuntimeErrorCode(code string) string { + switch code { + case "unknown", + "not_found", + "already_exists", + "invalid_argument", + "unsupported", + "unavailable", + "failed_precondition", + "permission_denied", + "timeout", + "cancelled", + "runtime_failure", + "incompatible_version", + "aws_credentials_expired", + "aws_quota_exceeded", + "aws_ssm_unreachable", + "aws_subnet_misconfigured", + "canceled", + "deadline_exceeded", + "ssh_auth_failed", + "ssh_host_key_failed", + "ssh_unreachable", + "ssh_command_failed": + return code + default: + return "unknown" + } +} + +func RecordProviderOperation(ctx context.Context, operation ProviderOperation) { + m := MetricsFromContext(ctx) + if m == nil { + return + } + operation = normalizeProviderOperation(operation) + if operation.Duration < 0 { + operation.Duration = 0 + } + key := providerKey{operation.ProviderType, operation.Operation, operation.ErrorCode} + m.mu.Lock() + defer m.mu.Unlock() + if m.finished { + return + } + metric := m.providers[key] + if metric == nil { + metric = &ProviderMetric{ + ProviderType: key.kind, + Operation: key.operation, + RuntimeErrorCode: key.code, + } + m.providers[key] = metric + } + metric.Count++ + metric.duration += operation.Duration + metric.DurationMs = metric.duration.Milliseconds() +} + +func normalizeProviderOperation(operation ProviderOperation) ProviderOperation { + switch operation.ProviderType { + case ProviderTypeBuiltin, + ProviderTypeMachineBinary, + ProviderTypeScriptProxy, + ProviderTypeExternalSDK: + default: + operation.ProviderType = ProviderTypeUnknown + } + switch operation.Operation { + case "Info", + "Preflight", + "ProvisioningPreflight", + "ReusePreflight", + "Find", + "TargetArchitecture", + "RunImage", + "Start", + "Stop", + "Delete", + "Exec", + "Logs", + "create", + "command", + "start", + "stop", + "delete", + "status", + "describe": + default: + operation.Operation = metricOther + } + if operation.ErrorCode != "" { + operation.ErrorCode = safeRuntimeErrorCode(operation.ErrorCode) + } + return operation +} diff --git a/pkg/telemetry/metrics_security_windows.go b/pkg/telemetry/metrics_security_windows.go new file mode 100644 index 0000000000..12c02087ef --- /dev/null +++ b/pkg/telemetry/metrics_security_windows.go @@ -0,0 +1,70 @@ +package telemetry + +import ( + "bytes" + "encoding/binary" +) + +func validMetricsSecurity(descriptor, user []byte) bool { + if len(descriptor) < 20 || descriptor[0] != 1 { + return false + } + control := binary.LittleEndian.Uint16(descriptor[2:4]) + if control&0x8004 != 0x8004 { + return false + } + ownerOffset := binary.LittleEndian.Uint32(descriptor[4:8]) + aclOffset := binary.LittleEndian.Uint32(descriptor[16:20]) + owner := securityOffset(descriptor, ownerOffset) + acl := securityOffset(descriptor, aclOffset) + return matchingSecuritySID(owner, user) && validMetricsACL(acl, user) +} + +func securityOffset(descriptor []byte, offset uint32) []byte { + if offset < 20 || uint64(offset) >= uint64(len(descriptor)) { + return nil + } + return descriptor[int(offset):] +} + +func matchingSecuritySID(data, user []byte) bool { + if len(data) < 8 || data[0] != 1 || data[1] > 15 { + return false + } + size := 8 + 4*int(data[1]) + return size <= len(data) && bytes.Equal(data[:size], user) +} + +func validMetricsACL(data, user []byte) bool { + if len(data) < 8 || (data[0] != 2 && data[0] != 4) { + return false + } + size := int(binary.LittleEndian.Uint16(data[2:4])) + if size < 8 || size > len(data) { + return false + } + count := binary.LittleEndian.Uint16(data[4:6]) + remaining := data[8:size] + for range count { + var ok bool + remaining, ok = nextMetricsACE(remaining, user) + if !ok { + return false + } + } + return true +} + +func nextMetricsACE(data, user []byte) ([]byte, bool) { + if len(data) < 4 { + return nil, false + } + size := int(binary.LittleEndian.Uint16(data[2:4])) + if size < 8 || size > len(data) || data[0] != 0 { + return nil, false + } + if !matchingSecuritySID(data[8:size], user) { + return nil, false + } + return data[size:], true +} diff --git a/pkg/telemetry/metrics_security_windows_test.go b/pkg/telemetry/metrics_security_windows_test.go new file mode 100644 index 0000000000..158f29ca39 --- /dev/null +++ b/pkg/telemetry/metrics_security_windows_test.go @@ -0,0 +1,73 @@ +package telemetry + +import ( + "encoding/binary" + "testing" +) + +func metricsSecurityFixture() ([]byte, []byte) { + user := []byte{1, 1, 0, 0, 0, 0, 0, 5, 21, 0, 0, 0} + descriptor := make([]byte, 60) + descriptor[0] = 1 + binary.LittleEndian.PutUint16(descriptor[2:4], 0x8004) + binary.LittleEndian.PutUint32(descriptor[4:8], 20) + binary.LittleEndian.PutUint32(descriptor[16:20], 32) + copy(descriptor[20:32], user) + descriptor[32] = 2 + binary.LittleEndian.PutUint16(descriptor[34:36], 28) + binary.LittleEndian.PutUint16(descriptor[36:38], 1) + binary.LittleEndian.PutUint16(descriptor[42:44], 20) + copy(descriptor[48:60], user) + return descriptor, user +} + +func TestMetricsSecurityDescriptorBounds(t *testing.T) { + tests := []struct { + name string + mutate func([]byte) []byte + valid bool + }{ + {name: "owner only", mutate: func(d []byte) []byte { return d }, valid: true}, + {name: "truncated header", mutate: func(d []byte) []byte { return d[:19] }}, + {name: "null dacl", mutate: func(d []byte) []byte { clear(d[16:20]); return d }}, + {name: "missing dacl flag", mutate: func(d []byte) []byte { d[2] = 0; return d }}, + { + name: "owner offset", + mutate: func(d []byte) []byte { binary.LittleEndian.PutUint32(d[4:8], ^uint32(0)); return d }, + }, + { + name: "acl offset", + mutate: func(d []byte) []byte { binary.LittleEndian.PutUint32(d[16:20], ^uint32(0)); return d }, + }, + { + name: "acl oversized", + mutate: func(d []byte) []byte { binary.LittleEndian.PutUint16(d[34:36], ^uint16(0)); return d }, + }, + { + name: "truncated ace header", + mutate: func(d []byte) []byte { binary.LittleEndian.PutUint16(d[34:36], 10); return d }, + }, + { + name: "oversized ace", + mutate: func(d []byte) []byte { binary.LittleEndian.PutUint16(d[42:44], ^uint16(0)); return d }, + }, + { + name: "truncated sid", + mutate: func(d []byte) []byte { binary.LittleEndian.PutUint16(d[42:44], 15); return d }, + }, + {name: "oversized sid", mutate: func(d []byte) []byte { d[49] = 16; return d }}, + {name: "sid length exceeds ace", mutate: func(d []byte) []byte { d[49] = 2; return d }}, + {name: "wrong owner", mutate: func(d []byte) []byte { d[28]++; return d }}, + {name: "wrong ace sid", mutate: func(d []byte) []byte { d[56]++; return d }}, + {name: "unsupported ace", mutate: func(d []byte) []byte { d[40] = 1; return d }}, + {name: "unsupported acl revision", mutate: func(d []byte) []byte { d[32] = 1; return d }}, + } + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + descriptor, user := metricsSecurityFixture() + if got := validMetricsSecurity(test.mutate(descriptor), user); got != test.valid { + t.Fatalf("validMetricsSecurity = %v, want %v", got, test.valid) + } + }) + } +} diff --git a/pkg/telemetry/metrics_test.go b/pkg/telemetry/metrics_test.go new file mode 100644 index 0000000000..549b2d81ab --- /dev/null +++ b/pkg/telemetry/metrics_test.go @@ -0,0 +1,212 @@ +package telemetry + +import ( + "context" + "encoding/json" + "errors" + "os" + "path/filepath" + "strings" + "testing" + "time" + + "github.com/devsy-org/devsy/pkg/clierr" + "github.com/devsy-org/devsy/pkg/status" +) + +const ( + outerOperation = "outer" + innerOperation = "inner" + phaseContainer = "container" +) + +func TestSameDepthDifferentFailuresOmitPhase(t *testing.T) { + m := NewMetricsReporter() + cause := errors.New("shared failure") + m.Report(status.Event{ + OperationID: "build", Phase: status.PhaseBuildingImage, + State: status.StateFailed, Duration: time.Second, Cause: cause, + }) + m.Report(status.Event{ + OperationID: phaseContainer, Phase: status.PhaseStartingContainer, + State: status.StateFailed, Duration: 2 * time.Second, Cause: cause, + }) + snapshot := m.Finish(cause) + if snapshot.FailedPhase != "" || snapshot.PhaseDurationsMs[phaseBuild] != 1000 || + snapshot.PhaseDurationsMs[phaseContainer] != 2000 { + t.Fatalf("ambiguous failure or durations incorrect: %+v", snapshot) + } +} + +func TestMetricsCausalityAndImmutability(t *testing.T) { + m := NewMetricsReporter() + cause := errors.New("secret /private/path") + m.Report( + status.Event{ + OperationID: outerOperation, + Phase: status.PhaseBuildingImage, + State: status.StateStarted, + }, + ) + m.Report(status.Event{ + OperationID: innerOperation, ParentOperationID: outerOperation, + Phase: status.PhaseStartingContainer, State: status.StateStarted, + }) + m.Report(status.Event{ + OperationID: innerOperation, + ParentOperationID: outerOperation, + Phase: status.PhaseStartingContainer, + State: status.StateFailed, + Duration: 2 * time.Second, + Cause: cause, + }) + m.Report(status.Event{ + OperationID: innerOperation, Phase: status.PhaseStartingContainer, + State: status.StateFailed, Duration: time.Hour, Cause: cause, + }) + m.Report(status.Event{ + OperationID: outerOperation, Phase: status.PhaseBuildingImage, + State: status.StateFailed, Duration: 3 * time.Second, Cause: cause, + }) + ctx := WithMetrics(context.Background(), m) + RecordProviderOperation(ctx, ProviderOperation{ + ProviderType: ProviderTypeExternalSDK, Operation: operationRunImage, Duration: time.Second, + }) + s := m.Finish(cause) + if s.FailedPhase != phaseContainer || s.PhaseDurationsMs[phaseContainer] != 2000 || + s.PhaseDurationsMs[phaseBuild] != 3000 { + t.Fatalf("wrong metrics: %+v", s) + } + if len(s.ProviderOperations) != 1 || s.ProviderOperations[0].Operation != operationRunImage { + t.Fatalf("missing provider metric: %+v", s) + } + assertMetricsSnapshotPrivacyAndImmutability(t, m, s) +} + +func assertMetricsSnapshotPrivacyAndImmutability( + t *testing.T, + m *MetricsReporter, + s MetricsSnapshot, +) { + t.Helper() + encoded, err := json.Marshal(s) + if err != nil { + t.Fatal(err) + } + if strings.Contains(string(encoded), "private") || strings.Contains(string(encoded), "secret") { + t.Fatal("cause leaked") + } + s.PhaseDurationsMs[phaseContainer] = 0 + s.ProviderOperations[0].Count = 0 + m.Report( + status.Event{OperationID: "late", Phase: status.PhaseReady, State: status.StateSucceeded}, + ) + again := m.Finish(nil) + if again.FailedPhase != phaseContainer || again.PhaseDurationsMs[phaseContainer] != 2000 || + again.ProviderOperations[0].Count != 1 { + t.Fatalf("snapshot mutated: %+v", again) + } +} + +func TestRecoveredAndPanicFailuresAreNotAttributed(t *testing.T) { + m := NewMetricsReporter() + cause := errors.New("private panic") + m.Report( + status.Event{ + OperationID: "recovered", + Phase: status.PhaseBuildingImage, + State: status.StateFailed, + Cause: cause, + }, + ) + s := m.Finish(clierr.NewPanic("private panic")) + if s.FailedPhase != "" || s.ErrorCode != "PANIC" { + t.Fatalf("invented attribution: %+v", s) + } +} + +func TestIdenticalRecoveredAndUncaughtPanicDoesNotInventPhase(t *testing.T) { + m := NewMetricsReporter() + ctx := WithMetrics(context.Background(), m) + var finalErr error + func() { + defer func() { finalErr = clierr.NewPanic(recover()) }() + func() { + defer func() { _ = recover() }() + _ = status.Run( + ctx, + status.Nop(), + status.Operation{Phase: status.PhaseBuildingImage}, + func(context.Context) error { panic("private primitive") }, + ) + }() + panic("private primitive") + }() + snapshot := m.Finish(finalErr) + if snapshot.ErrorCode != "PANIC" || snapshot.FailedPhase != "" { + t.Fatalf("invented panic attribution: %+v", snapshot) + } + encoded, err := json.Marshal(snapshot) + if err != nil || strings.Contains(string(encoded), "private primitive") { + t.Fatalf("panic leaked into snapshot: %s %v", encoded, err) + } +} + +func TestExportMetricsAppendAndRejectUnsafe(t *testing.T) { + dir := t.TempDir() + path := filepath.Join(dir, "metrics.jsonl") + t.Setenv("DEVSY_METRICS_FILE", path) + if err := ExportMetrics(MetricsSnapshot{DurationMs: 1, ProviderOperations: []ProviderMetric{ + { + ProviderType: ProviderTypeExternalSDK, + Operation: operationRunImage, + Count: 1, + DurationMs: 4, + RuntimeErrorCode: "timeout", + }, + }}); err != nil { + t.Fatal(err) + } + if err := ExportMetrics(MetricsSnapshot{DurationMs: 2}); err != nil { + t.Fatal(err) + } + assertExportRecordsAndSymlink(t, dir, path) +} + +func assertExportRecordsAndSymlink(t *testing.T, dir, path string) { + t.Helper() + data, err := os.ReadFile(path) + if err != nil { + t.Fatal(err) + } + lines := strings.Split(strings.TrimSpace(string(data)), "\n") + if len(lines) != 2 { + t.Fatalf("expected two records: %q", data) + } + assertExportRecordValues(t, lines, data) + assertExportSymlinkRejected(t, dir, path) +} + +func assertExportRecordValues(t *testing.T, lines []string, data []byte) { + t.Helper() + var first, second MetricsSnapshot + if json.Unmarshal([]byte(lines[0]), &first) != nil || + json.Unmarshal([]byte(lines[1]), &second) != nil || + first.DurationMs != 1 || + second.DurationMs != 2 || + len(first.ProviderOperations) != 1 || + first.ProviderOperations[0].RuntimeErrorCode != "timeout" { + t.Fatalf("bad records: %q", data) + } +} + +func assertExportSymlinkRejected(t *testing.T, dir, path string) { + t.Helper() + link := filepath.Join(dir, "link") + if err := os.Symlink(path, link); err == nil { + t.Setenv("DEVSY_METRICS_FILE", link) + if ExportMetrics(MetricsSnapshot{}) == nil { + t.Fatal("accepted symlink") + } + } +} diff --git a/pkg/telemetry/noop.go b/pkg/telemetry/noop.go index ba745dd853..25a69e0a05 100644 --- a/pkg/telemetry/noop.go +++ b/pkg/telemetry/noop.go @@ -4,8 +4,8 @@ import "github.com/devsy-org/devsy/pkg/client" type noopCollector struct{} -func (n *noopCollector) RecordCLI(err error) {} -func (n *noopCollector) RecordWorkspaceGauge(count int) {} -func (n *noopCollector) SetClient(client client.BaseWorkspaceClient) {} +func (n *noopCollector) RecordCLI(err error, snapshot MetricsSnapshot) {} +func (n *noopCollector) RecordWorkspaceGauge(count int) {} +func (n *noopCollector) SetClient(client client.BaseWorkspaceClient) {} func (n *noopCollector) Flush() {} diff --git a/pkg/telemetry/provider_metrics_test.go b/pkg/telemetry/provider_metrics_test.go new file mode 100644 index 0000000000..61e1a64eb7 --- /dev/null +++ b/pkg/telemetry/provider_metrics_test.go @@ -0,0 +1,49 @@ +package telemetry + +import ( + "context" + "testing" + "time" +) + +func TestProviderMetricsClassificationAndDuration(t *testing.T) { + m := NewMetricsReporter() + ctx := WithMetrics(context.Background(), m) + for range 2 { + RecordProviderOperation(ctx, ProviderOperation{ + ProviderType: ProviderTypeExternalSDK, Operation: "Find", + Duration: 1500 * time.Microsecond, ErrorCode: "permission_denied", + }) + } + RecordProviderOperation(ctx, ProviderOperation{ + ProviderType: ProviderType( + "private hostname", + ), + Operation: "private command", + ErrorCode: "private error", + }) + snapshot := m.Finish(nil) + assertProviderAggregates(t, snapshot) +} + +func assertProviderAggregates(t *testing.T, snapshot MetricsSnapshot) { + t.Helper() + var found, unknown bool + for _, metric := range snapshot.ProviderOperations { + if isExpectedProviderMetric(metric) { + found = true + } + if metric.ProviderType == ProviderTypeUnknown && metric.Operation == metricOther && + metric.RuntimeErrorCode == "unknown" { + unknown = true + } + } + if !found || !unknown { + t.Fatalf("unexpected aggregates: %+v", snapshot.ProviderOperations) + } +} + +func isExpectedProviderMetric(metric ProviderMetric) bool { + return metric.ProviderType == ProviderTypeExternalSDK && metric.Operation == "Find" && + metric.Count == 2 && metric.DurationMs == 3 && metric.RuntimeErrorCode == "permission_denied" +} diff --git a/pkg/telemetry/testdata/identity.json b/pkg/telemetry/testdata/identity.json new file mode 100644 index 0000000000..c3d7205bab --- /dev/null +++ b/pkg/telemetry/testdata/identity.json @@ -0,0 +1,24 @@ +{ + "version": 1, + "machine_vectors": [ + {"name":"linux-dbus-priority","platform":"linux","native_inputs":{"dbus_machine_id":" synthetic-machine-1\n","etc_machine_id":"ignored-machine-id","ioreg_output":null,"machine_guid":null},"normalized_machine_id":"synthetic-machine-1","distinct_id":"1c2e920264e22f547f8b3298338963bc8b97648b73b042be91c589808809cc1a"}, + {"name":"linux-empty-dbus","platform":"linux","native_inputs":{"dbus_machine_id":" \n","etc_machine_id":" linux-fallback-2 \n","ioreg_output":null,"machine_guid":null},"normalized_machine_id":"linux-fallback-2","distinct_id":"e8bf08432ece16e2a217c7bd4ded7c0253bf99fa580e7a4a40025c3d9e1b6510"}, + {"name":"darwin-case","platform":"darwin","native_inputs":{"dbus_machine_id":null,"etc_machine_id":null,"ioreg_output":" \"IOPlatformUUID\" = \"Mac-UUID-A1\"\n","machine_guid":null},"normalized_machine_id":"Mac-UUID-A1","distinct_id":"1b1440906c0e6750fa6580b4bca3da2f68aec3ffa405c2aeb12398167b41d551"}, + {"name":"windows-trim","platform":"windows","native_inputs":{"dbus_machine_id":null,"etc_machine_id":null,"ioreg_output":null,"machine_guid":" Win-GUID-B2 "},"normalized_machine_id":"Win-GUID-B2","distinct_id":"ae692c1f8fb03e359f5799e48a1c1c12295caf0a40710b705a31ebd8f635139a"}, + {"name":"equal-domain-input","platform":"linux","native_inputs":{"dbus_machine_id":"same-value","etc_machine_id":null,"ioreg_output":null,"machine_guid":null},"normalized_machine_id":"same-value","distinct_id":"762e2357c3da0648a1a46212c16840bb8ac66420e8b113bf32c570407e75b306"} + ], + "workspace_vectors": [ + {"name":"trusted-uid","workspace_uid":"workspace-uid-1","backend_id":"backend-1","context":"test-context","source":"git:synthetic-source","workspace_id":"37b331c6b57b53da152e64fdd3cc2ee63c1dabba2842ed5508539628f55640b9"}, + {"name":"equal-domain-input","workspace_uid":"same-value","backend_id":"different-backend","context":"other-context","source":"local:synthetic-source","workspace_id":"4b3f60d8eb570083f90afa676c07c6758a0f60bf49ee38838358610f202a563e"} + ], + "override_vectors": [ + {"name":"explicit-override","override":"already-derived","normalized_machine_id":"same-value","distinct_id":"already-derived"}, + {"name":"empty-override","override":"","normalized_machine_id":"same-value","distinct_id":"762e2357c3da0648a1a46212c16840bb8ac66420e8b113bf32c570407e75b306"} + ], + "failure_vectors": [ + {"name":"cached-random-fallback","platform":"linux","native_inputs":{"dbus_machine_id":null,"etc_machine_id":null,"ioreg_output":null,"machine_guid":null},"fallback_seed":"00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff","random_error":false,"distinct_id":"5c08544da57b6d07115af6991147e785fb33017384db3e496b518032c59bcf43"}, + {"name":"linux-unknown-does-not-fall-through","platform":"linux","native_inputs":{"dbus_machine_id":"unknown","etc_machine_id":"ignored-machine-id","ioreg_output":null,"machine_guid":null},"fallback_seed":"00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff","random_error":false,"distinct_id":"5c08544da57b6d07115af6991147e785fb33017384db3e496b518032c59bcf43"}, + {"name":"darwin-malformed","platform":"darwin","native_inputs":{"dbus_machine_id":null,"etc_machine_id":null,"ioreg_output":"IOPlatformUUID = unavailable","machine_guid":null},"fallback_seed":"00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff","random_error":false,"distinct_id":"5c08544da57b6d07115af6991147e785fb33017384db3e496b518032c59bcf43"}, + {"name":"random-failure","platform":"windows","native_inputs":{"dbus_machine_id":null,"etc_machine_id":null,"ioreg_output":null,"machine_guid":null},"fallback_seed":null,"random_error":true,"distinct_id":null} + ] +} diff --git a/pkg/transport/lifecycle.go b/pkg/transport/lifecycle.go index 30868b82ef..3833bb0b87 100644 --- a/pkg/transport/lifecycle.go +++ b/pkg/transport/lifecycle.go @@ -4,6 +4,7 @@ import ( "context" "errors" "io" + "log/slog" "net" "strings" "sync" @@ -145,10 +146,22 @@ type LogMetadata struct { } func LogClose(info CloseInfo, metadata LogMetadata) { - log.Debugw("ssh transport closed", - "reason", info.Reason, "side", info.Side, "error", info.Err, - "provider", metadata.Provider, "mode", metadata.Mode, - "workspace", metadata.Workspace, "transport_impl", metadata.TransportImpl, + log.DebugContext( + context.Background(), + "ssh transport closed", + slog.String( + "reason", + string(info.Reason), + ), + slog.String("side", string(info.Side)), + slog.Any("error", info.Err), + slog.String("provider", metadata.Provider), + slog.String("mode", metadata.Mode), + slog.String( + "workspace", + metadata.Workspace, + ), + slog.String("transport_impl", metadata.TransportImpl), ) } diff --git a/pkg/tunnel/browser.go b/pkg/tunnel/browser.go index 2337aa6848..0280534edb 100644 --- a/pkg/tunnel/browser.go +++ b/pkg/tunnel/browser.go @@ -4,6 +4,7 @@ import ( "context" "errors" "io" + "log/slog" "net" "os" "os/exec" @@ -70,11 +71,10 @@ func startBrowserTunnelSSH(ctx context.Context, p BrowserTunnelParams) error { return NewManagedSSHTunnel( ctx, func(ctx context.Context, stdin io.Reader, stdout io.Writer) error { - writer := log.Writer(log.LevelDebug) + writer := log.Writer(log.SlogLevelDebug) defer func() { _ = writer.Close() }() sshCmd, err := CreateSSHCommand(ctx, p.Client, p.User, []string{ - names.FlagValue(names.LogOutput, "raw"), names.FlagValue(names.ReuseSSHAuthSock, p.AuthSockID), names.Flag(names.Stdio), }) @@ -134,7 +134,11 @@ func runPreparedBrowserServices( run func(func(credentials.Readiness)) error, ) error { return run(func(status credentials.Readiness) { - log.Debugw("browser credentials prepared", "status", status.GitHubState) + log.DebugContext( + ctx, + "browser credentials prepared", + slog.String("status", status.GitHubState), + ) notifyBrowserPrepared(ctx, p) }) } @@ -143,7 +147,12 @@ func notifyBrowserPrepared(ctx context.Context, p BrowserTunnelParams) { if ctx.Err() != nil { return } - log.Infow("browser tunnel ready", "url", p.TargetURL, "done", "true") + log.InfoContext( + ctx, + "browser tunnel ready", + slog.String("url", p.TargetURL), + slog.String("done", "true"), + ) if p.OnPrepared != nil { p.OnPrepared(ctx) } @@ -171,7 +180,7 @@ func SetupBackhaul( log.Info("Setting up backhaul SSH connection") - writer := log.Writer(log.LevelInfo) + writer := log.Writer(log.SlogLevelInfo) defer func() { _ = writer.Close() }() // 5 steps × 200ms ≈ 1s covers the workspace.json atomic-rename window @@ -229,13 +238,10 @@ func buildBackhaulCmd(ctx context.Context, p backhaulCmdParams) *exec.Cmd { names.Flag(names.Context), p.client.Context(), p.client.Workspace(), - names.FlagValue(names.LogOutput, "raw"), names.Flag(names.Command), "while true; do sleep 6000000; done", // sleep infinity is not available on all systems ) - if log.DebugEnabled() { - cmd.Args = append(cmd.Args, names.Flag(names.Debug)) - } + cmd.Args = append(cmd.Args, log.ForwardFlagArgs()...) cmd.Stdout = p.writer cmd.Stderr = p.writer return cmd @@ -281,7 +287,6 @@ func CreateSSHCommand( clientContext: client.Context(), workspace: client.Workspace(), user: user, - debug: log.DebugEnabled(), extraArgs: extraArgs, }) @@ -295,7 +300,6 @@ type sshCommandArgsParams struct { clientContext string workspace string user string - debug bool extraArgs []string } @@ -315,9 +319,7 @@ func buildSSHCommandArgs(p sshCommandArgsParams) []string { p.clientContext, p.workspace, } - if p.debug { - args = append(args, names.Flag(names.Debug)) - } + args = append(args, log.ForwardFlagArgs()...) args = append(args, p.extraArgs...) return args } diff --git a/pkg/tunnel/browser_test.go b/pkg/tunnel/browser_test.go index 596e9d2fe7..98f35d0866 100644 --- a/pkg/tunnel/browser_test.go +++ b/pkg/tunnel/browser_test.go @@ -11,6 +11,7 @@ import ( client2 "github.com/devsy-org/devsy/pkg/client" "github.com/devsy-org/devsy/pkg/exitcode" + "github.com/devsy-org/devsy/pkg/log" "github.com/devsy-org/devsy/pkg/provider" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" @@ -64,10 +65,11 @@ func exitError(t *testing.T, code int) error { } func baseSSHArgs(ctx, user, ws string) []string { - return []string{ + args := []string{ "workspace", "ssh", "--user=" + user, "--agent-forwarding=false", "--start-services=false", "--context", ctx, ws, } + return append(args, log.ForwardFlagArgs()...) } func baseParams(user string) sshCommandArgsParams { @@ -97,34 +99,14 @@ func TestBuildSSHCommandArgs(t *testing.T) { params: baseParams(""), expected: baseSSHArgs(testCtxName, testUserRoot, testWorkspaceName), }, - { - name: "with debug", - params: sshCommandArgsParams{ - clientContext: testCtxName, workspace: testWorkspaceName, - user: testUserVSCode, debug: true, - }, - expected: append( - baseSSHArgs(testCtxName, testUserVSCode, testWorkspaceName), "--debug", - ), - }, { name: "with extra args", params: sshCommandArgsParams{ clientContext: "prod", workspace: "ws", user: testUserVSCode, - extraArgs: []string{"--stdio", "--log-output=raw"}, - }, - expected: append( - baseSSHArgs("prod", testUserVSCode, "ws"), "--stdio", "--log-output=raw", - ), - }, - { - name: "with debug and extra args", - params: sshCommandArgsParams{ - clientContext: testCtxName, workspace: testWorkspaceName, user: testUserVSCode, - debug: true, extraArgs: []string{"--stdio"}, + extraArgs: []string{"--stdio"}, }, expected: append( - baseSSHArgs(testCtxName, testUserVSCode, testWorkspaceName), "--debug", "--stdio", + baseSSHArgs("prod", testUserVSCode, "ws"), "--stdio", ), }, } diff --git a/pkg/tunnel/container.go b/pkg/tunnel/container.go index 101421b3a2..3cf85b65e5 100644 --- a/pkg/tunnel/container.go +++ b/pkg/tunnel/container.go @@ -8,6 +8,7 @@ import ( "context" "fmt" "io" + "strings" "sync" "time" @@ -132,9 +133,12 @@ func (c *ContainerTunnel) runHostTunnel( defer closeAndDrain() defer log.Debugf("Tunnel to host closed") - command := shellescape.Quote(c.client.AgentPath()) + " internal ssh-server --stdio" - if log.DebugEnabled() { - command += " --debug" + var command strings.Builder + command.WriteString(shellescape.Quote(c.client.AgentPath())) + command.WriteString(" internal ssh-server --stdio") + for _, arg := range log.ForwardFlagArgs() { + command.WriteByte(' ') + command.WriteString(shellescape.Quote(arg)) } return agent.InjectAgent(ctx, &agent.InjectOptions{ Exec: func(ctx context.Context, command string, stdin io.Reader, stdout io.Writer, stderr io.Writer) error { @@ -149,7 +153,7 @@ func (c *ContainerTunnel) runHostTunnel( IsLocal: c.client.AgentLocal(), RemoteAgentPath: c.client.AgentPath(), DownloadURL: c.client.AgentURL(), - Command: command, + Command: command.String(), Stdin: stdinReader, Stdout: stdoutWriter, Stderr: writer, @@ -188,19 +192,26 @@ func (c *ContainerTunnel) updateConfig(ctx context.Context, sshClient *ssh.Clien } buf := &containerTunnelOutput{} - command := fmt.Sprintf( + var command strings.Builder + _, _ = fmt.Fprintf( + &command, "%s internal agent workspace update-config --workspace-info %s", shellescape.Quote(c.client.AgentPath()), shellescape.Quote(workspaceInfo), ) if agentInfo.Agent.DataPath != "" { - command += " --agent-dir " + shellescape.Quote(agentInfo.Agent.DataPath) + command.WriteString(" --agent-dir ") + command.WriteString(shellescape.Quote(agentInfo.Agent.DataPath)) + } + for _, arg := range log.ForwardFlagArgs() { + command.WriteByte(' ') + command.WriteString(shellescape.Quote(arg)) } - log.Debugf("Run command in container: %s", command) + log.Debugf("Run command in container: %s", command.String()) err = devssh.Run(ctx, devssh.RunOptions{ Client: sshClient, - Command: command, + Command: command.String(), Stdout: buf, Stderr: buf, }) @@ -228,16 +239,15 @@ func (c *ContainerTunnel) runInContainer( writer, closeAndDrain := internalProcessStderr(log.PassthroughWriter()) defer closeAndDrain() - command := fmt.Sprintf( - "%s internal agent container-tunnel --workspace-info %s", - shellescape.Quote(c.client.AgentPath()), - shellescape.Quote(workspaceInfo), - ) - if log.DebugEnabled() { - command += " --debug" + var command strings.Builder + _, _ = fmt.Fprintf(&command, "%s internal agent container-tunnel --workspace-info %s", + shellescape.Quote(c.client.AgentPath()), shellescape.Quote(workspaceInfo)) + for _, arg := range log.ForwardFlagArgs() { + command.WriteByte(' ') + command.WriteString(shellescape.Quote(arg)) } containerConn, err := devssh.OpenSessionConn(ctx, sshClient, devssh.SessionConnOptions{ - Command: command, + Command: command.String(), Env: envVars, Stderr: writer, }) diff --git a/pkg/tunnel/container_host_test.go b/pkg/tunnel/container_host_test.go index 26dbf24948..cf851d7398 100644 --- a/pkg/tunnel/container_host_test.go +++ b/pkg/tunnel/container_host_test.go @@ -8,10 +8,12 @@ import ( "crypto/ecdsa" "crypto/elliptic" "crypto/rand" + "io" "net" "os" "path/filepath" "strings" + "sync/atomic" "testing" "time" @@ -29,15 +31,21 @@ const hostTunnelStdioFlag = "--stdio" type localHostTunnelClient struct { client.WorkspaceClient - path string - info string - dataPath string - refresh func(context.Context) error + path string + info string + dataPath string + refresh func(context.Context) error + pathCalls *atomic.Int32 } -func (c localHostTunnelClient) AgentPath() string { return c.path } -func (localHostTunnelClient) AgentURL() string { return "" } -func (localHostTunnelClient) AgentLocal() bool { return true } +func (c localHostTunnelClient) AgentPath() string { + if c.pathCalls != nil { + c.pathCalls.Add(1) + } + return c.path +} +func (localHostTunnelClient) AgentURL() string { return "" } +func (localHostTunnelClient) AgentLocal() bool { return true } func (c localHostTunnelClient) AgentInfo( provider.CLIOptions, @@ -54,25 +62,75 @@ func (c localHostTunnelClient) RefreshOptions(ctx context.Context, _ []string, _ func TestHostTunnelExecutesLiteralAgentPath(t *testing.T) { for _, name := range []string{"agent space", "agent'quote", "agent '\\$-\u03bb;$(false)"} { t.Run(name, func(t *testing.T) { - path := filepath.Join(t.TempDir(), name) - writeHostAgent(t, path, "#!/bin/sh\nprintf '%s\\000' \"$0\" \"$@\"\ncat\n") + dir := t.TempDir() + path := filepath.Join(dir, name) + events := filepath.Join(dir, "events") + stderr := filepath.Join(dir, "stderr") + t.Setenv("DEVSY_TEST_HOST_TUNNEL_EVENTS", events) + t.Setenv("DEVSY_TEST_HOST_TUNNEL_STDERR", stderr) + t.Setenv("DEVSY_TEST_HOST_TUNNEL_LEVEL", log.LevelString()) + script := `#!/bin/sh +exec 2>>"$DEVSY_TEST_HOST_TUNNEL_STDERR" +printf 'child_started\n' >>"$DEVSY_TEST_HOST_TUNNEL_EVENTS" +if [ "$#" -eq 5 ] && [ "$1" = internal ] && [ "$2" = ssh-server ] && [ "$3" = --stdio ] && + [ "$4" = --log-level ] && [ "$5" = "$DEVSY_TEST_HOST_TUNNEL_LEVEL" ]; then + printf 'command_admitted\n' >>"$DEVSY_TEST_HOST_TUNNEL_EVENTS" +else + printf 'command_mismatch\n' >>"$DEVSY_TEST_HOST_TUNNEL_EVENTS" +fi +printf '%s\000' "$0" "$@" +printf 'child_stdout_written\n' >>"$DEVSY_TEST_HOST_TUNNEL_EVENTS" +cat +result=$? +printf 'child_completed\n' >>"$DEVSY_TEST_HOST_TUNNEL_EVENTS" +exit "$result" +` + writeHostAgent(t, path, script) var stdout bytes.Buffer - tunnel := NewContainerTunnel(localHostTunnelClient{path: path}) + var pathCalls atomic.Int32 + tunnel := NewContainerTunnel(localHostTunnelClient{path: path, pathCalls: &pathCalls}) ctx, cancel := context.WithTimeout(t.Context(), 5*time.Second) defer cancel() - require.NoError( - t, - tunnel.runHostTunnel(ctx, strings.NewReader("host-input\n"), &stdout, time.Second), + err := tunnel.runHostTunnel( + ctx, + strings.NewReader("host-input\n"), + &stdout, + time.Second, ) - args := []string{path, "internal", "ssh-server", hostTunnelStdioFlag} - if log.DebugEnabled() { - args = append(args, "--debug") + if err != nil { + t.Fatalf( + "host tunnel failed: %v; path lookups=%d; output bytes=%d; events=%q; child stderr=%q", + err, + pathCalls.Load(), + stdout.Len(), + readHostFixtureDiagnostic(events), + readHostFixtureDiagnostic(stderr), + ) } + phases := readHostFixtureDiagnostic(events) + require.Contains(t, phases, "command_admitted\n") + require.Contains(t, phases, "child_stdout_written\n") + require.Contains(t, phases, "child_completed\n") + args := []string{path, "internal", "ssh-server", hostTunnelStdioFlag} + args = append(args, log.ForwardFlagArgs()...) require.Equal(t, strings.Join(args, "\x00")+"\x00host-input\n", stdout.String()) }) } } +func readHostFixtureDiagnostic(path string) string { + f, err := os.Open(path) + if err != nil { + return "" + } + defer func() { _ = f.Close() }() + data, err := io.ReadAll(io.LimitReader(f, 4096)) + if err != nil { + return "" + } + return string(data) +} + func TestContainerTunnelPreservesLiteralHostArguments(t *testing.T) { for _, mode := range []string{"container-tunnel", "update-config"} { t.Run(mode, func(t *testing.T) { @@ -115,15 +173,14 @@ func TestContainerTunnelPreservesLiteralHostArguments(t *testing.T) { "--agent-dir", workspace.dataPath, ) + args = append(args, log.ForwardFlagArgs()...) } else { _ = tunnel.runInContainer(ctx, client, func(context.Context, *ssh.Client) error { t.Error("fixture does not serve an inner SSH connection") return nil }, nil) args = append(args, mode, "--workspace-info", workspace.info) - if log.DebugEnabled() { - args = append(args, "--debug") - } + args = append(args, log.ForwardFlagArgs()...) } got, err := root.ReadFile("arguments") require.NoError(t, err) diff --git a/pkg/tunnel/dial.go b/pkg/tunnel/dial.go index e7596e18e2..e9a8a6ffb9 100644 --- a/pkg/tunnel/dial.go +++ b/pkg/tunnel/dial.go @@ -45,7 +45,7 @@ func (d *WorkspaceDialer) Dial(ctx context.Context) (io.ReadWriteCloser, error) // #nosec G204 -- binary is self-referencing executable cmd := exec.CommandContext(ctx, binary, args...) cmd.WaitDelay = 5 * time.Second - cmd.Stderr = log.Writer(log.LevelDebug) + cmd.Stderr = log.Writer(log.SlogLevelDebug) stdin, err := cmd.StdinPipe() if err != nil { diff --git a/pkg/tunnel/pipebridge_test.go b/pkg/tunnel/pipebridge_test.go index 4005aaa685..ae5269f040 100644 --- a/pkg/tunnel/pipebridge_test.go +++ b/pkg/tunnel/pipebridge_test.go @@ -11,8 +11,6 @@ import ( "github.com/devsy-org/devsy/pkg/log" "github.com/devsy-org/devsy/pkg/util/goleaktest" - "go.uber.org/zap/zapcore" - "go.uber.org/zap/zaptest/observer" ) func TestMain(m *testing.M) { @@ -323,9 +321,9 @@ func TestRunPairLogsParentCancellationDetails(t *testing.T) { } } -func capturePipeBridgeLogs(t *testing.T) *observer.ObservedLogs { +func capturePipeBridgeLogs(t *testing.T) *log.ObservedLogs { t.Helper() - return log.InitTestObserved(t, zapcore.DebugLevel) + return log.InitTestObserved(t, log.SlogLevelDebug) } func TestRunPairPipesClosedAfterReturn(t *testing.T) { diff --git a/pkg/tunnel/services.go b/pkg/tunnel/services.go index 2cf4f1a32b..6e6faffd8f 100644 --- a/pkg/tunnel/services.go +++ b/pkg/tunnel/services.go @@ -33,7 +33,6 @@ import ( ) const ( - debugFlag = " --debug" defaultExitTimeout = 5 * time.Second maxRetrySteps = 10 retryDuration = 1 * time.Second @@ -198,8 +197,8 @@ func formatCredentialsCommand(opts RunServicesOptions, gitSSHSigningKey string) if opts.ForwardPorts { command += " --forward-ports" } - if log.DebugEnabled() { - command += debugFlag + for _, arg := range log.ForwardFlagArgs() { + command += " " + shellescape.Quote(arg) } return command } diff --git a/pkg/tunnel/services_preparation_test.go b/pkg/tunnel/services_preparation_test.go index 78b00f1c80..e91d82bb25 100644 --- a/pkg/tunnel/services_preparation_test.go +++ b/pkg/tunnel/services_preparation_test.go @@ -10,7 +10,6 @@ import ( "github.com/devsy-org/devsy/pkg/credentials" "github.com/devsy-org/devsy/pkg/log" "github.com/stretchr/testify/require" - "go.uber.org/zap/zapcore" ) func TestServicePreparationWaitsForInstallAndServingWithoutEndingLifetime(t *testing.T) { @@ -151,7 +150,7 @@ func TestServicePreparationReportsFailureThroughoutServiceLifetime(t *testing.T) {name: cancelledPreparation, enabled: true, cancelled: true}, } { t.Run(tc.name, func(t *testing.T) { - logs := log.InitTestObserved(t, zapcore.WarnLevel) + logs := log.InitTestObserved(t, log.SlogLevelWarn) ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second) defer cancel() fail := make(chan struct{}) diff --git a/sites/docs-devsy-sh/content/docs/developing-in-workspaces/continuous-integration.mdx b/sites/docs-devsy-sh/content/docs/developing-in-workspaces/continuous-integration.mdx index bf74541203..c91dd6daa9 100644 --- a/sites/docs-devsy-sh/content/docs/developing-in-workspaces/continuous-integration.mdx +++ b/sites/docs-devsy-sh/content/docs/developing-in-workspaces/continuous-integration.mdx @@ -68,7 +68,7 @@ diagnostics or the command's own output. | Output | Effect of `--no-status` | | --- | --- | | Devsy progress | Hidden, including progress from the nested workspace command | -| Devsy diagnostics | Still controlled by `--quiet`, `--log-level`, and diagnostic format | +| Devsy diagnostics | Still controlled by `--log-level` and `--log-format` | | Command stdout and stderr | Preserved on their original streams | | Recorded events | Still recorded where the command already records them | @@ -78,16 +78,13 @@ For example, keep warnings and errors while hiding progress: devsy ci --no-status --result-format=plain --log-level=warn . -- bash .tools/test.sh ``` -To show only errors, use `--quiet` instead. It takes precedence over -`--log-level=warn` and suppresses warnings too: +To show only errors, use `--log-level=error`: ```sh -devsy ci --no-status --result-format=plain --quiet . -- bash .tools/test.sh +devsy ci --no-status --result-format=plain --log-level=error . -- bash .tools/test.sh ``` -When stdout is redirected, use `--result-format=plain` to keep the success -result JSON off stderr. Use `--result-format=json` when the caller needs the -structured result. +`--result-format` selects Devsy metadata, not the command's output. CI and workspace exec preserve child stdout and stderr as raw bytes and retain the child's exit code. Devsy may also write diagnostics and control metadata to stderr. Arbitrary child bytes can mix with those records, so stderr is not reliably parseable as newline-delimited JSON. ## Setup history after cleanup diff --git a/sites/docs-devsy-sh/content/docs/developing-providers/driver.mdx b/sites/docs-devsy-sh/content/docs/developing-providers/driver.mdx index 52b383fd71..9712e3ebe9 100644 --- a/sites/docs-devsy-sh/content/docs/developing-providers/driver.mdx +++ b/sites/docs-devsy-sh/content/docs/developing-providers/driver.mdx @@ -5,7 +5,7 @@ sidebar_label: Drivers A driver decides how Devsy deploys the workspace container. Set it with `driver` in the [agent section](./agent.mdx). The default is `docker`. -Built-in drivers: `docker`, `kubernetes`, `apple`, `microsandbox` and `custom`. The `external` driver runs a runtime plugin and is [described below](#external-driver). +Built-in drivers include `docker`, `kubernetes`, `apple`, `microsandbox` and `custom`. The built-in providers include Apple, Docker, Kubernetes, MicroSandbox and Podman. The `external` driver runs a runtime plugin and is [described below](#external-driver). ## Docker driver diff --git a/sites/docs-devsy-sh/content/docs/developing-providers/quickstart.mdx b/sites/docs-devsy-sh/content/docs/developing-providers/quickstart.mdx index 618451452d..0510564cc8 100644 --- a/sites/docs-devsy-sh/content/docs/developing-providers/quickstart.mdx +++ b/sites/docs-devsy-sh/content/docs/developing-providers/quickstart.mdx @@ -78,6 +78,12 @@ Cancellation cannot interrupt an arbitrary blocked reader or writer. File cancel - Devsy does not close caller-owned input or global standard input. Machine command transports close their own pipe endpoints when the original context is cancelled. - Keep draining output after standard input reaches EOF. Input and output can close independently. +### Logging and output + +Write diagnostics to stderr. Keep stdout reserved for provider results, status tokens, plugin handshakes, and transported command bytes. Do not wrap or rewrite command streams. Structured diagnostics use `ts`, `level`, and `msg` with typed attributes, snake_case keys, and static messages. Go providers should use `log.*Context` and canonical attribute constructors. Existing formatted and unstructured logging calls remain supported during migration. + +Honor `DEVSY_LOG_LEVEL`. The standalone provider default is `info`. Devsy forwards its effective level to child processes. Never log credentials, environment contents, command arguments, private paths, or raw backend payloads. Review diagnostics before sharing them. + ### Windows compatibility On Windows, Devsy runs these scripts in an [emulated shell](https://github.com/mvdan/sh). It does not provide `grep` or `sed`. Put that logic in a helper binary or require the user to install those tools. diff --git a/sites/docs-devsy-sh/content/docs/managing-providers/microsandbox.mdx b/sites/docs-devsy-sh/content/docs/managing-providers/microsandbox.mdx index 3ae347600c..a1be8b31bc 100644 --- a/sites/docs-devsy-sh/content/docs/managing-providers/microsandbox.mdx +++ b/sites/docs-devsy-sh/content/docs/managing-providers/microsandbox.mdx @@ -68,7 +68,7 @@ Set options in Desktop or with `devsy provider set microsandbox -o KEY=value`. I If the runtime version cannot be recognized, update it with `msb self update`. If inspect output cannot be parsed, the provider reports the runtime version and an incompatibility reporting link. For a relocated runtime, set both executable and firmware paths. A partial pair fails instead of selecting another installation. The installed adapter's `runtime-check` command checks the pair and version without starting a VM, although it can initialize the native library cache. -An invalid option value stops the workspace from starting and Devsy shows the cause in its normal output, for example `invalid MICROSANDBOX_MEMORY: ...` for `MICROSANDBOX_MEMORY=abc`, or `host-perms=mirror requires workspace stat virtualization` when `MICROSANDBOX_WORKSPACE_STAT_VIRTUALIZATION` is `off` with `mirror` permissions. Before provider v1.0.5, Devsy showed only `Unrecognized remote plugin message` and `runtime supervisor failed`, and `--debug` was needed to see the cause. +An invalid option value stops the workspace from starting and Devsy shows the cause in its normal output, for example `invalid MICROSANDBOX_MEMORY: ...` for `MICROSANDBOX_MEMORY=abc`, or `host-perms=mirror requires workspace stat virtualization` when `MICROSANDBOX_WORKSPACE_STAT_VIRTUALIZATION` is `off` with `mirror` permissions. Use `--log-level=debug` for additional diagnostics. `msb` rejects a bind mount host path that goes through a symbolic link, such as `/tmp` or `/var` on macOS. The provider resolves symbolic links in bind mount host paths, so a project folder under `/tmp` works. Before provider v1.0.5, this failed with `bind mount host path ... goes through symlink /tmp`, and the workaround was the resolved path, for example `/private/tmp/project`. diff --git a/sites/docs-devsy-sh/content/docs/troubleshooting/troubleshooting.mdx b/sites/docs-devsy-sh/content/docs/troubleshooting/troubleshooting.mdx index 83562a0849..fb5cd1e6e0 100644 --- a/sites/docs-devsy-sh/content/docs/troubleshooting/troubleshooting.mdx +++ b/sites/docs-devsy-sh/content/docs/troubleshooting/troubleshooting.mdx @@ -20,7 +20,7 @@ Port forwarding needs an open SSH session. With `--ide none`, keep one open with ### Reading CLI errors -Pass `--log-output json` to get errors as JSON with a stable `code` and a `message`. Some errors also include a `hint` and a `context` object. +Use `--log-format=json` to get ordinary command errors on stderr as JSON with a stable `code` and a `message`. Some errors also include a `hint` and a `context` object. Use `--result-format=json` for command results on stdout. It does not select the stderr error format. ```json { @@ -43,7 +43,21 @@ Pass `--log-output json` to get errors as JSON with a stable `code` and a `messa | `PANIC` | Devsy hit an internal error. Report it. | | `UNKNOWN` | The error was not classified. The original text is in `message`. | -Run with `--debug` to see the full error chain. +Run with `--log-level=debug` to see the full error chain. + +The CLI defaults to warning level. Set `--log-level` or `DEVSY_LOG_LEVEL` to `error`, `warn`, `info`, `debug`, or `trace`. The context option `LOG_LEVEL` is the fallback when neither is set. Standalone agents and providers default to `info`. + +Set `--log-format` or `DEVSY_LOG_FORMAT` to `auto`, `text`, `plain`, `json`, or `logfmt`. `plain` is an alias for `text`. Auto selects text for a terminal and JSON for pipes, the UI, and internal commands. Set `--result-format` or `DEVSY_RESULT_FORMAT` to select result rendering. `text` is an alias for `plain`. Ordinary commands write results and status to stdout and diagnostics and errors to stderr. + +The old debug, verbose, quiet, and log output flags are no longer accepted. Use the level and format flags instead. Provider versions JSON now uses the global `--result-format=json` selector instead of a command-specific JSON flag. Upgrade Desktop and the CLI together because older versions can use incompatible flags. The analytics identity has also changed, so events recorded after the cutover are not linked to earlier identities. + +### Export local metrics + +Set `DEVSY_METRICS_FILE` to opt in to local metrics export. Devsy appends one bounded JSONL snapshot per invocation with duration, phase, error, and provider operation summaries. + +The destination must be a private regular file owned by the current user. Devsy creates a missing file with private permissions, but its parent directories must already exist. Symlinks, nonregular files, and existing files with unsafe access are rejected. Lock waits are bounded. + +Export failures are sanitized and do not change the command exit status. Local export works when network telemetry is disabled. An early environment parsing failure can exit before a snapshot is recorded. ### Find the right log @@ -109,11 +123,11 @@ A failed hook is still a successful read. The command exits zero and returns the ### Hide live progress while keeping diagnostics -Pass `--no-status` to hide live progress messages. Diagnostics still follow `--quiet`, `--log-level` and the diagnostic format settings. A command's stdout and stderr stay on their original streams, and event and task recording continue. The flag does not turn off capture or history. `--quiet` also leaves capture on, and setup history stays readable with both flags. +Pass `--no-status` or set `DEVSY_NO_STATUS` to hide live progress messages. Diagnostics still follow `--log-level` and `--log-format`. Event and task recording continue. The flag does not turn off capture or history. CI and workspace exec preserve raw child streams, and their stderr can also contain Devsy diagnostics and control metadata. ### VS Code editor launch diagnostics -For VS Code, VSCodium and related editors, a failed CLI launch records the `flavor`, `operation`, `route`, failed `stage` and failure `class`, such as `exit status 1` or `permission denied`. A successful URI-handler fallback does not erase that CLI warning. With `--debug`, the logs also record executable resolution, extension enumeration and installation, and dispatch stages. Use the `operation` value to match records in the workspace task's logs. +For VS Code, VSCodium and related editors, a failed CLI launch records the `flavor`, `operation`, `route`, failed `stage` and failure `class`, such as `exit status 1` or `permission denied`. A successful URI-handler fallback does not erase that CLI warning. With `--log-level=debug`, the logs also record executable resolution, extension enumeration and installation, and dispatch stages. Use the `operation` value to match records in the workspace task's logs. Diagnostics omit executable paths, command arguments, folder URIs, editor output and error text, because these can contain private paths, host names or credentials. Failure classes and stage names remain. The `cli_kind` value names an executable or batch wrapper. It does not show that a Windows wrapper ran. diff --git a/sites/docs-devsy-sh/content/docs/tutorials/docker-provider-via-wsl.mdx b/sites/docs-devsy-sh/content/docs/tutorials/docker-provider-via-wsl.mdx index c0304d99e9..3ce6fb9b2f 100644 --- a/sites/docs-devsy-sh/content/docs/tutorials/docker-provider-via-wsl.mdx +++ b/sites/docs-devsy-sh/content/docs/tutorials/docker-provider-via-wsl.mdx @@ -89,7 +89,7 @@ devsy workspace up In VS Code or VSCodium with the [Open Remote - SSH](https://marketplace.visualstudio.com/items?itemName=jeanp413.open-remote-ssh) extension, choose **Open Folder in Remote...** and select that host. Devsy tunnels the session into the dev container, so you need no jump host. -The tunnel uses your local SSH keys and agent. If the editor log shows `write EPIPE`, run `devsy workspace up` with `DEVSY_DEBUG=true` to see the cause, such as a stopped WSL SSH server or an untrusted host key. +The tunnel uses your local SSH keys and agent. If the editor log shows `write EPIPE`, run `devsy workspace up --log-level=debug` to see the cause, such as a stopped WSL SSH server or an untrusted host key. ## Next steps From 13176f48e50707c7f63211636b5a80f2b239041c Mon Sep 17 00:00:00 2001 From: Samuel K Date: Tue, 17 Nov 2026 12:39:06 -0600 Subject: [PATCH 02/11] style(telemetry): format shared identity fixture --- pkg/telemetry/testdata/identity.json | 153 ++++++++++++++++++++++++--- 1 file changed, 140 insertions(+), 13 deletions(-) diff --git a/pkg/telemetry/testdata/identity.json b/pkg/telemetry/testdata/identity.json index c3d7205bab..886d520be1 100644 --- a/pkg/telemetry/testdata/identity.json +++ b/pkg/telemetry/testdata/identity.json @@ -1,24 +1,151 @@ { "version": 1, "machine_vectors": [ - {"name":"linux-dbus-priority","platform":"linux","native_inputs":{"dbus_machine_id":" synthetic-machine-1\n","etc_machine_id":"ignored-machine-id","ioreg_output":null,"machine_guid":null},"normalized_machine_id":"synthetic-machine-1","distinct_id":"1c2e920264e22f547f8b3298338963bc8b97648b73b042be91c589808809cc1a"}, - {"name":"linux-empty-dbus","platform":"linux","native_inputs":{"dbus_machine_id":" \n","etc_machine_id":" linux-fallback-2 \n","ioreg_output":null,"machine_guid":null},"normalized_machine_id":"linux-fallback-2","distinct_id":"e8bf08432ece16e2a217c7bd4ded7c0253bf99fa580e7a4a40025c3d9e1b6510"}, - {"name":"darwin-case","platform":"darwin","native_inputs":{"dbus_machine_id":null,"etc_machine_id":null,"ioreg_output":" \"IOPlatformUUID\" = \"Mac-UUID-A1\"\n","machine_guid":null},"normalized_machine_id":"Mac-UUID-A1","distinct_id":"1b1440906c0e6750fa6580b4bca3da2f68aec3ffa405c2aeb12398167b41d551"}, - {"name":"windows-trim","platform":"windows","native_inputs":{"dbus_machine_id":null,"etc_machine_id":null,"ioreg_output":null,"machine_guid":" Win-GUID-B2 "},"normalized_machine_id":"Win-GUID-B2","distinct_id":"ae692c1f8fb03e359f5799e48a1c1c12295caf0a40710b705a31ebd8f635139a"}, - {"name":"equal-domain-input","platform":"linux","native_inputs":{"dbus_machine_id":"same-value","etc_machine_id":null,"ioreg_output":null,"machine_guid":null},"normalized_machine_id":"same-value","distinct_id":"762e2357c3da0648a1a46212c16840bb8ac66420e8b113bf32c570407e75b306"} + { + "name": "linux-dbus-priority", + "platform": "linux", + "native_inputs": { + "dbus_machine_id": " synthetic-machine-1\n", + "etc_machine_id": "ignored-machine-id", + "ioreg_output": null, + "machine_guid": null + }, + "normalized_machine_id": "synthetic-machine-1", + "distinct_id": "1c2e920264e22f547f8b3298338963bc8b97648b73b042be91c589808809cc1a" + }, + { + "name": "linux-empty-dbus", + "platform": "linux", + "native_inputs": { + "dbus_machine_id": " \n", + "etc_machine_id": " linux-fallback-2 \n", + "ioreg_output": null, + "machine_guid": null + }, + "normalized_machine_id": "linux-fallback-2", + "distinct_id": "e8bf08432ece16e2a217c7bd4ded7c0253bf99fa580e7a4a40025c3d9e1b6510" + }, + { + "name": "darwin-case", + "platform": "darwin", + "native_inputs": { + "dbus_machine_id": null, + "etc_machine_id": null, + "ioreg_output": " \"IOPlatformUUID\" = \"Mac-UUID-A1\"\n", + "machine_guid": null + }, + "normalized_machine_id": "Mac-UUID-A1", + "distinct_id": "1b1440906c0e6750fa6580b4bca3da2f68aec3ffa405c2aeb12398167b41d551" + }, + { + "name": "windows-trim", + "platform": "windows", + "native_inputs": { + "dbus_machine_id": null, + "etc_machine_id": null, + "ioreg_output": null, + "machine_guid": " Win-GUID-B2 " + }, + "normalized_machine_id": "Win-GUID-B2", + "distinct_id": "ae692c1f8fb03e359f5799e48a1c1c12295caf0a40710b705a31ebd8f635139a" + }, + { + "name": "equal-domain-input", + "platform": "linux", + "native_inputs": { + "dbus_machine_id": "same-value", + "etc_machine_id": null, + "ioreg_output": null, + "machine_guid": null + }, + "normalized_machine_id": "same-value", + "distinct_id": "762e2357c3da0648a1a46212c16840bb8ac66420e8b113bf32c570407e75b306" + } ], "workspace_vectors": [ - {"name":"trusted-uid","workspace_uid":"workspace-uid-1","backend_id":"backend-1","context":"test-context","source":"git:synthetic-source","workspace_id":"37b331c6b57b53da152e64fdd3cc2ee63c1dabba2842ed5508539628f55640b9"}, - {"name":"equal-domain-input","workspace_uid":"same-value","backend_id":"different-backend","context":"other-context","source":"local:synthetic-source","workspace_id":"4b3f60d8eb570083f90afa676c07c6758a0f60bf49ee38838358610f202a563e"} + { + "name": "trusted-uid", + "workspace_uid": "workspace-uid-1", + "backend_id": "backend-1", + "context": "test-context", + "source": "git:synthetic-source", + "workspace_id": "37b331c6b57b53da152e64fdd3cc2ee63c1dabba2842ed5508539628f55640b9" + }, + { + "name": "equal-domain-input", + "workspace_uid": "same-value", + "backend_id": "different-backend", + "context": "other-context", + "source": "local:synthetic-source", + "workspace_id": "4b3f60d8eb570083f90afa676c07c6758a0f60bf49ee38838358610f202a563e" + } ], "override_vectors": [ - {"name":"explicit-override","override":"already-derived","normalized_machine_id":"same-value","distinct_id":"already-derived"}, - {"name":"empty-override","override":"","normalized_machine_id":"same-value","distinct_id":"762e2357c3da0648a1a46212c16840bb8ac66420e8b113bf32c570407e75b306"} + { + "name": "explicit-override", + "override": "already-derived", + "normalized_machine_id": "same-value", + "distinct_id": "already-derived" + }, + { + "name": "empty-override", + "override": "", + "normalized_machine_id": "same-value", + "distinct_id": "762e2357c3da0648a1a46212c16840bb8ac66420e8b113bf32c570407e75b306" + } ], "failure_vectors": [ - {"name":"cached-random-fallback","platform":"linux","native_inputs":{"dbus_machine_id":null,"etc_machine_id":null,"ioreg_output":null,"machine_guid":null},"fallback_seed":"00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff","random_error":false,"distinct_id":"5c08544da57b6d07115af6991147e785fb33017384db3e496b518032c59bcf43"}, - {"name":"linux-unknown-does-not-fall-through","platform":"linux","native_inputs":{"dbus_machine_id":"unknown","etc_machine_id":"ignored-machine-id","ioreg_output":null,"machine_guid":null},"fallback_seed":"00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff","random_error":false,"distinct_id":"5c08544da57b6d07115af6991147e785fb33017384db3e496b518032c59bcf43"}, - {"name":"darwin-malformed","platform":"darwin","native_inputs":{"dbus_machine_id":null,"etc_machine_id":null,"ioreg_output":"IOPlatformUUID = unavailable","machine_guid":null},"fallback_seed":"00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff","random_error":false,"distinct_id":"5c08544da57b6d07115af6991147e785fb33017384db3e496b518032c59bcf43"}, - {"name":"random-failure","platform":"windows","native_inputs":{"dbus_machine_id":null,"etc_machine_id":null,"ioreg_output":null,"machine_guid":null},"fallback_seed":null,"random_error":true,"distinct_id":null} + { + "name": "cached-random-fallback", + "platform": "linux", + "native_inputs": { + "dbus_machine_id": null, + "etc_machine_id": null, + "ioreg_output": null, + "machine_guid": null + }, + "fallback_seed": "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + "random_error": false, + "distinct_id": "5c08544da57b6d07115af6991147e785fb33017384db3e496b518032c59bcf43" + }, + { + "name": "linux-unknown-does-not-fall-through", + "platform": "linux", + "native_inputs": { + "dbus_machine_id": "unknown", + "etc_machine_id": "ignored-machine-id", + "ioreg_output": null, + "machine_guid": null + }, + "fallback_seed": "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + "random_error": false, + "distinct_id": "5c08544da57b6d07115af6991147e785fb33017384db3e496b518032c59bcf43" + }, + { + "name": "darwin-malformed", + "platform": "darwin", + "native_inputs": { + "dbus_machine_id": null, + "etc_machine_id": null, + "ioreg_output": "IOPlatformUUID = unavailable", + "machine_guid": null + }, + "fallback_seed": "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + "random_error": false, + "distinct_id": "5c08544da57b6d07115af6991147e785fb33017384db3e496b518032c59bcf43" + }, + { + "name": "random-failure", + "platform": "windows", + "native_inputs": { + "dbus_machine_id": null, + "etc_machine_id": null, + "ioreg_output": null, + "machine_guid": null + }, + "fallback_seed": null, + "random_error": true, + "distinct_id": null + } ] } From 1fc1229ea8b7bfa3634dbf37e48e37783f8369e3 Mon Sep 17 00:00:00 2001 From: Samuel K Date: Tue, 17 Nov 2026 13:37:02 -0600 Subject: [PATCH 03/11] fix(status): retain Desktop envelopes with hidden progress --- desktop/e2e/no-status-protocol.e2e.ts | 2 +- pkg/status/render.go | 9 +++- pkg/status/reporter_test.go | 72 +++++++++++++++++++++------ 3 files changed, 66 insertions(+), 17 deletions(-) diff --git a/desktop/e2e/no-status-protocol.e2e.ts b/desktop/e2e/no-status-protocol.e2e.ts index 31630c2a02..2df1aac999 100644 --- a/desktop/e2e/no-status-protocol.e2e.ts +++ b/desktop/e2e/no-status-protocol.e2e.ts @@ -39,7 +39,7 @@ test("candidate CLI status reaches the Desktop timeline with --no-status", () => [ "--no-status", "--result-format=json", - "--log-output=json", + "--log-format=json", "provider", "add", resolve(REPO_DIR, "providers/docker/provider.yaml"), diff --git a/pkg/status/render.go b/pkg/status/render.go index 2b5626637a..d2865ab5ae 100644 --- a/pkg/status/render.go +++ b/pkg/status/render.go @@ -35,11 +35,16 @@ const ( // NewReporter selects a status presentation. func NewReporter(opts ReporterOptions) (Reporter, error) { - r, err := newReporter(resolveFormat(opts), opts) + format := resolveFormat(opts) + desktop := os.Getenv("DEVSY_UI") == "true" + if opts.NoStatus && desktop && (format == formatPlain || format == "text") { + format = formatJSON + } + r, err := newReporter(format, opts) if err != nil { return nil, err } - if opts.NoStatus { + if opts.NoStatus && !desktop { return Nop(), nil } return r, nil diff --git a/pkg/status/reporter_test.go b/pkg/status/reporter_test.go index b2761db0c6..03d12f2555 100644 --- a/pkg/status/reporter_test.go +++ b/pkg/status/reporter_test.go @@ -10,6 +10,8 @@ import ( "github.com/stretchr/testify/require" ) +const testTextFormat = "text" + func TestNewReporter_SelectsPlainAndEnvelope(t *testing.T) { var plain bytes.Buffer plainReporter, err := NewReporter(ReporterOptions{ @@ -44,7 +46,7 @@ func TestNewReporter_SelectsPlainAndEnvelope(t *testing.T) { func TestTextFormatRendersPlain(t *testing.T) { var out bytes.Buffer - reporter, err := NewReporter(ReporterOptions{Format: "text", Out: &out}) + reporter, err := NewReporter(ReporterOptions{Format: testTextFormat, Out: &out}) if err != nil { t.Fatal(err) } @@ -117,7 +119,7 @@ func TestNewReporter_AutoRequiresEnvelopeWhenNonInteractive(t *testing.T) { func TestNewReporter_DesktopFormatPrecedence(t *testing.T) { t.Setenv("DEVSY_UI", "true") - for _, format := range []string{"plain", "text"} { + for _, format := range []string{formatPlain, testTextFormat} { var out bytes.Buffer reporter, err := NewReporter(ReporterOptions{Format: format, Out: &out, Interactive: true}) if err != nil { @@ -160,18 +162,6 @@ func TestNewReporter_NoStatus(t *testing.T) { } reporter.Report(Event{Phase: PhaseReady, State: StateStarted}) } - t.Setenv("DEVSY_UI", "true") - reporter, err := NewReporter( - ReporterOptions{ - Format: formatPlain, - NoStatus: true, - Envelope: func(Event) error { calls++; return nil }, - }, - ) - if err != nil { - t.Fatal(err) - } - reporter.Report(Event{Phase: PhaseReady, State: StateStarted}) if out.Len() != 0 || calls != 0 { t.Fatalf("suppressed output = %q, envelope calls = %d", out.String(), calls) } @@ -185,6 +175,60 @@ func TestNewReporter_NoStatus(t *testing.T) { } } +func TestNewReporter_DesktopForcesEnvelope(t *testing.T) { + t.Setenv("DEVSY_UI", "true") + var events []Event + reporter, err := NewReporter(ReporterOptions{ + Format: formatPlain, NoStatus: true, + Envelope: func(event Event) error { + events = append(events, event) + return nil + }, + }) + require.NoError(t, err) + reporter.Report(Event{Phase: PhaseReady, State: StateStarted}) + require.Len(t, events, 1) + require.Equal(t, PhaseReady, events[0].Phase) + require.Equal(t, StateStarted, events[0].State) + for _, opts := range []ReporterOptions{ + {Format: "ansi", NoStatus: true}, + {Format: formatJSON, NoStatus: true}, + {Format: formatPlain, NoStatus: true}, + } { + _, err := NewReporter(opts) + require.Error(t, err) + } +} + +func TestNewCLIReporter_NoStatusPreservesDesktopEnvelopes(t *testing.T) { + t.Setenv("DEVSY_UI", "true") + for _, format := range []string{formatAuto, formatJSON, formatPlain, testTextFormat} { + t.Run(format, func(t *testing.T) { + var events []Event + reporter, err := NewCLIReporter(CLIOptions{ + Format: format, NoStatus: true, + Envelope: func(event Event) error { + events = append(events, event) + return nil + }, + }) + require.NoError(t, err) + err = Run( + context.Background(), + reporter, + Operation{Phase: PhaseInstallingProvider}, + func(context.Context) error { return nil }, + ) + require.NoError(t, err) + require.Len(t, events, 2) + require.Equal(t, PhaseInstallingProvider, events[0].Phase) + require.Equal(t, StateStarted, events[0].State) + require.Equal(t, PhaseInstallingProvider, events[1].Phase) + require.Equal(t, StateSucceeded, events[1].State) + }) + } +} + func TestNoStatusTeePreservesRunEvents(t *testing.T) { t.Setenv("DEVSY_UI", "") var out bytes.Buffer From 787a6b447d6d29c77feaa69faf483c67f4fb788e Mon Sep 17 00:00:00 2001 From: Samuel K Date: Tue, 17 Nov 2026 13:37:38 -0600 Subject: [PATCH 04/11] refactor(desktop): simplify redaction and settings handlers --- desktop/src/main/ipc.ts | 65 +++++++---- desktop/src/main/logging.ts | 104 ++++++++++-------- .../src/pages/WorkspaceDetailPage.svelte | 27 +++-- 3 files changed, 117 insertions(+), 79 deletions(-) diff --git a/desktop/src/main/ipc.ts b/desktop/src/main/ipc.ts index 9c5b82d044..767895aa04 100644 --- a/desktop/src/main/ipc.ts +++ b/desktop/src/main/ipc.ts @@ -73,6 +73,12 @@ interface SecretIpcFailure { message: string } +interface ProtectionActionArgs { + action: string + newPassphrase?: string + currentPassphrase?: string +} + type SecretUnlockResult = (SecretIpcFailure | { ok: true }) & { remembered?: true } @@ -831,37 +837,50 @@ export function registerIpcHandlers(deps: IpcDependencies): { cli.setSessionPassphrase(value) } + function validateProtectionAction( + args: ProtectionActionArgs, + ): SecretIpcFailure | undefined { + const allowed = [ + "set-passphrase", + "change-passphrase", + "remove-passphrase", + "remember", + "forget", + ] + if (!args || typeof args !== "object" || !allowed.includes(args.action)) + return { ok: false, message: "Unknown protection action." } + return undefined + } + + function validateProtectionPassphrases( + currentPassphrase: string | undefined, + newPassphrase: string | undefined, + ): SecretIpcFailure | undefined { + if ( + currentPassphrase !== undefined && + typeof currentPassphrase !== "string" + ) + return { ok: false, message: "Enter a valid current passphrase." } + if (newPassphrase !== undefined && typeof newPassphrase !== "string") + return { ok: false, message: "Enter a non-empty passphrase." } + return undefined + } + ipcMain.handle( "secret_protection_action", - async ( - event, - args: { - action: string - newPassphrase?: string - currentPassphrase?: string - }, - ) => { + async (event, args: ProtectionActionArgs) => { const win = getMainWindow() if (!win || !isTrustedSecretIpcSender(event, win, secretDocumentURL)) return secretRequestDenied - const allowed = [ - "set-passphrase", - "change-passphrase", - "remove-passphrase", - "remember", - "forget", - ] - if (!args || typeof args !== "object" || !allowed.includes(args.action)) - return { ok: false, message: "Unknown protection action." } + const inputFailure = validateProtectionAction(args) + if (inputFailure) return inputFailure const action = args.action const { newPassphrase, currentPassphrase } = args - if ( - currentPassphrase !== undefined && - typeof currentPassphrase !== "string" + const passphraseFailure = validateProtectionPassphrases( + currentPassphrase, + newPassphrase, ) - return { ok: false, message: "Enter a valid current passphrase." } - if (newPassphrase !== undefined && typeof newPassphrase !== "string") - return { ok: false, message: "Enter a non-empty passphrase." } + if (passphraseFailure) return passphraseFailure const options: CliInvocationOptions = { allowUnlockPrompt: false, ...(currentPassphrase !== undefined diff --git a/desktop/src/main/logging.ts b/desktop/src/main/logging.ts index ede6241fca..32fcf8dd7c 100644 --- a/desktop/src/main/logging.ts +++ b/desktop/src/main/logging.ts @@ -30,52 +30,12 @@ function redactLabels(value: string): string { let copied = 0 for (let match = tokens.exec(value); match; match = tokens.exec(value)) { const start = match.index - let end = tokens.lastIndex - let label = match[0] - let candidateEnd = end - for (let parts = 0; parts < 2; parts++) { - const suffix = /^[ \t]+[a-z0-9_.-]+/i.exec( - value.slice(candidateEnd, candidateEnd + 64), - ) - if (!suffix) break - candidateEnd += suffix[0].length - const candidate = value.slice(start, candidateEnd) - if (sensitiveLabel.test(candidate)) { - end = candidateEnd - label = candidate - } - } - let next = end + const end = labelEnd(value, start, tokens.lastIndex) + const label = end === tokens.lastIndex ? match[0] : value.slice(start, end) if (!sensitiveKey.test(label)) continue - if (value[next] === '"' || value[next] === "'") next++ - while (next < value.length && /\s/.test(value[next])) next++ - if (value[next] !== ":" && value[next] !== "=") continue - next++ - while (next < value.length && /\s/.test(value[next])) next++ - const secretStart = next - const scheme = value.slice(next, next + 6).toLowerCase() - const schemeLength = scheme.startsWith("bearer") - ? 6 - : scheme.startsWith("basic") - ? 5 - : 0 - if (schemeLength && /\s/.test(value[next + schemeLength] ?? "")) { - next += schemeLength - while (next < value.length && /\s/.test(value[next])) next++ - } - const quote = - value[next] === '"' || value[next] === "'" ? value[next++] : "" - if (quote) { - while (next < value.length) { - if (value[next] === "\\") { - next = Math.min(next + 2, value.length) - } else if (value[next++] === quote) { - break - } - } - } else { - while (next < value.length && !/[\s,;]/.test(value[next])) next++ - } + const secretStart = labelValueStart(value, end) + if (secretStart < 0) continue + const next = secretEnd(value, secretStart) if (next === secretStart) continue output += `${value.slice(copied, secretStart)}***` copied = next @@ -84,6 +44,60 @@ function redactLabels(value: string): string { return output + value.slice(copied) } +function labelEnd(value: string, start: number, initialEnd: number): number { + let end = initialEnd + let candidateEnd = end + for (let parts = 0; parts < 2; parts++) { + const suffix = /^[ \t]+[a-z0-9_.-]+/i.exec( + value.slice(candidateEnd, candidateEnd + 64), + ) + if (!suffix) break + candidateEnd += suffix[0].length + const candidate = value.slice(start, candidateEnd) + if (sensitiveLabel.test(candidate)) end = candidateEnd + } + return end +} + +function skipWhitespace(value: string, next: number): number { + while (next < value.length && /\s/.test(value[next])) next++ + return next +} + +function labelValueStart(value: string, end: number): number { + let next = end + if (value[next] === '"' || value[next] === "'") next++ + next = skipWhitespace(value, next) + if (value[next] !== ":" && value[next] !== "=") return -1 + return skipWhitespace(value, next + 1) +} + +function secretEnd(value: string, start: number): number { + let next = start + const scheme = value.slice(next, next + 6).toLowerCase() + const schemeLength = scheme.startsWith("bearer") + ? 6 + : scheme.startsWith("basic") + ? 5 + : 0 + if (schemeLength && /\s/.test(value[next + schemeLength] ?? "")) { + next = skipWhitespace(value, next + schemeLength) + } + const quote = value[next] === '"' || value[next] === "'" ? value[next++] : "" + if (!quote) { + while (next < value.length && !/[\s,;]/.test(value[next])) next++ + return next + } + while (next < value.length) { + if (value[next] === "\\") { + next = Math.min(next + 2, value.length) + } else if (value[next++] === quote) { + break + } + } + return next +} + function redactText(value: string): string { let result = value const secrets = Object.entries(process.env) diff --git a/desktop/src/renderer/src/pages/WorkspaceDetailPage.svelte b/desktop/src/renderer/src/pages/WorkspaceDetailPage.svelte index 9bb0de2109..984c96c580 100644 --- a/desktop/src/renderer/src/pages/WorkspaceDetailPage.svelte +++ b/desktop/src/renderer/src/pages/WorkspaceDetailPage.svelte @@ -774,6 +774,21 @@ $effect(() => { resetPresentationEdit() }) +function presentationSaveFailure( + err: unknown, +): Partial> { + if (err instanceof WorkspaceEditError) { + const conflictNote = + err.code === "conflict" && + err.conflict && + !err.message.includes(err.conflict) + ? ` Conflicts with ${err.conflict}.` + : "" + return { [err.field]: `${err.message}${conflictNote}` } + } + return { workspace: extractErrorMessage(err) } +} + async function savePresentation() { const base = presentationBase if (!base || presentationSaving) return @@ -805,17 +820,7 @@ async function savePresentation() { toasts.success("Workspace details saved") } catch (err) { if (presentationBase !== base) return - if (err instanceof WorkspaceEditError) { - const conflictNote = - err.code === "conflict" && - err.conflict && - !err.message.includes(err.conflict) - ? ` Conflicts with ${err.conflict}.` - : "" - presentationErrors = { [err.field]: `${err.message}${conflictNote}` } - } else { - presentationErrors = { workspace: extractErrorMessage(err) } - } + presentationErrors = presentationSaveFailure(err) } finally { if (presentationBase === base) presentationSaving = false } From cf66c5fbc5c8a6450f4c55309b2775f55ea696f0 Mon Sep 17 00:00:00 2001 From: Samuel K Date: Tue, 17 Nov 2026 15:34:57 -0600 Subject: [PATCH 05/11] fix(logging): align workspace status and CI consumers --- cmd/workspace/up/status_no_status_test.go | 22 ++++++++- cmd/workspace/up/up.go | 2 +- e2e/tests/ci/ci.go | 45 +++++++++++++++++- e2e/tests/outdated/outdated.go | 4 ++ .../up/provider_microsandbox_performance.go | 35 +++++++++----- .../provider_microsandbox_performance_test.go | 47 +++++++++++++++---- 6 files changed, 130 insertions(+), 25 deletions(-) diff --git a/cmd/workspace/up/status_no_status_test.go b/cmd/workspace/up/status_no_status_test.go index afb3938a50..d2277fd704 100644 --- a/cmd/workspace/up/status_no_status_test.go +++ b/cmd/workspace/up/status_no_status_test.go @@ -2,10 +2,13 @@ package up import ( "bytes" + "encoding/json" + "io" "os" "testing" "github.com/devsy-org/devsy/cmd/flags" + config2 "github.com/devsy-org/devsy/pkg/devcontainer/config" "github.com/devsy-org/devsy/pkg/provider" "github.com/devsy-org/devsy/pkg/status" "github.com/devsy-org/devsy/pkg/task" @@ -69,7 +72,24 @@ func TestConfigureRunNoStatusPreservesJournalAndWorkerRecording(t *testing.T) { require.Equal(t, status.PhasePreparingDevContainer, events[0].Phase) require.Equal(t, status.StateSucceeded, events[1].State) require.Equal(t, status.PhaseStartingContainer, events[1].Phase) - require.Empty(t, out.String()) + if !worker { + require.Empty(t, out.String()) + return + } + decoder := json.NewDecoder(&out) + var parent, child config2.StatusEnvelope + require.NoError(t, decoder.Decode(&parent)) + require.NoError(t, decoder.Decode(&child)) + require.Equal(t, config2.KindStatus, parent.Kind) + require.Equal(t, string(status.PhasePreparingDevContainer), parent.Phase) + require.Equal(t, status.StateStarted, parent.State) + require.Equal(t, "parent", parent.OperationID) + require.Equal(t, config2.KindStatus, child.Kind) + require.Equal(t, string(status.PhaseStartingContainer), child.Phase) + require.Equal(t, status.StateSucceeded, child.State) + require.Equal(t, "child", child.OperationID) + require.Equal(t, parent.OperationID, child.ParentOperationID) + require.ErrorIs(t, decoder.Decode(&config2.StatusEnvelope{}), io.EOF) }) } } diff --git a/cmd/workspace/up/up.go b/cmd/workspace/up/up.go index 5cf83f0385..56d381de6a 100644 --- a/cmd/workspace/up/up.go +++ b/cmd/workspace/up/up.go @@ -370,7 +370,7 @@ func (cmd *UpCmd) configureRun(workspaceID string) (bool, io.Writer, error) { cmd.ResultFormat, out, log.InfoEnabled(), - cmd.NoStatus, + cmd.NoStatus && cmd.workerTask == nil, ) if err == nil { cmd.statusReporter = withJournal(cmd.statusReporter, workspaceID) diff --git a/e2e/tests/ci/ci.go b/e2e/tests/ci/ci.go index 0ed099294c..731cc91b62 100644 --- a/e2e/tests/ci/ci.go +++ b/e2e/tests/ci/ci.go @@ -4,6 +4,7 @@ import ( "bufio" "bytes" "context" + "encoding/json" "errors" "os" "os/exec" @@ -12,6 +13,7 @@ import ( "time" "github.com/devsy-org/devsy/e2e/framework" + "github.com/devsy-org/devsy/pkg/status" "github.com/devsy-org/devsy/pkg/workspace" "github.com/onsi/ginkgo/v2" "github.com/onsi/gomega" @@ -127,12 +129,51 @@ var _ = ginkgo.Describe("devsy ci test suite", ginkgo.Label("ci"), ginkgo.Ordere framework.ExpectNoError(err) gomega.Expect(stdout).To(gomega.Equal( `child-out:{"kind":"status"}{"kind":"result"}{"kind":"error"}{"kind":"unlock"}`)) - gomega.Expect(stderr).To(gomega.ContainSubstring("child-err")) - if wantStatus { + childMarkers := 0 + scanner := bufio.NewScanner(strings.NewReader(stderr)) + var statusEvents []status.Event + for scanner.Scan() { + line := strings.TrimSpace(scanner.Text()) + for strings.HasPrefix(line, "child-err") { + childMarkers++ + line = strings.TrimPrefix(line, "child-err") + } + if !strings.HasPrefix(line, "{") { + continue + } + var envelope struct { + Kind string `json:"kind"` + SchemaVersion int `json:"schemaVersion"` + status.Event + } + framework.ExpectNoError(json.Unmarshal([]byte(line), &envelope)) + if envelope.Kind == "status" { + gomega.Expect(envelope.SchemaVersion).To(gomega.Equal(1)) + gomega.Expect(envelope.Pipeline).ToNot(gomega.BeEmpty()) + gomega.Expect(envelope.Phase).ToNot(gomega.BeEmpty()) + gomega.Expect(status.ValidState(envelope.State)).To(gomega.BeTrue()) + statusEvents = append(statusEvents, envelope.Event) + } + } + framework.ExpectNoError(scanner.Err()) + gomega.Expect(childMarkers).To(gomega.Equal(1)) + if wantStatus && len(flags) == 0 { + var started, succeeded bool + for _, event := range statusEvents { + if event.Pipeline == status.PipelineWorkspaceUp && + event.Phase == status.PhaseRunningCommand && event.Step == "CI command" { + started = started || event.State == status.StateStarted + succeeded = succeeded || event.State == status.StateSucceeded + } + } + gomega.Expect(started).To(gomega.BeTrue(), "missing CI command start status") + gomega.Expect(succeeded).To(gomega.BeTrue(), "missing CI command success status") + } else if wantStatus { gomega.Expect(stderr).To(gomega.MatchRegexp(`\[RUN\]\s+ci:`)) } else { gomega.Expect(stderr). NotTo(gomega.MatchRegexp(`\[(RUN|OK|FAIL)\]\s+(ci|workspace):`)) + gomega.Expect(statusEvents).To(gomega.BeEmpty()) } if len(flags) > 0 && flags[0] == noStatusFlag && len(flags) == 2 { gomega.Expect(stderr).To(gomega.Equal("child-err")) diff --git a/e2e/tests/outdated/outdated.go b/e2e/tests/outdated/outdated.go index 4023763ad7..b0050c5cf1 100644 --- a/e2e/tests/outdated/outdated.go +++ b/e2e/tests/outdated/outdated.go @@ -17,6 +17,7 @@ const ( cmdFeature = "feature" cmdOutdated = "outdated" flagWorkspaceFolder = "--workspace-folder" + resultFormatPlain = "--result-format=plain" ) var _ = ginkgo.Describe("outdated command", ginkgo.Label("outdated"), func() { @@ -50,6 +51,7 @@ var _ = ginkgo.Describe("outdated command", ginkgo.Label("outdated"), func() { stdout, _, err := f.ExecCommandCapture(ctx, []string{ cmdFeature, cmdOutdated, flagWorkspaceFolder, tempDir, + resultFormatPlain, }) framework.ExpectNoError(err) @@ -80,6 +82,7 @@ var _ = ginkgo.Describe("outdated command", ginkgo.Label("outdated"), func() { stdout, _, err := f.ExecCommandCapture(ctx, []string{ cmdFeature, cmdOutdated, flagWorkspaceFolder, tempDir, + resultFormatPlain, }) framework.ExpectNoError(err) @@ -101,6 +104,7 @@ var _ = ginkgo.Describe("outdated command", ginkgo.Label("outdated"), func() { stdout, _, err := f.ExecCommandCapture(ctx, []string{ cmdFeature, cmdOutdated, flagWorkspaceFolder, tempDir, + resultFormatPlain, }) framework.ExpectNoError(err) diff --git a/e2e/tests/up/provider_microsandbox_performance.go b/e2e/tests/up/provider_microsandbox_performance.go index 1f8be9170f..d1269729ef 100644 --- a/e2e/tests/up/provider_microsandbox_performance.go +++ b/e2e/tests/up/provider_microsandbox_performance.go @@ -10,10 +10,10 @@ import ( "errors" "fmt" "io" + "math" "os" "os/exec" "path/filepath" - "regexp" "runtime" "strings" "time" @@ -38,8 +38,6 @@ const ( performanceUpReused = "reused" ) -var startupEvent = regexp.MustCompile(`External runtime ([^ ]+) startup completed in ([^\s]+)`) - type microsandboxPerformanceCapture struct { active bool probe string @@ -339,17 +337,32 @@ func (c *microsandboxPerformanceCapture) captureFreshWorkspace( func parseStartupEvents(output string) []startupPerformance { var events []startupPerformance for line := range strings.SplitSeq(output, "\n") { - match := startupEvent.FindStringSubmatch(line) - if len(match) != 3 { + var record struct { + Time string `json:"ts"` + Level string `json:"level"` + Message string `json:"msg"` + Operation string `json:"operation"` + DurationMS *int64 `json:"duration_ms"` + } + if json.Unmarshal([]byte(line), &record) != nil || + record.Level != "debug" || record.Message != "External runtime startup completed" || + record.DurationMS == nil || *record.DurationMS < 0 || *record.DurationMS > math.MaxInt64/int64(time.Millisecond) { continue } - duration, err := time.ParseDuration(match[2]) - if err == nil && duration > 0 { - events = append( - events, - startupPerformance{Operation: match[1], DurationNS: duration.Nanoseconds()}, - ) + if _, err := time.Parse(time.RFC3339Nano, record.Time); err != nil { + if _, err := time.Parse("2006-01-02T15:04:05.000Z0700", record.Time); err != nil { + continue + } + } + switch record.Operation { + case "Info", "Preflight", "ProvisioningPreflight", "ReusePreflight", "Find", + "TargetArchitecture", "RunImage", "Start", "Stop", "Delete", "Exec", "Logs": + default: + continue } + events = append(events, startupPerformance{ + Operation: record.Operation, DurationNS: *record.DurationMS * int64(time.Millisecond), + }) } return events } diff --git a/e2e/tests/up/provider_microsandbox_performance_test.go b/e2e/tests/up/provider_microsandbox_performance_test.go index 1e87a66bbd..616f46154e 100644 --- a/e2e/tests/up/provider_microsandbox_performance_test.go +++ b/e2e/tests/up/provider_microsandbox_performance_test.go @@ -211,23 +211,50 @@ func TestValidateSDKToolRejectsDifferentBuildSource(t *testing.T) { } func TestParseStartupEvents(t *testing.T) { + const startupPrefix = `{"ts":"2026-11-17T20:11:24.373Z","level":"debug",` + + `"msg":"External runtime startup completed",` + output := strings.Join([]string{ + startupPrefix + `"duration_ms":80,"operation":"Info"}`, + `{"ts":"2026-11-17T20:11:24.791Z","level":"debug","msg":"External runtime startup completed",` + + `"duration_ms":0,"operation":"Find","operation_id":"op-3","parent_operation_id":""}`, + `{"ts":"2026-11-17T20:11:24.373+0100","level":"debug","msg":"External runtime startup completed",` + + `"duration_ms":12,"operation":"Exec"}`, + `{"ts":"2026-11-17T20:11:24.373+01:00","level":"debug","msg":"External runtime startup completed",` + + `"duration_ms":13,"operation":"Logs"}`, + `{"ts":"2026-11-17T20:11:24.373Z","level":"debug","msg":"External runtime startup completed","operation":"Info"}`, + startupPrefix + `"duration_ms":null,"operation":"Info"}`, + startupPrefix + `"duration_ms":-1,"operation":"Info"}`, + startupPrefix + `"duration_ms":9223372036855,"operation":"Info"}`, + startupPrefix + `"duration_ms":1.5,"operation":"Info"}`, + startupPrefix + `"duration_ms":"80","operation":"Info"}`, + `{"ts":"invalid","level":"debug","msg":"External runtime startup completed","duration_ms":80,"operation":"Info"}`, + `{"ts":"2026-11-17T20:11:24.373Z","level":"info",` + + `"msg":"External runtime startup completed","duration_ms":80,"operation":"Info"}`, + `{"ts":"2026-11-17T20:11:24.373Z","level":"debug","msg":"different event","duration_ms":80,"operation":"Info"}`, + startupPrefix + `"duration_ms":80,"operation":"Unknown"}`, + `{"ts":"2026-11-17T20:11:24.373Z","level":"debug","msg":"External runtime startup completed","duration_ms":80}`, + startupPrefix + `"duration_ms":80,"operation":"Info"`, + "prefix " + startupPrefix + `"duration_ms":80,"operation":"Info"}`, + startupPrefix + `"duration_ms":80,"operation":"Info"} {}`, + `{"msg":"{\"msg\":\"External runtime startup completed\",\"operation\":\"Info\",\"duration_ms\":80}"}`, "DEBU External runtime Info startup completed in 4.2ms", - "DEBU External runtime Find startup completed in 1s", - "DEBU External runtime Info startup completed in someday", - "DEBU External runtime Info startup completed in 0s", - "DEBU External runtime Info startup completed in -3ms", }, "\n") events := parseStartupEvents(output) - if len(events) != 2 { - t.Fatalf("expected two positive startup timings, got %#v", events) + expected := []startupPerformance{ + {Operation: "Info", DurationNS: int64(80 * time.Millisecond)}, + {Operation: "Find", DurationNS: 0}, + {Operation: "Exec", DurationNS: int64(12 * time.Millisecond)}, + {Operation: "Logs", DurationNS: int64(13 * time.Millisecond)}, } - if events[0].Operation != "Info" || events[0].DurationNS != int64(4200*time.Microsecond) { - t.Errorf("unexpected first startup event: %#v", events[0]) + if len(events) != len(expected) { + t.Fatalf("expected %#v, got %#v", expected, events) } - if events[1].Operation != "Find" || events[1].DurationNS != int64(time.Second) { - t.Errorf("unexpected second startup event: %#v", events[1]) + for i := range expected { + if events[i] != expected[i] { + t.Errorf("event %d: expected %#v, got %#v", i, expected[i], events[i]) + } } } From b52c4535f60330f61f8a4bfa4463fc32e9338421 Mon Sep 17 00:00:00 2001 From: Samuel K Date: Wed, 18 Nov 2026 01:05:05 -0600 Subject: [PATCH 06/11] test(desktop): verify real CLI in hosted Electron --- .github/workflows/desktop-ci.yml | 16 ++ desktop/e2e/context-options.real-cli.ts | 252 ++++++++++++++++++++++++ desktop/e2e/real-cli-bootstrap.cjs | 9 + desktop/e2e/run-real-cli-linux.sh | 142 +++++++++++++ desktop/playwright.real-cli.config.ts | 17 ++ 5 files changed, 436 insertions(+) create mode 100644 desktop/e2e/context-options.real-cli.ts create mode 100644 desktop/e2e/real-cli-bootstrap.cjs create mode 100755 desktop/e2e/run-real-cli-linux.sh create mode 100644 desktop/playwright.real-cli.config.ts diff --git a/.github/workflows/desktop-ci.yml b/.github/workflows/desktop-ci.yml index 7690c0fe41..a66ca89a55 100644 --- a/.github/workflows/desktop-ci.yml +++ b/.github/workflows/desktop-ci.yml @@ -167,6 +167,22 @@ jobs: npm run electron:build npx playwright test + - name: Run real CLI e2e test (Linux) + if: runner.os == 'Linux' + working-directory: desktop + env: + REAL_CLI_EVIDENCE: ${{ runner.temp }}/real-cli-evidence-${{ github.run_id }}-${{ github.run_attempt }} + run: bash e2e/run-real-cli-linux.sh + + - name: Upload real CLI evidence (Linux) + if: always() && runner.os == 'Linux' + uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 + with: + name: desktop-real-cli-linux-${{ github.run_id }}-${{ github.run_attempt }} + path: ${{ runner.temp }}/real-cli-evidence-${{ github.run_id }}-${{ github.run_attempt }} + if-no-files-found: warn + retention-days: 7 + - name: Package with electron-builder working-directory: desktop run: npx electron-builder ${{ matrix.builder-args }} --config electron-builder.yml diff --git a/desktop/e2e/context-options.real-cli.ts b/desktop/e2e/context-options.real-cli.ts new file mode 100644 index 0000000000..74d6cc31a7 --- /dev/null +++ b/desktop/e2e/context-options.real-cli.ts @@ -0,0 +1,252 @@ +import { spawnSync } from "node:child_process" +import { createHash, randomUUID } from "node:crypto" +import { + appendFileSync, + mkdirSync, + readFileSync, + renameSync, + writeFileSync, +} from "node:fs" +import { homedir } from "node:os" +import { dirname, isAbsolute, join, relative, resolve } from "node:path" +import { fileURLToPath } from "node:url" +import { + type ElectronApplication, + _electron as electron, + expect, + test, +} from "@playwright/test" + +const required = (name: string): string => { + const value = process.env[name] + if (!value || !isAbsolute(value)) throw new Error(`${name} must be absolute`) + return value +} +const root = required("REAL_CLI_ROOT") +const evidence = required("REAL_CLI_EVIDENCE") +const executable = required("REAL_CLI_ELECTRON") +const cli = required("DEVSY_CLI_PATH") +const config = required("DEVSY_CONFIG") +const desktop = resolve(dirname(fileURLToPath(import.meta.url)), "..") +const home = join(root, "home") +const devsyHome = join(home, ".devsy") +const logs = join(root, "electron-logs") +const identity = JSON.parse( + readFileSync(join(desktop, "package.json"), "utf8"), +) as { + name: string + version: string +} +const userData = join(root, "electron-user-data") +const sessionData = join(root, "electron-session-data") +const withinDevsyHome = relative(devsyHome, config) +if ( + !withinDevsyHome || + withinDevsyHome.startsWith("..") || + isAbsolute(withinDevsyHome) +) + throw new Error("DEVSY_CONFIG must be inside HOME/.devsy") + +const diagnostic = join(evidence, "real-cli-diagnostics.log") +let diagnosticBytes = 0 +function log(label: string, value: string) { + const text = `${label}: ${value}\n`.slice( + 0, + Math.max(0, 256_000 - diagnosticBytes), + ) + if (text) appendFileSync(diagnostic, text, { mode: 0o600 }) + diagnosticBytes += Buffer.byteLength(text) +} +function run(args: string[], succeeds = true) { + const result = spawnSync(cli, args, { + env: process.env, + encoding: "utf8", + timeout: 15_000, + maxBuffer: 1_000_000, + }) + log( + `cli ${args.join(" ")} exit=${result.status}`, + `${result.stdout}\n${result.stderr}\n${result.error ?? ""}`, + ) + expect(result.error).toBeUndefined() + if (succeeds) expect(result.status).toBe(0) + else expect(result.status).not.toBe(0) + return result +} + +test("private context options reach the real Electron sheet and errors reach its toast", async () => { + expect(process.platform).toBe("linux") + expect(process.env.DEVSY_DISABLE_DAEMON).toBe("true") + expect(process.env.DEVSY_LOG_FORMAT).toBe("text") + expect(process.env.DEVSY_RESULT_FORMAT).toBe("text") + expect(process.env.HOME).toBe(home) + expect(homedir()).toBe(home) + expect(process.env.DEVSY_HOME).toBe(devsyHome) + expect(process.env.DEVSY_UI).toBeUndefined() + expect(process.env.ELECTRON_RUN_AS_NODE).toBeUndefined() + mkdirSync(userData, { recursive: true, mode: 0o700 }) + mkdirSync(sessionData, { recursive: true, mode: 0o700 }) + mkdirSync(logs, { recursive: true, mode: 0o700 }) + log( + "candidate sha256", + createHash("sha256").update(readFileSync(cli)).digest("hex"), + ) + let app: ElectronApplication | undefined + let originalConfig: Buffer | undefined + let modified = false + try { + app = await electron.launch({ + executablePath: executable, + args: ["--require", join(desktop, "e2e/real-cli-bootstrap.cjs"), desktop], + env: Object.fromEntries( + Object.entries(process.env).filter( + (entry): entry is [string, string] => entry[1] !== undefined, + ), + ), + timeout: 30_000, + }) + app + .process() + .stdout?.on("data", (data) => log("electron stdout", String(data))) + app + .process() + .stderr?.on("data", (data) => log("electron stderr", String(data))) + const paths = await app.evaluate(({ app }) => ({ + platform: process.platform, + packaged: app.isPackaged, + home: require("node:os").homedir(), + electronHome: app.getPath("home"), + envHome: process.env.HOME, + devsyHome: process.env.DEVSY_HOME, + config: process.env.DEVSY_CONFIG, + name: app.getName(), + version: app.getVersion(), + appPath: app.getAppPath(), + userData: app.getPath("userData"), + sessionData: app.getPath("sessionData"), + logs: app.getPath("logs"), + cli: process.env.DEVSY_CLI_PATH, + })) + log("electron paths", JSON.stringify(paths)) + expect(paths).toEqual({ + platform: "linux", + packaged: false, + home, + electronHome: home, + envHome: home, + devsyHome, + config, + name: identity.name, + version: identity.version, + appPath: desktop, + userData, + sessionData, + logs, + cli, + }) + const page = await app.firstWindow({ timeout: 30_000 }) + page.on("console", (message) => + log(`renderer ${message.type()}`, message.text()), + ) + page.on("pageerror", (error) => + log("renderer error", error.stack ?? error.message), + ) + await expect(page.locator("body")).toBeVisible() + const runningApp = app + await expect + .poll(() => + runningApp.evaluate(({ BrowserWindow }) => + BrowserWindow.getAllWindows().some( + (window) => !window.isDestroyed() && window.isVisible(), + ), + ), + ) + .toBe(true) + run(["--version"]) + const name = `real-cli-${randomUUID()}` + const value = "37" + run(["context", "create", name, "-o", `AGENT_INJECT_TIMEOUT=${value}`]) + const list = JSON.parse( + run(["context", "list", "--result-format=json"]).stdout, + ) as Array<{ name: string; default?: boolean }> + expect(list.find((entry) => entry.name === name)?.default).toBe(true) + const plain = run(["context", "get", "--context", name]).stdout + expect(plain).toContain("AGENT_INJECT_TIMEOUT") + expect(plain).toMatch(/AGENT_INJECT_TIMEOUT[^\n]*\b37\b/) + expect(() => JSON.parse(plain)).toThrow() + const options = JSON.parse( + run(["context", "get", "--context", name, "--result-format=json"]).stdout, + ) as Record + expect(options.AGENT_INJECT_TIMEOUT.value).toBe(value) + await page.click('[data-sidebar="sidebar"] a[href="#/contexts"]') + await expect( + page.locator('[data-slot="sidebar-inset"] h1').first(), + ).toContainText(/contexts/i) + const card = page + .locator('[data-slot="sidebar-inset"] main') + .locator("button", { + has: page.getByRole("heading", { name, exact: true }), + }) + await expect(card).toBeVisible() + await card.click() + const sheet = page.getByRole("dialog") + await expect(sheet).toBeVisible() + await expect(sheet.getByPlaceholder("20")).toHaveValue(value) + await page.screenshot({ path: join(evidence, "context-options.png") }) + await page.keyboard.press("Escape") + await expect(sheet).toBeHidden() + originalConfig = readFileSync(config) + const temporary = `${config}.real-cli-invalid` + writeFileSync(temporary, "contexts: [\n", { mode: 0o600, flag: "wx" }) + renameSync(temporary, config) + modified = true + const textFailure = run( + ["context", "get", "--context", name, "--result-format=json"], + false, + ) + expect(textFailure.stderr).not.toContain('"kind":"error"') + expect(textFailure.stderr).toContain("yaml:") + const failure = run( + [ + "context", + "get", + "--context", + name, + "--result-format=json", + "--log-format=json", + ], + false, + ) + expect(failure.stdout).toBe("") + const envelope = failure.stderr + .split(/\r?\n/) + .map((line) => { + try { + return JSON.parse(line) as Record + } catch { + return undefined + } + }) + .find((entry) => entry?.kind === "error" && entry.outcome === "error") + expect(envelope).toBeDefined() + expect(envelope?.code).toEqual(expect.any(String)) + expect(envelope?.message).toEqual(expect.any(String)) + expect(String(envelope?.code).length).toBeGreaterThan(0) + expect(String(envelope?.message).length).toBeGreaterThan(0) + expect(textFailure.stderr).toContain(String(envelope?.message)) + await card.click() + await expect( + page.getByText(`Failed to load context options: ${envelope?.message}`, { + exact: false, + }), + ).toBeVisible() + await page.screenshot({ path: join(evidence, "context-error.png") }) + } finally { + try { + if (modified && originalConfig) + writeFileSync(config, originalConfig, { mode: 0o600 }) + } finally { + await app?.close() + } + } +}) diff --git a/desktop/e2e/real-cli-bootstrap.cjs b/desktop/e2e/real-cli-bootstrap.cjs new file mode 100644 index 0000000000..1a72d91b47 --- /dev/null +++ b/desktop/e2e/real-cli-bootstrap.cjs @@ -0,0 +1,9 @@ +const { app } = require("electron") +const { isAbsolute, join } = require("node:path") + +const root = process.env.REAL_CLI_ROOT +if (!root || !isAbsolute(root)) + throw new Error("REAL_CLI_ROOT must be absolute") +app.setPath("userData", join(root, "electron-user-data")) +app.setPath("sessionData", join(root, "electron-session-data")) +app.setAppLogsPath(join(root, "electron-logs")) diff --git a/desktop/e2e/run-real-cli-linux.sh b/desktop/e2e/run-real-cli-linux.sh new file mode 100755 index 0000000000..55ef0f7798 --- /dev/null +++ b/desktop/e2e/run-real-cli-linux.sh @@ -0,0 +1,142 @@ +#!/usr/bin/env bash +set -Eeuo pipefail +umask 077 + +if [[ ${1-} == --namespace ]]; then + shift + root=$1 evidence=$2 desktop=$3 node=$4 go=$5 uid=$6 gid=$7 host_netns=$8 host_pidns=$9 revision=${10} + mount --make-rprivate / + mount -t proc -o nosuid,nodev,noexec proc /proc + mount -t tmpfs -o mode=1777,nosuid,nodev tmpfs /tmp + mount -t tmpfs -o mode=0755,nosuid,nodev tmpfs /run + if [[ $(readlink -f /var/run) != /run ]]; then + mount -t tmpfs -o mode=0755,nosuid,nodev tmpfs /var/run + fi + mountpoint -q /tmp + mountpoint -q /run + mountpoint -q "$(readlink -f /var/run)" + sockets=$(ss -H -x -a) + [[ -z $(find /tmp /run /var/run -type s -print -quit) && -z $sockets ]] + ip link set lo up + exec setpriv --reuid "$uid" --regid "$gid" --clear-groups --no-new-privs \ + --bounding-set=-all --inh-caps=-all --ambient-caps=-all \ + env -i PATH="$(dirname "$node"):/usr/local/bin:/usr/bin:/bin" \ + HOME="$root/home" DEVSY_HOME="$root/home/.devsy" DEVSY_CONFIG="$root/home/.devsy/config.yaml" \ + XDG_CONFIG_HOME="$root/xdg-config" XDG_CACHE_HOME="$root/xdg-cache" \ + XDG_DATA_HOME="$root/xdg-data" XDG_STATE_HOME="$root/xdg-state" \ + XDG_RUNTIME_DIR="$root/xdg-runtime" TMPDIR="$root/tmp" \ + DOCKER_CONFIG="$root/docker" GNUPGHOME="$root/gnupg" \ + DEVSY_DISABLE_DAEMON=true DEVSY_DISABLE_TELEMETRY=true DEVSY_LOG_FORMAT=text DEVSY_RESULT_FORMAT=text MISE_AUTO_INSTALL=0 GOTOOLCHAIN=local GOENV=off \ + REAL_CLI_ROOT="$root" REAL_CLI_EVIDENCE="$evidence" \ + REAL_CLI_ELECTRON="$desktop/node_modules/electron/dist/electron" \ + DEVSY_CLI_PATH="$desktop/resources/bin/devsy" \ + /bin/bash "$desktop/e2e/run-real-cli-linux.sh" --run "$desktop" "$node" "$go" "$uid" "$gid" "$host_netns" "$host_pidns" "$revision" +fi + +if [[ ${1-} == --run ]]; then + shift + desktop=$1 node=$2 go=$3 uid=$4 gid=$5 host_netns=$6 host_pidns=$7 revision=$8 + [[ $(id -u) == "$uid" && $(id -g) == "$gid" && $uid != 0 ]] + [[ $(readlink /proc/self/ns/net) != "$host_netns" ]] + [[ $(readlink /proc/self/ns/pid) != "$host_pidns" && $(readlink /proc/self/ns/pid) == "$(readlink /proc/1/ns/pid)" ]] + sockets=$(ss -H -x -a) + [[ -z $(find /tmp /run /var/run -type s -print -quit) && -z $sockets ]] + awk '/^Cap(Inh|Prm|Eff|Bnd|Amb):/ { if ($2 !~ /^0+$/) exit 1; n++ } /^NoNewPrivs:/ { if ($2 != 1) exit 1; p++ } END { if (n != 5 || p != 1) exit 1 }' /proc/self/status + ip -j link show >"$REAL_CLI_EVIDENCE/links.json" + ip -j -4 route show table all >"$REAL_CLI_EVIDENCE/routes-v4.json" + ip -j -6 route show table all >"$REAL_CLI_EVIDENCE/routes-v6.json" + "$node" - "$REAL_CLI_EVIDENCE" <<'NODE' +const fs = require('node:fs') +const root = process.argv[2] +const read = name => JSON.parse(fs.readFileSync(`${root}/${name}`, 'utf8')) +const links = read('links.json') +if (links.length !== 1 || links[0].ifname !== 'lo' || !links[0].flags.includes('UP')) process.exit(1) +for (const file of ['routes-v4.json', 'routes-v6.json']) { + if (read(file).some(route => route.dst === 'default' || route.gateway || (route.dev && route.dev !== 'lo'))) process.exit(1) +} +NODE + printf 'netns=%s\npidns=%s\nuid=%s gid=%s\nunix_sockets=none\n' "$(readlink /proc/self/ns/net)" "$(readlink /proc/self/ns/pid)" "$uid" "$gid" >"$REAL_CLI_EVIDENCE/boundary.txt" + grep -E '^(Cap(Inh|Prm|Eff|Bnd|Amb)|NoNewPrivs):' /proc/self/status >>"$REAL_CLI_EVIDENCE/boundary.txt" + [[ -f $REAL_CLI_ELECTRON && ! -L $REAL_CLI_ELECTRON && -x $REAL_CLI_ELECTRON ]] + [[ -f $DEVSY_CLI_PATH && ! -L $DEVSY_CLI_PATH && -x $DEVSY_CLI_PATH ]] + [[ -f $desktop/node_modules/@playwright/test/cli.js && -f $desktop/playwright.real-cli.config.ts ]] + "$node" - "$desktop" <<'NODE' +const fs = require('node:fs') +const dir = process.argv[2] +const pkg = JSON.parse(fs.readFileSync(`${dir}/node_modules/electron/package.json`, 'utf8')) +const lock = JSON.parse(fs.readFileSync(`${dir}/package-lock.json`, 'utf8')) +if (pkg.version !== '44.5.1' || lock.packages['node_modules/electron'].version !== '44.5.1' || fs.readFileSync(`${dir}/node_modules/electron/dist/version`, 'utf8').trim() !== 'v44.5.1') process.exit(1) +NODE + [[ $(ELECTRON_RUN_AS_NODE=1 timeout 15s "$REAL_CLI_ELECTRON" -e 'process.stdout.write(process.versions.electron)') == 44.5.1 ]] + timeout 15s "$DEVSY_CLI_PATH" --version >"$REAL_CLI_EVIDENCE/cli-version.txt" + [[ -s $REAL_CLI_EVIDENCE/cli-version.txt ]] + timeout 15s "$DEVSY_CLI_PATH" context get --help >"$REAL_CLI_EVIDENCE/cli-api.txt" + timeout 15s "$go" version -m "$DEVSY_CLI_PATH" >"$REAL_CLI_EVIDENCE/cli-build.txt" + grep -Fq 'github.com/devsy-org/devsy' "$REAL_CLI_EVIDENCE/cli-build.txt" + awk -v revision="$revision" '$1 == "build" && $2 ~ /^vcs\.revision=/ { revisions++; if ($2 != "vcs.revision=" revision) exit 1 } $1 == "build" && $2 ~ /^vcs\.modified=/ { modified++; if ($2 != "vcs.modified=false") exit 1 } END { if (revisions != 1 || modified != 1) exit 1 }' "$REAL_CLI_EVIDENCE/cli-build.txt" + sha256sum "$DEVSY_CLI_PATH" "$REAL_CLI_ELECTRON" "$desktop/package-lock.json" >>"$REAL_CLI_EVIDENCE/hashes.txt" + cd "$desktop" + exec timeout --kill-after=10s 180s xvfb-run -a "$node" "$desktop/node_modules/@playwright/test/cli.js" test --config playwright.real-cli.config.ts --workers=1 --retries=0 --reporter=list --output "$REAL_CLI_EVIDENCE/playwright-output" +fi + +[[ $(uname -s) == Linux && $(id -u) != 0 && ${RUNNER_ENVIRONMENT-} == github-hosted && ${GITHUB_ACTIONS-} == true ]] +: "${RUNNER_TEMP:?}" "${REAL_CLI_EVIDENCE:?}" "${GITHUB_REF:?}" "${GITHUB_SHA:?}" "${GITHUB_RUN_ID:?}" "${GITHUB_RUN_ATTEMPT:?}" +desktop=$(cd "$(dirname "$0")/.." && pwd -P) +runner_temp=$(realpath -e "$RUNNER_TEMP") +case "$runner_temp/" in /tmp/* | /var/run/* | /run/*) + echo 'RUNNER_TEMP is hidden by the namespace' >&2 + exit 1 + ;; +esac +[[ $REAL_CLI_EVIDENCE == /* && $REAL_CLI_EVIDENCE == "$runner_temp"/* && ! -e $REAL_CLI_EVIDENCE ]] +mkdir -m 700 "$REAL_CLI_EVIDENCE" +ulimit -f 131072 +exec > >(tee "$REAL_CLI_EVIDENCE/runner.log") 2>&1 +root=$(mktemp -d "$runner_temp/real-cli-root.XXXXXXXX") +namespace_status=not_started +owner="$(id -u):$(id -g)" +cleanup() { + status=$? + trap - EXIT + umask 077 + if actual_owner=$(stat -c '%u:%g' "$root") && [[ $actual_owner == "$owner" ]] && rm -rf -- "$root" && [[ ! -e $root && ! -L $root ]]; then + result=removed + else + result=failed + status=1 + fi + printf 'private_root=%s\nowner=%s\nnamespace_command_status=%s\ncleanup=%s\nexit_status=%s\n' "$root" "$owner" "$namespace_status" "$result" "$status" >"$REAL_CLI_EVIDENCE/cleanup.txt" || status=1 + exit "$status" +} +trap cleanup EXIT +mkdir -m 700 "$root"/{home,xdg-config,xdg-cache,xdg-data,xdg-state,xdg-runtime,tmp,docker,gnupg} +mkdir -m 700 "$root/home/.devsy" +node=$(command -v node) +go=$(command -v go) +[[ $node == /* && $go == /* && -x $node && -x $go ]] +checkout=$(git -C "$desktop" rev-parse --show-toplevel) +revision=$(git -C "$checkout" rev-parse --verify HEAD) +checkout_ref=$(git -C "$checkout" symbolic-ref -q HEAD || printf detached) +printf 'runner_environment=%s\ngithub_actions=%s\nrun_id=%s\nrun_attempt=%s\ngithub_ref=%s\ngithub_sha=%s\ncheckout_ref=%s\ncheckout_head=%s\n' \ + "$RUNNER_ENVIRONMENT" "$GITHUB_ACTIONS" "$GITHUB_RUN_ID" "$GITHUB_RUN_ATTEMPT" "$GITHUB_REF" "$GITHUB_SHA" "$checkout_ref" "$revision" >"$REAL_CLI_EVIDENCE/identity.txt" +proof_files=(.github/workflows/desktop-ci.yml desktop/playwright.real-cli.config.ts desktop/e2e/context-options.real-cli.ts desktop/e2e/real-cli-bootstrap.cjs desktop/e2e/run-real-cli-linux.sh) +git -C "$checkout" ls-files --error-unmatch -- "${proof_files[@]}" >/dev/null +for file in "${proof_files[@]}"; do + [[ -f $checkout/$file && ! -L $checkout/$file ]] + actual_blob=$(git -C "$checkout" hash-object --no-filters -- "$file") + expected_blob=$(git -C "$checkout" rev-parse --verify "$revision:$file") + [[ $actual_blob == "$expected_blob" ]] +done +(cd "$checkout" && sha256sum "${proof_files[@]}") >"$REAL_CLI_EVIDENCE/hashes.txt" +[[ -d $desktop/dist && -n $(find "$desktop/dist" -type f -print -quit) ]] +find "$desktop/dist" -type f -print0 | sort -z | xargs -0 -r sha256sum >>"$REAL_CLI_EVIDENCE/hashes.txt" +host_netns=$(readlink /proc/self/ns/net) +host_pidns=$(readlink /proc/self/ns/pid) +if timeout --kill-after=15s 240s sudo -n -- /usr/bin/env -i PATH=/usr/sbin:/usr/bin:/sbin:/bin \ + unshare --net --mount --pid --fork --kill-child -- /bin/bash "$desktop/e2e/run-real-cli-linux.sh" --namespace \ + "$root" "$REAL_CLI_EVIDENCE" "$desktop" "$node" "$go" "$(id -u)" "$(id -g)" "$host_netns" "$host_pidns" "$revision"; then + namespace_status=0 +else + namespace_status=$? + exit "$namespace_status" +fi diff --git a/desktop/playwright.real-cli.config.ts b/desktop/playwright.real-cli.config.ts new file mode 100644 index 0000000000..85bad67d8d --- /dev/null +++ b/desktop/playwright.real-cli.config.ts @@ -0,0 +1,17 @@ +import { isAbsolute, join } from "node:path" +import { defineConfig } from "@playwright/test" + +const evidence = process.env.REAL_CLI_EVIDENCE +if (!evidence || !isAbsolute(evidence)) + throw new Error("REAL_CLI_EVIDENCE must be absolute") + +export default defineConfig({ + testDir: "./e2e", + testMatch: "**/context-options.real-cli.ts", + timeout: 90_000, + expect: { timeout: 15_000 }, + retries: 0, + workers: 1, + reporter: [["list"]], + outputDir: join(evidence, "playwright"), +}) From 9baeef9d72d0d59f627e561439cf4e2e52d20e51 Mon Sep 17 00:00:00 2001 From: Samuel K Date: Wed, 18 Nov 2026 01:58:23 -0600 Subject: [PATCH 07/11] fix(ci): preserve scoped lint and hosted preflight --- .github/workflows/pr-ci.yml | 11 +- desktop/e2e/run-real-cli-linux.sh | 71 ++++++-- hack/ci/lint_patch.go | 221 +++++++++++++++++++++++ hack/ci/lint_patch_test.go | 291 ++++++++++++++++++++++++++++++ hack/ci/main.go | 4 +- 5 files changed, 581 insertions(+), 17 deletions(-) create mode 100644 hack/ci/lint_patch.go create mode 100644 hack/ci/lint_patch_test.go diff --git a/.github/workflows/pr-ci.yml b/.github/workflows/pr-ci.yml index 62da49ee05..c62bad2675 100644 --- a/.github/workflows/pr-ci.yml +++ b/.github/workflows/pr-ci.yml @@ -178,6 +178,9 @@ jobs: runs-on: ubuntu-latest steps: - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7 + with: + ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || '' }} + fetch-depth: ${{ github.event_name == 'pull_request' && '0' || '1' }} - uses: ./.github/actions/relocate-tmp @@ -186,11 +189,17 @@ jobs: with: go-version-file: go.mod + - name: Generate complete pull request lint patch + id: lint-patch + if: github.event_name == 'pull_request' + run: go run ./hack/ci lint-patch >> "$GITHUB_OUTPUT" + - name: golangci-lint uses: golangci/golangci-lint-action@ba0d7d2ec06a0ea1cb5fa41b2e4a3ab91d21278a # v9 with: version: v2.14.0 - only-new-issues: true + only-new-issues: ${{ github.event_name != 'pull_request' }} + args: ${{ steps.lint-patch.outputs.args }} # Native host tests: they execute the real `gh` CLI and, on macOS, the native # keyring, so they run per host OS outside the unit tier's package list. diff --git a/desktop/e2e/run-real-cli-linux.sh b/desktop/e2e/run-real-cli-linux.sh index 55ef0f7798..6f2e61530b 100755 --- a/desktop/e2e/run-real-cli-linux.sh +++ b/desktop/e2e/run-real-cli-linux.sh @@ -57,24 +57,65 @@ for (const file of ['routes-v4.json', 'routes-v6.json']) { NODE printf 'netns=%s\npidns=%s\nuid=%s gid=%s\nunix_sockets=none\n' "$(readlink /proc/self/ns/net)" "$(readlink /proc/self/ns/pid)" "$uid" "$gid" >"$REAL_CLI_EVIDENCE/boundary.txt" grep -E '^(Cap(Inh|Prm|Eff|Bnd|Amb)|NoNewPrivs):' /proc/self/status >>"$REAL_CLI_EVIDENCE/boundary.txt" - [[ -f $REAL_CLI_ELECTRON && ! -L $REAL_CLI_ELECTRON && -x $REAL_CLI_ELECTRON ]] - [[ -f $DEVSY_CLI_PATH && ! -L $DEVSY_CLI_PATH && -x $DEVSY_CLI_PATH ]] - [[ -f $desktop/node_modules/@playwright/test/cli.js && -f $desktop/playwright.real-cli.config.ts ]] - "$node" - "$desktop" <<'NODE' + preflight_fail() { + printf 'preflight: %s\n' "$1" | tee -a "$REAL_CLI_EVIDENCE/preflight.txt" >&2 + exit 1 + } + [[ -f $REAL_CLI_ELECTRON && ! -L $REAL_CLI_ELECTRON && -x $REAL_CLI_ELECTRON ]] || + preflight_fail 'Electron executable missing, symlinked, or not executable' + [[ -f $DEVSY_CLI_PATH && ! -L $DEVSY_CLI_PATH && -x $DEVSY_CLI_PATH ]] || + preflight_fail 'candidate CLI missing, symlinked, or not executable' + [[ -f $desktop/node_modules/@playwright/test/cli.js ]] || + preflight_fail 'local Playwright CLI missing' + [[ -f $desktop/playwright.real-cli.config.ts ]] || + preflight_fail 'real CLI Playwright config missing' + sha256sum "$DEVSY_CLI_PATH" "$REAL_CLI_ELECTRON" "$desktop/package-lock.json" >>"$REAL_CLI_EVIDENCE/hashes.txt" || + preflight_fail 'executable or lockfile hashing failed' + if ! "$node" - "$desktop" >>"$REAL_CLI_EVIDENCE/preflight.txt" <<'NODE'; then const fs = require('node:fs') const dir = process.argv[2] -const pkg = JSON.parse(fs.readFileSync(`${dir}/node_modules/electron/package.json`, 'utf8')) -const lock = JSON.parse(fs.readFileSync(`${dir}/package-lock.json`, 'utf8')) -if (pkg.version !== '44.5.1' || lock.packages['node_modules/electron'].version !== '44.5.1' || fs.readFileSync(`${dir}/node_modules/electron/dist/version`, 'utf8').trim() !== 'v44.5.1') process.exit(1) +const values = [ + ['electron_package', () => JSON.parse(fs.readFileSync(`${dir}/node_modules/electron/package.json`, 'utf8')).version], + ['electron_lock', () => JSON.parse(fs.readFileSync(`${dir}/package-lock.json`, 'utf8')).packages['node_modules/electron'].version], + ['electron_dist', () => fs.readFileSync(`${dir}/node_modules/electron/dist/version`, 'utf8').trim()], +] +let failed = false +for (const [name, read] of values) { + let value + try { + value = read() + } catch { + console.log(`${name}=unreadable`) + failed = true + continue + } + const safe = typeof value === 'string' && /^v?[0-9.]{1,32}$/.test(value) ? value : 'invalid' + console.log(`${name}=${safe}`) + const normalized = name === 'electron_dist' && safe.startsWith('v') ? safe.slice(1) : safe + if (normalized !== '44.5.1') failed = true +} +if (failed) process.exit(1) NODE - [[ $(ELECTRON_RUN_AS_NODE=1 timeout 15s "$REAL_CLI_ELECTRON" -e 'process.stdout.write(process.versions.electron)') == 44.5.1 ]] - timeout 15s "$DEVSY_CLI_PATH" --version >"$REAL_CLI_EVIDENCE/cli-version.txt" - [[ -s $REAL_CLI_EVIDENCE/cli-version.txt ]] - timeout 15s "$DEVSY_CLI_PATH" context get --help >"$REAL_CLI_EVIDENCE/cli-api.txt" - timeout 15s "$go" version -m "$DEVSY_CLI_PATH" >"$REAL_CLI_EVIDENCE/cli-build.txt" - grep -Fq 'github.com/devsy-org/devsy' "$REAL_CLI_EVIDENCE/cli-build.txt" - awk -v revision="$revision" '$1 == "build" && $2 ~ /^vcs\.revision=/ { revisions++; if ($2 != "vcs.revision=" revision) exit 1 } $1 == "build" && $2 ~ /^vcs\.modified=/ { modified++; if ($2 != "vcs.modified=false") exit 1 } END { if (revisions != 1 || modified != 1) exit 1 }' "$REAL_CLI_EVIDENCE/cli-build.txt" - sha256sum "$DEVSY_CLI_PATH" "$REAL_CLI_ELECTRON" "$desktop/package-lock.json" >>"$REAL_CLI_EVIDENCE/hashes.txt" + preflight_fail 'Electron package, lock, or distribution version invalid; see preflight.txt' + fi + if electron_version=$(ELECTRON_RUN_AS_NODE=1 timeout 15s "$REAL_CLI_ELECTRON" -e 'process.stdout.write(process.versions.electron)' 2>/dev/null); then + [[ $electron_version =~ ^[0-9.]{1,32}$ ]] || preflight_fail 'Electron runtime version output invalid' + printf 'electron_runtime=%s\n' "$electron_version" >>"$REAL_CLI_EVIDENCE/preflight.txt" + [[ $electron_version == 44.5.1 ]] || preflight_fail 'Electron runtime version mismatch; see preflight.txt' + else + preflight_fail 'Electron runtime version command failed or timed out' + fi + timeout 15s "$DEVSY_CLI_PATH" --version >"$REAL_CLI_EVIDENCE/cli-version.txt" || + preflight_fail 'candidate CLI version command failed or timed out' + [[ -s $REAL_CLI_EVIDENCE/cli-version.txt ]] || preflight_fail 'candidate CLI version output empty' + timeout 15s "$DEVSY_CLI_PATH" context get --help >"$REAL_CLI_EVIDENCE/cli-api.txt" || + preflight_fail 'candidate CLI API probe failed or timed out' + timeout 15s "$go" version -m "$DEVSY_CLI_PATH" >"$REAL_CLI_EVIDENCE/cli-build.txt" || + preflight_fail 'candidate CLI build metadata probe failed or timed out' + grep -Fq 'github.com/devsy-org/devsy' "$REAL_CLI_EVIDENCE/cli-build.txt" || + preflight_fail 'candidate CLI module identity mismatch' + awk -v revision="$revision" '$1 == "build" && $2 ~ /^vcs\.revision=/ { revisions++; if ($2 != "vcs.revision=" revision) exit 1 } $1 == "build" && $2 ~ /^vcs\.modified=/ { modified++; if ($2 != "vcs.modified=false") exit 1 } END { if (revisions != 1 || modified != 1) exit 1 }' "$REAL_CLI_EVIDENCE/cli-build.txt" || + preflight_fail 'candidate CLI revision or clean-build metadata mismatch' cd "$desktop" exec timeout --kill-after=10s 180s xvfb-run -a "$node" "$desktop/node_modules/@playwright/test/cli.js" test --config playwright.real-cli.config.ts --workers=1 --retries=0 --reporter=list --output "$REAL_CLI_EVIDENCE/playwright-output" fi diff --git a/hack/ci/lint_patch.go b/hack/ci/lint_patch.go new file mode 100644 index 0000000000..a58c3a60d7 --- /dev/null +++ b/hack/ci/lint_patch.go @@ -0,0 +1,221 @@ +package main + +import ( + "crypto/sha256" + "encoding/json" + "errors" + "fmt" + "io" + "os" + "os/exec" + "path/filepath" + "regexp" + "strings" +) + +var ( + lintCommitID = regexp.MustCompile(`^[0-9a-fA-F]{40}$`) + lintSafePath = regexp.MustCompile(`^/[A-Za-z0-9_./-]+$`) +) + +type lintPatchRef struct { + SHA string `json:"sha"` +} + +type lintPatchPullRequest struct { + Base lintPatchRef `json:"base"` + Head lintPatchRef `json:"head"` +} + +type lintPatchEvent struct { + PullRequest *lintPatchPullRequest `json:"pull_request"` +} + +type lintPatchInput struct { + repo string + eventPath string + runnerTemp string +} + +type lintPatchResult struct { + base, head, checkout, mergeBase, path, digest string +} + +func lintPatchCLI(args []string, stdout, stderr io.Writer) int { + if len(args) != 0 { + _, _ = fmt.Fprintln(stderr, "lint-patch: unexpected arguments") + return 2 + } + repo, err := os.Getwd() + if err != nil { + _, _ = fmt.Fprintln(stderr, "lint-patch: cannot determine checkout directory") + return 1 + } + result, err := generateLintPatch(lintPatchInput{ + repo: repo, eventPath: os.Getenv("GITHUB_EVENT_PATH"), + runnerTemp: os.Getenv("RUNNER_TEMP"), + }) + if err != nil { + _, _ = fmt.Fprintf(stderr, "lint-patch: %v\n", err) + return 1 + } + _, _ = fmt.Fprintf( + stderr, + "lint-patch: base=%s head=%s checkout=%s merge_base=%s patch_sha256=%s\n", + result.base, + result.head, + result.checkout, + result.mergeBase, + result.digest, + ) + if _, err := fmt.Fprintf( + stdout, + "args=--new-from-patch=%s --new=false --new-from-rev= --new-from-merge-base=\n", + result.path, + ); err != nil { + _, _ = fmt.Fprintln(stderr, "lint-patch: cannot write action output") + return 1 + } + return 0 +} + +func generateLintPatch(input lintPatchInput) (lintPatchResult, error) { + var result lintPatchResult + base, head, err := readLintPatchEvent(input.eventPath) + if err != nil { + return result, err + } + result.base, result.head = base, head + checkout, err := validateLintCheckout(input.repo, head) + if err != nil { + return result, err + } + result.checkout = checkout + mergeBase, err := uniqueLintMergeBase(input.repo, base, head) + if err != nil { + return result, err + } + result.mergeBase = mergeBase + path, digest, err := writeLintPatch(input.repo, input.runnerTemp, mergeBase, head) + if err != nil { + return result, err + } + current, err := validateLintCheckout(input.repo, head) + if err != nil || current != checkout { + return result, errors.New("checkout changed while generating pull request patch") + } + result.path, result.digest = path, digest + return result, nil +} + +func readLintPatchEvent(path string) (string, string, error) { + if path == "" { + return "", "", errors.New("missing pull request event path") + } + file, err := os.Open(path) + if err != nil { + return "", "", errors.New("cannot open pull request event") + } + defer func() { _ = file.Close() }() + var event lintPatchEvent + decoder := json.NewDecoder(file) + if err := decoder.Decode(&event); err != nil || event.PullRequest == nil { + return "", "", errors.New("invalid pull request event") + } + if err := decoder.Decode(&struct{}{}); !errors.Is(err, io.EOF) { + return "", "", errors.New("invalid pull request event") + } + base := event.PullRequest.Base.SHA + head := event.PullRequest.Head.SHA + if !lintCommitID.MatchString(base) || !lintCommitID.MatchString(head) { + return "", "", errors.New("pull request base and head must be full SHA1 hashes") + } + return strings.ToLower(base), strings.ToLower(head), nil +} + +func validateLintCheckout(repo, head string) (string, error) { + prefix, err := lintGitOutput(repo, "rev-parse", "--show-prefix") + if err != nil || prefix != "" { + return "", errors.New("checkout must be the repository root") + } + checkout, err := lintGitOutput(repo, "rev-parse", "--verify", "HEAD^{commit}") + if err != nil || checkout != head { + return "", errors.New("checkout does not match pull request head") + } + return checkout, nil +} + +func uniqueLintMergeBase(repo, base, head string) (string, error) { + output, err := lintGitOutput(repo, "merge-base", "--all", base, head) + if err != nil { + return "", errors.New("cannot compute pull request merge base") + } + parts := strings.Fields(output) + if len(parts) != 1 || !lintCommitID.MatchString(parts[0]) { + return "", errors.New("pull request must have exactly one merge base") + } + return parts[0], nil +} + +func lintGitOutput(repo string, args ...string) (string, error) { + cmd := exec.Command("git", args...) + cmd.Dir = repo + output, err := cmd.Output() + if err != nil { + return "", err + } + return strings.TrimSpace(string(output)), nil +} + +func writeLintPatch(repo, temp, mergeBase, head string) (string, string, error) { + file, path, err := openLintPatch(temp) + if err != nil { + return "", "", err + } + hash := sha256.New() + cmd := exec.Command( + "git", + "--no-pager", + "diff", + "--no-ext-diff", + "--no-textconv", + "--no-color", + "--no-relative", + "--src-prefix=a/", + "--dst-prefix=b/", + "--find-renames", + "-l0", + "--unified=3", + mergeBase, + head, + "--", + ) + cmd.Dir = repo + cmd.Stdout = io.MultiWriter(file, hash) + runErr := cmd.Run() + info, statErr := file.Stat() + closeErr := file.Close() + if runErr != nil || statErr != nil || closeErr != nil { + return "", "", errors.New("cannot generate complete pull request patch") + } + if info.Size() == 0 { + return "", "", errors.New("pull request patch is empty") + } + return path, fmt.Sprintf("%x", hash.Sum(nil)), nil +} + +func openLintPatch(temp string) (*os.File, string, error) { + if !filepath.IsAbs(temp) || filepath.Clean(temp) != temp || !lintSafePath.MatchString(temp) { + return nil, "", errors.New("RUNNER_TEMP must be a safe absolute directory") + } + dir, err := os.MkdirTemp(temp, "devsy-lint-patch-") + if err != nil { + return nil, "", errors.New("cannot create private patch directory") + } + path := filepath.Join(dir, "pull-request.patch") + file, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0o600) + if err != nil { + return nil, "", errors.New("cannot create patch file") + } + return file, path, nil +} diff --git a/hack/ci/lint_patch_test.go b/hack/ci/lint_patch_test.go new file mode 100644 index 0000000000..4d144a1c51 --- /dev/null +++ b/hack/ci/lint_patch_test.go @@ -0,0 +1,291 @@ +package main + +import ( + "crypto/sha256" + "encoding/json" + "fmt" + "os" + "os/exec" + "path/filepath" + "strings" + "testing" +) + +type lintPatchFixture struct { + repo, temp, event string + base, head, merge, ancestor string +} + +func newLintPatchFixture(t *testing.T) lintPatchFixture { + t.Helper() + repo := t.TempDir() + gitFixture(t, repo, "init", "--initial-branch=main") + gitFixture(t, repo, "config", "user.name", "Test User") + gitFixture(t, repo, "config", "user.email", "test@example.invalid") + gitFixture(t, repo, "config", "commit.gpgsign", "false") + var initial strings.Builder + for i := range 100 { + fmt.Fprintf(&initial, "original line %03d\n", i) + } + writeFixture(t, filepath.Join(repo, "shared.txt"), initial.String()) + gitFixture(t, repo, "add", "shared.txt") + gitFixture(t, repo, "commit", "-m", "initial") + ancestor := gitFixture(t, repo, "rev-parse", "HEAD") + gitFixture(t, repo, "checkout", "-b", "feature") + headContent := strings.Replace( + initial.String(), + "original line 099", + "head-only final change", + 1, + ) + writeFixture(t, filepath.Join(repo, "shared.txt"), headContent) + var large strings.Builder + for i := range 21050 { + fmt.Fprintf(&large, "feature patch line %05d\n", i) + } + writeFixture(t, filepath.Join(repo, "large.txt"), large.String()) + writeFixture(t, filepath.Join(repo, "z-last.txt"), "late-head-marker\n") + gitFixture(t, repo, "add", "shared.txt", "large.txt", "z-last.txt") + gitFixture(t, repo, "commit", "-m", "feature") + head := gitFixture(t, repo, "rev-parse", "HEAD") + gitFixture(t, repo, "checkout", "main") + writeFixture(t, filepath.Join(repo, "shared.txt"), "base-only line\n"+initial.String()) + gitFixture(t, repo, "add", "shared.txt") + gitFixture(t, repo, "commit", "-m", "base") + base := gitFixture(t, repo, "rev-parse", "HEAD") + gitFixture(t, repo, "merge", "--no-ff", "--no-edit", head) + merge := gitFixture(t, repo, "rev-parse", "HEAD") + gitFixture(t, repo, "checkout", "--detach", head) + temp := t.TempDir() + event := filepath.Join(t.TempDir(), "event.json") + writeLintEvent(t, event, base, head) + return lintPatchFixture{ + repo: repo, + temp: temp, + event: event, + base: base, + head: head, + merge: merge, + ancestor: ancestor, + } +} + +func gitFixture(t *testing.T, repo string, args ...string) string { + t.Helper() + cmd := exec.Command("git", args...) + cmd.Dir = repo + cmd.Env = append( + os.Environ(), + "GIT_CONFIG_NOSYSTEM=1", + "GIT_CONFIG_GLOBAL=/dev/null", + "GIT_TERMINAL_PROMPT=0", + ) + output, err := cmd.CombinedOutput() + if err != nil { + t.Fatalf("git %q: %v\n%s", args, err, output) + } + return strings.TrimSpace(string(output)) +} + +func writeFixture(t *testing.T, path, value string) { + t.Helper() + if err := os.WriteFile(path, []byte(value), 0o600); err != nil { + t.Fatal(err) + } +} + +func writeLintEvent(t *testing.T, path, base, head string) { + t.Helper() + event := map[string]any{"pull_request": map[string]any{ + "base": map[string]string{"sha": base}, "head": map[string]string{"sha": head}, + }} + data, err := json.Marshal(event) + if err != nil { + t.Fatal(err) + } + writeFixture(t, path, string(data)) +} + +func (f lintPatchFixture) input() lintPatchInput { + return lintPatchInput{repo: f.repo, eventPath: f.event, runnerTemp: f.temp} +} + +func TestLintPatchIncludesCompleteHeadDiff(t *testing.T) { + f := newLintPatchFixture(t) + result, err := generateLintPatch(f.input()) + if err != nil { + t.Fatal(err) + } + data, err := os.ReadFile(result.path) + if err != nil { + t.Fatal(err) + } + assertLintPatchContents(t, data, result, f) + assertHeadAndMergedFixture(t, f) +} + +func assertHeadAndMergedFixture(t *testing.T, f lintPatchFixture) { + t.Helper() + head := gitFixture(t, f.repo, "show", "HEAD:shared.txt") + if strings.HasPrefix(head, "base-only line\n") || + !strings.HasSuffix(head, "head-only final change") { + t.Fatal("head checkout does not preserve the head-side source") + } + merged := gitFixture(t, f.repo, "show", f.merge+":shared.txt") + if !strings.HasPrefix(merged, "base-only line\n") || + !strings.HasSuffix(merged, "head-only final change") { + t.Fatal("fixture merge did not retain both base and head changes") + } +} + +func assertLintPatchContents( + t *testing.T, + data []byte, + result lintPatchResult, + f lintPatchFixture, +) { + t.Helper() + patch := string(data) + if strings.Count(patch, "\n") <= 20000 || !strings.Contains(patch, "+late-head-marker\n") { + t.Fatal("patch omitted its large body or final file") + } + if !strings.Contains(patch, "+head-only final change\n") || + strings.Contains(patch, "base-only line") { + t.Fatal("patch was not computed from merge base to pull request head") + } + if !strings.Contains(patch, "@@ -97,4 +97,4 @@") { + t.Fatal("patch did not retain the head-side hunk position") + } + assertLintPatchBinding(t, data, result, f) +} + +func assertLintPatchBinding(t *testing.T, data []byte, result lintPatchResult, f lintPatchFixture) { + t.Helper() + if result.base != f.base || result.head != f.head || result.checkout != f.head || + result.mergeBase != f.ancestor { + t.Fatalf("unexpected commit binding: %+v", result) + } + if got := fmt.Sprintf("%x", sha256.Sum256(data)); got != result.digest { + t.Fatalf("patch digest = %s, want %s", result.digest, got) + } + info, err := os.Stat(result.path) + if err != nil || info.Mode().Perm() != 0o600 { + t.Fatalf("patch permissions: %v %v", info, err) + } +} + +func TestLintPatchRejectsInvalidEventsAndCheckouts(t *testing.T) { + f := newLintPatchFixture(t) + for _, test := range []struct { + name string + edit func(*lintPatchInput) + }{ + {"missing event", func(input *lintPatchInput) { input.eventPath = "" }}, + {"missing file", func(input *lintPatchInput) { input.eventPath = filepath.Join(f.temp, "missing") }}, + {"unsafe temporary path", func(input *lintPatchInput) { input.runnerTemp += ";unsafe" }}, + } { + t.Run(test.name, func(t *testing.T) { + input := f.input() + test.edit(&input) + if _, err := generateLintPatch(input); err == nil { + t.Fatal("accepted invalid input") + } + }) + } + for _, test := range []struct{ name, base, head string }{ + {"missing base", "", f.head}, + {"malicious base", "--upload-pack=unsafe", f.head}, + {"abbreviated head", f.base, f.head[:12]}, + {"mismatched head", f.base, f.ancestor}, + {"missing object", strings.Repeat("a", 40), f.head}, + } { + t.Run(test.name, func(t *testing.T) { + event := filepath.Join(t.TempDir(), "event.json") + writeLintEvent(t, event, test.base, test.head) + input := f.input() + input.eventPath = event + if _, err := generateLintPatch(input); err == nil { + t.Fatal("accepted invalid event") + } + }) + } + for _, checkout := range []struct{ name, commit string }{ + {"synthetic merge checkout", f.merge}, + {"base checkout", f.base}, + } { + t.Run(checkout.name, func(t *testing.T) { + gitFixture(t, f.repo, "checkout", "--detach", checkout.commit) + if _, err := generateLintPatch(f.input()); err == nil { + t.Fatal("accepted checkout other than pull request head") + } + }) + } +} + +func TestLintPatchRejectsEmptyDiff(t *testing.T) { + f := newLintPatchFixture(t) + if _, _, err := writeLintPatch(f.repo, f.temp, f.ancestor, f.ancestor); err == nil { + t.Fatal("accepted empty patch") + } +} + +func TestLintPatchRejectsMalformedEvent(t *testing.T) { + for _, body := range []string{"{", "{}", "{} {}", setupNullDoc, "[]"} { + path := filepath.Join(t.TempDir(), "event.json") + writeFixture(t, path, body) + if _, _, err := readLintPatchEvent(path); err == nil { + t.Fatalf("accepted malformed event %q", body) + } + } + path := filepath.Join(t.TempDir(), "event.json") + writeLintEvent(t, path, strings.Repeat("a", 40), strings.Repeat("b", 40)) + data, err := os.ReadFile(path) + if err != nil { + t.Fatal(err) + } + writeFixture(t, path, string(data)+" {}") + if _, _, err := readLintPatchEvent(path); err == nil { + t.Fatal("accepted trailing event data") + } +} + +func TestLintPatchRejectsGitErrorsAndAmbiguousBases(t *testing.T) { + f := newLintPatchFixture(t) + if _, _, err := writeLintPatch(f.repo, f.temp, strings.Repeat("a", 40), f.head); err == nil { + t.Fatal("accepted git diff error") + } + tree := gitFixture(t, f.repo, "rev-parse", f.ancestor+"^{tree}") + a := f.treeCommit(t, tree, "branch a", f.ancestor) + b := f.treeCommit(t, tree, "branch b", f.ancestor) + left := f.treeCommit(t, tree, "left merge", a, b) + right := f.treeCommit(t, tree, "right merge", b, a) + if _, err := uniqueLintMergeBase(f.repo, left, right); err == nil { + t.Fatal("accepted multiple merge bases") + } + unrelated := f.treeCommit(t, tree, "unrelated") + if _, err := uniqueLintMergeBase(f.repo, left, unrelated); err == nil { + t.Fatal("accepted unrelated histories") + } +} + +func (f lintPatchFixture) treeCommit(t *testing.T, tree, message string, parents ...string) string { + t.Helper() + args := []string{"commit-tree", tree} + for _, parent := range parents { + args = append(args, "-p", parent) + } + cmd := exec.Command("git", args...) + cmd.Dir = f.repo + cmd.Env = append( + os.Environ(), + "GIT_CONFIG_NOSYSTEM=1", + "GIT_CONFIG_GLOBAL=/dev/null", + "GIT_TERMINAL_PROMPT=0", + ) + cmd.Stdin = strings.NewReader(message + "\n") + output, err := cmd.CombinedOutput() + if err != nil { + t.Fatalf("git commit-tree: %v\n%s", err, output) + } + return strings.TrimSpace(string(output)) +} diff --git a/hack/ci/main.go b/hack/ci/main.go index 6e7ae3c7c6..68b6460e8f 100644 --- a/hack/ci/main.go +++ b/hack/ci/main.go @@ -23,7 +23,7 @@ func main() { func runCLI(args []string, stdout, stderr io.Writer) int { if len(args) == 0 { - _, _ = fmt.Fprintln(stderr, "usage: ci [args]") + _, _ = fmt.Fprintln(stderr, "usage: ci [args]") return 2 } switch args[0] { @@ -37,6 +37,8 @@ func runCLI(args []string, stdout, stderr io.Writer) int { return setupCLI(args[1:], stdout, stderr) case "success": return successCLI(args[1:], stdout, stderr) + case "lint-patch": + return lintPatchCLI(args[1:], stdout, stderr) default: _, _ = fmt.Fprintf(stderr, "unknown command: %s\n", args[0]) return 2 From 475f1d7c117f23aaaf8adb7ef22cc8f3e13f8826 Mon Sep 17 00:00:00 2001 From: Samuel K Date: Wed, 18 Nov 2026 02:22:35 -0600 Subject: [PATCH 08/11] test(desktop): load the OS module during Electron evaluation --- desktop/e2e/context-options.real-cli.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/desktop/e2e/context-options.real-cli.ts b/desktop/e2e/context-options.real-cli.ts index 74d6cc31a7..da91d34584 100644 --- a/desktop/e2e/context-options.real-cli.ts +++ b/desktop/e2e/context-options.real-cli.ts @@ -114,7 +114,7 @@ test("private context options reach the real Electron sheet and errors reach its const paths = await app.evaluate(({ app }) => ({ platform: process.platform, packaged: app.isPackaged, - home: require("node:os").homedir(), + home: process.getBuiltinModule("node:os").homedir(), electronHome: app.getPath("home"), envHome: process.env.HOME, devsyHome: process.env.DEVSY_HOME, From 1bf1f1d93d6803f792f183cdc843b2192a86f9a0 Mon Sep 17 00:00:00 2001 From: Samuel K Date: Wed, 18 Nov 2026 02:45:59 -0600 Subject: [PATCH 09/11] fix(ci): support native Windows lint fixture paths --- hack/ci/lint_patch.go | 9 ++++-- hack/ci/lint_patch_test.go | 57 ++++++++++++++++++++++++++++++++++++-- 2 files changed, 60 insertions(+), 6 deletions(-) diff --git a/hack/ci/lint_patch.go b/hack/ci/lint_patch.go index a58c3a60d7..293c7f9a1a 100644 --- a/hack/ci/lint_patch.go +++ b/hack/ci/lint_patch.go @@ -15,7 +15,9 @@ import ( var ( lintCommitID = regexp.MustCompile(`^[0-9a-fA-F]{40}$`) - lintSafePath = regexp.MustCompile(`^/[A-Za-z0-9_./-]+$`) + lintSafePath = regexp.MustCompile( + `^(?:/[A-Za-z0-9_.-][A-Za-z0-9_./-]*|[A-Za-z]:/[A-Za-z0-9_./-]*)$`, + ) ) type lintPatchRef struct { @@ -205,7 +207,8 @@ func writeLintPatch(repo, temp, mergeBase, head string) (string, string, error) } func openLintPatch(temp string) (*os.File, string, error) { - if !filepath.IsAbs(temp) || filepath.Clean(temp) != temp || !lintSafePath.MatchString(temp) { + if !filepath.IsAbs(temp) || filepath.Clean(temp) != temp || + !lintSafePath.MatchString(filepath.ToSlash(temp)) { return nil, "", errors.New("RUNNER_TEMP must be a safe absolute directory") } dir, err := os.MkdirTemp(temp, "devsy-lint-patch-") @@ -217,5 +220,5 @@ func openLintPatch(temp string) (*os.File, string, error) { if err != nil { return nil, "", errors.New("cannot create patch file") } - return file, path, nil + return file, filepath.ToSlash(path), nil } diff --git a/hack/ci/lint_patch_test.go b/hack/ci/lint_patch_test.go index 4d144a1c51..5089716eee 100644 --- a/hack/ci/lint_patch_test.go +++ b/hack/ci/lint_patch_test.go @@ -7,6 +7,7 @@ import ( "os" "os/exec" "path/filepath" + "runtime" "strings" "testing" ) @@ -168,9 +169,59 @@ func assertLintPatchBinding(t *testing.T, data []byte, result lintPatchResult, f if got := fmt.Sprintf("%x", sha256.Sum256(data)); got != result.digest { t.Fatalf("patch digest = %s, want %s", result.digest, got) } - info, err := os.Stat(result.path) - if err != nil || info.Mode().Perm() != 0o600 { - t.Fatalf("patch permissions: %v %v", info, err) + assertLintPatchFile(t, result.path, f.temp) +} + +func assertLintPatchFile(t *testing.T, path, temp string) { + t.Helper() + assertLintPatchContainment(t, path, temp) + info, err := os.Lstat(path) + if err != nil || !info.Mode().IsRegular() { + t.Fatalf("patch is not a regular file: %v %v", info, err) + } + if runtime.GOOS != "windows" && info.Mode().Perm() != 0o600 { + t.Fatalf("patch permissions: %v", info.Mode()) + } +} + +func assertLintPatchContainment(t *testing.T, path, temp string) { + t.Helper() + rel, err := filepath.Rel(temp, path) + if err != nil || rel == "." || rel == ".." || + strings.HasPrefix(rel, ".."+string(os.PathSeparator)) { + t.Fatalf("patch is outside its temporary directory: %q %v", rel, err) + } +} + +func TestLintPatchSafePaths(t *testing.T) { + for _, test := range []struct { + path string + want bool + }{ + {"/tmp/runner-temp", true}, + {"C:/runner-temp", true}, + {"C:/", true}, + {"relative/path", false}, + {"//server/share", false}, + {"//?/C:/temp", false}, + {"C:/temp/D:/file", false}, + {"C:/temp with spaces", false}, + {"/tmp/file;unsafe", false}, + } { + if got := lintSafePath.MatchString(test.path); got != test.want { + t.Errorf("safe path %q = %t, want %t", test.path, got, test.want) + } + } + for _, path := range []string{ + "relative/path", + filepath.Join(os.TempDir(), "safe") + string(os.PathSeparator) + "..", + "//server/share", + } { + file, _, err := openLintPatch(path) + if err == nil { + _ = file.Close() + t.Errorf("accepted unsafe path %q", path) + } } } From 7b91802b8edac4d0b2a9dfdc7931427a58c8f521 Mon Sep 17 00:00:00 2001 From: Samuel K Date: Wed, 18 Nov 2026 03:05:04 -0600 Subject: [PATCH 10/11] test(desktop): match the rendered CLI result --- desktop/e2e/context-options.real-cli.ts | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/desktop/e2e/context-options.real-cli.ts b/desktop/e2e/context-options.real-cli.ts index da91d34584..c66e46534d 100644 --- a/desktop/e2e/context-options.real-cli.ts +++ b/desktop/e2e/context-options.real-cli.ts @@ -10,6 +10,7 @@ import { import { homedir } from "node:os" import { dirname, isAbsolute, join, relative, resolve } from "node:path" import { fileURLToPath } from "node:url" +import { stripVTControlCharacters } from "node:util" import { type ElectronApplication, _electron as electron, @@ -171,8 +172,9 @@ test("private context options reach the real Electron sheet and errors reach its ) as Array<{ name: string; default?: boolean }> expect(list.find((entry) => entry.name === name)?.default).toBe(true) const plain = run(["context", "get", "--context", name]).stdout - expect(plain).toContain("AGENT_INJECT_TIMEOUT") - expect(plain).toMatch(/AGENT_INJECT_TIMEOUT[^\n]*\b37\b/) + const visiblePlain = stripVTControlCharacters(plain) + expect(visiblePlain).toContain("AGENT_INJECT_TIMEOUT") + expect(visiblePlain).toMatch(/AGENT_INJECT_TIMEOUT[^\n]*\b37\b/) expect(() => JSON.parse(plain)).toThrow() const options = JSON.parse( run(["context", "get", "--context", name, "--result-format=json"]).stdout, From 1f33a68d71ef0ee33956acfc9cefee98260d599d Mon Sep 17 00:00:00 2001 From: Samuel K Date: Wed, 18 Nov 2026 20:59:19 -0600 Subject: [PATCH 11/11] test(desktop): capture the real CLI error toast --- desktop/e2e/context-options.real-cli.ts | 17 ++++++++++++----- 1 file changed, 12 insertions(+), 5 deletions(-) diff --git a/desktop/e2e/context-options.real-cli.ts b/desktop/e2e/context-options.real-cli.ts index c66e46534d..eb23126e8e 100644 --- a/desktop/e2e/context-options.real-cli.ts +++ b/desktop/e2e/context-options.real-cli.ts @@ -237,12 +237,19 @@ test("private context options reach the real Electron sheet and errors reach its expect(String(envelope?.message).length).toBeGreaterThan(0) expect(textFailure.stderr).toContain(String(envelope?.message)) await card.click() - await expect( - page.getByText(`Failed to load context options: ${envelope?.message}`, { - exact: false, - }), - ).toBeVisible() + const title = "Failed to load context options: " + const message = String(envelope?.message) + const cleanToast = `${title}${message}` + const wrappedToast = `${title}Error invoking remote method 'context_options': Error: ${message}` + const notifications = page.locator('section[aria-label^="Notifications"]') + const toast = notifications + .locator("[data-sonner-toast] [data-title]") + .filter({ hasText: title }) + await expect(toast).toBeVisible() + const actualToast = await toast.textContent() + log("context options toast", actualToast ?? "") await page.screenshot({ path: join(evidence, "context-error.png") }) + expect([cleanToast, wrappedToast]).toContain(actualToast) } finally { try { if (modified && originalConfig)