CPANscan

Net::Statsd::Lite is a lightweight Perl client for StatsD that implements the StatsD Metrics Export Specification v0.1 and lets you batch multiple metrics into a single UDP packet for efficient reporting. It provides the usual metric types you expect from a StatsD client, including counters, gauges, timings (and histogram), as well as set operations and a secure_set_add helper that HMAC-SHA-256 hashes sensitive values before sending. The client is configurable with host, port, prefix, autoflush and buffer size and exposes a record_metric hook so you can easily add extensions such as tagging in subclasses. Notes and caveats are documented by the author and include the fact that many StatsD daemons do not support every metric type or multimetric packets, measured values are expected to be integers within the spec limits, and a consistent secure_set_key must be used across processes and hosts to avoid skewed set counts. The module requires Perl 5.20 or later and is actively developed on GitHub.

Crypt::Passphrase::SaltedHash is a small adapter that lets Crypt::Passphrase recognize and validate password hashes produced by Crypt::SaltedHash, so you can verify legacy SaltedHash strings and detect when those hashes should be rehashed under a stronger scheme. It plugs into Crypt::Passphrase via the validators option and supports the usual verify_password and needs_rehash workflow, making it easy to authenticate users stored with SaltedHash and migrate them to modern encoders like Argon2. This is the initial 0.01 release.

Text::Unpack::Auto detects column boundaries in fixed-width plain text and either generates an unpack template or returns parsed rows for you, so you do not need to handcraft unpack strings. It exports guess_unpack to produce an unpack format from sample lines and auto_unpack to split each input line into an arrayref of trimmed fields, returning one arrayref per line. You can tune detection with options such as minimum_gap to control how small spaces are interpreted, which makes it handy for parsing legacy reports, command output, or any columnar text where widths are consistent but formats are not documented.

Test::Returns provides a lightweight testing helper to assert that a function's return value matches a schema, exporting returns_ok (alias returns_is) and returns_not_ok so you can declare expected types and structures for return values in unit tests instead of writing ad hoc checks. It uses Return::Set and Params::Validate::Strict to perform the validation and integrates with Test::Builder so it works smoothly alongside Test::More and Test::Most. If your tests need to verify that routines return the right kind of data structures or types this module makes those checks concise and readable. The recent 0.03 release adds convenient handling of type => 'array' as a synonym for type => 'arrayref', documents that underscore-prefixed schema keys are passed through unchanged, and fixes a bug to make array validations behave correctly while providing clearer diagnostics when a non-reference is returned.

File::Meta::Cache provides a lightweight, high-performance cache of open file descriptors and stat metadata so programs that repeatedly access the same files can avoid repeated open and stat calls and reduce the number of open file descriptors required. It is aimed at servers and other high-frequency readers of static files and offers both an object oriented API and direct callable opener/closer/sweeper/updater subs for minimal overhead. Cache entries are array references with fixed index fields and include a USER slot where you can stash precomputed data such as HTTP headers, so the module favors speed over a fancy interface and requires callers to manage per-user file positions. The cache tracks its own reference counts and exposes a sweep method you should call periodically to expire unused entries. Recent releases added redirected file linking to emulate links on filesystems that lack them and fixed a posix open edge case where a '0 but true' file descriptor value needed conversion. If you need to speed repeated file reads and are comfortable with low-level, index-based entries and manual position management, this module is likely relevant.

Email::Address::List parses RFC-style address lists found in headers like From, To, Cc, Bcc, Reply-To, Sender and Resent-* and turns them into a stream of typed entries such as mailboxes, group start/end markers, standalone comments, and unknown tokens so you can inspect or manipulate the full structured content of a header rather than just pluck addresses from free text. Each mailbox entry carries an Email::Address object and helpful flags for obsolete syntax and non-ASCII local-part or domain parts, and the parser aggressively removes stray whitespace and Unicode format characters from local-part and domain to avoid undeliverable addresses introduced by copy/paste. You can control what the parser emits with options to skip comments, groups, non-ASCII mailboxes, or unknown elements, and it attempts graceful recovery from malformed input by skipping to the next separator. Note that group names are not fully post-processed yet and may include noise, and recent maintenance improved Unicode whitespace stripping and addressed past regex backtracking issues for better robustness.

