mirror of
https://github.com/hanzoai/o11y-foundry.git
synced 2026-11-02 14:03:05 +00:00
PandeyandGitHub
09b16ec619
## Summary Reshape foundryctl's output contract so it composes with agents and shell pipelines. Three changes that fall out of the same observation: **stdout, stderr, and exit codes should be a stable contract — today they're conflated.** - **Logger to stderr, silent by default.** `instrumentation.NewLogger` writes to `os.Stderr` (was `os.Stdout`) and uses `slog.DiscardHandler` unless `--debug` is set. Matches helm/aws CLI convention. stdout is now reserved for command results. - **Typed exit codes.** `internal/errors.typ` carries a `code int` field; `errors.ExitCode(err)` walks the wrap chain via `errors.As` and returns a deterministic code: `InvalidInput=2, NotFound=3, Unsupported=4, Internal=5, Fatal=6`, untyped=1, nil=0. Compact 1-6 scheme rather than sysexits.h because sysexits would collapse `Internal` and `Fatal` into the same `EX_SOFTWARE (70)`, losing a distinction we care about (Fatal = recovered panic; Internal = expected-but-failed path). `cmd/foundryctl/main.go` now exits with `errors.ExitCode(err)`. - **`fmt.Errorf` forbidden by lint.** New forbidigo rules in `.golangci.yml` ban `fmt.Errorf` and `fmt.Print*` / `print` / `println`. 168 call sites across 38 files converted to `errors.Newf` / `errors.Wrapf` with contextually-chosen types. Narrow exception for `internal/errors/error_test.go` so the ExitCode wrap-chain test stays authentic. Sites of note for review: - `internal/errors/type.go` — exit code mapping table (one source of truth) - `internal/errors/error.go` — `ExitCode(err)` helper - `internal/instrumentation/logger.go` — `slog.DiscardHandler` default - `.golangci.yml` — forbidigo config + the single narrow test exclusion ## Test plan - [x] `go build ./...` - [x] `go test ./...` (all packages pass; new `TestExitCode` covers 9 cases: nil, untyped, each typed, fmt.Errorf-wrapped, foundry-Wrapf-wrapped) - [x] `golangci-lint run ./...` — 0 issues - [x] Manual: `foundryctl forge` on a missing file exits non-zero and emits nothing on stdout (logs hidden); `--debug` emits JSON on stderr only - [x] Manual: end-to-end forge + cast against the docker/compose flavor still produces a healthy stack
173 lines
7.6 KiB
Go
173 lines
7.6 KiB
Go
package railwaytemplatecasting
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"log/slog"
|
|
"path/filepath"
|
|
|
|
"github.com/signoz/foundry/api/v1alpha1/installation"
|
|
"github.com/signoz/foundry/internal/casting"
|
|
"github.com/signoz/foundry/internal/domain"
|
|
"github.com/signoz/foundry/internal/errors"
|
|
"github.com/signoz/foundry/internal/molding"
|
|
)
|
|
|
|
var _ casting.Casting = (*railwayTemplateCasting)(nil)
|
|
|
|
type railwayTemplateCasting struct {
|
|
logger *slog.Logger
|
|
castings []*domain.Template
|
|
}
|
|
|
|
func New(logger *slog.Logger) *railwayTemplateCasting {
|
|
return &railwayTemplateCasting{
|
|
logger: logger,
|
|
castings: []*domain.Template{
|
|
telemetryKeeperDockerfileTemplate,
|
|
telemetryStoreDockerfileTemplate,
|
|
ingesterDockerfileTemplate,
|
|
signozDockerfileTemplate,
|
|
telemetryStoreMigratorDockerfileTemplate,
|
|
railwayTelemetryKeeperTemplate,
|
|
railwayTelemetryStoreTemplate,
|
|
railwayIngesterTemplate,
|
|
railwaySignozTemplate,
|
|
railwayTelemetryStoreMigratorTemplate,
|
|
telemetryKeeperOverrideTemplate,
|
|
telemetryStoreOverrideTemplate,
|
|
},
|
|
}
|
|
}
|
|
|
|
func (c *railwayTemplateCasting) Enricher(ctx context.Context, config *installation.Casting) (molding.MoldingEnricher, error) {
|
|
return newRailwayTemplateMoldingEnricher(config)
|
|
}
|
|
|
|
func (c *railwayTemplateCasting) Forge(ctx context.Context, config installation.Casting, poursPath string) ([]domain.Material, error) {
|
|
var materials []domain.Material
|
|
|
|
// TelemetryKeeper: Dockerfile + configs + railway.json
|
|
if config.Spec.TelemetryKeeper.Spec.IsEnabled() {
|
|
dockerfileBuf := bytes.NewBuffer(nil)
|
|
if err := telemetryKeeperDockerfileTemplate.Execute(dockerfileBuf, config); err != nil {
|
|
return nil, errors.Wrapf(err, errors.TypeInternal, "telemetrykeeper dockerfile")
|
|
}
|
|
materials = append(materials, domain.NewBlobMaterial(dockerfileBuf.Bytes(), filepath.Join(casting.DeploymentDir, "telemetrykeeper/Dockerfile")))
|
|
railwayBuf := bytes.NewBuffer(nil)
|
|
if err := railwayTelemetryKeeperTemplate.Execute(railwayBuf, config); err != nil {
|
|
return nil, errors.Wrapf(err, errors.TypeInternal, "telemetrykeeper railway.json")
|
|
}
|
|
materials = append(materials, domain.NewBlobMaterial(railwayBuf.Bytes(), filepath.Join(casting.DeploymentDir, "telemetrykeeper/railway.json")))
|
|
for filename, content := range config.Spec.TelemetryKeeper.Spec.Config.Data {
|
|
m, err := domain.NewYAMLMaterial([]byte(content), filepath.Join(casting.DeploymentDir, "telemetrykeeper/keeper.d/", filename))
|
|
if err != nil {
|
|
return nil, errors.Wrapf(err, errors.TypeInternal, "telemetrykeeper config")
|
|
}
|
|
materials = append(materials, m)
|
|
}
|
|
}
|
|
|
|
// TelemetryStore: Dockerfile + configs + railway.json
|
|
if config.Spec.TelemetryStore.Spec.IsEnabled() {
|
|
dockerfileBuf := bytes.NewBuffer(nil)
|
|
if err := telemetryStoreDockerfileTemplate.Execute(dockerfileBuf, config); err != nil {
|
|
return nil, errors.Wrapf(err, errors.TypeInternal, "telemetrystore dockerfile")
|
|
}
|
|
materials = append(materials, domain.NewBlobMaterial(dockerfileBuf.Bytes(), filepath.Join(casting.DeploymentDir, "telemetrystore/Dockerfile")))
|
|
railwayBuf := bytes.NewBuffer(nil)
|
|
if err := railwayTelemetryStoreTemplate.Execute(railwayBuf, config); err != nil {
|
|
return nil, errors.Wrapf(err, errors.TypeInternal, "telemetrystore railway.json")
|
|
}
|
|
materials = append(materials, domain.NewBlobMaterial(railwayBuf.Bytes(), filepath.Join(casting.DeploymentDir, "telemetrystore/railway.json")))
|
|
for filename, content := range config.Spec.TelemetryStore.Spec.Config.Data {
|
|
m, err := domain.NewYAMLMaterial([]byte(content), filepath.Join(casting.DeploymentDir, "telemetrystore/config.d/", filename))
|
|
if err != nil {
|
|
return nil, errors.Wrapf(err, errors.TypeInternal, "telemetrystore config")
|
|
}
|
|
materials = append(materials, m)
|
|
}
|
|
}
|
|
|
|
// Ingester: Dockerfile + configs + railway.json
|
|
if config.Spec.Ingester.Spec.IsEnabled() {
|
|
dockerfileBuf := bytes.NewBuffer(nil)
|
|
if err := ingesterDockerfileTemplate.Execute(dockerfileBuf, config); err != nil {
|
|
return nil, errors.Wrapf(err, errors.TypeInternal, "ingester dockerfile")
|
|
}
|
|
materials = append(materials, domain.NewBlobMaterial(dockerfileBuf.Bytes(), filepath.Join(casting.DeploymentDir, "ingester/Dockerfile")))
|
|
railwayBuf := bytes.NewBuffer(nil)
|
|
if err := railwayIngesterTemplate.Execute(railwayBuf, config); err != nil {
|
|
return nil, errors.Wrapf(err, errors.TypeInternal, "ingester railway.json")
|
|
}
|
|
materials = append(materials, domain.NewBlobMaterial(railwayBuf.Bytes(), filepath.Join(casting.DeploymentDir, "ingester/railway.json")))
|
|
for filename, content := range config.Spec.Ingester.Spec.Config.Data {
|
|
m, err := domain.NewYAMLMaterial([]byte(content), filepath.Join(casting.DeploymentDir, "ingester/", filename))
|
|
if err != nil {
|
|
return nil, errors.Wrapf(err, errors.TypeInternal, "ingester config")
|
|
}
|
|
materials = append(materials, m)
|
|
}
|
|
}
|
|
|
|
// Signoz: Dockerfile + railway.json
|
|
if config.Spec.Signoz.Spec.IsEnabled() {
|
|
dockerfileBuf := bytes.NewBuffer(nil)
|
|
if err := signozDockerfileTemplate.Execute(dockerfileBuf, config); err != nil {
|
|
return nil, errors.Wrapf(err, errors.TypeInternal, "signoz dockerfile")
|
|
}
|
|
materials = append(materials, domain.NewBlobMaterial(dockerfileBuf.Bytes(), filepath.Join(casting.DeploymentDir, "signoz/Dockerfile")))
|
|
railwayBuf := bytes.NewBuffer(nil)
|
|
if err := railwaySignozTemplate.Execute(railwayBuf, config); err != nil {
|
|
return nil, errors.Wrapf(err, errors.TypeInternal, "signoz railway.json")
|
|
}
|
|
materials = append(materials, domain.NewBlobMaterial(railwayBuf.Bytes(), filepath.Join(casting.DeploymentDir, "signoz/railway.json")))
|
|
}
|
|
|
|
// TelemetryStore migrator: Dockerfile + railway.json
|
|
if config.Spec.TelemetryStore.Spec.IsEnabled() {
|
|
dockerfileBuf := bytes.NewBuffer(nil)
|
|
if err := telemetryStoreMigratorDockerfileTemplate.Execute(dockerfileBuf, config); err != nil {
|
|
return nil, errors.Wrapf(err, errors.TypeInternal, "telemetrystore-migrator dockerfile")
|
|
}
|
|
materials = append(materials, domain.NewBlobMaterial(dockerfileBuf.Bytes(), filepath.Join(casting.DeploymentDir, "telemetrystore-migrator/Dockerfile")))
|
|
railwayBuf := bytes.NewBuffer(nil)
|
|
if err := railwayTelemetryStoreMigratorTemplate.Execute(railwayBuf, config); err != nil {
|
|
return nil, errors.Wrapf(err, errors.TypeInternal, "telemetrystore-migrator railway.json")
|
|
}
|
|
materials = append(materials, domain.NewBlobMaterial(railwayBuf.Bytes(), filepath.Join(casting.DeploymentDir, "telemetrystore-migrator/railway.json")))
|
|
}
|
|
|
|
return materials, nil
|
|
}
|
|
|
|
func (c *railwayTemplateCasting) Cast(ctx context.Context, config installation.Casting, poursPath string) error {
|
|
c.logger.InfoContext(ctx, "Please use the template.")
|
|
return nil
|
|
}
|
|
|
|
func getRailwayMaterial(config *installation.Casting) ([]domain.StructuredMaterial, error) {
|
|
var materials []domain.StructuredMaterial
|
|
|
|
keeperBuf := bytes.NewBuffer(nil)
|
|
if err := telemetryKeeperOverrideTemplate.Execute(keeperBuf, config); err != nil {
|
|
return nil, errors.Wrapf(err, errors.TypeInternal, "failed to execute keeper override template")
|
|
}
|
|
keeperMaterial, err := domain.NewYAMLMaterial(keeperBuf.Bytes(), "keeper_overrides.yaml")
|
|
if err != nil {
|
|
return nil, errors.Wrapf(err, errors.TypeInternal, "failed to create keeper override material")
|
|
}
|
|
materials = append(materials, keeperMaterial)
|
|
|
|
storeBuf := bytes.NewBuffer(nil)
|
|
if err := telemetryStoreOverrideTemplate.Execute(storeBuf, config); err != nil {
|
|
return nil, errors.Wrapf(err, errors.TypeInternal, "failed to execute keeper override template")
|
|
}
|
|
storeMaterial, err := domain.NewYAMLMaterial(storeBuf.Bytes(), "store_overrides.yaml")
|
|
if err != nil {
|
|
return nil, errors.Wrapf(err, errors.TypeInternal, "failed to create keeper override material")
|
|
}
|
|
materials = append(materials, storeMaterial)
|
|
return materials, nil
|
|
}
|