OnCallReadyStart learning

Spring Boot Runtime, Resilience & Python Ops: glossary

47 terms, in plain words, with where each one is taught.

/actuator/prometheus (actuator/prometheus)
The Actuator page with every counter, gauge and timer of the app in a plain text format that monitoring tools collect (the format is named after one of them). Lesson 26.1
application.properties (application.yaml, application.yml)
Spring Boot's configuration file: key=value settings such as server.port=8080, packed inside the jar and overridable from outside. Lesson 26.1
argparse
Python's standard library for command-line flags and --help, like getopts in bash but with types and defaults. Lesson 26.31
backpressure
Refusing or slowing new work when queues are full, instead of accepting it and falling over. Lesson 26.22
bean (beans, Spring bean)
An object that Spring creates and wires together for the application (a database pool, an HTTP client, a controller). Lesson 26.1
bounded queue (queue-capacity)
A work queue with a maximum size; when it is full new work is rejected immediately instead of waiting forever. Lesson 26.25
bulkhead
A separate, limited pool of threads or connections per dependency, so one slow dependency cannot use up everything. Lesson 26.22
cardinality (high cardinality)
How many different series a metric creates; labels with unbounded values (user ids) make it explode. Lesson 26.11
circuit breaker (breaker, CLOSED, OPEN)
A switch around calls to a dependency: after too many failures it opens and fails calls immediately for a while, then lets a few through to test. Lesson 26.22
CompletableFuture (future, async)
Java's promise: a result that will arrive later, computed on another thread (an executor). Like a JavaScript Promise. Lesson 26.25
connect timeout (read timeout, connection timeout)
Connect timeout = how long to wait for the TCP connection; read timeout = how long to wait for the answer once connected. Without a read timeout a thread can wait forever. Lesson 26.18
connectionTimeout (connection-timeout, max-lifetime, keepalive-time)
Hikari settings: how long a request waits for a free connection, how long a connection lives, how often an idle one is pinged. Lesson 26.15
counter (counters, _total)
A metric that only goes up (requests served, errors); you look at how fast it grows. Resets to 0 when the app restarts. Lesson 26.11
endpoint exposure (management.endpoints.web.exposure.include)
The Spring setting that lists which Actuator endpoints are reachable over HTTP; by default only health. Lesson 26.1
exception (exceptions, try/except, raise)
Python's error mechanism: code raises an exception, a try/except block catches it; uncaught ones end the script with a traceback. Lesson 26.31
fixture (fixtures, tmp_path, conftest.py)
In pytest, a function that prepares something a test needs (a temp dir, a fake config); the test gets it by naming it as a parameter. Lesson 26.34
framework
A ready-made skeleton for a kind of program: you write the business parts, it provides the web server, configuration, logging and so on. Lesson 26.1
gauge (gauges)
A metric that shows a current value that can go up and down (pending connections, live threads). Lesson 26.11
graceful shutdown (server.shutdown=graceful, timeout-per-shutdown-phase)
On SIGTERM the app stops taking new requests and finishes the running ones, up to a timeout, before exiting. Lesson 26.8
health group (health groups, liveness group, readiness group)
A named subset of Spring's health checks: the liveness group checks only the app itself, the readiness group may add dependencies such as the database. Lesson 26.3
health indicator (health indicators, health components)
One check inside /actuator/health (db, diskSpace, ping...); the overall status is the worst of them. Lesson 26.3
hey
A small HTTP load generator: hey -n 1000 -c 50 URL sends 1000 requests, 50 at a time, and prints the latency distribution. Lesson 26.15
HikariCP (Hikari, hikaricp)
The database connection pool Spring Boot uses by default; its metrics show active, idle and pending connections. Lesson 26.15
histogram buckets (_bucket, percentiles-histogram)
Counts of requests faster than each of several limits; from them a monitoring system computes percentiles such as p99 across all pods. Lesson 26.11
idempotent (idempotency)
An operation that has the same effect when done twice (reading, setting a value); only those are safe to retry blindly. Lesson 26.22
jitter (full jitter)
A random part added to retry waits so that many clients do not retry at the same moment. Lesson 26.22
kubernetes Python client (load_kube_config, load_incluster_config, CoreV1Api)
The official Python library for the Kubernetes API; load_kube_config() uses your kubeconfig, load_incluster_config() the pod's ServiceAccount. Lesson 26.34
logging (logging module)
Python's standard logging library: levels (DEBUG, INFO, WARNING, ERROR), timestamps, and output to stderr or a file instead of print(). Lesson 26.31
management port (management.server.port)
A separate port where Actuator endpoints are served, so probes and monitoring can reach them while the public traffic port never exposes them. Lesson 26.1
Micrometer
The metrics library inside Spring Boot: the app records counters, gauges and timers through it, and it publishes them in formats monitoring tools read. Lesson 26.11
monkeypatch
A pytest fixture that temporarily replaces a function, attribute or environment variable for one test, for example a network call with a fake. Lesson 26.34
PEP 668 (externally-managed-environment)
The Python rule Ubuntu follows: pip refuses to install into the system Python (error: externally-managed-environment) so it cannot break apt's packages. Use a venv. Lesson 26.29
pool exhaustion (pending connections, connection pool exhaustion)
Every connection in a pool is in use, so new requests queue for one: latency climbs while errors and CPU stay low. Lesson 26.15
profile (profiles, spring.profiles.active)
A named set of extra settings (application-prod.properties) that Spring loads when that profile is active. Lesson 26.5
property source (property sources, config precedence)
One place Spring reads settings from (command line, environment variables, an external file, the jar's application.properties); the higher one wins. Lesson 26.5
PyPI
The Python Package Index: the public registry pip downloads from, like the npm registry. Lesson 26.29
pytest
The usual Python test runner: functions named test_* with plain assert, run with pytest; its exit code tells CI whether tests passed. Lesson 26.34
Python (python3)
A general-purpose scripting language, installed on every Ubuntu server as python3; the usual choice for ops tools bigger than a bash script. Lesson 26.29
relaxed binding
Spring's rule that DB_POOL_MAX in the environment sets the property db.pool.max: upper case, underscores instead of dots. Lesson 26.5
Resilience4j
The Java library behind circuit breakers, retries and bulkheads in Spring Boot apps; its state is visible at /actuator/circuitbreakers. Lesson 26.22
retry (retries)
Trying a failed call again; exponential backoff waits longer after each failure (1s, 2s, 4s...). Lesson 26.22
retry storm (thundering herd)
Many clients retrying at once against a service that is trying to recover, keeping it down. Lesson 26.22
subprocess (subprocess.run)
Python's way to run another program: subprocess.run([...], capture_output=True, text=True, timeout=5), with arguments as a list so no shell is involved. Lesson 26.31
time series (series)
One stored line of numbers over time for one metric and one combination of labels. Lesson 26.11
timeout budget (deadline)
The total time a caller can afford; every timeout and retry below it must fit inside. Lesson 26.18
timer (_count, _sum, _max)
A metric for durations: _count = how many, _sum = total seconds, _max = the longest recently; average = _sum / _count. Lesson 26.11
traceback
The error report Python prints when an exception is not caught: the call chain and the error message at the bottom. Lesson 26.31