Environment variable prefix override support (#8)

* use DISABLE_CODE_ prefix for environment variable names
* add DISABLE_S2CODE_ prefix as a temporary backward compatibility option
* environment variable prefix override support at compile time
* support Go back to 1.23.0

Author: S2BryanW

README.md

@@ -36,7 +36,7 @@ once.
 ## Controlling the Gate
 
 Code gates are controlled by environment variables. Code gates are created in the enabled state unless an environment
-variable named `DISABLE_<codegate-name>` is found in the process environment. The value of the variable is ignored;
+variable named `DISABLE_CODE_<codegate-name>` is found in the process environment. The value of the variable is ignored;
 any value, including blank, is sufficient to disable the code gate. The normal use case for a code gate is to disable or
 revert some code by defining the code gate environment variable and *restarting* the service or application.
 

codegate.go

@@ -9,26 +9,38 @@ import (
 )
 
 // Gate is a code gate, allowing code to be selectively enabled or disabled.
-// Gate currently contains only a Name field, but may grow in the future to
-// include other metadata about the gate.
 type Gate struct {
 	name    string
 	enabled bool
 }
 
+// EnvVarPrefix is the prefix for environment variables used to disable
+// code gates. This prefix is defined in an exported variable so that it
+// may be changed at compile time with build flags:
+//
+//	go build -ldflags "-X 'github.com/singlestore-labs/codegate.EnvVarPrefix=MY_PREFIX_'"
+//
+// This variable should not be changed at runtime including in init functions,
+// because it is used by the New function which may be called in static
+// initializers.
+var (
+	EnvVarPrefix = "DISABLE_CODE_"
+)
+
 const (
-	gateNameMaxLength = 100
-	gateEnvVarPrefix  = "DISABLE_"
+	// Deprecated: use DISABLE_CODE_ prefix instead
+	envVarPrefix2 = "DISABLE_S2CODE_"
+	nameMaxLength = 100
 )
 
 var (
+	// gate names must be valid environment variable names
 	validName     = regexp.MustCompile("^[A-Za-z][A-Za-z0-9_]*$")
 	usedNames     = map[string]struct{}{}
 	disabledGates []string
+	gateLock      sync.Mutex
 )
 
-var gateLock sync.Mutex
-
 // New creates a code gate. Code gate names must be globally unique and should
 // be defined in static initializers. For example,
 //
@@ -39,20 +51,23 @@ var gateLock sync.Mutex
 // for each code domain (e.g., "RBAC" for RBAC related behaviors) is recommended.
 // New panics if the name is missing, invalid, or is a duplicate.
 func New(name string) Gate {
-	if !validName.MatchString(name) || len(name) > gateNameMaxLength {
+	if !validName.MatchString(name) || len(name) > nameMaxLength {
 		panic(fmt.Errorf(`code gate name (%s) is invalid. Code gate names must begin with an alpha, contain only alphanumerics or underbars, and be no more than %d characters in length`,
-			name, gateNameMaxLength))
+			name, nameMaxLength))
 	}
 	gateLock.Lock()
 	defer gateLock.Unlock()
-	if _, ok := usedNames[name]; ok {
-		panic(fmt.Errorf(`code gate name (%s) has been used twice. Code gate names must be unique`, name))
+	if _, found := usedNames[name]; found {
+		panic(fmt.Errorf(`code gate name (%s) is already in use. Code gate names must be unique`, name))
 	}
 	usedNames[name] = struct{}{}
-	_, ok := os.LookupEnv(gateEnvVarPrefix + name)
+	_, disabled := os.LookupEnv(EnvVarPrefix + name)
+	if !disabled {
+		_, disabled = os.LookupEnv(envVarPrefix2 + name)
+	}
 	return Gate{
 		name:    name,
-		enabled: !ok,
+		enabled: !disabled,
 	}
 }
 
@@ -91,21 +106,30 @@ func (gate Gate) String() string {
 	return label + " (disabled)"
 }
 
-// DisabledGates returns the names of all currently disabled code gates. If
-// forceRefresh is true, the list is reloaded from the environment variables.
-// forceRefresh should only be used for testing purposes.
-func DisabledGates(forceRefresh bool) []string {
+// DisabledGates returns the names of all currently disabled code gates. The
+// list is loaded from the environment variables and includes all variables
+// prefixed with the code gate prefix regardless of whether a gate has been
+// created for that name.
+func DisabledGates() []string {
 	gateLock.Lock()
 	defer gateLock.Unlock()
-	if forceRefresh || disabledGates == nil {
+	if disabledGates == nil {
 		disabledGates = []string{}
 		// Get all disabled code gates from the environment variables.
 		for _, env := range os.Environ() {
 			envName, _, _ := strings.Cut(env, "=")
-			if strings.HasPrefix(envName, gateEnvVarPrefix) {
-				disabledGates = append(disabledGates, strings.TrimPrefix(envName, gateEnvVarPrefix))
+			if strings.HasPrefix(envName, EnvVarPrefix) {
+				disabledGates = append(disabledGates, strings.TrimPrefix(envName, EnvVarPrefix))
+			} else if strings.HasPrefix(envName, envVarPrefix2) {
+				disabledGates = append(disabledGates, strings.TrimPrefix(envName, envVarPrefix2))
 			}
 		}
 	}
 	return disabledGates
 }
+
+func resetDisabledGates() {
+	gateLock.Lock()
+	defer gateLock.Unlock()
+	disabledGates = nil
+}

codegate_test.go

@@ -1,23 +1,21 @@
 package codegate
 
 import (
-	"os"
 	"strings"
 	"testing"
 
 	"github.com/stretchr/testify/require"
 )
 
-// Code gates are somewhat troublesome to test due to the reliance on a static environment variable
-// at the time of the gate creation. All tests run in the same environment, so setting an environment
-// variable in one test may affect other tests (depending on order.) DisableGates() testing only
-// works because it is implemented to dynamically inspect the environment at call time and does not
-// cache results.
+// Code gates are troublesome to test due to the reliance on static environment
+// variables at the time of the gate creation. All tests run in the same environment,
+// so setting an environment in one test may affect other tests. All tests in this
+// file should use unique gate names to avoid conflicts.
 
 func TestNoDisabledGates(t *testing.T) {
 	gateTestFoo := New("FOO")
 	require.True(t, gateTestFoo.Enabled(), "arbitrary code behavior should be enabled by default")
-	require.NotContains(t, DisabledGates(true), "FOO")
+	require.NotContains(t, DisabledGates(), "FOO")
 }
 
 func TestGateNames(t *testing.T) {
@@ -45,31 +43,45 @@ func TestGateNames(t *testing.T) {
 }
 
 func TestDisableOneGate(t *testing.T) {
-	_ = os.Setenv("DISABLE_Bar", "disabled")
+	t.Setenv("DISABLE_CODE_Bar", "disabled")
 
 	// refresh disabled gates to pick up the changes to the environment
 	// variables
-	DisabledGates(true)
+	resetDisabledGates()
 
 	gateTestBar := New("Bar")
 	require.False(t, gateTestBar.Enabled(), "Bar should be disabled")
 	require.True(t, New("Bar2").Enabled(), "Other gates should be enabled")
-	require.Contains(t, DisabledGates(false), "Bar")
+	require.Contains(t, DisabledGates(), "Bar")
+}
+
+func TestDisableOldGate(t *testing.T) {
+	t.Setenv("DISABLE_S2CODE_Deprecated", "disabled")
+
+	// refresh disabled gates to pick up the changes to the environment
+	// variables
+	resetDisabledGates()
+
+	gateTestDeprecated := New("Deprecated")
+	require.False(t, gateTestDeprecated.Enabled(), "Deprecated should be disabled")
+	require.True(t, New("Deprecated2").Enabled(), "Other gates should be enabled")
+	require.Contains(t, DisabledGates(), "Deprecated")
 }
 
 func TestDisableMultipleGates(t *testing.T) {
 	// create some random environment variables
-	_ = os.Setenv("NOISE", "LOUD")
-	_ = os.Setenv("MORE_NOISE", "LOUDER")
-	_ = os.Setenv("DISABLED_CODE", "")
+	t.Setenv("NOISE", "LOUD")
+	t.Setenv("MORE_NOISE", "LOUDER")
+	t.Setenv("DISABLED_CODE", "")
+	t.Setenv("DISABLED_CODE_TOO", "")
 
 	// disable two gates
-	_ = os.Setenv("DISABLE_Baz1", "disabled")
-	_ = os.Setenv("DISABLE_Baz3", "disabled")
+	t.Setenv("DISABLE_CODE_Baz1", "disabled")
+	t.Setenv("DISABLE_CODE_Baz3", "disabled")
 
 	// refresh disabled gates to pick up the changes to the environment
 	// variables
-	DisabledGates(true)
+	resetDisabledGates()
 
 	// define four gates
 	gateTestBaz1 := New("Baz1")
@@ -82,20 +94,20 @@ func TestDisableMultipleGates(t *testing.T) {
 	require.False(t, gateTestBaz3.Enabled(), "Baz3 should be disabled")
 	require.True(t, gateTestBaz4.Enabled(), "Baz4 should be enabled")
 
-	require.Contains(t, DisabledGates(false), "Baz1")
-	require.NotContains(t, DisabledGates(false), "Baz2")
-	require.Contains(t, DisabledGates(false), "Baz3")
-	require.NotContains(t, DisabledGates(false), "Baz4")
+	require.Contains(t, DisabledGates(), "Baz1")
+	require.NotContains(t, DisabledGates(), "Baz2")
+	require.Contains(t, DisabledGates(), "Baz3")
+	require.NotContains(t, DisabledGates(), "Baz4")
 }
 
-func TestRefreshDisabledGates(t *testing.T) {
+func TestResetDisabledGates(t *testing.T) {
 	// ensure no disabled gates at start
-	_ = os.Unsetenv("DISABLE_Foo")
-	require.NotContains(t, DisabledGates(false), "Foo")
+	require.NotContains(t, DisabledGates(), "Foo")
 
 	// disable Foo
-	_ = os.Setenv("DISABLE_Foo", "disabled")
-	require.NotContains(t, DisabledGates(false), "Foo")
+	t.Setenv("DISABLE_CODE_Foo", "disabled")
+	require.NotContains(t, DisabledGates(), "Foo")
 	// refresh disabled gates
-	require.Contains(t, DisabledGates(true), "Foo", "DisabledGates(true) should refresh the disabled gates")
+	resetDisabledGates()
+	require.Contains(t, DisabledGates(), "Foo", "DisabledGates(true) should refresh the disabled gates")
 }

go.mod

@@ -1,6 +1,6 @@
 module github.com/singlestore-labs/codegate
 
-go 1.24.9
+go 1.23.0
 
 require github.com/stretchr/testify v1.11.1