Generic resource pooling for Node.JS
Connection pool for node-postgres
A general purpose buffer pool.
Offload tasks to a pool of workers on node.js and in the browser
Turn a function into an `http.Agent` instance
Map-like, concurrent promise processing for Node.js
OpenTelemetry instrumentation for `node:net` network API module
OpenTelemetry instrumentation for `generic-pool` resource pool for managing expensive resources
TypeScript definitions for pg-pool
Resource pooling for Node.JS
A minimal and tiny Node.js Worker Thread Pool implementation, a fork of piscina, but with fewer features
The `@minecraft/server-net` module contains types for executing HTTP-based requests. This module can only be used on Bedrock Dedicated Server.
Reuse typed arrays
A fast, efficient Node.js Worker Thread Pool implementation
Workers Vitest integration for writing Vitest unit and integration tests that run inside the Workers runtime
A tiny Node.js module to make any server force-closeable
Web3 module to interact with the Ethereum nodes networking properties.
A Pulumi package for interacting with Docker in Pulumi programs
Drop-in replacement for Nodes http and https that transparently make http request to both http1 / http2 server, it's using the ALPN protocol
Runs Promises in a pool that limits their concurrency.
Simple and robust resource pool for node.js
🦄 Core smart contracts of Uniswap v4
The Swagger API toolchain for .NET, Web API and TypeScript.
[](https://github.com/StarpTech/apollo-datasource-http/actions/workflows/ci.yml)
Manages persistent connections using Net::HTTP plus a speed fix for Ruby 1.8. It's thread-safe too! Using persistent HTTP connections can dramatically increase the speed of HTTP. Creating a new HTTP connection for every request involves an extra TCP round-trip and causes TCP congestion avoidance negotiation to start over. Net::HTTP supports persistent connections with some API methods but does not handle reconnection gracefully. Net::HTTP::Persistent supports reconnection and retry according to RFC 2616.
Manages persistent connections using Net::HTTP including a thread pool for connecting to multiple hosts. Using persistent HTTP connections can dramatically increase the speed of HTTP. Creating a new HTTP connection for every request involves an extra TCP round-trip and causes TCP congestion avoidance negotiation to start over. Net::HTTP supports persistent connections with some API methods but does not make setting up a single persistent connection or managing multiple connections easy. Net::HTTP::Persistent wraps Net::HTTP and allows you to focus on how to make HTTP requests.
A persistent Net::Http adapter for Faraday with a connection pool shared across threads and fibres.
This is an experimental branch that implements a connection pool of Net::HTTP objects instead of a connection/thread. C/T is fine if you're only using your http threads to make connections but if you use them in child threads then I suspect you will have a thread memory leak. Also, I want to see if I get less connection resets if the most recently used connection is always returned. Also added a :force_retry option that if set to true will retry POST requests as well as idempotent requests. This branch is currently incompatible with the master branch in the following ways: * It doesn't allow you to recreate the Net::HTTP::Persistent object on the fly. This is possible in the master version since all the data is kept in thread local storage. For this version, you should probably create a class instance of the object and use that in your instance methods. * It uses a hash in the initialize method. This was easier for me as I use a HashWithIndifferentAccess created from a YAML file to define my options. This should probably be modified to check the arguments to achieve backwards compatibility. * The method shutdown is unimplemented as I wasn't sure how I should implement it and I don't need it as I do a graceful shutdown from nginx to finish up my connections. For connection issues, I completely recreate a new Net::HTTP instance. I was running into an issue which I suspect is a JRuby bug where an SSL connection that times out would leave the ssl context in a frozen state which would then make that connection unusable so each time that thread handled a connection a 500 error with the exception "TypeError: can't modify frozen". I think Joseph West's fork resolves this issue but I'm paranoid so I recreate the object. Compatibility with the master version could probably be achieved by creating a Strategy wrapper class for GenePool and a separate strategy class with the connection/thread implementation.