IPC::Shareable is a Perl module that lets you tie scalars, arrays, hashes or objects to SysV shared memory so multiple processes can read and write the same data in a familiar tie() interface. It serializes complex structures into shared segments using JSON by default with an optional Storable mode, and nested references are stored in separate child segments so large or hierarchical data is supported. The module provides advisory lock() and unlock() methods with shared and exclusive modes, non blocking attempts and a handy code reference form that auto unlocks, and it also offers software enforcement and warnings to catch accidental unsynchronized reads or writes. You can use singleton() to ensure only one copy of a script runs, inspect low level shared segment and semaphore objects for debugging, and call cleanup methods or mark segments as protected so they persist until you explicitly remove them. Be aware that shared memory size and count are limited by your operating system and that locks are inherited across forks and END cleanup does not run for untrapped signals so you should manage signal handlers if you rely on destroy. Overall this is a practical tool for sharing structured Perl data between processes with built in locking, diagnostics and lifecycle controls.

App::Perl::Module::Examples is a lightweight base class for the perl-module-examples command line tool that helps you find Perl modules in a directory and surface the example snippets from their POD documentation. It exposes a simple object API with new and run and supports common CLI options such as -h, --version, -d for debug mode and an optional working directory. The module relies on standard utilities like File::Find::Rule and Pod::Example to discover modules and parse =head1 EXAMPLES and nested =head2 example sections, making it useful for authors who want to collect, display or validate the example code embedded in their modules. Recent changes added explicit EXAMPLES parsing, support for subexample sections, an examples section in the documentation, optional working directory handling and a debug mode that prints found Perl modules.

App::ElasticSearch::Utilities is a bundled set of command line tools and a small Perl library that make it easy to inspect, monitor, and perform routine maintenance on Elasticsearch and OpenSearch clusters. It provides ready-made scripts for searching indices, watching cluster and node metrics, scanning for index problems, and managing daily or alias-based indexes, plus programmatic helpers you can import into your own Perl scripts for tasks like connecting, issuing requests, enumerating indices, fetching index stats, and applying settings. Configuration can live in system or user YAML files and the tools support TLS, basic auth with a safe password-exec hook, a noop mode for dry runs, and flexible pattern and date-based index selection so you can target monthly, daily, or otherwise segmented indices. Simple formatting helpers let you render sizes and counts in human-friendly form and a comprehensive set of exported functions makes it straightforward to automate common ops. Recent releases improved OpenSearch compatibility, cleaned up documentation and CLI behavior, and updated test workflows for newer Perl versions.

CLI::Helpers is a lightweight toolkit for building simple Perl command line scripts that makes common tasks like formatted output, interactive prompts and basic argument handling much easier. It provides output helpers with color, tagging, sticky and stderr flags, verbosity and debug levels, optional syslog and data-file support, and the ability to render references as JSON or YAML so you can print complex data structures cleanly. For input it offers confirm, text_input, menu and pwprompt with validators and no-echo password prompting. The module integrates with Getopt::Long while letting you choose whether to preprocess, delay, or operate on a copy of @ARGV so it does not clash with your own parsing, and it exports named groups so you only import what you need. Extras include debug_var for developer dumps, an options_description() helper to work with Getopt::Long::Descriptive, and optional App::Nopaste support for posting output to paste services. Recent releases focused on packaging and project migration to Codeberg, and earlier 2.1/2.2 updates added JSON/YAML encoding for output and improved option-description support.

Parse::Syslog::Line is a lightweight Perl module that turns a single syslog line into a ready-to-use hash reference, extracting fields like priority and facility (text and integer), timestamps (raw, ISO8601 string, UTC string and epoch), host and domain, program name and PID, message content, and structured data from RFC5424 blocks or auto-detected JSON or key/value payloads. It is aimed at network syslog input and includes options to tune behavior such as enabling or disabling date parsing, auto-detecting JSON or Splunk-style key/values, stripping RFC5424 structured data, pruning raw or empty fields, and speeding up parsing by skipping program extraction. There is also a multi-line parser for continued messages and simple timezone helpers to set or use UTC for parsing. Date processing uses Time::Moment and the author notes DST and timezone edge cases so you should prefer the epoch or datetime_utc for portability. If you need a simple, configurable way to convert varied syslog lines into a consistent data structure for logging, monitoring, or indexing, this module is a practical choice.

Eris is a developer-friendly toolkit for turning messy, unstructured log lines into structured messages you can index or analyze, with a deliberately pluggable architecture that makes parsers easy to build and debug. It separates work into decoders that run on raw text, contexts that add or enrich structured fields based on matchers, dictionaries that filter key/value space, and schemas that shape documents for storage, and it ships with sample decoders, contexts and scripts to test, bulk-format, or send data to Elasticsearch so you can experiment without running a heavyweight service. Configuration lets you add your own namespaces and extend behavior, which keeps maintenance and troubleshooting transparent compared with monolithic log processors. The recent 0.009 release fixes an unused-variable bug and adds a Test::UnusedVars plugin to improve test quality.

