24134227371

Committed 08 Apr 2026 12:01PM UTC coverage: 63.788%. First build

Build # 24134227371

Build Type

Pull #5010

github

Committed by

web-flow

Commit Message

Merge 03bac0987 into d03a45bc0

Pull Request Pull Request #5010: Prod deploy

Coverage Stats

595 of 825 new or added lines in 28 files covered. (72.12%)

9778 of 15329 relevant lines covered (63.79%)

6.89 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

80.16

/cmd/root_analytics.go

package cmd

import (
        "os"
        "sort"
        "strconv"
        "strings"

        "github.com/google/uuid"
        "github.com/spf13/cobra"
        "github.com/spf13/pflag"
        "github.com/supabase/cli/internal/telemetry"
        "github.com/supabase/cli/internal/utils"
        "github.com/supabase/cli/internal/utils/agent"
        "golang.org/x/term"
)

const (
        telemetrySafeValueAnnotation = "supabase.com/telemetry-safe-value"
        redactedTelemetryValue       = "<redacted>"
        maxTelemetryEnvValueLength   = 80
)

func commandAnalyticsContext(cmd *cobra.Command) telemetry.CommandContext {
        return telemetry.CommandContext{
                RunID:   uuid.NewString(),
                Command: commandName(cmd),
                Flags:   changedFlagValues(cmd),
        }
}

func commandName(cmd *cobra.Command) string {
        path := strings.TrimSpace(cmd.CommandPath())
        rootName := strings.TrimSpace(cmd.Root().Name())
        if path == rootName || path == "" {
                return rootName
        }
        return strings.TrimSpace(strings.TrimPrefix(path, rootName))
}

func changedFlagValues(cmd *cobra.Command) map[string]any {
        flags := changedFlags(cmd)
        if len(flags) == 0 {
                return nil
        }
        values := make(map[string]any, len(flags))
        for _, flag := range flags {
                values[flag.Name] = telemetryFlagValue(flag)
        }
        return values
}

func changedFlags(cmd *cobra.Command) []*pflag.Flag {
        seen := make(map[string]struct{})
        var result []*pflag.Flag
        collect := func(flags *pflag.FlagSet) {
                if flags == nil {
                        return
                }
                flags.Visit(func(flag *pflag.Flag) {
                        if _, ok := seen[flag.Name]; ok {
                                return
                        }
                        seen[flag.Name] = struct{}{}
                        result = append(result, flag)
                })
        }
        for current := cmd; current != nil; current = current.Parent() {
                collect(current.PersistentFlags())
        }
        collect(cmd.Flags())
        sort.Slice(result, func(i, j int) bool {
                return result[i].Name < result[j].Name
        })
        return result
}

func markFlagTelemetrySafe(flag *pflag.Flag) {
        if flag == nil {
                return
        }
        if flag.Annotations == nil {
                flag.Annotations = map[string][]string{}
        }
        flag.Annotations[telemetrySafeValueAnnotation] = []string{"true"}
}

func telemetryFlagValue(flag *pflag.Flag) any {
        if flag == nil {
                return nil
        }
        if isTelemetrySafeFlag(flag) || isBooleanFlag(flag) || isEnumFlag(flag) {
                return actualTelemetryFlagValue(flag)
        }
        return redactedTelemetryValue
}

func isTelemetrySafeFlag(flag *pflag.Flag) bool {
        if flag == nil || flag.Annotations == nil {
                return false
        }
        values, ok := flag.Annotations[telemetrySafeValueAnnotation]
        return ok && len(values) > 0 && values[0] == "true"
}

func isBooleanFlag(flag *pflag.Flag) bool {
        return flag != nil && flag.Value.Type() == "bool"
}

func isEnumFlag(flag *pflag.Flag) bool {
        if flag == nil {
                return false
        }
        _, ok := flag.Value.(*utils.EnumFlag)
        return ok
}

func actualTelemetryFlagValue(flag *pflag.Flag) any {
        if isBooleanFlag(flag) {
                value, err := strconv.ParseBool(flag.Value.String())
                if err == nil {
                        return value
                }
        }
        return flag.Value.String()
}

func telemetryIsCI() bool {
        return os.Getenv("CI") != "" ||
                os.Getenv("GITHUB_ACTIONS") != "" ||
                os.Getenv("BUILDKITE") != "" ||
                os.Getenv("TF_BUILD") != "" ||
                os.Getenv("JENKINS_URL") != "" ||
                os.Getenv("GITLAB_CI") != ""
}

