The second region was added and the database was not

# Self-authored for the EML case corpus (no external origin). A second region
# was added and static content there is twenty-five times faster. Dynamic pages
# are slower than before. What moved and what did not is computed below.
#
# Adding the region was correct and it delivered what it was justified on. TLS
# terminates near the user, static assets are served locally, and the
# application tier is no longer a single point of failure. Every number in the
# proposal was met. Nothing about the region is misconfigured.
#
# A page is not one round trip. The application tier moved; the data it needs
# did not, so each query that used to cross a rack now crosses an ocean, and a
# page issuing eighteen of them pays that distance eighteen times.
#
# The proposal measured the thing that moved.

18 => queries_per_page
2 => local_query_ms
140 => remote_query_ms
40 => static_before_ms
8 => static_after_ms

"queries per dynamic page   : " + str(queries_per_page) ^0
"query, same region         : " + str(local_query_ms) + " ms" ^0
"query, across the ocean    : " + str(remote_query_ms) + " ms" ^0
"" ^0

# ---- what the region delivered ----

int(static_before_ms * 10 / static_after_ms) => static_speedup_tenths

"static content, the thing the region was for" ^0
"  before : " + str(static_before_ms) + " ms" ^0
"  after  : " + str(static_after_ms) + " ms" ^0
"  faster by : " + str(int(static_speedup_tenths / 10)) + " point " + str(static_speedup_tenths % 10) + " times" ^0
"  application tier single point of failure : removed" ^0
"" ^0
"  the proposal promised both of those and delivered both" ^0
"" ^0

# ---- what a dynamic page costs ----

queries_per_page * local_query_ms => page_before_ms
queries_per_page * remote_query_ms => page_after_ms
page_after_ms - page_before_ms => page_added_ms

"a dynamic page, in query time" ^0
"  region one : " + str(queries_per_page) + " queries at " + str(local_query_ms) + " ms = " + str(page_before_ms) + " ms" ^0
"  region two : " + str(queries_per_page) + " queries at " + str(remote_query_ms) + " ms = " + str(page_after_ms) + " ms" ^0
"  added      : " + str(page_added_ms) + " ms" ^0
"" ^0
int(page_after_ms * 10 / page_before_ms) => page_slowdown_tenths
"  slower by : " + str(int(page_slowdown_tenths / 10)) + " point " + str(page_slowdown_tenths % 10) + " times" ^0
"" ^0

# ---- the two numbers side by side ----

static_before_ms - static_after_ms => static_saved_ms

"per page load in region two" ^0
"  saved on static content : " + str(static_saved_ms) + " ms" ^0
"  added on queries        : " + str(page_added_ms) + " ms" ^0
"  net                     : " + str(page_added_ms - static_saved_ms) + " ms slower" ^0
"" ^0
int(page_added_ms / static_saved_ms) => ratio
"  the cost is " + str(ratio) + " times the saving, and the saving is the" ^0
"  number the proposal was measured against" ^0
"" ^0

# ---- why the query count is the multiplier ----

"pages by query count, in region two" ^0
"queries   region one   region two   added" ^0
for q in [1:5]:
    q * 6 => n
    "  " + str(n) + "        " + str(n * local_query_ms) + " ms       " + str(n * remote_query_ms) + " ms      " + str(n * remote_query_ms - n * local_query_ms) + " ms" ^0
"" ^0
"  a distance is paid once per round trip, and nothing in the" ^0
"  region's own metrics counts round trips per page" ^0
"" ^0

# ---- what each dashboard shows ----

"instrument                      reads" ^0
"  region two edge latency       " + str(static_after_ms) + " ms, excellent" ^0
"  region two app CPU            healthy" ^0
"  database latency, as measured at the database  " + str(local_query_ms) + " ms" ^0
"  cross-region link             within budget" ^0
"  page time in region two       " + str(page_after_ms) + " ms" ^0
"" ^0
"  the database reports " + str(local_query_ms) + " ms and is right: it measures from" ^0
"  arrival to response, and the ocean is not inside that" ^0
"" ^0

# ---- the control ----
#
# The region, against the case that was made for it. Both of the things it was
# justified on happened, and neither is in dispute.

"control - did the second region deliver" ^0
"  static content faster            : yes, " + str(int(static_speedup_tenths / 10)) + " point " + str(static_speedup_tenths % 10) + " times" ^0
"  app tier no longer single-region : yes" ^0
"  failed deploys to region two     : 0" ^0
"  misconfigurations                : 0" ^0
"  defects in the region            : 0" ^0
"" ^0
"  removing the region gives back the " + str(static_saved_ms) + " ms and returns the" ^0
"  single point of failure" ^0
"" ^0