POE::Component::ElasticSearch::Indexer is a POE session that makes it easy for event-driven Perl programs to batch and submit documents to an Elasticsearch cluster using the bulk API. It integrates into POE kernels with simple events such as "queue" to add documents, "flush" to force a send, "backlog" to recover disk-stored batches, and "shutdown" to tidy up, and it handles HTTP or HTTPS connections with optional basic auth and connection pooling. The indexer batches by size or time, supports strftime-based default index naming and ES 7.x-compatible types, writes failed batches to disk for later recovery, and offers configurable timeouts, concurrency limits, stats callbacks, and disk-space-based backlog pruning. Recent releases improved OpenSearch compatibility and logging and fixed packaging issues in version 0.017. Use this module when you run a POE-based service and need reliable, high-throughput, recoverable indexing into Elasticsearch or OpenSearch.

Pod::Example is a small utility for extracting example code blocks from a Perl module's POD documentation so you can print, run, or re-use those examples programmatically. It offers two simple functions: get accepts a filename or module name and returns the example code as a scalar or as a two-element list including an optional filename when the POD contains a filename=FILENAME directive, and sections returns the list of example sections found in the POD, with a default section name of EXAMPLE and support for numbered sections like EXAMPLE1 and EXAMPLE2. This module is handy if you are building tooling around documentation, generating example files from docs, or automating example testing.

File::Unpack2 is a Perl library and command line tool that reliably extracts a very wide range of archive and packed file types by detecting content with MIME analysis instead of trusting file name extensions. It recursively unpacks nested containers such as tar.bz2, zip, 7z, rpm, deb, cab, lzma and many others until the payload files are exposed and it records each extraction as JSON in a logfile. The module uses libmagic and shared-mime-info where available, supports built‑in handlers and simple shell-script helper plugins so you can add custom format support, and provides safety features like maximum file size limits, free-disk checks, an optional jailed working directory, symlink controls and configurable output permissions and layout. It also includes a general run wrapper for invoking external tools and ships with a file_unpack2 CLI for ad hoc use. The author notes MIME detection can be messy across differing magic databases and that the bundled helper list is not exhaustive, but the tool is very useful for administrators, build systems, forensics and automation tasks that must unpack many and possibly nested archives without relying on file suffixes.

Archive::Tar is a portable, pure-Perl, object-oriented toolkit for creating, reading, inspecting and modifying tar archives. It models archives as objects made of Archive::Tar::File entries and gives you easy methods to add files or raw data, list or retrieve file contents, rename entries, change ownership and permissions, remove items, and extract to disk. It can read and write plain tars and, when the appropriate modules are present, gzip, bzip2 or xz compressed tars. For large archives you can avoid loading everything into memory by using the provided iterator or the extract_archive helper which writes files directly to disk. The module exposes configuration flags to control extraction safety, symlink and hardlink handling, long-path behavior and permission restoration so you can tune compatibility and security. Because it is implemented in Perl it is highly portable and convenient for programmatic archive manipulation, but it will be slower and use more memory than the system tar utility. Recent releases have improved security around links by validating symlink and hardlink targets in secure mode and made hardlink extraction opt-in to reduce risk.

Genealogy::Relationship::Name is a compact Perl module that turns two generational step counts plus the sex of a person into a human-readable kinship name, for example "first cousin once-removed", and can localize the result into several languages. You construct a namer object with an optional default language, optional Log::Abstraction logger, or an Object::Configure config file, then call name() with steps_to_ancestor, steps_from_ancestor, sex and optional per-call language and family_side to distinguish maternal versus paternal terms where available. The module ships lookup tables for English, German, Spanish, Farsi, French and some Classical Latin terms and provides helpers to list supported languages and valid sex codes. Calls return a localized string or undef when a particular step combination is not in the table. Note that the included tables cover steps 0 through 6 in each direction so very distant relationships are not yet tabulated and Latin coverage is sparse.

PAGI is a modern asynchronous web application specification and toolkit for Perl that brings async/await programming to the web as a spiritual successor to PSGI. It defines a small, stable app interface where an async coderef receives a scope, a receive callback and a send callback and it supports HTTP/1.1, WebSocket and Server Sent Events plus process lifecycle events. The distribution bundles a reference server, convenience helpers for requests, responses, WebSocket and SSE handling, routers, middleware and example apps so you can build and test async services quickly. The PAGI spec and the reference server are intended to be stable while many helper modules and routers are still evolving, so expect some APIs to change as the project matures. PAGI addresses practical concerns such as UTF8 handling, send-side backpressure and loop interoperability and requires Perl 5.18 or later with IO::Async and Future::AsyncAwait. A notable recent change is the new PAGI::Context factory that provides a unified context object and introduced updated endpoint handler signatures along with improved stash and session helpers, so review the changelog before upgrading. If you want an evented, futures based approach to building web services in Perl PAGI is worth evaluating.

Mojolicious::Plugin::Statsd is a small, easy plugin for Mojolicious apps that gives you a convenient helper to emit counters, timings, gauges and set updates to a StatsD-compatible server. You call the helper from controllers or hooks to increment or decrement counters, time blocks of code either by passing a duration or a coderef, send gauge values and add members to sets, with optional sampling and a with_prefix helper to scope metric names. The plugin is adapter-based so you can switch backends or use the bundled in-memory adapter for testing, and by default it emits UDP packets to localhost:8125; recent versions added a client attribute and now use Net::Statsd::Tiny for protocol handling. Configuration lets you change the helper name and prefix and pass options to the adapter, and the module requires Perl v5.16 or later. The 0.06 release fixed a metric-injection security issue and adds a security policy so take care not to expose sensitive data in metrics and to sanitize names to avoid colons or pipes used by the StatsD protocol.

EV::ClickHouse is an async, XS-based ClickHouse client for Perl that plugs into the EV event loop and speaks both the HTTP and native TCP protocols without requiring an external client library. It is designed for high-throughput, nonblocking access: you can run parameterized queries, stream large results via per-block callbacks or a synchronous iterator, and push bulk inserts with a buffered insert_streamer that handles batching and backpressure. The client offers connection-level and per-query settings, automatic reconnect with backoff, optional compression and TLS (including mutual auth), raw HTTP bodies for CSV or Parquet, and typed decoding for many ClickHouse column types. For multi-node deployments there is built-in multi-host failover and, in the latest release, a full connection pool with circuit-breaker, hedged queries, fan-out and session pinning, plus async DNS, retry helpers, external-table support and idempotent/async insert helpers. If you are writing Perl services or ETL pipelines that need low-latency, event-driven access to ClickHouse this module provides a production-oriented feature set and tooling to handle streaming, retries, and operational concerns.

String::Obfuscate provides a fast, reversible substitution cipher to scramble text for non-security-sensitive purposes. It builds a reproducible character mapping from a numeric seed or passphrase via the ISAAC random generator so you can decode what you encoded by reusing the same seed. By default it shuffles ASCII letters and digits but you can supply your own character set or use the included Base64 and Base64::URL subclasses for binary or UTF-8 data. The module is explicitly not cryptographically secure, but it is far faster than full encryption and generates compact encode/decode routines that can be dumped for inspection. It requires Perl 5.20 or later and optionally uses List::Util::XS for a deterministic shuffle. Use this module when you need lightweight, reversible obfuscation of IDs, test data, or configuration values rather than protection of secrets.

HTML::Gumbo is a thin Perl wrapper around Google's Gumbo C library that brings a standards‑compliant HTML5 parser to Perl programs. It can parse HTML into a cleaned, balanced string, drive a callback stream of parse events for streaming or token-level processing, or produce an experimental HTML::Element-based tree for DOM-like access. The module accepts decoded Perl strings or raw octets and offers options to control how character encoding is handled, and it is designed to be robust against malformed input and lightweight in use. A few features are still incomplete or experimental, for example tree output is alpha, some library features like source locations are not exposed, and automatic encoding sniffing and prescan are not implemented. If you need reliable, spec-accurate HTML5 parsing from Perl with simple APIs for string output or event callbacks, HTML::Gumbo is a practical choice.

Catalyst::Plugin::Authentication provides the core authentication and basic authorization infrastructure for Catalyst web applications. It lets you define one or more realms that pair a credential verifier with a user store so your app can authenticate users and look up their data, and it integrates with Catalyst sessions so login state can persist across requests. You configure realms in your app and then use simple methods such as $c->authenticate, $c->user, $c->user_exists and $c->logout to manage login flow. The plugin works with many storage backends and credential modules, from a simple in-memory hash to DBIx::Class or LDAP stores and Password, HTTP or OpenID credential handlers, so you can change storage without rewriting your app. Note that since version 0.10 it uses a realms-based API and older credential or store modules must be updated or used in a compatibility mode that disables realm features. Overall this is the standard, flexible glue for adding user authentication to Catalyst apps and integrates with other Catalyst authorization and session plugins.