func telemetryIsTTY() bool {
        return term.IsTerminal(int(os.Stdout.Fd())) //nolint:gosec // G115: stdout fd is a small int on supported platforms
}

func telemetryIsAgent() bool {
        return agent.IsAgent()
}

func telemetryEnvSignals() map[string]any {
        return envSignals(telemetry.EnvSignalPresenceKeys[:], telemetry.EnvSignalValueKeys[:])
}

func envSignals(presenceKeys []string, valueKeys []string) map[string]any {
        signals := make(map[string]any, len(presenceKeys)+len(valueKeys))
        for _, key := range presenceKeys {
                if hasTelemetryEnvValue(key) {
                        signals[key] = true
                }
        }
        for _, key := range valueKeys {
                if value := telemetryEnvValue(key); value != "" {
                        signals[key] = value
                }
        }
        if len(signals) == 0 {
                return nil
        }
        return signals
}

func hasTelemetryEnvValue(key string) bool {
        return strings.TrimSpace(os.Getenv(key)) != ""
}

func telemetryEnvValue(key string) string {
        value := strings.TrimSpace(os.Getenv(key))
        if value == "" {
                return ""
        }
        if len(value) > maxTelemetryEnvValueLength {
                return value[:maxTelemetryEnvValueLength]
        }
        return value
}

