2024-03-01 17:13:50 +00:00
package cli
import (
2026-07-16 13:00:32 +03:00
"archive/tar"
2024-03-01 17:13:50 +00:00
"archive/zip"
"bytes"
2025-06-24 11:16:31 +02:00
"context"
2024-03-07 14:43:46 +00:00
"encoding/base64"
2024-03-01 17:13:50 +00:00
"encoding/json"
2026-07-16 13:00:32 +03:00
"errors"
2024-03-01 17:13:50 +00:00
"fmt"
2026-07-16 13:00:32 +03:00
"io"
"io/fs"
2026-01-20 10:28:52 +11:00
"net/http"
2024-03-21 17:06:28 +00:00
"net/url"
2024-03-01 17:13:50 +00:00
"os"
2026-07-16 13:00:32 +03:00
"path"
2024-03-01 17:13:50 +00:00
"path/filepath"
"strings"
"text/tabwriter"
"time"
2024-04-11 10:09:10 +01:00
"github.com/google/uuid"
2024-03-01 17:13:50 +00:00
"golang.org/x/xerrors"
2026-01-08 10:29:41 +04:00
"cdr.dev/slog/v3"
"cdr.dev/slog/v3/sloggers/sloghuman"
2024-03-21 17:06:28 +00:00
"github.com/coder/coder/v2/cli/cliui"
2026-01-08 15:24:11 +04:00
"github.com/coder/coder/v2/cli/cliutil"
2024-03-01 17:13:50 +00:00
"github.com/coder/coder/v2/codersdk"
"github.com/coder/coder/v2/support"
2024-03-15 11:24:38 -05:00
"github.com/coder/serpent"
2024-03-01 17:13:50 +00:00
)
2024-03-17 09:45:26 -05:00
func ( r * RootCmd ) support () * serpent . Command {
supportCmd := & serpent . Command {
2024-03-01 17:13:50 +00:00
Use : "support" ,
Short : "Commands for troubleshooting issues with a Coder deployment." ,
2024-03-15 11:24:38 -05:00
Handler : func ( inv * serpent . Invocation ) error {
2024-03-01 17:13:50 +00:00
return inv . Command . HelpHandler ( inv )
},
2024-03-17 09:45:26 -05:00
Children : [] * serpent . Command {
2024-03-01 17:13:50 +00:00
r . supportBundle (),
},
}
return supportCmd
}
2026-07-16 13:00:32 +03:00
func supportBundleBlurb ( workspaceFilePatterns [] string ) string {
blurb := cliui . Bold ( "This will collect the following information:\n" ) +
` - Coder deployment version
2024-03-25 15:14:27 +00:00
- Coder deployment Configuration (sanitized), including enabled experiments
2024-03-21 17:06:28 +00:00
- Coder deployment health snapshot
2026-01-20 10:28:52 +11:00
- Coder deployment stats (aggregated workspace/session metrics)
- Entitlements (if available)
- Health settings (dismissed healthchecks)
2024-03-21 17:06:28 +00:00
- Coder deployment Network troubleshooting information
2026-01-20 10:28:52 +11:00
- Workspace list accessible to the user (sanitized)
2024-03-21 17:06:28 +00:00
- Workspace configuration, parameters, and build logs
- Template version and source code for the given workspace
- Agent details (with environment variable sanitized)
- Agent network diagnostics
- Agent logs
2026-07-16 13:00:32 +03:00
`
if len ( workspaceFilePatterns ) > 0 {
blurb += " - Workspace files matching:\n"
for _ , pattern := range workspaceFilePatterns {
blurb += " - " + pattern + "\n"
}
}
return blurb + ` - License status
2026-01-20 10:28:52 +11:00
- pprof profiling data (if --pprof is enabled)
2024-03-21 17:06:28 +00:00
` + cliui . Bold ( "Note: " ) +
2026-07-16 13:00:32 +03:00
cliui . Wrap ( "While we try to sanitize sensitive data from support bundles, we cannot guarantee that they do not contain information that you or your organization may consider sensitive.\n" ) +
cliui . Bold ( "Please confirm that you will:\n" ) +
" - Review the support bundle before distribution\n" +
" - Only distribute it via trusted channels\n" +
cliui . Bold ( "Continue? " )
}
2024-03-21 17:06:28 +00:00
2024-03-17 09:45:26 -05:00
func ( r * RootCmd ) supportBundle () * serpent . Command {
2024-03-01 17:13:50 +00:00
var outputPath string
2024-03-21 17:06:28 +00:00
var coderURLOverride string
2026-01-20 10:28:52 +11:00
var workspacesTotalCap64 int64 = 10
var templateName string
2026-07-16 13:00:32 +03:00
var workspaceFilePatterns [] string
2026-01-20 10:28:52 +11:00
var pprof bool
2024-03-17 09:45:26 -05:00
cmd := & serpent . Command {
2026-04-22 17:21:28 +03:00
Use : "bundle [<workspace>] [<agent>]" ,
2024-03-01 17:13:50 +00:00
Short : "Generate a support bundle to troubleshoot issues connecting to a workspace." ,
2026-04-22 17:21:28 +03:00
Long : `This command generates a file containing detailed troubleshooting information about the Coder deployment and workspace connections. You may specify a single workspace (and optionally an agent name). When run inside a workspace, the workspace and agent are inferred from the environment if not provided.` ,
2024-03-15 11:24:38 -05:00
Middleware : serpent . Chain (
serpent . RequireRangeArgs ( 0 , 2 ),
2024-03-01 17:13:50 +00:00
),
2024-03-15 11:24:38 -05:00
Handler : func ( inv * serpent . Invocation ) error {
2025-09-22 17:14:07 +04:00
client , err := r . InitClient ( inv )
if err != nil {
return err
}
2024-03-21 17:06:28 +00:00
var cliLogBuf bytes . Buffer
cliLogW := sloghuman . Sink ( & cliLogBuf )
cliLog := slog . Make ( cliLogW ). Leveled ( slog . LevelDebug )
if r . verbose {
cliLog = cliLog . AppendSinks ( sloghuman . Sink ( inv . Stderr ))
}
ans , err := cliui . Prompt ( inv , cliui . PromptOptions {
2026-07-16 13:00:32 +03:00
Text : supportBundleBlurb ( workspaceFilePatterns ),
2024-03-21 17:06:28 +00:00
Secret : false ,
IsConfirm : true ,
})
if err != nil || ans != cliui . ConfirmYes {
return err
}
if skip , _ := inv . ParsedFlags (). GetBool ( "yes" ); skip {
cliLog . Debug ( inv . Context (), "user auto-confirmed" )
} else {
cliLog . Debug ( inv . Context (), "user confirmed manually" , slog . F ( "answer" , ans ))
}
vi := defaultVersionInfo ()
cliLog . Debug ( inv . Context (), "version info" ,
slog . F ( "version" , vi . Version ),
slog . F ( "build_time" , vi . BuildTime ),
slog . F ( "external_url" , vi . ExternalURL ),
slog . F ( "slim" , vi . Slim ),
slog . F ( "agpl" , vi . AGPL ),
slog . F ( "boring_crypto" , vi . BoringCrypto ),
2024-03-01 17:13:50 +00:00
)
2024-03-21 17:06:28 +00:00
cliLog . Debug ( inv . Context (), "invocation" , slog . F ( "args" , strings . Join ( os . Args , " " )))
2026-03-18 13:43:10 +00:00
// Bypass rate limiting for support bundle collection since it makes many API calls.
// Note: this can only be done by the owner user.
if ok , err := support . CanGenerateFull ( inv . Context (), client ); err == nil && ok {
cliLog . Debug ( inv . Context (), "running as owner" )
client . HTTPClient . Transport = & codersdk . HeaderTransport {
Transport : client . HTTPClient . Transport ,
Header : http . Header { codersdk . BypassRatelimitHeader : { "true" }},
}
} else if ! ok {
cliLog . Warn ( inv . Context (), "not running as owner, not all information available" )
} else {
cliLog . Error ( inv . Context (), "failed to look up current user" , slog . Error ( err ))
}
2024-03-21 17:06:28 +00:00
// Check if we're running inside a workspace
if val , found := os . LookupEnv ( "CODER" ); found && val == "true" {
2024-04-15 17:10:49 +01:00
cliui . Warn ( inv . Stderr , "Running inside Coder workspace; this can affect results!" )
2024-03-21 17:06:28 +00:00
cliLog . Debug ( inv . Context (), "running inside coder workspace" )
}
if coderURLOverride != "" && coderURLOverride != client . URL . String () {
u , err := url . Parse ( coderURLOverride )
if err != nil {
return xerrors . Errorf ( "invalid value for Coder URL override: %w" , err )
}
_ , _ = fmt . Fprintf ( inv . Stderr , "Overrode Coder URL to %q; this can affect results!\n" , coderURLOverride )
cliLog . Debug ( inv . Context (), "coder url overridden" , slog . F ( "url" , coderURLOverride ))
client . URL = u
}
2024-03-01 17:13:50 +00:00
2024-04-11 10:09:10 +01:00
var (
2026-01-20 10:28:52 +11:00
wsID uuid . UUID
agtID uuid . UUID
templateID uuid . UUID
2024-04-11 10:09:10 +01:00
)
2026-04-22 17:21:28 +03:00
if len ( inv . Args ) == 0 {
// When running inside a workspace, infer the workspace
// and agent from environment variables set by the agent.
// Prefer CODER_WORKSPACE_ID for a direct UUID lookup;
// fall back to owner/name for older agents that do not
// set the ID variable.
if inv . Environ . Get ( "CODER" ) == "true" {
var wsArg string
if v := inv . Environ . Get ( "CODER_WORKSPACE_ID" ); v != "" {
wsArg = v
} else {
wsOwner := inv . Environ . Get ( "CODER_WORKSPACE_OWNER_NAME" )
wsName := inv . Environ . Get ( "CODER_WORKSPACE_NAME" )
if wsOwner != "" && wsName != "" {
wsArg = wsOwner + "/" + wsName
}
}
agtName := inv . Environ . Get ( "CODER_WORKSPACE_AGENT_NAME" )
if wsArg != "" {
cliLog . Info ( inv . Context (), "detected workspace from environment" ,
slog . F ( "workspace_arg" , wsArg ),
slog . F ( "agent_name" , agtName ),
)
cliui . Info ( inv . Stderr , "Detected workspace from environment: " + wsArg )
inv . Args = append ( inv . Args , wsArg )
if agtName != "" {
inv . Args = append ( inv . Args , agtName )
}
}
}
}
2024-03-01 17:13:50 +00:00
if len ( inv . Args ) == 0 {
2024-04-11 10:09:10 +01:00
cliLog . Warn ( inv . Context (), "no workspace specified" )
2024-04-15 17:10:49 +01:00
cliui . Warn ( inv . Stderr , "No workspace specified. This will result in incomplete information." )
2024-04-11 10:09:10 +01:00
} else {
2026-04-27 12:58:26 +01:00
ws , err := client . ResolveWorkspace ( inv . Context (), inv . Args [ 0 ])
2024-04-11 10:09:10 +01:00
if err != nil {
return xerrors . Errorf ( "invalid workspace: %w" , err )
}
cliLog . Debug ( inv . Context (), "found workspace" ,
slog . F ( "workspace_name" , ws . Name ),
slog . F ( "workspace_id" , ws . ID ),
)
wsID = ws . ID
agentName := ""
if len ( inv . Args ) > 1 {
agentName = inv . Args [ 1 ]
}
2024-03-01 17:13:50 +00:00
2024-04-11 10:09:10 +01:00
agt , found := findAgent ( agentName , ws . LatestBuild . Resources )
if ! found {
cliLog . Warn ( inv . Context (), "could not find agent in workspace" , slog . F ( "agent_name" , agentName ))
} else {
cliLog . Debug ( inv . Context (), "found workspace agent" ,
slog . F ( "agent_name" , agt . Name ),
slog . F ( "agent_id" , agt . ID ),
)
agtID = agt . ID
}
2024-03-01 17:13:50 +00:00
}
2026-01-20 10:28:52 +11:00
// Resolve template by name if provided (captures active version)
// Fallback: if canonical name lookup fails, match DisplayName (case-insensitive).
if templateName != "" {
id , err := resolveTemplateID ( inv . Context (), client , templateName )
if err != nil {
return err
}
templateID = id
}
2024-03-01 17:13:50 +00:00
if outputPath == "" {
cwd , err := filepath . Abs ( "." )
if err != nil {
return xerrors . Errorf ( "could not determine current working directory: %w" , err )
}
fname := fmt . Sprintf ( "coder-support-%d.zip" , time . Now (). Unix ())
outputPath = filepath . Join ( cwd , fname )
}
2024-03-21 17:06:28 +00:00
cliLog . Debug ( inv . Context (), "output path" , slog . F ( "path" , outputPath ))
2024-03-01 17:13:50 +00:00
w , err := os . Create ( outputPath )
if err != nil {
return xerrors . Errorf ( "create output file: %w" , err )
}
zwr := zip . NewWriter ( w )
defer zwr . Close ()
2024-03-21 17:06:28 +00:00
clientLog := slog . Make (). Leveled ( slog . LevelDebug )
if r . verbose {
clientLog . AppendSinks ( sloghuman . Sink ( inv . Stderr ))
}
2026-01-20 10:28:52 +11:00
if pprof {
_ , _ = fmt . Fprintln ( inv . Stderr , "pprof data collection will take approximately 30 seconds..." )
}
2024-03-21 17:06:28 +00:00
deps := support . Deps {
Client : client ,
// Support adds a sink so we don't need to supply one ourselves.
2026-07-16 13:00:32 +03:00
Log : clientLog ,
WorkspaceID : wsID ,
AgentID : agtID ,
WorkspacesTotalCap : int ( workspacesTotalCap64 ),
TemplateID : templateID ,
WorkspaceFilePatterns : workspaceFilePatterns ,
CollectPprof : pprof ,
2024-03-21 17:06:28 +00:00
}
2024-03-01 17:13:50 +00:00
bun , err := support . Run ( inv . Context (), & deps )
if err != nil {
_ = os . Remove ( outputPath ) // best effort
return xerrors . Errorf ( "create support bundle: %w" , err )
}
2024-04-16 13:31:56 +01:00
2024-08-22 11:15:02 +01:00
summarizeBundle ( inv , bun )
2024-03-21 17:06:28 +00:00
bun . CLILogs = cliLogBuf . Bytes ()
2024-03-01 17:13:50 +00:00
if err := writeBundle ( bun , zwr ); err != nil {
_ = os . Remove ( outputPath ) // best effort
return xerrors . Errorf ( "write support bundle to %s: %w" , outputPath , err )
}
2024-03-21 17:06:28 +00:00
_ , _ = fmt . Fprintln ( inv . Stderr , "Wrote support bundle to " + outputPath )
2024-04-15 17:10:49 +01:00
2024-03-01 17:13:50 +00:00
return nil
},
}
2024-03-15 11:24:38 -05:00
cmd . Options = serpent . OptionSet {
2024-03-21 17:06:28 +00:00
cliui . SkipPromptOption (),
2024-03-01 17:13:50 +00:00
{
2024-03-21 17:06:28 +00:00
Flag : "output-file" ,
FlagShorthand : "O" ,
Env : "CODER_SUPPORT_BUNDLE_OUTPUT_FILE" ,
2024-03-01 17:13:50 +00:00
Description : "File path for writing the generated support bundle. Defaults to coder-support-$(date +%s).zip." ,
2024-03-15 11:24:38 -05:00
Value : serpent . StringOf ( & outputPath ),
2024-03-01 17:13:50 +00:00
},
2024-03-21 17:06:28 +00:00
{
Flag : "url-override" ,
Env : "CODER_SUPPORT_BUNDLE_URL_OVERRIDE" ,
Description : "Override the URL to your Coder deployment. This may be useful, for example, if you need to troubleshoot a specific Coder replica." ,
Value : serpent . StringOf ( & coderURLOverride ),
},
2026-01-20 10:28:52 +11:00
{
Flag : "workspaces-total-cap" ,
Env : "CODER_SUPPORT_BUNDLE_WORKSPACES_TOTAL_CAP" ,
Description : "Maximum number of workspaces to include in the support bundle. Set to 0 or negative value to disable the cap. Defaults to 10." ,
Value : serpent . Int64Of ( & workspacesTotalCap64 ),
},
{
Flag : "template" ,
Env : "CODER_SUPPORT_BUNDLE_TEMPLATE" ,
Description : "Template name to include in the support bundle. Use org_name/template_name if template name is reused across multiple organizations." ,
Value : serpent . StringOf ( & templateName ),
},
2026-07-16 13:00:32 +03:00
{
Flag : "workspace-file" ,
Env : "CODER_SUPPORT_BUNDLE_WORKSPACE_FILE" ,
Description : "File path or glob to collect from inside the remote workspace. Environment variables are expanded in the workspace; paths must then be absolute or start with ~/, which resolves against the agent user's home directory. Files local to the machine running this command are not collected. Can be specified multiple times." ,
Value : serpent . StringArrayOf ( & workspaceFilePatterns ),
},
2026-01-20 10:28:52 +11:00
{
Flag : "pprof" ,
Env : "CODER_SUPPORT_BUNDLE_PPROF" ,
Description : "Collect pprof profiling data from the Coder server and agent. Requires Coder server version 2.28.0 or newer." ,
Value : serpent . BoolOf ( & pprof ),
},
2024-03-01 17:13:50 +00:00
}
return cmd
}
2026-01-20 10:28:52 +11:00
// Resolve a template to its ID, supporting:
// - org/name form
// - slug or display name match (case-insensitive) across all memberships
func resolveTemplateID ( ctx context . Context , client * codersdk . Client , templateArg string ) ( uuid . UUID , error ) {
orgPart := ""
namePart := templateArg
if slash := strings . IndexByte ( templateArg , '/' ); slash > 0 && slash < len ( templateArg ) - 1 {
orgPart = templateArg [: slash ]
namePart = templateArg [ slash + 1 :]
}
resolveInOrg := func ( orgID uuid . UUID ) ( codersdk . Template , bool , error ) {
if t , err := client . TemplateByName ( ctx , orgID , namePart ); err == nil {
return t , true , nil
}
tpls , err := client . TemplatesByOrganization ( ctx , orgID )
if err != nil {
return codersdk . Template {}, false , nil
}
for _ , t := range tpls {
if strings . EqualFold ( t . Name , namePart ) || strings . EqualFold ( t . DisplayName , namePart ) {
return t , true , nil
}
}
return codersdk . Template {}, false , nil
}
if orgPart != "" {
org , err := client . OrganizationByName ( ctx , orgPart )
if err != nil {
return uuid . Nil , xerrors . Errorf ( "get organization %q: %w" , orgPart , err )
}
t , found , err := resolveInOrg ( org . ID )
if err != nil {
return uuid . Nil , err
}
if ! found {
return uuid . Nil , xerrors . Errorf ( "template %q not found in organization %q" , namePart , orgPart )
}
return t . ID , nil
}
orgs , err := client . OrganizationsByUser ( ctx , codersdk . Me )
if err != nil {
return uuid . Nil , xerrors . Errorf ( "get organizations: %w" , err )
}
var (
foundTpl codersdk . Template
foundOrgs [] string
)
for _ , org := range orgs {
if t , found , err := resolveInOrg ( org . ID ); err == nil && found {
if len ( foundOrgs ) == 0 {
foundTpl = t
}
foundOrgs = append ( foundOrgs , org . Name )
}
}
switch len ( foundOrgs ) {
case 0 :
return uuid . Nil , xerrors . Errorf ( "template %q not found in your organizations" , namePart )
case 1 :
return foundTpl . ID , nil
default :
return uuid . Nil , xerrors . Errorf (
"template %q found in multiple organizations (%s); use --template \"<org_name/%s>\" to target desired template." ,
namePart ,
strings . Join ( foundOrgs , ", " ),
namePart ,
)
}
}
2024-08-22 11:15:02 +01:00
// summarizeBundle makes a best-effort attempt to write a short summary
// of the support bundle to the user's terminal.
func summarizeBundle ( inv * serpent . Invocation , bun * support . Bundle ) {
if bun == nil {
cliui . Error ( inv . Stdout , "No support bundle generated!" )
return
}
2026-03-18 13:43:10 +00:00
var docsURL string
if bun . Deployment . Config != nil {
docsURL = bun . Deployment . Config . Values . DocsURL . String ()
} else {
cliui . Warn ( inv . Stdout , "No deployment configuration available. This may require the Owner role." )
2024-08-22 11:15:02 +01:00
}
2026-03-18 13:43:10 +00:00
if bun . Deployment . HealthReport != nil {
deployHealthSummary := bun . Deployment . HealthReport . Summarize ( docsURL )
if len ( deployHealthSummary ) > 0 {
cliui . Warn ( inv . Stdout , "Deployment health issues detected:" , deployHealthSummary ... )
}
} else {
cliui . Warn ( inv . Stdout , "No deployment health report available." )
2024-08-22 11:15:02 +01:00
}
if bun . Network . Netcheck == nil {
cliui . Error ( inv . Stdout , "No network troubleshooting information available!" )
return
}
clientNetcheckSummary := bun . Network . Netcheck . Summarize ( "Client netcheck:" , docsURL )
if len ( clientNetcheckSummary ) > 0 {
2025-08-21 10:08:51 +10:00
cliui . Warn ( inv . Stdout , "Networking issues detected:" , clientNetcheckSummary ... )
2024-08-22 11:15:02 +01:00
}
}
2024-03-01 17:13:50 +00:00
func findAgent ( agentName string , haystack [] codersdk . WorkspaceResource ) ( * codersdk . WorkspaceAgent , bool ) {
for _ , res := range haystack {
for _ , agt := range res . Agents {
if agentName == "" {
// just return the first
return & agt , true
}
if agt . Name == agentName {
return & agt , true
}
}
}
return nil , false
}
func writeBundle ( src * support . Bundle , dest * zip . Writer ) error {
2024-03-15 11:01:39 +00:00
// We JSON-encode the following:
2024-03-01 17:13:50 +00:00
for k , v := range map [ string ] any {
2024-03-15 11:01:39 +00:00
"agent/agent.json" : src . Agent . Agent ,
"agent/listening_ports.json" : src . Agent . ListeningPorts ,
"agent/manifest.json" : src . Agent . Manifest ,
"agent/peer_diagnostics.json" : src . Agent . PeerDiagnostics ,
"agent/ping_result.json" : src . Agent . PingResult ,
2024-04-12 09:40:04 +01:00
"deployment/buildinfo.json" : src . Deployment . BuildInfo ,
"deployment/config.json" : src . Deployment . Config ,
"deployment/experiments.json" : src . Deployment . Experiments ,
"deployment/health.json" : src . Deployment . HealthReport ,
2026-01-20 10:28:52 +11:00
"deployment/stats.json" : src . Deployment . Stats ,
"deployment/entitlements.json" : src . Deployment . Entitlements ,
"deployment/health_settings.json" : src . Deployment . HealthSettings ,
"deployment/workspaces.json" : src . Deployment . Workspaces ,
2024-04-12 09:40:04 +01:00
"network/connection_info.json" : src . Network . ConnectionInfo ,
"network/netcheck.json" : src . Network . Netcheck ,
2024-06-13 13:09:54 +04:00
"network/interfaces.json" : src . Network . Interfaces ,
2024-03-07 14:43:46 +00:00
"workspace/template.json" : src . Workspace . Template ,
"workspace/template_version.json" : src . Workspace . TemplateVersion ,
"workspace/parameters.json" : src . Workspace . Parameters ,
2024-04-12 09:40:04 +01:00
"workspace/workspace.json" : src . Workspace . Workspace ,
2024-03-01 17:13:50 +00:00
} {
f , err := dest . Create ( k )
if err != nil {
return xerrors . Errorf ( "create file %q in archive: %w" , k , err )
}
enc := json . NewEncoder ( f )
enc . SetIndent ( "" , " " )
if err := enc . Encode ( v ); err != nil {
return xerrors . Errorf ( "write json to %q: %w" , k , err )
}
}
2026-01-20 10:28:52 +11:00
// Include named template artifacts (if requested)
if src . NamedTemplate . Template . ID != uuid . Nil {
name := src . NamedTemplate . Template . Name
// JSON files
for k , v := range map [ string ] any {
"templates/" + name + "/template.json" : src . NamedTemplate . Template ,
"templates/" + name + "/template_version.json" : src . NamedTemplate . TemplateVersion ,
} {
f , err := dest . Create ( k )
if err != nil {
return xerrors . Errorf ( "create file %q in archive: %w" , k , err )
}
enc := json . NewEncoder ( f )
enc . SetIndent ( "" , " " )
if err := enc . Encode ( v ); err != nil {
return xerrors . Errorf ( "write json to %q: %w" , k , err )
}
}
// Binary template file (zip)
if namedZipBytes , err := base64 . StdEncoding . DecodeString ( src . NamedTemplate . TemplateFileBase64 ); err == nil {
k := "templates/" + name + "/template_file.zip"
f , err := dest . Create ( k )
if err != nil {
return xerrors . Errorf ( "create file %q in archive: %w" , k , err )
}
if _ , err := f . Write ( namedZipBytes ); err != nil {
return xerrors . Errorf ( "write file %q in archive: %w" , k , err )
}
}
}
var buildInfoRef string
if src . Deployment . BuildInfo != nil {
if raw , err := json . Marshal ( src . Deployment . BuildInfo ); err == nil {
buildInfoRef = base64 . StdEncoding . EncodeToString ( raw )
}
}
tailnetHTML := src . Network . TailnetDebug
if buildInfoRef != "" {
tailnetHTML += "\n<!-- trace " + buildInfoRef + " -->"
}
2024-03-07 14:43:46 +00:00
templateVersionBytes , err := base64 . StdEncoding . DecodeString ( src . Workspace . TemplateFileBase64 )
if err != nil {
return xerrors . Errorf ( "decode template zip from base64" )
}
2025-06-24 11:16:31 +02:00
licenseStatus , err := humanizeLicenses ( src . Deployment . Licenses )
if err != nil {
return xerrors . Errorf ( "format license status: %w" , err )
}
2024-03-15 11:01:39 +00:00
// The below we just write as we have them:
2024-03-01 17:13:50 +00:00
for k , v := range map [ string ] string {
2024-03-15 11:01:39 +00:00
"agent/logs.txt" : string ( src . Agent . Logs ),
2024-03-15 15:33:49 +00:00
"agent/agent_magicsock.html" : string ( src . Agent . AgentMagicsockHTML ),
"agent/client_magicsock.html" : string ( src . Agent . ClientMagicsockHTML ),
2024-03-15 11:01:39 +00:00
"agent/startup_logs.txt" : humanizeAgentLogs ( src . Agent . StartupLogs ),
2024-03-15 15:33:49 +00:00
"agent/prometheus.txt" : string ( src . Agent . Prometheus ),
2026-01-20 10:28:52 +11:00
"deployment/prometheus.txt" : string ( src . Deployment . Prometheus ),
2024-03-21 17:06:28 +00:00
"cli_logs.txt" : string ( src . CLILogs ),
2024-04-12 09:40:04 +01:00
"logs.txt" : strings . Join ( src . Logs , "\n" ),
"network/coordinator_debug.html" : src . Network . CoordinatorDebug ,
2026-01-20 10:28:52 +11:00
"network/tailnet_debug.html" : tailnetHTML ,
2024-04-12 09:40:04 +01:00
"workspace/build_logs.txt" : humanizeBuildLogs ( src . Workspace . BuildLogs ),
"workspace/template_file.zip" : string ( templateVersionBytes ),
2025-06-24 11:16:31 +02:00
"license-status.txt" : licenseStatus ,
2024-03-01 17:13:50 +00:00
} {
f , err := dest . Create ( k )
if err != nil {
return xerrors . Errorf ( "create file %q in archive: %w" , k , err )
}
if _ , err := f . Write ([] byte ( v )); err != nil {
return xerrors . Errorf ( "write file %q in archive: %w" , k , err )
}
}
2026-01-20 10:28:52 +11:00
2026-07-16 13:00:32 +03:00
if err := writeWorkspaceFilesArchive ( src . Agent . WorkspaceFilesArchive , dest , supportBundleWorkspaceFilesMaxBytes ); err != nil {
return xerrors . Errorf ( "write workspace files: %w" , err )
}
2026-01-20 10:28:52 +11:00
// Write pprof binary data
if err := writePprofData ( src . Pprof , dest ); err != nil {
return xerrors . Errorf ( "write pprof data: %w" , err )
}
2024-03-01 17:13:50 +00:00
if err := dest . Close (); err != nil {
return xerrors . Errorf ( "close zip file: %w" , err )
}
return nil
}
2026-07-16 13:00:32 +03:00
// supportBundleWorkspaceFilesMaxBytes guards against a misbehaving agent;
// the agent itself caps collection at 100 MiB.
const supportBundleWorkspaceFilesMaxBytes int64 = 110 * 1024 * 1024
// writeWorkspaceFilesArchive unpacks the agent's tar into the bundle under
// agent/workspace_files/; dropped entries are recorded in collection_errors.txt.
func writeWorkspaceFilesArchive ( src [] byte , dest * zip . Writer , maxBytes int64 ) error {
if len ( src ) == 0 {
return nil
}
tr := tar . NewReader ( bytes . NewReader ( src ))
remaining := maxBytes
var skipped [] string
for {
hdr , err := tr . Next ()
if errors . Is ( err , io . EOF ) {
break
}
if err != nil {
// A malformed archive shouldn't sink the rest of the bundle.
skipped = append ( skipped , fmt . Sprintf ( "read workspace files archive: %s" , err ))
break
}
name , ok := safeWorkspaceFilesArchiveEntryName ( hdr . Name )
if ! ok || hdr . Typeflag != tar . TypeReg {
skipped = append ( skipped , fmt . Sprintf ( "%s: unexpected entry" , hdr . Name ))
continue
}
if hdr . Size > remaining {
// Only a misbehaving agent exceeds the budget; stop trusting
// the rest of the archive.
skipped = append ( skipped , fmt . Sprintf ( "%s: %d bytes exceeds remaining %d byte budget, aborting" , name , hdr . Size , remaining ))
break
}
// A failed create means the output zip itself is broken.
f , err := dest . Create ( path . Join ( "agent/workspace_files" , name ))
if err != nil {
return xerrors . Errorf ( "create workspace files entry %q: %w" , name , err )
}
// io.CopyN bounds the copy at hdr.Size so a header lying about
// size cannot make us read past the entry; copy failures are
// recorded, not fatal.
n , err := io . CopyN ( f , tr , hdr . Size )
remaining -= n
if errors . Is ( err , io . EOF ) {
err = nil
}
if err != nil {
skipped = append ( skipped , fmt . Sprintf ( "%s: copy: %s (entry may be truncated)" , name , err ))
}
}
return writeWorkspaceFilesCollectionErrors ( dest , skipped )
}
// writeWorkspaceFilesCollectionErrors records dropped workspace file entries in the
// bundle instead of failing it.
func writeWorkspaceFilesCollectionErrors ( dest * zip . Writer , skipped [] string ) error {
if len ( skipped ) == 0 {
return nil
}
f , err := dest . Create ( "agent/workspace_files/collection_errors.txt" )
if err != nil {
return xerrors . Errorf ( "create workspace files errors: %w" , err )
}
body := "# workspace file entries dropped while assembling the support bundle\n" +
strings . Join ( skipped , "\n" ) + "\n"
if _ , err := f . Write ([] byte ( body )); err != nil {
return xerrors . Errorf ( "write workspace files errors: %w" , err )
}
return nil
}
// safeWorkspaceFilesArchiveEntryName returns name when it is safe to embed in
// the bundle: a valid slash path within the expected layout. Backslashes
// are rejected; some Windows extractors treat them as separators.
func safeWorkspaceFilesArchiveEntryName ( name string ) ( string , bool ) {
if strings . Contains ( name , `\` ) || ! fs . ValidPath ( name ) {
return "" , false
}
if name != "manifest.json" && ! strings . HasPrefix ( name , "files/" ) {
return "" , false
}
return name , true
}
2026-01-20 10:28:52 +11:00
func writePprofData ( pprof support . Pprof , dest * zip . Writer ) error {
// Write server pprof data directly to pprof directory
if pprof . Server != nil {
if err := writePprofCollection ( "pprof" , pprof . Server , dest ); err != nil {
return xerrors . Errorf ( "write server pprof data: %w" , err )
}
}
// Write agent pprof data
if pprof . Agent != nil {
if err := writePprofCollection ( "pprof/agent" , pprof . Agent , dest ); err != nil {
return xerrors . Errorf ( "write agent pprof data: %w" , err )
}
}
return nil
}
func writePprofCollection ( basePath string , collection * support . PprofCollection , dest * zip . Writer ) error {
// Define the pprof files to write with their extensions
files := map [ string ][] byte {
"allocs.prof.gz" : collection . Allocs ,
"heap.prof.gz" : collection . Heap ,
"profile.prof.gz" : collection . Profile ,
"block.prof.gz" : collection . Block ,
"mutex.prof.gz" : collection . Mutex ,
"goroutine.prof.gz" : collection . Goroutine ,
"threadcreate.prof.gz" : collection . Threadcreate ,
"trace.gz" : collection . Trace ,
}
// Write binary pprof files
for filename , data := range files {
if len ( data ) > 0 {
filePath := basePath + "/" + filename
f , err := dest . Create ( filePath )
if err != nil {
return xerrors . Errorf ( "create pprof file %q: %w" , filePath , err )
}
if _ , err := f . Write ( data ); err != nil {
return xerrors . Errorf ( "write pprof file %q: %w" , filePath , err )
}
}
}
// Write cmdline as text file
if collection . Cmdline != "" {
filePath := basePath + "/cmdline.txt"
f , err := dest . Create ( filePath )
if err != nil {
return xerrors . Errorf ( "create cmdline file %q: %w" , filePath , err )
}
if _ , err := f . Write ([] byte ( collection . Cmdline )); err != nil {
return xerrors . Errorf ( "write cmdline file %q: %w" , filePath , err )
}
}
if collection . Symbol != "" {
filePath := basePath + "/symbol.txt"
f , err := dest . Create ( filePath )
if err != nil {
return xerrors . Errorf ( "create symbol file %q: %w" , filePath , err )
}
if _ , err := f . Write ([] byte ( collection . Symbol )); err != nil {
return xerrors . Errorf ( "write symbol file %q: %w" , filePath , err )
}
}
return nil
}
2024-03-01 17:13:50 +00:00
func humanizeAgentLogs ( ls [] codersdk . WorkspaceAgentLog ) string {
var buf bytes . Buffer
tw := tabwriter . NewWriter ( & buf , 0 , 2 , 1 , ' ' , 0 )
for _ , l := range ls {
_ , _ = fmt . Fprintf ( tw , "%s\t[%s]\t%s\n" ,
l . CreatedAt . Format ( "2006-01-02 15:04:05.000" ), // for consistency with slog
string ( l . Level ),
l . Output ,
)
}
_ = tw . Flush ()
return buf . String ()
}
func humanizeBuildLogs ( ls [] codersdk . ProvisionerJobLog ) string {
var buf bytes . Buffer
tw := tabwriter . NewWriter ( & buf , 0 , 2 , 1 , ' ' , 0 )
for _ , l := range ls {
_ , _ = fmt . Fprintf ( tw , "%s\t[%s]\t%s\t%s\t%s\n" ,
l . CreatedAt . Format ( "2006-01-02 15:04:05.000" ), // for consistency with slog
string ( l . Level ),
string ( l . Source ),
l . Stage ,
l . Output ,
)
}
_ = tw . Flush ()
return buf . String ()
}
2025-06-24 11:16:31 +02:00
func humanizeLicenses ( licenses [] codersdk . License ) ( string , error ) {
formatter := cliutil . NewLicenseFormatter ()
if len ( licenses ) == 0 {
return "No licenses found" , nil
}
return formatter . Format ( context . Background (), licenses )
}