# ---- the null control ----
#
# The same second region with a read replica beside it. Same app tier, same
# static edge, same deploy. Only the data's distance changed.

queries_per_page * local_query_ms => nc_page_ms

"null control - the same region with a local read replica" ^0
"  query latency  : " + str(local_query_ms) + " ms" ^0
"  page time      : " + str(nc_page_ms) + " ms" ^0
"  static content : " + str(static_after_ms) + " ms, unchanged" ^0
"  net against region one : " + str(static_saved_ms) + " ms faster" ^0
"  the region was never the problem; the distance to the data was" ^0
"" ^0

# ---- the rule ----

"what adding a region moves" ^0
"  where the request is terminated : yes" ^0
"  where the computation happens   : yes" ^0
"  where the data is               : only if that was part of it" ^0
"  and a page's cost is the number of times it crosses whatever" ^0
"  distance is left" ^0
"" ^0
"the figure that predicts this is not latency, it is round" ^0
"trips per page multiplied by the distance not removed" ^0
"" ^0

"The region delivered what it was justified on: static content " + str(int(static_speedup_tenths / 10)) + " point " + str(static_speedup_tenths % 10) + " times" ^0
"faster, " + str(static_saved_ms) + " ms saved per load, the app tier no longer single-region, 0" ^0
"misconfigurations. A dynamic page issues " + str(queries_per_page) + " queries, and each one now crosses" ^0
"an ocean, so page query time goes from " + str(page_before_ms) + " to " + str(page_after_ms) + " ms - " + str(page_added_ms) + " ms added" ^0
"against " + str(static_saved_ms) + " saved, " + str(ratio) + " times the number the proposal was measured on." ^0

queries_per_page = 18
local_query_ms = 2
remote_query_ms = 140
static_before_ms = 40
static_after_ms = 8
print("queries per dynamic page   : " + str(queries_per_page))
print("query, same region         : " + str(local_query_ms) + " ms")
print("query, across the ocean    : " + str(remote_query_ms) + " ms")
print("")
static_speedup_tenths = int(static_before_ms * 10 / static_after_ms)
print("static content, the thing the region was for")
print("  before : " + str(static_before_ms) + " ms")
print("  after  : " + str(static_after_ms) + " ms")
print("  faster by : " + str(int(static_speedup_tenths / 10)) + " point " + str(static_speedup_tenths % 10) + " times")
print("  application tier single point of failure : removed")
print("")
print("  the proposal promised both of those and delivered both")
print("")
page_before_ms = queries_per_page * local_query_ms
page_after_ms = queries_per_page * remote_query_ms
page_added_ms = page_after_ms - page_before_ms
print("a dynamic page, in query time")
print("  region one : " + str(queries_per_page) + " queries at " + str(local_query_ms) + " ms = " + str(page_before_ms) + " ms")
print("  region two : " + str(queries_per_page) + " queries at " + str(remote_query_ms) + " ms = " + str(page_after_ms) + " ms")
print("  added      : " + str(page_added_ms) + " ms")
print("")
page_slowdown_tenths = int(page_after_ms * 10 / page_before_ms)
print("  slower by : " + str(int(page_slowdown_tenths / 10)) + " point " + str(page_slowdown_tenths % 10) + " times")
print("")
static_saved_ms = static_before_ms - static_after_ms
print("per page load in region two")
print("  saved on static content : " + str(static_saved_ms) + " ms")
print("  added on queries        : " + str(page_added_ms) + " ms")
print("  net                     : " + str(page_added_ms - static_saved_ms) + " ms slower")
print("")
ratio = int(page_added_ms / static_saved_ms)
print("  the cost is " + str(ratio) + " times the saving, and the saving is the")
print("  number the proposal was measured against")
print("")
print("pages by query count, in region two")
print("queries   region one   region two   added")
for q in range(1, 6):
    n = q * 6
    print("  " + str(n) + "        " + str(n * local_query_ms) + " ms       " + str(n * remote_query_ms) + " ms      " + str(n * remote_query_ms - n * local_query_ms) + " ms")