1	package cmd
2
3	import (
4	"os"
5	"sort"
6	"strconv"
7	"strings"
8
9	"github.com/google/uuid"
10	"github.com/spf13/cobra"
11	"github.com/spf13/pflag"
12	"github.com/supabase/cli/internal/telemetry"
13	"github.com/supabase/cli/internal/utils"
14	"github.com/supabase/cli/internal/utils/agent"
15	"golang.org/x/term"
16	)
17
18	const (
19	telemetrySafeValueAnnotation = "supabase.com/telemetry-safe-value"
20	redactedTelemetryValue = "<redacted>"
21	maxTelemetryEnvValueLength = 80
22	)
23
24	func commandAnalyticsContext(cmd *cobra.Command) telemetry.CommandContext {	1✔
25	return telemetry.CommandContext{	1✔
26	RunID: uuid.NewString(),	1✔
27	Command: commandName(cmd),	1✔
28	Flags: changedFlagValues(cmd),	1✔
29	}	1✔
30	}	1✔
31
32	func commandName(cmd *cobra.Command) string {	3✔
33	path := strings.TrimSpace(cmd.CommandPath())	3✔
34	rootName := strings.TrimSpace(cmd.Root().Name())	3✔
35	if path == rootName \|\| path == "" {	4✔
36	return rootName	1✔
37	}	1✔
38	return strings.TrimSpace(strings.TrimPrefix(path, rootName))	2✔
39	}
40
41	func changedFlagValues(cmd *cobra.Command) map[string]any {	1✔
42	flags := changedFlags(cmd)	1✔
43	if len(flags) == 0 {	1✔
NEW 44	return nil	×
NEW 45	}	×
46	values := make(map[string]any, len(flags))	1✔
47	for _, flag := range flags {	5✔
48	values[flag.Name] = telemetryFlagValue(flag)	4✔
49	}	4✔
50	return values	1✔
51	}
52
53	func changedFlags(cmd cobra.Command) []pflag.Flag {	1✔
54	seen := make(map[string]struct{})	1✔
55	var result []*pflag.Flag	1✔
56	collect := func(flags *pflag.FlagSet) {	4✔
57	if flags == nil {	3✔
NEW 58	return	×
NEW 59	}	×
60	flags.Visit(func(flag *pflag.Flag) {	7✔
61	if _, ok := seen[flag.Name]; ok {	4✔
NEW 62	return	×
NEW 63	}	×
64	seen[flag.Name] = struct{}{}	4✔
65	result = append(result, flag)	4✔
66	})
67	}
68	for current := cmd; current != nil; current = current.Parent() {	3✔
69	collect(current.PersistentFlags())	2✔
70	}	2✔
71	collect(cmd.Flags())	1✔
72	sort.Slice(result, func(i, j int) bool {	4✔
73	return result[i].Name < result[j].Name	3✔
74	})	3✔
75	return result	1✔
76	}
77
78	func markFlagTelemetrySafe(flag *pflag.Flag) {	13✔
79	if flag == nil {	13✔
NEW 80	return	×
NEW 81	}	×
82	if flag.Annotations == nil {	26✔
83	flag.Annotations = map[string][]string{}	13✔
84	}	13✔
85	flag.Annotations[telemetrySafeValueAnnotation] = []string{"true"}	13✔
86	}
87
88	func telemetryFlagValue(flag *pflag.Flag) any {	4✔
89	if flag == nil {	4✔
NEW 90	return nil	×
NEW 91	}	×
92	if isTelemetrySafeFlag(flag) \|\| isBooleanFlag(flag) \|\| isEnumFlag(flag) {	7✔
93	return actualTelemetryFlagValue(flag)	3✔
94	}	3✔
95	return redactedTelemetryValue	1✔
96	}
97
98	func isTelemetrySafeFlag(flag *pflag.Flag) bool {	4✔
99	if flag == nil \|\| flag.Annotations == nil {	7✔
100	return false	3✔
101	}	3✔
102	values, ok := flag.Annotations[telemetrySafeValueAnnotation]	1✔
103	return ok && len(values) > 0 && values[0] == "true"	1✔
104	}
105
106	func isBooleanFlag(flag *pflag.Flag) bool {	6✔
107	return flag != nil && flag.Value.Type() == "bool"	6✔
108	}	6✔
109
110	func isEnumFlag(flag *pflag.Flag) bool {	2✔
111	if flag == nil {	2✔
NEW 112	return false	×
NEW 113	}	×
114	_, ok := flag.Value.(*utils.EnumFlag)	2✔
115	return ok	2✔
116	}
117
118	func actualTelemetryFlagValue(flag *pflag.Flag) any {	3✔
119	if isBooleanFlag(flag) {	4✔
120	value, err := strconv.ParseBool(flag.Value.String())	1✔
121	if err == nil {	2✔
122	return value	1✔
123	}	1✔
124	}
125	return flag.Value.String()	2✔
126	}
127
NEW 128	func telemetryIsCI() bool {	×
NEW 129	return os.Getenv("CI") != "" \|\|	×
NEW 130	os.Getenv("GITHUB_ACTIONS") != "" \|\|	×
NEW 131	os.Getenv("BUILDKITE") != "" \|\|	×
NEW 132	os.Getenv("TF_BUILD") != "" \|\|	×
NEW 133	os.Getenv("JENKINS_URL") != "" \|\|	×
NEW 134	os.Getenv("GITLAB_CI") != ""	×
NEW 135	}	×
136
NEW 137	func telemetryIsTTY() bool {	×
NEW 138	return term.IsTerminal(int(os.Stdout.Fd())) //nolint:gosec // G115: stdout fd is a small int on supported platforms	×
NEW 139	}	×
140
141	func telemetryIsAgent() bool {	2✔
142	return agent.IsAgent()	2✔
143	}	2✔
144
145	func telemetryEnvSignals() map[string]any {	1✔
146	return envSignals(telemetry.EnvSignalPresenceKeys[:], telemetry.EnvSignalValueKeys[:])	1✔
147	}	1✔
148
149	func envSignals(presenceKeys []string, valueKeys []string) map[string]any {	2✔
150	signals := make(map[string]any, len(presenceKeys)+len(valueKeys))	2✔
151	for _, key := range presenceKeys {	39✔
152	if hasTelemetryEnvValue(key) {	38✔
153	signals[key] = true	1✔
154	}	1✔
155	}
156	for _, key := range valueKeys {	10✔
157	if value := telemetryEnvValue(key); value != "" {	11✔
158	signals[key] = value	3✔
159	}	3✔
160	}
161	if len(signals) == 0 {	2✔
NEW 162	return nil	×
NEW 163	}	×
164	return signals	2✔
165	}
166
167	func hasTelemetryEnvValue(key string) bool {	37✔
168	return strings.TrimSpace(os.Getenv(key)) != ""	37✔
169	}	37✔
170
171	func telemetryEnvValue(key string) string {	8✔
172	value := strings.TrimSpace(os.Getenv(key))	8✔
173	if value == "" {	13✔
174	return ""	5✔
175	}	5✔
176	if len(value) > maxTelemetryEnvValueLength {	4✔
177	return value[:maxTelemetryEnvValueLength]	1✔
178	}	1✔
179	return value	2✔
180	}

supabase / cli / 24134227371

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous