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