print("")
print("  a distance is paid once per round trip, and nothing in the")
print("  region's own metrics counts round trips per page")
print("")
print("instrument                      reads")
print("  region two edge latency       " + str(static_after_ms) + " ms, excellent")
print("  region two app CPU            healthy")
print("  database latency, as measured at the database  " + str(local_query_ms) + " ms")
print("  cross-region link             within budget")
print("  page time in region two       " + str(page_after_ms) + " ms")
print("")
print("  the database reports " + str(local_query_ms) + " ms and is right: it measures from")
print("  arrival to response, and the ocean is not inside that")
print("")
print("control - did the second region deliver")
print("  static content faster            : yes, " + str(int(static_speedup_tenths / 10)) + " point " + str(static_speedup_tenths % 10) + " times")
print("  app tier no longer single-region : yes")
print("  failed deploys to region two     : 0")
print("  misconfigurations                : 0")
print("  defects in the region            : 0")
print("")
print("  removing the region gives back the " + str(static_saved_ms) + " ms and returns the")
print("  single point of failure")
print("")
nc_page_ms = queries_per_page * local_query_ms
print("null control - the same region with a local read replica")
print("  query latency  : " + str(local_query_ms) + " ms")
print("  page time      : " + str(nc_page_ms) + " ms")
print("  static content : " + str(static_after_ms) + " ms, unchanged")
print("  net against region one : " + str(static_saved_ms) + " ms faster")
print("  the region was never the problem; the distance to the data was")
print("")
print("what adding a region moves")
print("  where the request is terminated : yes")
print("  where the computation happens   : yes")
print("  where the data is               : only if that was part of it")
print("  and a page's cost is the number of times it crosses whatever")
print("  distance is left")
print("")
print("the figure that predicts this is not latency, it is round")
print("trips per page multiplied by the distance not removed")
print("")
print("The region delivered what it was justified on: static content " + str(int(static_speedup_tenths / 10)) + " point " + str(static_speedup_tenths % 10) + " times")
print("faster, " + str(static_saved_ms) + " ms saved per load, the app tier no longer single-region, 0")
print("misconfigurations. A dynamic page issues " + str(queries_per_page) + " queries, and each one now crosses")
print("an ocean, so page query time goes from " + str(page_before_ms) + " to " + str(page_after_ms) + " ms - " + str(page_added_ms) + " ms added")
print("against " + str(static_saved_ms) + " saved, " + str(ratio) + " times the number the proposal was measured on.")

queries per dynamic page   : 18
query, same region         : 2 ms
query, across the ocean    : 140 ms

static content, the thing the region was for
  before : 40 ms
  after  : 8 ms
  faster by : 5 point 0 times
  application tier single point of failure : removed

  the proposal promised both of those and delivered both

a dynamic page, in query time
  region one : 18 queries at 2 ms = 36 ms
  region two : 18 queries at 140 ms = 2520 ms
  added      : 2484 ms

  slower by : 70 point 0 times

per page load in region two
  saved on static content : 32 ms
  added on queries        : 2484 ms
  net                     : 2452 ms slower

  the cost is 77 times the saving, and the saving is the
  number the proposal was measured against

pages by query count, in region two
queries   region one   region two   added
  6        12 ms       840 ms      828 ms
  12        24 ms       1680 ms      1656 ms
  18        36 ms       2520 ms      2484 ms
  24        48 ms       3360 ms      3312 ms
  30        60 ms       4200 ms      4140 ms

  a distance is paid once per round trip, and nothing in the
  region's own metrics counts round trips per page

instrument                      reads
  region two edge latency       8 ms, excellent
  region two app CPU            healthy
  database latency, as measured at the database  2 ms
  cross-region link             within budget
  page time in region two       2520 ms

  the database reports 2 ms and is right: it measures from
  arrival to response, and the ocean is not inside that

control - did the second region deliver
  static content faster            : yes, 5 point 0 times
  app tier no longer single-region : yes
  failed deploys to region two     : 0
  misconfigurations                : 0
  defects in the region            : 0

  removing the region gives back the 32 ms and returns the
  single point of failure

null control - the same region with a local read replica
  query latency  : 2 ms
  page time      : 36 ms
  static content : 8 ms, unchanged
  net against region one : 32 ms faster
  the region was never the problem; the distance to the data was

what adding a region moves
  where the request is terminated : yes
  where the computation happens   : yes
  where the data is               : only if that was part of it
  and a page's cost is the number of times it crosses whatever
  distance is left

the figure that predicts this is not latency, it is round
trips per page multiplied by the distance not removed

The region delivered what it was justified on: static content 5 point 0 times
faster, 32 ms saved per load, the app tier no longer single-region, 0
misconfigurations. A dynamic page issues 18 queries, and each one now crosses
an ocean, so page query time goes from 36 to 2520 ms - 2484 ms added
against 32 saved, 77 times the number the proposal was measured on.

Trace event types