The flag was the string false

# Self-authored for the EML case corpus (no external origin). The feature is
# gated behind a config flag and the gate reads the flag on every request. What
# the flag's value is is computed below.
#
# The gate is careful. It reads the real config value, not a default baked into
# the binary; it reads it fresh each request, not once at boot; the flag is
# present in config, not missing; and the gate is a plain if on that value.
#
# The value arrived from JSON/env as the string "false", and a non-empty string
# is truthy.

2000000 => requests_in_the_window
2000000 => requests_that_saw_the_feature_on
0 => requests_that_saw_the_feature_off
0 => config_reads_that_failed

requests_in_the_window - requests_that_saw_the_feature_on => requests_the_flag_meant_to_gate_off
int(requests_that_saw_the_feature_on * 10000 / requests_in_the_window) => feature_on_share_per_myriad

"requests in the window          : " + str(requests_in_the_window) ^0
"  saw the feature ON            : " + str(requests_that_saw_the_feature_on) ^0
"  saw the feature OFF           : " + str(requests_that_saw_the_feature_off) ^0
"config reads that failed        : " + str(config_reads_that_failed) ^0
"the flag was meant to gate OFF  : " + str(requests_the_flag_meant_to_gate_off) ^0
"feature-on share                : " + str(feature_on_share_per_myriad) + " per ten thousand" ^0
"" ^0

# ---- what the gate verified ----

"the feature gate" ^0
"  reads : the real config value, not a baked default" ^0
"  when : fresh on every request, not once at boot" ^0
"  flag present in config : yes, set to false" ^0
"  the gate : a plain if on the value" ^0
"  requests that read stale config : 0" ^0
"  verdict : GATE EVALUATED EVERY REQUEST" ^0
"" ^0
"  reading fresh each request rather than caching at boot" ^0
"  is the part done right here, and it is why a real toggle" ^0
"  would take effect at once" ^0
"" ^0

# ---- what the value is ----

"the flag's value as loaded" ^0
"  what config says : false" ^0
"  how it arrived : as the JSON/env string \"false\"" ^0
"  what the gate tests : if (flag)" ^0
"  what a non-empty string is : truthy" ^0
"  so if (\"false\") : is taken, the feature is ON" ^0
"" ^0

# ---- what the operator intended ----

"the operator who set false" ^0
"  what they meant : the feature is off" ^0
"  what the gate did : turned it on for everyone" ^0
"  requests affected : " + str(requests_that_saw_the_feature_on) ^0
"  is the gate reading the wrong key : no; it reads the" ^0
"    right flag" ^0
"  is the string \"false\" a false value : no; only an empty" ^0
"    string is falsy, and \"false\" is five characters" ^0
"" ^0

# ---- null control ----

# The same config, with the value parsed to a boolean (or compared to the string
# "true") before the gate tests it.
10000 => nc_feature_on_when_string_is_truthy
0 => nc_feature_on_when_parsed_to_boolean
2000000 => nc_requests_correctly_gated_off

"null control - parse the flag to a boolean" ^0
"  feature on, string truthiness : " ^0
"    " + str(nc_feature_on_when_string_is_truthy) + " per ten thousand" ^0
"  feature on, parsed boolean : " + str(nc_feature_on_when_parsed_to_boolean) ^0
"  requests correctly gated off : " + str(nc_requests_correctly_gated_off) ^0
"  no config and no gate location changed; the value" ^0
"  stopped being judged by its length instead of its" ^0
"  meaning" ^0
"" ^0

# ---- the rule ----

"what a fresh-read config gate guarantees" ^0
"  the gate evaluates the current config value each" ^0
"    request : exactly, no stale boot-time cache" ^0
"  the feature is off when the flag is false : not" ^0
"    addressed; the value is the string \"false\" and a" ^0
"    non-empty string is truthy, so if (flag) is taken and" ^0
"    the feature ran ON for all " + str(requests_that_saw_the_feature_on) + " requests" ^0
"" ^0

"a boolean gate needs a boolean, and a string that spells a boolean is not one;" ^0
"'false' as text is truthy because it is non-empty, so the flag reads as its own" ^0
"opposite the moment it is not parsed" ^0
"" ^0

"It reads the real flag fresh on every request with a plain if - the gate ran" ^0
"every time. The value is the string \"false\", which is truthy, so if (flag) was" ^0
"taken and the feature was ON for all " + str(requests_that_saw_the_feature_on) + " requests the flag meant to gate" ^0
"off, " + str(feature_on_share_per_myriad) + " per ten thousand." ^0

requests_in_the_window = 2000000
requests_that_saw_the_feature_on = 2000000
requests_that_saw_the_feature_off = 0
config_reads_that_failed = 0
requests_the_flag_meant_to_gate_off = requests_in_the_window - requests_that_saw_the_feature_on
feature_on_share_per_myriad = int(requests_that_saw_the_feature_on * 10000 / requests_in_the_window)
print("requests in the window          : " + str(requests_in_the_window))
print("  saw the feature ON            : " + str(requests_that_saw_the_feature_on))
print("  saw the feature OFF           : " + str(requests_that_saw_the_feature_off))
print("config reads that failed        : " + str(config_reads_that_failed))
print("the flag was meant to gate OFF  : " + str(requests_the_flag_meant_to_gate_off))
print("feature-on share                : " + str(feature_on_share_per_myriad) + " per ten thousand")
print("")
print("the feature gate")
print("  reads : the real config value, not a baked default")
print("  when : fresh on every request, not once at boot")
print("  flag present in config : yes, set to false")
print("  the gate : a plain if on the value")
print("  requests that read stale config : 0")
print("  verdict : GATE EVALUATED EVERY REQUEST")
print("")
print("  reading fresh each request rather than caching at boot")
print("  is the part done right here, and it is why a real toggle")
print("  would take effect at once")
print("")
print("the flag's value as loaded")
print("  what config says : false")
print("  how it arrived : as the JSON/env string \"false\"")
print("  what the gate tests : if (flag)")
print("  what a non-empty string is : truthy")
print("  so if (\"false\") : is taken, the feature is ON")
print("")
print("the operator who set false")
print("  what they meant : the feature is off")
print("  what the gate did : turned it on for everyone")
print("  requests affected : " + str(requests_that_saw_the_feature_on))
print("  is the gate reading the wrong key : no; it reads the")
print("    right flag")
print("  is the string \"false\" a false value : no; only an empty")
print("    string is falsy, and \"false\" is five characters")
print("")
nc_feature_on_when_string_is_truthy = 10000
nc_feature_on_when_parsed_to_boolean = 0
nc_requests_correctly_gated_off = 2000000
print("null control - parse the flag to a boolean")
print("  feature on, string truthiness : ")
print("    " + str(nc_feature_on_when_string_is_truthy) + " per ten thousand")
print("  feature on, parsed boolean : " + str(nc_feature_on_when_parsed_to_boolean))
print("  requests correctly gated off : " + str(nc_requests_correctly_gated_off))
print("  no config and no gate location changed; the value")
print("  stopped being judged by its length instead of its")
print("  meaning")
print("")
print("what a fresh-read config gate guarantees")
print("  the gate evaluates the current config value each")
print("    request : exactly, no stale boot-time cache")
print("  the feature is off when the flag is false : not")
print("    addressed; the value is the string \"false\" and a")
print("    non-empty string is truthy, so if (flag) is taken and")
print("    the feature ran ON for all " + str(requests_that_saw_the_feature_on) + " requests")
print("")
print("a boolean gate needs a boolean, and a string that spells a boolean is not one;")
print("'false' as text is truthy because it is non-empty, so the flag reads as its own")
print("opposite the moment it is not parsed")
print("")
print("It reads the real flag fresh on every request with a plain if - the gate ran")
print("every time. The value is the string \"false\", which is truthy, so if (flag) was")
print("taken and the feature was ON for all " + str(requests_that_saw_the_feature_on) + " requests the flag meant to gate")
print("off, " + str(feature_on_share_per_myriad) + " per ten thousand.")

requests in the window          : 2000000
  saw the feature ON            : 2000000
  saw the feature OFF           : 0
config reads that failed        : 0
the flag was meant to gate OFF  : 0
feature-on share                : 10000 per ten thousand

the feature gate
  reads : the real config value, not a baked default
  when : fresh on every request, not once at boot
  flag present in config : yes, set to false
  the gate : a plain if on the value
  requests that read stale config : 0
  verdict : GATE EVALUATED EVERY REQUEST

  reading fresh each request rather than caching at boot
  is the part done right here, and it is why a real toggle
  would take effect at once

the flag's value as loaded
  what config says : false
  how it arrived : as the JSON/env string "false"
  what the gate tests : if (flag)
  what a non-empty string is : truthy
  so if ("false") : is taken, the feature is ON

the operator who set false
  what they meant : the feature is off
  what the gate did : turned it on for everyone
  requests affected : 2000000
  is the gate reading the wrong key : no; it reads the
    right flag
  is the string "false" a false value : no; only an empty
    string is falsy, and "false" is five characters

null control - parse the flag to a boolean
  feature on, string truthiness : 
    10000 per ten thousand
  feature on, parsed boolean : 0
  requests correctly gated off : 2000000
  no config and no gate location changed; the value
  stopped being judged by its length instead of its
  meaning

what a fresh-read config gate guarantees
  the gate evaluates the current config value each
    request : exactly, no stale boot-time cache
  the feature is off when the flag is false : not
    addressed; the value is the string "false" and a
    non-empty string is truthy, so if (flag) is taken and
    the feature ran ON for all 2000000 requests

a boolean gate needs a boolean, and a string that spells a boolean is not one;
'false' as text is truthy because it is non-empty, so the flag reads as its own
opposite the moment it is not parsed

It reads the real flag fresh on every request with a plain if - the gate ran
every time. The value is the string "false", which is truthy, so if (flag) was
taken and the feature was ON for all 2000000 requests the flag meant to gate
off, 10000 per ten thousand.

Trace event types