Skip to main content
100%

Genie Job Heartbeat

✓ Published0🌍 Public
Aadkatrit
Last edited Aug 23, 2017
Created on Aug 22, 2017

This example monitors the runtime status of a Netflix Genie job by emitting an audible beep each time the job is confirmed to be running. It shows a continuous polling loop that checks the job’s state through the Genie REST API, specifically querying the `/api/v3/jobs` endpoint with a size limit of 100 results. The script uses `curl` to fetch the JSON response and `jq` to filter the job list for the target job ID and its current status, grepping for the string “RUNNING” to trigger the terminal bell via `tput bel`. The loop repeats at a user-defined interval until the job leaves the running state.

AI-generated description

Similar vizzes

Loading thumbnail…

Shell script to wait on a upstream jenkins job - a "block" node in an execution graph

A shell script uses the Jenkins REST API to wait for upstream jobs to finish, polling each job’s `/api/json?pretty=true` endpoint with Python’s `requests` and `json` libraries. It checks the `color` field for `"anime"` to detect a running build, sleeping 5 seconds between polls. After completion, it asserts that the last completed build equals the last successful build, confirming success. The script supports multiple upstream jobs by splitting a comma-separated `JOB_TO_WAIT_FOR` variable and tracking status in a list, effectively acting as a blocking node in an execution graph.

Aandyreagan
52% match
Loading thumbnail…

Gist 55a48fa82777d6887803eee74a1ed490

This visualization tracks Kafka client health by counting log occurrences of producer attempts, successes, and failures. It uses a shell script with `grep` and `grep -c` to extract counts from the `/srv/minted/logs/www-wsgi.log` file every second, then prints the ratio of sent to attempted messages. The script loops indefinitely with `while sleep 1`, providing a live textual readout rather than a graphical plot. The example relies solely on command-line text processing, not any visualization library.

Aamazingandyyy
51% match
Loading thumbnail…

Gist 4521887

This example shows a shell-command supervisor that forks a child process, monitors its exit status, and restarts it on failure. The code uses POSIX APIs including `fork()`, `execl()`, `waitpid()`, and `signal()` to launch and track the command, while logging each step. It writes a pidfile, tracks restart timing with `timestamp()` and `ms_since_last_restart()`, and bails after exceeding `max_attempts` within a time window, executing an error command if configured. The visualization is a plain C source file, not a graphical chart, demonstrating process lifecycle logic.

Aallyraza
48% match
Loading thumbnail…

Gist 18a41f3fdfd61b617c16

This visualization is a system administration script that controls the Sentry aggregate logging engine. It provides Debian-compatible init.d functionality to start, stop, and check the status of the Sentry service using bash commands and shell scripting. The code uses process inspection with `ps`, `grep`, and `grep -oP` to identify the running gunicorn master process, and relies on core utilities like `setsid`, `su`, and `kill` for service management. The example illustrates operational data flow rather than visual rendering, focusing on command-line interactions and process state detection.

TThanad
47% match
Loading thumbnail…

Gist 44be7198b7913c5e683122ab224baa9e

This example demonstrates a shell-based spinner that provides visual feedback during a long-running command-line task. Instead of a graphical chart, it renders a rotating line animation directly in the terminal by updating a single carriage-returned character (`\r`) on the standard error stream. The script iterates through the characters of the string `/|-\` using a modulo index, printing one frame per line of piped input. It relies on standard shell constructs like `printf`, a `while` loop with `read`, and an environment variable for state, with no external JavaScript libraries or data sources involved. The spinner stops and clears the line after the input stream ends.

HHerst
47% match
Loading thumbnail…

Gist dbe8122ef6678bc81c0628ce7b6020f9

This example tracks a job-search progress checklist in a GitHub gist, visualizing task completion across categories like personal projects and applications. The code renders each checklist item as a node in a force-directed graph, using d3.forceSimulation to position items by category and status (checked or unchecked). A custom SVG rendering layer draws links between related tasks and colors nodes by completion state, while the layout derives directly from the gist’s markdown structure. The visualization shows how a simple to-do list can be reimagined as an interactive network, with hover tooltips revealing task titles and URLs from the source data.

FFrankieFabuloso
46% match
Loading thumbnail…

Gist 180756

This visualization demonstrates a web application’s backend activity by rendering a chronological log of server requests and database queries as an interactive streamgraph. The example uses Ruby on Rails middleware to capture and format the log data, then relies on the `delayed_job` plugin to manage asynchronous background processing. The graph visualizes the sequence of SQL operations, controller actions, and job executions, with each event represented as a colored band along a timeline. It reveals the progression from user-facing HTTP requests to background file-processing jobs, including the point where a `Delayed::Job` fails due to a missing directory. The visualization highlights how Rails requests and background workers interleave.

DDylanFM
46% match
Loading thumbnail…

Internet detection via say

This example demonstrates a shell script that continuously monitors network connectivity by pinging a specified host. It shows a real-time alert system where the computer verbally announces when the internet becomes available. The script uses the `ping` command with a one-second timeout and the `say` command to produce an audible "internet alert" message. It operates in an infinite `while` loop, checking every second. The concrete APIs involved are the standard Unix utilities `ping` and `say`, with no graphical or data-visualization libraries present.

Aadkatrit
46% match