goenv
Go library that reads one environment variable and tells you if you're in prod or dev. github.com/psyb0t/goenv wraps os.Getenv("ENV") behind three calls. goenv.Get() returns the current env as a string ("prod" or "dev"), goenv.IsProd() and goenv.IsDev() return bools. It recognizes exactly two environments, dev when ENV is precisely "dev", and prod for everything else (unset, empty, "production", "DEV", anything), a fail-safe default to prod. Exposes constants goenv.Prod/goenv.Dev and the env-var name as goenv.EnvVarName. Zero dependencies beyond the stdlib os; no network, no files, no config. Note Type is a string alias, so it gives no compile-time safety over a bare string. Use when the user wants a tiny dependency-free prod/dev switch in a Go program, or is already importing goenv and wants to branch behavior on the environment.
goenv
A Go library that reads a single environment variable, ENV, and answers one question: are you in prod or dev? That's the whole package. os.Getenv("ENV") with a fail-safe default and three named helpers, zero dependencies. Import it and call goenv.Get().
For install, the exact match/default behavior, and a worked example, see references/setup.md.
Security & safety
- It reads exactly one environment variable,
ENV, and nothing else. No other env vars are read, nothing is written to disk, no network calls are made at runtime, and no data leaves your process. Its only import is the stdlibos. - It's a library you compile into your own binary, so it has no runtime surface of its own. Whatever your program does with the prod/dev answer is on you, same as any code you'd write by hand.
- Fail-safe by design: an unrecognized or unset
ENVresolves toprod, so a misconfigured environment errs toward production-grade behavior rather than accidentally enabling dev-only shortcuts.
When to use
- A Go program needs a small, dependency-free way to branch behavior between two environments (prod vs dev), e.g. verbose logging in dev, stricter defaults in prod.
- The project already imports
github.com/psyb0t/goenvand you want to add or read a prod/dev check consistently (goenv.IsProd()/goenv.IsDev()instead of hand-rolledos.Getenvcomparisons). - You want the fail-safe "default to prod" semantics without writing the switch yourself.
When NOT to use
- You need more than two environments (staging, test, ci, local, …): goenv only knows
devandprod; everything that isn't exactly"dev"collapses toprod. - You need to read env vars other than
ENV, or a configurable variable name: goenv reads the hardcodedENVand nothing else. Reach for a real config library (e.g.gonfiguration) for anything richer. - You expect compile-time type safety from the
Typetype: it's astringalias, sogoenv.Typeisstring; the constants are conveniences, not an enum, and any string is assignable. If you need a distinct nominal type, this isn't it.
Usage
import "github.com/psyb0t/goenv"
// The current environment as a string ("prod" or "dev"):
switch goenv.Get() {
case goenv.Dev:
// dev-only behavior
default: // goenv.Prod
// prod behavior
}
// Or the boolean shortcuts:
if goenv.IsDev() {
logger.SetLevel("debug")
}
if goenv.IsProd() {
enableStrictMode()
}
// The recognized values and the variable name are exported constants:
_ = goenv.Prod // "prod"
_ = goenv.Dev // "dev"
_ = goenv.EnvVarName // "ENV"
The mapping is exact: Get() returns Dev only when ENV is precisely "dev"; every other value (unset, empty, "DEV", "development", "prod", or anything else) returns Prod. Set it before your process starts:
ENV=dev ./yourapp # dev
ENV=prod ./yourapp # prod
./yourapp # ENV unset → prod (the default)
For the module path, supported Go version, and the full behavior table, see references/setup.md.
- Downloads
- Security audit
- Pass
- Last updated
- 1w ago
- Current version
- v1.0.12
- License
- MIT-0
