Files
Ehab Younes 28192213ab feat!: label the VS Code family and report built-in app usage per app (#29906)
The session banner now labels the VS Code family "VS Code Family", so it isn't confused with the VS Code editor. coderd_insights_applications_usage_seconds now reports built-in apps per app instead of per family.

- Generate the frontend's family labels from the Go table in codersdk.
- Add the connection_method label: workspace_app for template apps, and ssh, reconnecting_pty, or port_forwarding for built-in apps.
- Rename the application_name label to display_name. For built-in apps it holds the registry name, "Unknown" for unknown, and "Other apps" for overflow.
- Built-in apps get one series per app name, only for apps used in the window. The series limit and the fold rule are shared with the template insights API.
- Breaking: selectors with a value for application_name, or with slug="", match nothing. The Prometheus docs map each old series to its new one.

Closes #29940
Closes CLIENT-1034
Closes CLIENT-1036
2026-10-27 09:58:36 +00:00

344 lines
8.9 KiB
Go

package main
import (
"bytes"
_ "embed"
"errors"
"flag"
"fmt"
"go/ast"
"go/format"
"go/parser"
"go/token"
"log"
"os"
"slices"
"strings"
"text/template"
"golang.org/x/xerrors"
"github.com/coder/coder/v2/coderd/rbac"
"github.com/coder/coder/v2/coderd/rbac/policy"
utilstrings "github.com/coder/coder/v2/coderd/util/strings"
"github.com/coder/coder/v2/codersdk"
)
//go:embed appfamilies.tstmpl
var appFamiliesTemplate string
//go:embed rbacobject.gotmpl
var rbacObjectTemplate string
//go:embed codersdk.gotmpl
var codersdkTemplate string
//go:embed typescript.tstmpl
var typescriptTemplate string
//go:embed scopenames.gotmpl
var scopenamesTemplate string
//go:embed countries.tstmpl
var countriesTemplate string
//go:embed dbenums.gotmpl
var dbEnumsTemplate string
// databaseEnums lists the database enums codersdk mirrors under the same name.
var databaseEnums = []string{
"ConnectionLogMethod",
}
func usage() {
_, _ = fmt.Println("Usage: typegen <type> [template]")
_, _ = fmt.Println("Types:")
_, _ = fmt.Println(" appfamilies - Generate app family display names TypeScript")
_, _ = fmt.Println(" rbac <object|codersdk|typescript> - Generate RBAC related files")
_, _ = fmt.Println(" countries - Generate countries TypeScript")
_, _ = fmt.Println(" dbenums - Generate codersdk mirrors of database enums")
}
// main will generate a file based on the type and template specified.
// This is to provide an "AllResources" function that is always
// in sync.
func main() {
flag.Parse()
if len(flag.Args()) < 1 {
usage()
os.Exit(1)
}
var (
out []byte
err error
)
// It did not make sense to have 2 different generators that do essentially
// the same thing, but different format for the BE and the sdk.
// So the argument switches the go template to use.
switch strings.ToLower(flag.Args()[0]) {
case "appfamilies":
out, err = generateAppFamilies()
case "rbac":
if len(flag.Args()) < 2 {
usage()
os.Exit(1)
}
out, err = generateRBAC(flag.Args()[1])
case "countries":
out, err = generateCountries()
case "dbenums":
out, err = generateDatabaseEnums()
default:
_, _ = fmt.Fprintf(os.Stderr, "%q is not a valid type\n", flag.Args()[0])
usage()
os.Exit(2)
}
if err != nil {
log.Fatalf("Generate source: %s", err.Error())
}
_, _ = fmt.Fprint(os.Stdout, string(out))
}
func generateRBAC(tmpl string) ([]byte, error) {
formatSource := format.Source
var source string
switch strings.ToLower(tmpl) {
case "codersdk":
source = codersdkTemplate
case "object":
source = rbacObjectTemplate
case "typescript":
source = typescriptTemplate
formatSource = func(src []byte) ([]byte, error) {
// No typescript formatting
return src, nil
}
case "scopenames":
source = scopenamesTemplate
default:
return nil, xerrors.Errorf("%q is not a valid RBAC template target", tmpl)
}
out, err := generateRbacObjects(source)
if err != nil {
return nil, err
}
return formatSource(out)
}
func generateAppFamilies() ([]byte, error) {
tmpl, err := template.New("appfamilies.tstmpl").Parse(appFamiliesTemplate)
if err != nil {
return nil, xerrors.Errorf("parse template: %w", err)
}
var out bytes.Buffer
if err := tmpl.Execute(&out, codersdk.AppFamilyDisplayNames()); err != nil {
return nil, xerrors.Errorf("execute template: %w", err)
}
return out.Bytes(), nil
}
func generateCountries() ([]byte, error) {
tmpl, err := template.New("countries.tstmpl").Parse(countriesTemplate)
if err != nil {
return nil, xerrors.Errorf("parse template: %w", err)
}
var out bytes.Buffer
err = tmpl.Execute(&out, codersdk.Countries)
if err != nil {
return nil, xerrors.Errorf("execute template: %w", err)
}
return out.Bytes(), nil
}
type databaseEnum struct {
Name string
Values []EnumValue
}
func generateDatabaseEnums() ([]byte, error) {
f, err := parser.ParseFile(token.NewFileSet(), "./coderd/database/models.go", nil, 0)
if err != nil {
return nil, xerrors.Errorf("parsing models.go: %w", err)
}
enums := make([]databaseEnum, 0, len(databaseEnums))
for _, name := range databaseEnums {
values := enumValues(f, name)
if len(values) == 0 {
return nil, xerrors.Errorf("enum %s not found in models.go", name)
}
enums = append(enums, databaseEnum{Name: name, Values: values})
}
tmpl, err := template.New("dbenums.gotmpl").Parse(dbEnumsTemplate)
if err != nil {
return nil, xerrors.Errorf("parse template: %w", err)
}
var out bytes.Buffer
if err := tmpl.Execute(&out, enums); err != nil {
return nil, xerrors.Errorf("execute template: %w", err)
}
return format.Source(out.Bytes())
}
func pascalCaseName[T ~string](name T) string {
names := strings.Split(string(name), "_")
for i := range names {
names[i] = utilstrings.Capitalize(names[i])
}
return strings.Join(names, "")
}
type Definition struct {
policy.PermissionDefinition
Type string
}
func (p Definition) FunctionName() string {
if p.Name != "" {
return p.Name
}
return p.Type
}
// enumValues returns the constants of the named string type in file, in
// source order. Constant names are not available at runtime, so parse them.
func enumValues(file *ast.File, typeName string) []EnumValue {
var values []EnumValue
for _, decl := range file.Decls {
genDecl, ok := decl.(*ast.GenDecl)
if !ok || genDecl.Tok != token.CONST {
continue
}
for _, spec := range genDecl.Specs {
vSpec, ok := spec.(*ast.ValueSpec)
if !ok || len(vSpec.Names) != 1 || len(vSpec.Values) != 1 {
continue
}
if typeIdent, ok := vSpec.Type.(*ast.Ident); !ok || typeIdent.Name != typeName {
continue
}
literal, ok := vSpec.Values[0].(*ast.BasicLit)
if !ok || literal.Kind != token.STRING {
continue
}
values = append(values, EnumValue{
Enum: vSpec.Names[0].Name,
Value: strings.Trim(literal.Value, `"`),
})
}
}
return values
}
type EnumValue struct {
Enum string
Value string
}
// generateRbacObjects will take the policy.go file, and send it as input
// to the go templates. Some AST of the Action enum is also included.
func generateRbacObjects(templateSource string) ([]byte, error) {
// Parse the policy.go file for the action enums
f, err := parser.ParseFile(token.NewFileSet(), "./coderd/rbac/policy/policy.go", nil, parser.ParseComments)
if err != nil {
return nil, xerrors.Errorf("parsing policy.go: %w", err)
}
actionList := enumValues(f, "Action")
actionMap := make(map[string]string, len(actionList))
for _, action := range actionList {
actionMap[action.Value] = action.Enum
}
// Sorting actions for auto gen consistency.
slices.SortFunc(actionList, func(a, b EnumValue) int {
return strings.Compare(a.Enum, b.Enum)
})
var errorList []error
var x int
tpl, err := template.New("object.gotmpl").Funcs(template.FuncMap{
"capitalize": utilstrings.Capitalize,
"pascalCaseName": pascalCaseName[string],
"actionsList": func() []EnumValue {
return actionList
},
"actionsOf": func(d Definition) []string {
// Extract and sort action string keys for deterministic output.
list := make([]string, 0, len(d.Actions))
for a := range d.Actions {
list = append(list, string(a))
}
slices.Sort(list)
return list
},
"allCaseList": func(defs []Definition) string {
// Build a multi-line comma-separated list of all scope constants (including builtins)
// suitable for use in a `case ...:` clause, without a trailing comma.
var names []string
// Builtins first, sourced dynamically from the rbac package to avoid drift.
for _, n := range rbac.BuiltinScopeNames() {
// Use typed string literals to avoid relying on constant identifiers.
names = append(names, fmt.Sprintf("ScopeName(%q)", string(n)))
}
for _, d := range defs {
res := pascalCaseName[string](d.Type)
acts := make([]string, 0, len(d.Actions))
for a := range d.Actions {
acts = append(acts, string(a))
}
slices.Sort(acts)
for _, a := range acts {
names = append(names, "Scope"+res+pascalCaseName[string](a))
}
}
return strings.Join(names, ",\n\t\t")
},
"actionEnum": func(action policy.Action) string {
x++
v, ok := actionMap[string(action)]
if !ok {
errorList = append(errorList, xerrors.Errorf("action value %q does not have a constant a matching enum constant", action))
}
return v
},
"concat": func(strs ...string) string { return strings.Join(strs, "") },
}).Parse(templateSource)
if err != nil {
return nil, xerrors.Errorf("parse template: %w", err)
}
// Convert to sorted list for autogen consistency.
var out bytes.Buffer
list := make([]Definition, 0)
for t, v := range policy.RBACPermissions {
list = append(list, Definition{
PermissionDefinition: v,
Type: t,
})
}
slices.SortFunc(list, func(a, b Definition) int {
return strings.Compare(a.Type, b.Type)
})
err = tpl.Execute(&out, list)
if err != nil {
return nil, xerrors.Errorf("execute template: %w", err)
}
if len(errorList) > 0 {
return nil, errors.Join(errorList...)
}
return out.Bytes(), nil
}