Template::Toolkit is a mature, Perl-based template processing system for generating any kind of text output, most commonly static and dynamic web pages. It cleanly separates presentation from application logic so designers can build and edit templates without touching Perl code while developers can integrate and extend the toolkit through plugins and APIs. The system is input-agnostic and works with HTML, XML, CSS, JavaScript, plain text and more. Non-Perl users can easily author templates and Perl developers can hook Template::Toolkit into existing code or use the bundled command-line tools tpage and ttree to process files or directories. Extensive POD documentation, tutorials and a rich module/plugin ecosystem make it straightforward to learn, adapt and deploy for a wide range of templating needs.

Dist::PolicyFiles is a tiny utility for Perl authors that automates creating CONTRIBUTING.md and SECURITY.md files for a distribution. You give it your GitHub login and module name and it fills in sensible defaults and links such as CPAN request tracker and a GitHub issue/SECURITY.md URL, can pull your name and email from SSH config, and lets you supply or override a CONTRIBUTING.md template. The security file generation delegates to Software::Security::Policy::Individual so you get a standard policy layout with configurable maintainer, program and URL values, including options to add a repo prefix or force lowercasing. It also ships a dist-policyfiles command line tool for convenience. The recent 0.09 release added helper methods to return the CPAN RT URL, the computed repo name and the GitHub repo URL.

App::FatPacker::Simple is a focused utility for turning a Perl script and a set of known module files into a single bundled script for easy distribution and deployment. Unlike fuller fatpacking tools it does not try to trace dependencies for you, so it is best when you already understand what needs to be included; it concentrates on embedding modules from directories, offers automatic perl-strip support to remove unneeded code, and provides options to exclude specific modules from the bundle. You interact with it via the fatpack-simple command and a short tutorial is available, making it a lightweight, controlled way to produce standalone Perl scripts. Recent releases raised the minimum required Perl to 5.24 and improved packaging to exclude authoring files from release archives.

WWW::RobotRules is a small utility for parsing robots.txt files and keeping a local database of the resulting access rules so your crawler can ask whether a given URL is allowed for a named robot. You create a WWW::RobotRules object with your agent name, feed it the contents of robots.txt files from one or more hosts, and then call allowed($url) to decide whether to fetch that URL. The module supports the standard User-agent and Disallow records and will apply the most specific matching rule for each agent, and changing the agent name resets the cached rules. Recent updates hardened on-disk cache handling to avoid a symlink race and tightened file permissions, but note there remains a caller-trust requirement because the underlying AnyDBM_File tie follows symlinks on platforms that do not provide O_NOFOLLOW, so you should keep the cache file in a directory writable only by the crawling user.

AtteanX::Endpoint provides a PSGI-compatible SPARQL 1.1 Protocol endpoint that you can mount in a Plack-based web app to expose an Attean RDF model over HTTP, accepting SPARQL requests, invoking the planner and model to evaluate them, and returning PSGI responses via its run($request) method. The module is driven by a configurable conf hash so you can control the service description, choose whether to expose named and default graphs, enable or disable data loading and update support, and set the default graph IRI. It also includes simple logging hooks for queries and errors. Use this module when you want a lightweight, Perl-native SPARQL endpoint for serving or integrating RDF stores into web services and applications.

CLI::Simple is a compact, object‑oriented helper for writing Perl command‑line programs that need options, subcommands and positional arguments while staying lightweight and testable. It is built around the modulino pattern so a single module can act as both a reusable library and an executable script, and it auto-creates getter/setter accessors for options, integrates Log::Log4perl for logging with optional per-command log levels, supports aliases and abbreviated commands, and exposes handy internal tools to introspect a live modulino, dump a YAML manifest, scaffold role stubs, migrate to a role-based layout, and generate bash completion scripts. For larger projects it offers an optional role-based workflow where commands and options live in a YAML manifest and are implemented as Role::Tiny roles, letting you move from a simple script to a composable, distribution-friendly layout with minimal fuss. It is aimed at internal tools and small to medium CLIs where you want structure without a heavyweight framework, and the 2.0.x series notably added the manifest/role architecture plus scaffolding and completion tools while the 2.0.2 release made a few packaging and shell usage improvements.

Log::Dispatch::UDP is a small Log::Dispatch output class that sends plain text log messages from a Perl program to a remote UDP socket. It plugs into the Log::Dispatch framework so you can route info or higher level events to a hostname and port and the datagrams contain just the message text, making it simple to capture with tools like netcat or a lightweight UDP collector. Because traffic is sent unencrypted and unstructured, it is best suited for non-sensitive, low-overhead remote logging rather than secure or audited record keeping. The module requires Perl 5.8 or later and only the latest release is supported. The recent 0.02 maintenance release added a new maintainer, a security policy and explicit security considerations, strengthened prerequisite version minimums, cleaned up unused code and added author tests.