Skip to main content
100%

Gist 1074953

✓ Published0🌍 Public
Aalessioalex
Last edited Jul 10, 2011
Created on Jul 10, 2011

This example demonstrates server-side request benchmarking and logging through real-time socket events. The code uses the `GO.aop` aspect-oriented programming module to intercept controller execution, measuring rendering time with the `GO.time` vendor library. Each HTTP request triggers two socket emissions: one reports the page render duration via a benchmark message, while the other logs Apache-style visit details including the URL and user-agent. Data is transmitted through `GO.Socket.emit` with timestamps and unique identifiers generated by `GO.utils.uid`.

AI-generated description

Similar vizzes

Loading thumbnail…

AB Benchmark Node.js (via Restify) - 10,000 requests (10 concurrent)

This example displays the results of an ApacheBench load test against a Node.js Restify server, showing 10,000 requests completed with 10 concurrent connections. The visualization plots the percentage of requests served within specific time thresholds, from the 50th percentile at 3 milliseconds up to the longest request at 18 milliseconds. The chart uses D3.js to render the distribution of response times, with data parsed from the ApacheBench text output. The visualization highlights the server’s consistent performance, as most requests complete within 4 milliseconds, and reveals the small variance in request handling times.

HHugoberry
60% match
Loading thumbnail…

Gist 75fe6f98cacb874f8d9ebce7248b1b66

This example presents a web-based client-server application that serves static files and handles socket connections. The server is built with Express and Socket.IO, listening on a configurable port, and delegates all routes to a single `index.html` file. It uses the `body-parser` middleware for JSON parsing and the `path` module to resolve file locations. The rendering approach is not specified, but the code clearly establishes the infrastructure for delivering a front-end visualization, with the server acting as the backbone for real-time communication and static asset delivery.

RRonolibert
60% match
Loading thumbnail…

Gist 837424

This visualization shows the response time of a single HTTP POST request sent via `curl` to a test endpoint. A time series line chart plots the server’s response latency in milliseconds, with the x-axis representing sequential request attempts and the y-axis showing duration. The code uses `d3.json` to fetch the endpoint, then builds the chart with `d3.scaleTime`, `d3.axisBottom`, and `d3.line`. The data comes from the server’s JSON response, which contains timestamped latency values. The rendering relies on standard SVG elements generated through D3’s selection and join methods, with a hover tooltip provided by `d3.tip`.

Aabernier
59% match
Loading thumbnail…

Gist 1070395

This example demonstrates a real-time messaging dashboard where a Node.js server relays messages to a browser client over the Faye Bayeux protocol. It shows how server-side JavaScript publishes messages to a subscribed client, which logs incoming text to the console. The code sets up an HTTP server with `http.createServer`, serves static HTML files from the filesystem, and attaches Faye’s `NodeAdapter` to handle WebSocket connections at `/faye`. A `Faye.Client` subscribes to the `/messages` channel, receiving and printing each message’s `text` property. The rendering relies on terminal output rather than visual charts.

Aalessioalex
59% match
Loading thumbnail…

Gist 1075489a3f6f94d13b2ab76cff4c7cea

This example visualizes the asynchronous execution order of Node.js operations by logging their completion times relative to a shared start timestamp. It uses Node’s `https.request` to fetch Google’s homepage, `crypto.pbkdf2` for four CPU-intensive password hashes, and `fs.readFile` to read a local file. The console output reveals how the event loop interleaves I/O callbacks, with the network request finishing before the file read and hash computations, illustrating the non-blocking concurrency model.

Aamazingandyyy
59% match
Loading thumbnail…

Gist 1a03bf15beee9f72953b414669e44576

This example demonstrates a Node.js utility that asynchronously fetches the HTTP status code for a given URL. It first reads a text file using the `fs.readFile` method to extract a domain or URL from its first line, then passes that address to the `request` library’s `getStatusCodeAsync` function, which returns the server’s response code. The visualization shows how file I/O and network requests are chained through callbacks, highlighting the flow of data from local storage to remote servers without any graphical rendering.

MMailnickko
57% match
Loading thumbnail…

Gist 48d689f1ba856686fff5

This example demonstrates a simple WebSocket-based message exchange between a server and a browser client. The server sends a `server_ping` event with a `Hello bob` payload, and the client’s JavaScript listens for that event, logs the incoming message to the console, and also handles disconnections. The visualization itself is minimal, relying on the browser console for output rather than graphical rendering. The code uses the raw WebSocket API through a channel object (likely from a library like Socket.IO or similar) and standard `console.log` for feedback.

Aandybak
57% match
Loading thumbnail…

Async node-postgres sample code

This example demonstrates a web server that tracks and reports visitor counts using an asynchronous PostgreSQL workflow. It uses Express routes and the `node-postgres` library to insert a timestamp into a `visit` table and then query the total count, returning the result as an HTTP response. The code highlights both modern async/await syntax with `await query(...)` and a callback-style alternative using `errto` for error handling, showing two equivalent approaches for database interactions.

Aalessioalex
57% match