2600hz/kazoo

This system is a modular telephony and communications platform built on the Erlang VM, designed to manage voice, video, and messaging services. It provides core infrastructure for call control, media handling, and event routing, while offering specialized applications for call flow logic, conferencing, SMS routing, and push notifications. The architecture supports integration with external services for payments, fax, and authentication, enabling a comprehensive suite of unified communications features.

57 changes.

This period marks the comprehensive modularization of the Kazoo platform, where the codebase was restructured into distinct, independent applications such as CDR, ACDC, and Blackhole. The work involved establishing standard build systems, licensing, and dependency management for each component, while simultaneously removing legacy RabbitMQ client implementations to clean up the dependency tree.

81 changes.

This period focused on expanding the codebase with numerous new core libraries and applications, including call inspection, push notifications, and task scheduling. The work established a standardized build system, centralized configuration management, and introduced modular components for authentication, caching, and media handling. Additionally, the project adopted the Mozilla Public License 2.0 across the repository.

67 changes.

This period focused on establishing a robust internal infrastructure, introducing the EDR eventing system and centralized event handling to decouple application logic. It also introduced foundational libraries for data conversion, number management, and testing utilities, while significantly expanding test coverage across the codebase.

The ACDC (Automatic Call Distribution) application is introduced with its core Erlang modules, including the agent state machine (acdc\_agent\_fsm), the AMQP listener (acdc\_agent\_listener), and the agent manager (acdc\_agent\_manager). This includes the necessary build files (Makefile, deps.mk), application metadata (acdc.app.src), and configuration headers (acdc\_config.hrl, acdc.hrl) that define constants, types, and macros for the call center queue system.

applications/acdc · high confidence

Introduces kz\_ast.hrl, a new header file providing type definitions and macros for Erlang Abstract Syntax Tree (AST) manipulation. This includes record definitions for module ASTs, type aliases for functions, records, exports, specs, and types, as well as helper macros for constructing AST nodes like functions, records, and dynamic function calls. This enables more structured and readable parsing and generation of Erlang code within the Kazoo ecosystem.

_core/kazoo\ast/include · high confidence

The Ananke application is introduced to the codebase, providing a scheduler for calls on events. This change includes the application's source structure, a Makefile for compilation, a deps.mk for dependencies, and a .gitignore for build artifacts. The application is released under the Mozilla Public License 2.0, as evidenced by the new LICENSE file and .shipyard.yml metadata.

applications/ananke · high confidence

New Erlang modules were added to the Braintree SDK to handle payment-related entities and operations. The changes introduce support for managing credit cards, customer records, subscriptions, transactions, addresses, add-ons, discounts, and client tokens. These modules provide functions to create, update, and delete records, as well as convert between XML, JSON, and internal record formats, enabling the system to interact with the Braintree payment gateway.

applications/braintree/src/sdk · high confidence

A new Erlang module, cb\_braintree, has been added to handle client requests for Braintree documents. This module implements the core integration logic, including routing for customer, card, address, and transaction endpoints, and binds to the Crossbar framework to manage HTTP methods and validation for these payment-related resources.

applications/braintree/src/integration · high confidence

Introduced a new EDR subsystem with multiple backend implementations: an AMQP backend for publishing events to RabbitMQ, an HTTP backend for sending events via HTTP POST, a file backend for logging events to disk, and a skeleton template for custom backends. The system also includes an API module for validating and formatting EDR events before they are dispatched.

applications/edr/src/backends · high confidence

Added documentation for the Jonny5 application, including a README explaining call limit management for accounts and resellers, a detailed guide on the Skel application listener pattern for AMQP message bus interactions, and reference pages listing SUP-able maintenance functions such as authz\_details, flush, and limits\_summary.

applications/jonny5/doc · high confidence

The diff introduces the core implementation for the Kazoo Tasks system, including the application source, header files, and the main Erlang module (kz\_tasks.erl) which provides functions for task validation, creation, and status tracking. This adds the foundational logic for handling background tasks, including mandatory/optional field verification and JSON serialization, effectively establishing the new tasks module within the core/kazoo\_tasks location.

_core/kazoo\tasks · high confidence

The \core/kazoo\_apps\ directory now includes a \LICENSE\ file containing the Mozilla Public License 2.0, replacing the previous license header. Additionally, the directory has been restructured to include new Erlang modules for managing application configuration and maintenance tasks. These include \kapps\_config\ and \kapps\_config\_doc\ for retrieving and managing system and account configurations, \kapps\_config\_maintenance\ for debugging and pretty-printing configuration values, and \kapps\_controller\ for starting, stopping, and monitoring Kazoo applications. The \kapps\_maintenance\ module provides utilities for database migrations, view refreshes, and system checks.

_core/kazoo\apps · high confidence

The Pivot application documentation is now available, providing an overview of the Pivot feature, its request payload fields, supported response formats (Kazoo JSON and TwiML), and debugging options. The update also includes example scripts, such as fireNYC.php, which demonstrate how to handle call data and return appropriate callflow responses.

applications/pivot/doc · high confidence

Introduces the amqp\_cron module, a distributed task scheduler for Erlang clusters that uses amqp\_leader for leader election. It supports scheduling tasks via one-shot, sleeper, or cron-style schedules, allowing periodic execution of functions or anonymous funs across the cluster. The change includes the core implementation (amqp\_cron.erl, amqp\_cron\_app.erl, amqp\_cron\_sup.erl, amqp\_cron\_task.erl), application metadata, build configuration (Makefile, deps.mk), and licensing (LICENSE, THANKS).

_core/amqp\cron · high confidence

The stepswitch application now includes a Makefile for compilation and testing, a deps.mk file specifying lager and poolboy as dependencies, a .gitignore to exclude build artifacts, and a .shipyard.yml configuration for packaging the kazoo-application-stepswitch RPM. These changes establish the standard build, test, and packaging structure for the stepswitch module.

applications/stepswitch · high confidence

The Blackhole application is introduced with standard build infrastructure, including a Makefile and dependency definitions for Cowboy and Lager, alongside a .gitignore and .shipyard.yml for packaging. The component is now licensed under the Mozilla Public License 2.0.

applications/blackhole · high confidence

The call\_inspector application is introduced with the necessary build system files (Makefile, deps.mk) and a .gitignore to manage compilation artifacts. The application is now licensed under the Mozilla Public License 2.0, and its dependencies (hep, lager) are explicitly defined for the build process.

_applications/call\inspector · high confidence

The crossbar application now includes a Makefile and dependency definitions (deps.mk) to manage compilation and testing, alongside a .gitignore and .shipyard.yml for build and packaging configuration. A LICENSE file was added to explicitly state the Mozilla Public License 2.0 terms, ensuring legal compliance for the application's distribution.

applications/crossbar · high confidence

The scripts directory now includes a detailed README (both Markdown and Org formats) that documents all available utility scripts. This includes tools for checking code style, spelling, and cross-references, as well as scripts for managing Erlang VM processes, generating API documentation, and handling copyright updates. The addition of these scripts and their documentation improves the developer experience by providing clear instructions and automated checks for common tasks.

scripts · high confidence

Added comprehensive documentation for the Kazoo Number Manager (KNM) in the \core/kazoo\_numbers/doc\ directory. This includes an overview of the number management interface, carrier type definitions (such as \knm\_local\, \knm\_inventory\, \knm\_managed\, and \knm\_mdn\), and detailed configuration guides for specific carrier modules including Bandwidth2, Telnyx, VoIP Innovations, and Voxbone. The update also introduces documentation for maintenance commands, number states, and feature provider whitelisting, providing users with the necessary information to configure and manage phone numbers within the system.

_core/kazoo\numbers/doc · high confidence

Users can now find documentation on using the Webhook callflow action, which allows callflows to trigger HTTP requests to external endpoints. The new guide explains how to configure the action's parameters, including the target URI, HTTP verb, retry count, and custom data payload, with examples for integrating webhooks into phone tree flows.

applications/callflow/doc/.org · high confidence

Introduced the \kz\_fax\_attachment\ module to manage fax document attachments, including saving outbound faxes and fetching various formats (original, PDF, TIFF) for both sent and received faxes. The module handles conversion and storage of fax documents based on configuration settings, and includes the Mozilla Public License 2.0.

_core/kazoo\fax · high confidence

Introduces the kazoo\_perf application, providing tools for performance testing and system metrics collection. This includes a maintenance script that gathers memory, process, and scheduler statistics and outputs them in Graphite-compatible and JSON formats, alongside utilities for generating load and tracing execution paths.

_core/kazoo\perf · high confidence

The Konami application introduces a suite of new metaflow modules that enable dynamic call control and media handling. Users can now configure workflows to play media, perform text-to-speech, record calls, manage hold states, and execute transfer, intercept, and move operations. Additionally, new modules allow for call break/hangup, callflow overlay, and audio level adjustments, expanding the range of interactive voice and media capabilities available within call flows.

applications/konami/src/module · high confidence

The 'sup' command-line interface is now supported via a new shell script wrapper (core/sup/priv/sup) that locates the Kazoo release root and invokes the underlying escript. Additionally, a new escript (core/sup/priv/build-autocomplete.escript) has been added to generate bash completion scripts for 'sup', enabling tab-completion for commands and arguments. This change improves usability by providing a convenient entry point and interactive shell features for the sup tool.

core/sup/priv · high confidence

Introduces a new 'skel' application in the codebase, providing a template for creating new Kazoo services. This includes the application source files (skel\_app.erl, skel\_sup.erl, skel\_listener.erl, skel\_handlers.erl), configuration (skel.app.src, skel.hrl), and build files (Makefile, deps.mk). The skeleton implements a basic AMQP listener and handler structure, allowing developers to quickly scaffold new Kazoo applications with standard dependencies and supervision trees.

applications/skel · high confidence

The stats application is introduced to provide statistical snapshots of the Kazoo server and the Erlang VM via SNMP. This includes a new MIB (KAZOO-MIB) and Erlang modules (kazoo\_snmp, stats\_handler, stats\_listener) that collect and expose metrics such as memory usage, AMQP activity, and ecallmgr statistics. The application registers processes like stats\_cache and stats\_sup, and listens for targeted AMQP messages to update the internal state used by the SNMP agent.

applications/stats · high confidence

Added JSON sample files for various webhook events (channel\_answer, channel\_bridge, channel\_create, channel\_destroy, notifications, object, parking) to provide reference payloads for developers. Additionally, added a JavaScript function sample for serverless functions and a schema generation script that updates the timezone enum for scheduled port requests.

applications/crossbar/priv · high confidence

The webhooks application is introduced, providing HTTP callbacks for events within Kazoo. This change adds the core build infrastructure (Makefile, deps.mk, .gitignore) and packaging metadata (.shipyard.yml) for the component, while also updating the license to Mozilla Public License 2.0.

applications/webhooks · high confidence

The webseq module has been added to provide functionality for creating and managing sequence diagrams. This includes a new Erlang application (webseq) with associated source files, headers, and a Makefile for compilation. The module supports logging events, titles, and notes to either files or databases, enabling users to generate sequence diagrams compatible with tools like WebSequenceDiagrams.com.

core/webseq · high confidence

The pusher application now includes dedicated modules for Apple APNs (pm\_apple.erl) and Firebase FCM (pm\_firebase.erl) to handle push notifications. These new modules implement gen\_server processes that manage connections to the respective push services, allowing the system to send notifications to iOS and Android devices.

applications/pusher/src/modules · high confidence

The \core/kazoo\proper\ directory was introduced, containing a new test framework for Kazoo. This includes a \Makefile\ and \deps.mk\ for building the project, a \LICENSE\ file adopting the Mozilla Public License 2.0, and a suite of Erlang modules (\pqc\\*\) that provide API clients, state models, and sequence definitions for testing various Kazoo features such as accounts, blacklists, callflows, CDRs, and websockets. The \kazoo\_proper.app.src\ file defines the application with dependencies on Cowboy, Gun, and other Kazoo internal libraries, establishing the foundation for property-based and stateful testing of the platform.

_core/kazoo\proper · high confidence

A new example implementation for Kazoo's authentication system has been added to demonstrate an OAuth2 flow with Google. The example includes an HTML page that uses jQuery to initiate an authorization request to Google's OAuth2 endpoint, handling the redirect and parsing the response. A corresponding JavaScript file (popup.js) provides the logic for managing the popup window and polling for the OAuth2 callback, allowing users to see how to integrate Google Drive and other Google services via the Kazoo auth framework.

_core/kazoo\auth/doc/example · high confidence

New documentation files have been added to the Kazoo PropEr project, providing guides for testing rates, ratedecks, and service plans using PropEr. The \rates.md\ and \rates.org\ files detail how to create and assign ratedecks, and test service plan assignments to accounts. Additionally, a \README.md\ introduces the PropEr quickcheck models for various Kazoo components (Crossbar, Phone Numbers, IPs, Recordings), and \maintenance.md\ documents SUP-able functions for running these tests.

_core/kazoo\proper/doc · high confidence

Two new Python 3 scripts, list\_task\_modules.py and schema\_to\_header.py, have been added to the priv directory. These scripts automate the generation of Erlang header files (.hrl) from existing source files and JSON schemas, respectively, ensuring that header definitions are kept in sync with the underlying module and schema definitions.

applications/tasks/priv · high confidence

The \core/kazoo\_xml\ module has been introduced to provide generic helpers for manipulating XML records. This includes functions to extract element values, convert XML attributes to proplists, and filter empty text nodes. The module depends on \kazoo\_stdlib\ and \kazoo\, and is now licensed under the Mozilla Public License 2.0.

_core/kazoo\xml · high confidence

The \core/kazoo\_databases\ module now includes new Erlang modules for managing account lifecycles (\kzdb\_account.erl\) and ratedeck key generation (\kzdb\_ratedeck.erl\). The account module provides functions to create and delete accounts, including associated services, numbers, and database records. The ratedeck module provides a utility to generate prefix keys for number sequences. These changes are accompanied by a new test suite for the ratedeck functionality and the addition of a Makefile and license header.

_core/kazoo\databases · high confidence

The \kazoo\_telemetry\ application has been introduced to collect and transmit anonymous usage statistics from Kazoo clusters. This feature gathers data about node topology, application versions, database clusters, and service items, then sends periodic pings to the Waveguide telemetry service. Configuration options allow administrators to enable or disable the collection of specific metrics (apps, database, FreeSWITCH, Kamailio, services) and control cluster ID anonymization.

_core/kazoo\telemetry · high confidence

The call\_inspector application now includes new Erlang modules for handling call analysis and chunking: ci\_analysis defines a record and accessor functions for tracking call metadata (call ID, originate/terminate types, failure location, and reason) and converting them to JSON; ci\_analyzers provides a placeholder for chunk processing; and ci\_analyzers\_sup sets up a standard OTP supervisor to manage these components.

_applications/call\inspector/src/analyzers · high confidence

New email notification templates have been added for various events, including fax (inbound, outbound, and errors), voicemail, low balance, top-up, porting status, and system alerts. These templates provide both text and HTML versions of the messages, ensuring consistent and informative notifications for users regarding their account activities and system events.

applications/notify/priv · high confidence

New sample files have been added to the Pivot application's private directory, providing reference implementations for various telephony actions. These include XML templates for dialing (user, SIP, device, and conference calls), gathering user input, playing audio, and speaking text, as well as a JSON template for Kazoo user data. These samples serve as examples for developers integrating with the Pivot framework.

applications/pivot/priv · high confidence

New HTML templates have been introduced for generating directory listings and Letters of Authorization (LOA) documents. The directory template renders a table of user names and associated phone numbers, while the LOA template provides a structured form for authorizing telephone number porting, including sections for customer details, carrier information, and an optional QR code image.

applications/crossbar/priv/couchdb/templates · high confidence

The \braintree\ application has been introduced to the codebase, providing the core integration with the Braintree payment service. This includes the application supervisor, a shared message listener for handling bookkeeper requests (sales, refunds, recurring charges, and updates), and specific request handlers for each transaction type. The module also defines SDK constants, data records, and maintenance routines for syncing payment information.

applications/braintree/src · high confidence

The \cccp\ (Calling Card Callback Platform) application is introduced with its core Erlang modules, including the main application entry point, HTTP route handlers, and AMQP listeners for call events and camping requests. The package includes a \cccp.app.src\ manifest declaring dependencies on \crossbar\, \kazoo\, \kazoo\_data\, and others, alongside build and metadata files (\Makefile\, \.shipyard.yml\, \.gitignore\).

applications/cccp · high confidence

The \applications/cdr\ directory now contains the complete source code for the CDR (Call Detail Record) application, including the main application module, supervisor, and handlers for processing call events. The code implements the logic for receiving CDR events from the AMQP bus, filtering out loopback and anonymous calls, and saving the records to the database. It also includes utilities for CSV conversion and view registration.

applications/cdr · high confidence

The callflow application is introduced with a new build structure, including a Makefile that triggers schema validation via a new bash script (check-schemas.bash). This script ensures that JSON schema files exist for each callflow module, automatically generating stub schemas if they are missing. The application also includes a .gitignore file to exclude build artifacts, a .shipyard.yml for packaging, and a LICENSE file specifying the Mozilla Public License 2.0.

applications/callflow · high confidence

Added documentation for the Kazoo AMQP library, including an Org-mode README detailing the Erlang library architecture and connection management, a Markdown README, and specific guides for AMQP worker publishing/consuming patterns and SUP-able maintenance functions.

_core/kazoo\amqp/doc · high confidence

Added comprehensive documentation for the services module, including the structure and merge logic for service plans, the HTTP bookkeeper interface for external billing reconciliation, account standing management, and a reference for SUP maintenance functions.

_core/kazoo\services/doc · high confidence

The global state management and node tracking logic have been extracted from the core application into a new, standalone \kazoo\_globals\ Erlang application. This new module now handles cluster-wide process registration, AMQP message routing for global state changes, and node status reporting. The change introduces new supervision trees, ETS-based storage for global names and node information, and dedicated gen\_server processes to manage these shared resources, improving modularity and allowing other parts of the system to depend on this isolated component for global state queries and updates.

_core/kazoo\globals · high confidence

The HotOrNot application has been restructured to support an in-memory trie-based rate lookup mechanism. A new \hon\_trie\ module manages a persistent in-memory trie for fast DID-to-rate matching, while a new \hon\_trie\_lru\ module provides an LRU-cached variant that progressively loads rates. The \hotornot\_listener\ has been updated to bind to trie update events, and the \hotornot\_config\ module now exposes configuration options to enable the trie and select the caching strategy. This change improves rate lookup performance by reducing database queries for active rates.

applications/hotornot · high confidence

This change establishes the foundational configuration for the Kazoo project, introducing a structured build system via a new Makefile and erlang.mk integration, alongside essential development tooling. It adds a coding standards guide (CONTRIBUTING.md) to direct contributors on code style, testing, and commit practices. The repository is configured with an .editorconfig for consistent formatting, a .gitignore to exclude build artifacts and IDE files, and an aspell configuration (.aspell.en.prepl) to support automated spelling checks. Additionally, a license file (LICENSE) and version file (VERSION) are added to define the project's legal and release status.

(repo-wide) · high confidence

The Doodle application is introduced as a new component for SMS routing and store-and-forward capabilities. It includes the core Erlang modules for handling inbound and outbound SMS messages, managing text flows, and interacting with AMQP queues. The application is licensed under the Mozilla Public License 2.0 and is configured to depend on other Kazoo core applications such as kazoo\_amqp, kazoo\_numbers, and kazoo\_data.

applications/doodle · high confidence

The Teletype application is introduced as a new component within the Kazoo suite, providing email notification and branding services for receiving emails about events within the system. This initial commit establishes the application's build infrastructure, including a Makefile for compilation and testing, a dependency manifest (deps.mk) specifying requirements like cowlib, gen\_smtp, lager, and poolboy, and a build script to generate default module headers. The application is licensed under the Mozilla Public License 2.0.

applications/spyvsspy, applications/teletype · high confidence

A new \amqp\_leader\ module has been added to the core, providing a leader election and coordination mechanism for AMQP services. This includes the application bootstrapping (\amqp\_leader\_app\), a supervisor tree (\amqp\_leader\_sup\, \amqp\_leader\_proc\_sup\), and the core leader process (\amqp\_leader\_proc\) which manages node state and candidate selection. The component also includes a listener (\amqp\_leader\_listener\) for handling AMQP events and a header file (\amqp\_leader.hrl\) defining application metadata. The code is licensed under the Mozilla Public License 2.0.

_core/amqp\leader · high confidence

Adds a new CNAM (Caller Name) lookup service to the platform, enabling the system to retrieve caller identification information. The change introduces the core lookup logic, a caching layer, and provider implementations for OpenCNAM and Telnyx, allowing the system to fetch and cache caller name data.

_core/kazoo\cnam · high confidence

Adds the core EDR library to enable sending and subscribing to internal events within Kazoo applications. This includes the \edr.hrl\ header with event and binding records, \kz\_edr\ for emitting events, and \edr\_bindings\ for managing event subscriptions and distribution. The component is licensed under the Mozilla Public License 2.0.

_core/kazoo\edr · high confidence

Added the \kazoo\_etsmgr\ application, which provides a \kazoo\_etsmgr\_srv\ gen\_server to manage ETS tables. This server protects against the main writer dying by using ETS heir mechanisms to transfer table ownership to a designated successor process, ensuring data persistence and availability.

_core/kazoo\etsmgr · high confidence

The EDR application is introduced, providing a framework for processing and formatting event data records. This includes a new \edr\ application with a \backend\ record and associated modules (\edr\_app\, \edr\_sup\, \edr\_backend\_sup\, \edr\_maintenance\, \edr\_util\, \gen\_edr\_backend\, \edr\_formatter\, and \edr\_fmt\_json\) that enable the registration, lifecycle management, and push-based processing of event data. The system supports pluggable backends and formatters (e.g., JSON), allowing for flexible event data handling.

applications/edr/src · high confidence

Added the \kazoo\_fixturedb\ application, a simple file-based CouchDB implementation designed for testing. This new module provides an in-memory or file-backed database that mimics CouchDB behavior, allowing developers to run tests against a lightweight, self-contained database without needing a real CouchDB instance. The implementation includes modules for managing databases, documents, attachments, and views, all under the Mozilla Public License 2.0.

_core/kazoo\fixturedb · high confidence

A new \kazoo\_stats\ application has been added to the core, providing a gen\_server-based mechanism to collect and aggregate node-level metrics (such as memory usage) and SIP event statistics across the Kazoo cluster. The library exposes APIs to increment counters and send absolute values, which are then periodically dispatched to a master process for centralized monitoring.

_core/kazoo\stats · high confidence

The \core/kazoo\_templates\ directory is introduced, establishing a new Erlang application for handling template-based document generation. This includes the \kz\_template\ module for compiling and rendering ErlyDTL templates, and the \kz\_pdf\ module for converting HTML templates to PDF using HTMLDoc. The module depends on \erlydtl\ and \kazoo\_stdlib\, and is licensed under the Mozilla Public License 2.0.

_core/kazoo\templates · high confidence

The \kazoo\_events\ application has been introduced to centralize call event distribution and hook management. It provides the \kz\_hooks\ API, allowing applications to register for specific call events (such as \channel\_create\ or \channel\_destroy\) without managing their own AMQP queues. The module exposes functions like \register/1\ and \bind/2\ to subscribe to events, which are then routed via a shared listener (\kz\_hooks\_listener\) and a round-robin shared listener (\kz\_hooks\_shared\_listener\) to registered processes. This change consolidates event handling logic into the \core/kazoo\_events\ directory, including the associated supervisor trees and AMQP exchange declarations.

_core/kazoo\events · high confidence

The call\_inspector application now includes dedicated parsers for HEP, FreeSWITCH, and Kamailio log formats. Each parser is implemented as a gen\_server that reads from a configured source (UDP socket for HEP, file for logs) and produces ci\_chunk records containing structured SIP data. The ci\_parsers\_sup supervisor dynamically starts these parser workers based on configuration, enabling the call\_inspector to ingest and analyze call data from multiple telephony platforms.

_applications/call\inspector/src/parsers · high confidence

Adds the \kazoo\_im\ application to manage instant messaging metadata, commands, and routing. This includes new Erlang modules for representing IM payloads (\kz\_im\), handling IM commands (\kapps\_im\_command\), and routing inbound/outbound messages via AMQP listeners (\kz\_im\_offnet\, \kz\_im\_onnet\). The change also introduces flat-rate ledgering for IMs (\kz\_im\_flat\_rate\) and registers the necessary supervisors and application callbacks to support these new capabilities.

_core/kazoo\im · high confidence

Added the \kazoo\_ips\ module to handle dedicated IP address management, including creating, assigning, releasing, and deleting IPs, as well as querying available and assigned IPs by zone and host. The module depends on \kazoo\_data\ and \kazoo\_services\ and uses the \kz\_datamgr\ for database interactions.

_core/kazoo\ips · high confidence

The \kazoo\_attachments\ application is introduced as a new module providing an abstraction layer for storing and retrieving attachments across multiple storage backends. It defines a \gen\_attachment\ behavior that standardizes the interface for storage handlers, allowing for the integration of diverse storage providers such as Azure, Dropbox, FTP, and Google Drive. This change enables the system to route attachment operations to different storage engines based on configuration, supporting features like OAuth2 authentication for cloud providers and URL-based access for FTP. The module includes a supervisor for managing worker processes for each storage backend and a comprehensive error handling structure (\kz\_att\_error\) to capture context (such as database name, document ID, and request URLs) for debugging and logging purposes.

_core/kazoo\attachments · high confidence

The hangups application has been introduced to monitor abnormal call terminations (hangups) and provide alerting capabilities when specific hangup causes exceed configured thresholds. This includes a new Erlang application structure with a supervisor, listener, and monitoring server that tracks metrics via Folsom and sends detailed alerts. The system allows configuration of monitored and ignored hangup causes, supports querying meter statistics, and provides maintenance routines to view and set thresholds for hangup causes and account IDs.

applications/hangups · high confidence

The core/kazoo\_bindings directory now contains a new Erlang application that manages routing keys and PIDs, allowing payloads to be passed to bound handlers for evaluation. This includes the addition of \map\, \pmap\ (parallel map), and \fold\ functions to route messages to registered handlers, alongside the application's supervision tree and ETS-based storage for bindings.

_core/kazoo\bindings · high confidence

Adds the kazoo\_csv library, providing functions to parse, validate, and transform CSV data. This includes utilities for counting rows, folding over CSV content, mapping rows to maps, and associating CSV data with task fields. The library is licensed under the Mozilla Public License 2.0.

_core/kazoo\csv · high confidence

The kazoo\_data module and its supporting files (including the MPL 2.0 license, Makefile, and Erlang source files like kz\_data.erl and kz\_data.hrl) have been added to the codebase. This introduces a new abstraction layer for Kazoo's data access, defining behaviors, connection handling, and configuration utilities that will be used by other Kazoo components to interact with storage backends.

_core/kazoo\data · high confidence

The codebase now includes a new \kazoo\_stdlib\ application that consolidates shared Erlang utilities, including modules for JSON manipulation (\kz\_json\), date/time handling (\kz\_date\), binary operations (\kz\_binary\), and logging (\kz\_log\). This change provides a centralized location for common functions such as \kz\_json:merge\, \kz\_date:from\_iso8601\, and \kz\_binary:hexencode\, making them available to other Kazoo applications. The library is licensed under the Mozilla Public License 2.0.

_core/kazoo\stdlib · high confidence

The speech module has been refactored to support pluggable ASR (Automatic Speech Recognition) and TTS (Text-to-Speech) providers via a standardized behavior interface. This change introduces specific implementations for Google ASR and iSpeech ASR, along with a new billing mechanism (\asr\_flat\_rate\) that handles account and reseller authorization and ledger entries for transcription usage. The update also includes utility modules for content type conversion and request handling, enabling the system to process audio from various sources and route it to the configured speech provider.

_core/kazoo\speech · high confidence

The voicemail module now stores messages in a modular database (MODB) structure, enabling better organization and retrieval of voicemail data. A new maintenance module provides utilities to migrate existing voicemail data to this new format, recover missing metadata for messages, and re-send notifications for specific messages. Additionally, the module now supports fetching messages while respecting account-specific retention policies, ensuring older messages are handled according to configured retention periods.

_core/kazoo\voicemail · high confidence

Added new Erlang modules to handle FreeSWITCH event streams for call channels, conferences, and registered events. The \ecallmgr\_fs\_event\_stream\ module manages the TCP connection and event parsing, while \ecallmgr\_fs\_channel\_stream\ and \ecallmgr\_fs\_conference\_stream\ process specific channel and conference events respectively. The \ecallmgr\_fs\_event\_stream\_registered\ module handles registered event notifications. These components are wired into the \ecallmgr\_fs\_event\_stream\_sup\ supervisor, which manages the lifecycle of these event stream processes.

_applications/ecallmgr/src/event\stream · high confidence

The core/kazoo\_provisioner module has been updated to support the new provisioner\_v5 backend. This change introduces a new implementation for provisioning devices and accounts, including functions to update and delete devices and accounts, as well as handling user synchronization. The module now relies on the provisioner\_v5 module to handle the actual HTTP requests to the provisioning server, replacing or augmenting previous methods. Additionally, the contact list functionality has been refactored to work with the new structure, and tests have been added to verify the new behavior.

_core/kazoo\provisioner · high confidence

The reorder application is introduced to handle routing for numbers that are not assigned to any account or callflow. It provides capabilities for handling numbers unassigned to accounts or callflows, including responding to route requests for unknown or known numbers, and optionally transferring or bridging calls based on configuration. The application includes a supervisor, listener, and route request handler, with dependencies on kazoo, kazoo\_numbers, and other Kazoo core components.

applications/reorder · high confidence

The Ananke application is introduced to schedule calls on events. It includes a listener (ananke\_listener) that handles voicemail saved notifications and processes schedules from configuration. The application registers processes ananke\_tasks\_sup, ananke\_listener, and ananke\_sup, and depends on amqp\_cron, kazoo, kazoo\_amqp, kazoo\_apps, kazoo\_data, kazoo\_documents, kazoo\_stdlib, kazoo\_voicemail, kernel, lager, and stdlib.

applications/ananke/src · high confidence

The call\_inspector application is now available to inspect and troubleshoot calls. It provides a datastore for storing and retrieving call chunks and analysis data, a listener for processing lookup and filter requests, and maintenance commands to start, stop, and flush parsers. The application version is set to 4.0.0.

_applications/call\inspector/src · high confidence

The Camper application is added to the Kazoo platform, enabling users to place callers on hold (camp) while waiting for a callee to become available. This new component manages both on-net and off-net call camping requests, handling the logic for originating calls, parking calls, and bridging them once the target is free. The implementation includes a request listener to process delegation messages, handlers for on-net and off-net scenarios, and associated supervision trees.

applications/camper · high confidence

The Frontier application is introduced to provide access control list (ACL) and rate-limiting information to Kamailio. It exposes AMQP-based APIs for querying and updating ACLs and rate limits for accounts and devices, and includes default rate limit configurations for registrations, invites, and total packets. The application also supports flushing ACLs and manages AMQP exchanges for these operations.

applications/frontier · high confidence

The \kazoo\_ast\ library is introduced to parse Erlang Abstract Syntax Trees (AST) and automatically generate JSON schemas and reference documentation for various Kazoo components. This includes generating schemas for callflow actions (\cf\_data\_usage\), conference configurations (\conference\_schema\_builder\), FreeSWITCH headers (\fs\_prop\_usage\), AMQP API payloads (\kapi\_schemas\), and system/account configurations (\kapps\_config\_usage\). The library also provides utilities for counting module:function/arity usage (\code\_usage\) and generating Swagger/OpenAPI documentation for Crossbar API endpoints (\cb\_api\_endpoints\).

_core/kazoo\ast · high confidence

The \applications/conference\ directory now contains the full source code for the Kazoo conferencing service, including Erlang modules for handling routing, discovery, participant management, and configuration requests. This adds the core backend logic for managing conference calls, participant states, and profile caching, enabling the system to route and process conference-related AMQP messages and SIP headers.

applications/conference · high confidence

The kazoo\_auth library is introduced to centralize authentication logic, providing capabilities for creating, validating, and authorizing JWT-based tokens. This includes managing application and provider credentials, handling bearer tokens, and verifying identity signatures. The library also introduces maintenance functions for refreshing database states and flushing caches for private keys, profiles, and tokens.

_core/kazoo\auth · high confidence

The \core/kazoo\_config\ directory now contains a new Erlang application that centralizes the loading, parsing, and retrieval of the \config.ini\ file. This change introduces a dedicated module (\kz\_config\) with typed API functions (\get\, \get\_boolean\, \get\_integer\, etc.) to access configuration values, along with a \kz\_config\_init\ module that handles the file loading logic (supporting both legacy and v4 paths) and environment variable overrides. The application also includes a supervisor (\kazoo\_config\_sup\) and a license file, establishing the foundation for the Kazoo configuration system.

_core/kazoo\config · high confidence

Adds the \kazoo\_convert\ library, providing a unified interface for converting document formats to and from TIFF, PDF, and OpenOffice formats. This includes a core \gen\_kz\_converter\ behavior, a default \kz\_fax\_converter\ implementation, and an optional \kz\_fax\_converter\_convertapi\ provider that integrates with the ConvertAPI service. The library also introduces an \kz\_openoffice\_server\ to serialize OpenOffice conversions, ensuring only one document is processed at a time.

_core/kazoo\convert · high confidence

The kazoo\_couch module is introduced to provide a simplified interface to CouchDB, handling database and document operations such as creating, deleting, and archiving databases, as well as saving, deleting, and copying documents. The module includes utilities for managing attachments, querying views, and handling connection details. This change also includes the addition of a Makefile, dependency makefile, and header files to support the new module structure.

_core/kazoo\couch · high confidence

The kazoo\_oauth application is introduced to handle OAuth2 authentication flows. It provides utilities for verifying access tokens, refreshing tokens, and managing OAuth application and provider configurations. The module includes functions for authenticating users via third-party providers, fetching user profiles, and generating JWT-based service tokens. The application depends on kazoo, kazoo\_data, and kazoo\_web, and uses the kz\_http module for HTTP requests.

_core/kazoo\oauth · high confidence

The kazoo\_web application is introduced as a new core module, providing a dedicated HTTP client (kz\_http) with support for GET, HEAD, POST, PUT, PATCH, DELETE, and TRACE methods, alongside HTML escaping (kz\_html) and MIME type handling (kz\_mime). The module also includes URL decoding/encoding utilities (kz\_http\_util) and client blacklisting maintenance functions (kazoo\_web\_maintenance). This change consolidates web-related functionality into a separate, versioned (4.0.0) application licensed under MPL 2.0.

_core/kazoo\web · high confidence

The media\_mgr application is introduced to handle media services, including converting media paths into HTTP URLs for FreeSWITCH streaming and managing call recordings. This change adds the core Erlang modules (media\_mgr\_app, media\_listener, media\_proxy, media\_store\_proxy, media\_recording) and their associated configuration, licensing, and build files, establishing the new standalone application within the Kazoo ecosystem.

_applications/media\mgr · high confidence

The omnipresence application has been added to track presence states and manage subscriptions. This includes a new \omnip\_subscriptions\ gen\_server to store and query subscriptions in an ETS table, an \omnipresence\_listener\ to route incoming AMQP presence/subscription events, and an API module (\kapi\_omnipresence\) to handle subscribe and notify message validation and publishing. Maintenance functions are also provided to query, reset, and manage subscriptions and presence states.

applications/omnipresence · high confidence

Added the \kazoo\_token\_buckets\ application, which provides a token bucket-based throttling mechanism. This includes the application and supervisor modules, a \kz\_buckets\ server for managing ETS-backed buckets, and a \kz\_token\_bucket\ gen\_server that implements the core algorithm. The module exposes API functions such as \consume\_token\, \consume\_tokens\, and \consume\_tokens\_until\ to manage rate limiting across the system.

_core/kazoo\_token\buckets · high confidence

The \kazoo\_caches\ application has been added to the codebase, providing a new, centralized module for managing system caches. This includes a new ETS-backed cache implementation (\kz\_cache\), a listener for AMQP configuration changes (\kz\_cache\_listener\), and processes for handling node lifecycle events (\kz\_cache\_nodes\). This change introduces new functionality for cache management, including support for origin tracking, expiration, and process monitoring.

_core/kazoo\caches · high confidence

The Konami application has been added to the codebase, providing functionality to listen for and process DTMF sequences during calls to trigger metaflows. This new component includes its own build configuration (Makefile), dependency management (deps.mk), and licensing (MPL 2.0).

applications/konami · high confidence

The kazoo\_ledgers module has been introduced to manage account ledgers, including the creation and deletion of accounts, and the handling of ledger amounts with fractional values. This includes new functions for calculating available units and dollars, managing rollovers, and verifying monthly rollovers. The module also supports listing and summing sources, and provides utilities for currency conversion and formatting.

_core/kazoo\ledgers · high confidence

The \core/kazoo\_modb\ directory now contains the \kazoo\_modb\ Erlang module and its supporting files (including \kazoo\_modb\_maintenance\ and \kazoo\_modb\_migrate\_maintenance\). This module provides utilities for managing account-specific, month-based databases (MODBs), including operations to open, save, and move documents, as well as maintenance functions for archiving, deleting, and migrating data (such as voicemails and CDRs) into these month-based structures.

_core/kazoo\modb · high confidence

The kazoo\_transactions library has been added to the codebase, introducing a new Erlang module for handling account transactions. This includes the core kz\_transaction and kz\_transactions modules, which provide functionality to fetch, save, and manage transaction records, including support for fetching transactions by account and date range, as well as calculating legacy totals. The library is licensed under the Mozilla Public License 2.0.

_core/kazoo\transactions · high confidence

The 'tasks' application has been introduced to the codebase, providing a new container for interactive and background tasks within Kazoo. This change includes the application's build infrastructure (Makefile, dependencies), configuration files, and the license header. The codebase is now licensed under the Mozilla Public License 2.0.

applications/tasks · high confidence

The core/kazoo directory now contains the foundational build system (Makefile, deps.mk) and the application source (kazoo.app.src, version 4.0.0). The kz\_util module provides essential utility functions for the platform, including memory and binary usage tracking, file system operations (write, rename, delete, make directory), and node identification. The project license has been updated to the Mozilla Public License 2.0.

core/kazoo · high confidence

The \kazoo\_schemas\ module has been restructured into a new standalone Erlang application, introducing a \kz\_json\_schema\ module for JSON schema loading, validation, and diffing, alongside a \kz\_json\_schema\_extensions\ module that adds custom validation rules (such as URL validation, regex checks, and storage attachment credential checks). Additionally, a new \kz\_oas\_schema\ module has been added to convert JSON schemas to OpenAPI Specification 2 and 3 formats. These changes provide enhanced schema validation capabilities and API documentation generation tools for users.

_core/kazoo\schemas · high confidence

The \core/kazoo\_amqp/include\ directory now contains a new set of Erlang header files (\kapi\_conf.hrl\, \kapi\_definition.hrl\, \kapi\_offnet\_resource.hrl\, \kazoo\_amqp\_pool.hrl\, \kz\_amqp.hrl\, \kz\_api.hrl\, and \kz\_api\_literals.hrl\). These files introduce standardized AMQP message headers, exchange/routing key constants, and record definitions for API validation and configuration. This change establishes the structural foundation for AMQP-based API communication, defining how messages are formatted, validated, and routed within the system.

_core/kazoo\amqp/include · high confidence

The Blackhole WebSocket gateway now includes dedicated modules for token authentication (bh\_token\_auth), subscription authorization (bh\_authz\_subscribe), and handling specific event types including calls (bh\_call), conferences (bh\_conference), faxes (bh\_fax), generic objects (bh\_object), ping/pong keep-alives (bh\_ping), and presence updates (bh\_presence). These modules implement validation, binding, and listener logic for their respective domains, enabling the gateway to manage subscriptions and authenticate users via tokens.

applications/blackhole/src/modules · high confidence

Added new Erlang modules in the ecallmgr application to handle FreeSWITCH configuration fetch requests for ACLs, conference profiles, Kazoo settings, and Sofia SIP profiles. These handlers translate internal JSON payloads into the appropriate XML configuration responses for FreeSWITCH, enabling dynamic management of these core telephony components.

applications/ecallmgr/src/config · high confidence

The ecallmgr application now introduces a dedicated set of Erlang modules to manage and monitor FreeSWITCH nodes. This includes \ecallmgr\_fs\_monitor\ for tracking node status, \ecallmgr\_fs\_node\ for handling node resources and capabilities, \ecallmgr\_fs\_node\_command\ for executing node commands (such as HTTP requests), \ecallmgr\_fs\_nodes\ for maintaining the registry of connected nodes, \ecallmgr\_fs\_notify\ for handling presence and MWI updates, and \ecallmgr\_fs\_pinger\ for periodic node health checks. These components are orchestrated by new supervisors (\ecallmgr\_fs\_node\_sup\, \ecallmgr\_fs\_pinger\_sup\) to ensure reliable operation and automatic recovery.

applications/ecallmgr/src/node · high confidence

The kazoo\_sip module now includes new Erlang modules for handling SIP headers and URIs. The kzsip\_diversion module provides functions to parse and manipulate the SIP Diversion header, extracting fields like reason, counter, limit, privacy, and screen. Additionally, the kzsip\_uri module introduces utilities to parse, encode, and manipulate SIP URIs, supporting both 'sip' and 'sips' schemes. These additions are accompanied by a new LICENSE file adopting the Mozilla Public License 2.0 and updated build configuration files (Makefile, app.src, .hrl) to support the new code.

_core/kazoo\sip · high confidence

Added two new Erlang modules in the ananke tasks application: ananke\_callback\_worker.erl, which implements a generic scheduled task worker that can execute a sequence of routines (such as sending a request and checking conditions) with configurable schedules and timeouts; and ananke\_vm\_callback.erl, which handles voicemail notification callbacks by checking for unread messages and initiating a callback to the user's configured number. These changes introduce new background task capabilities for handling voicemail alerts and other scheduled callbacks within the ananke service.

applications/ananke/src/tasks · high confidence

The tasks application now includes new background crawlers for accounts, phone numbers, and port requests, which automatically scan and update their respective databases on a scheduled interval. Additionally, the system introduces a task scheduler to manage one-off tasks, a trigger mechanism to initiate jobs on a schedule, and a help module to discover available tasks. These components work together to provide a robust framework for executing and managing background tasks within the application.

applications/tasks/src · high confidence

The tasks application now includes new background jobs: kt\_bill\_early triggers early billing and reminders based on account configuration; kt\_cdrs provides a background task to export Call Detail Records (CDRs) to CSV; kt\_cleanup handles the removal of soft-deleted documents; kt\_compactor and kt\_compactor\_worker manage database and shard compaction with configurable heuristics; kt\_compaction\_reporter tracks and reports on compaction job status and history; and kt\_initial\_occurrence detects and notifies about an account's first registration and call. These additions expand the automated maintenance and reporting capabilities available to administrators.

applications/tasks/src/modules · high confidence

The ecallmgr application now includes dedicated Erlang modules for handling specific call commands and FreeSWITCH interactions. New files introduce handlers for call commands (ecallmgr\_call\_command.erl), channel redirection (ecallmgr\_channel\_redirect.erl), bridging (ecallmgr\_fs\_bridge.erl), and other FreeSWITCH operations (ecallmgr\_fs\_command.erl, ecallmgr\_fs\_fax.erl, ecallmgr\_fs\_flite.erl, ecallmgr\_fs\_transfer.erl). These modules implement the logic for executing, bridging, transferring, and managing call states, effectively replacing or refactoring the previous monolithic command handling into specialized components.

_applications/ecallmgr/src/call\cmd · high confidence

The \core/kazoo\_translator\ module has been introduced to handle the translation of call control formats (TwiML and Kazoo JSON) into internal 2600Hz commands. This includes new Erlang modules for executing TwiML verbs (Dial, Say, Play, etc.) and parsing JSON-based callflows, enabling the system to process and route calls based on these external control languages.

_core/kazoo\translator · high confidence

The callflow module introduces several new actions to give administrators more control over call handling. A new \cf\_after\_bridge\ action allows configuring automatic park, transfer, or hangup actions after a bridge completes. The \cf\_answer\ module provides an explicit step to answer the call. \cf\_audio\_macro\ enables playing sequences of audio prompts, TTS, and tones. \cf\_branch\_variable\ and \cf\_branch\_bnumber\ allow dynamic callflow routing based on variable values or capture groups, with support for regex-based hunting. Additionally, \cf\_call\_forward\ and \cf\_set\_variables\ enhance call forwarding and variable management capabilities.

applications/callflow/src/module · high confidence

The conference management logic has been restructured into new modules: \ecallmgr\_conference\_command\ handles command execution and routing, while \ecallmgr\_conference\_control\ acts as a gen\_listener to receive and process conference commands. A new supervisor \ecallmgr\_conference\_control\_sup\ manages the lifecycle of these control processes. This change introduces a more robust, distributed approach to managing FreeSWITCH conference states and participant actions.

applications/ecallmgr/src/conference · high confidence

Added two new Erlang header files, kz\_config.hrl and kz\_system\_config.hrl, to the core/kazoo/include directory. The new kz\_config.hrl introduces a macro to conditionally enable federated listeners based on the use\_federated\_listener configuration, while kz\_system\_config.hrl defines constants for CouchDB and system-level configuration keys.

core/kazoo/include · high confidence

Added new Erlang modules to handle FreeSWITCH fetch requests for dialplan routing, channel information, directory lookups, and language configuration. These new files implement the server-side logic for processing these specific fetch types, including binding to the appropriate message queues and responding to FreeSWITCH with the required XML or JSON data.

applications/ecallmgr/src/fetch · high confidence

The Teletype application introduces a suite of new email notification templates to cover previously unhandled or generic notification scenarios. These include alerts for account zone changes, bill reminders, call flow updates, CNAM requests, customer updates, denied emergency bridges, user deregistrations, and inbound fax errors. Each template defines specific macros, subject lines, and recipient logic to ensure relevant stakeholders are notified about these specific account and system events.

applications/teletype/src/templates · high confidence

Added new HTML and text email templates for several notification types: account zone changes, bill reminders, CNAM (Caller Name) requests, customer updates, denied emergency bridge calls, and device deregistration. Each notification now has a dedicated, styled email template that provides detailed information about the specific event, such as zone details, invoice amounts and due dates, caller ID change requests, or device registration status, ensuring users receive clear and formatted notifications for these account events.

applications/teletype/priv/templates · high confidence

A new header file, kazoo\_oauth\_types.hrl, has been added to the core/kazoo\_oauth/include directory. This file introduces type definitions and records for OAuth2-related entities, including oauth\_token, oauth\_refresh\_token, oauth\_provider, oauth\_app, oauth\_service\_app, and oauth\_user. These types are now available for use in the OAuth2 module.

_core/kazoo\oauth/include · high confidence

Added new header files to the standard library: \kazoo\_dbg.hrl\ provides macros for tracing function calls; \kz\_log.hrl\ defines logging macros that route to \lager\ or \io\ depending on the environment; \kz\_types.hrl\ introduces type definitions for JSON terms, time constants, and account matching patterns; \kz\_records.hrl\ defines Erlang records for node and application info; and \kz\_databases.hrl\ defines constants for various database names.

_core/kazoo\stdlib/include · high confidence

Added three new header files to the core/kazoo\_documents/include directory: doc\_types.hrl defines the set of supported document types (such as accounts, callflows, devices, and voicemail boxes) and their module types; kazoo\_documents.hrl introduces type definitions for document validation errors and functions, along with constants for VM folders and API versions; and kzd\_ratedeck.hrl provides macros for encoding and matching ratedeck database keys. These headers support the internal structure and validation logic for document handling within the system.

_core/kazoo\documents/include · high confidence

The kazoo\_directory module has been introduced to handle directory lookups for endpoints, users, resources, and groups. This new component provides a unified interface for retrieving profile information, including caller ID, presence, and call forwarding settings, by delegating to specific handlers for each entity type.

_core/kazoo\directory · high confidence

The pusher application has been introduced to handle push notification routing and delivery. This includes the \kapi\_pusher\ module for constructing and publishing AMQP messages to a 'pushes' exchange, and the \pusher\_listener\ to process incoming push events and registration updates. The system now supports Firebase (Google/Firebase) and Apple (APNS) push modules, with configuration for app credentials and certificates managed via \pusher\_maintenance\. The \pusher.app.src\ declares dependencies on \kazoo\_amqp\, \kazoo\_data\, and others, and registers processes for Apple and Firebase modules.

applications/pusher/src · high confidence

The \rel\ directory now contains a complete set of new configuration files to support building and running the application in different environments. This includes \ci.\\ files for continuous integration, \dev.\\ files for local development, and \dist.\*\ files for production deployments. These files configure the Erlang runtime (vm.args), application settings (sys.config), and the release build process (relx.config), establishing the baseline structure for managing the application's lifecycle across different stages.

rel · high confidence

The stepswitch application introduces a new set of resource selectors that allow users to filter and order resources based on specific criteria. Users can now apply list-based filters (exact, subset, intersect, disjoint) via \kz\_srs\_filter\_list\, prefix-based matching via \kz\_srs\_filter\_prefix\, and regular expression matching via \kz\_srs\_filter\_regex\. Additionally, resources can be sorted by specific values in ascending or descending order using the new \kz\_srs\_order\ selector. These changes provide more granular control over resource selection and ordering within the stepswitch pipeline.

_applications/stepswitch/src/resource\selectors · high confidence

The system introduces a new set of JSON schemas for CouchDB, including \account\_config\ variants (for call commands, CDRs, conferences, auth, SMS, fax, media, webhooks, and more), \access\_lists\, \acls\, \allotments\, and \account\_rate\_limits\. These schemas define the structure and validation rules for account-level settings, access control lists, and rate limiting configurations, enabling more granular control over account behavior and security.

applications/crossbar/priv/couchdb/schemas · high confidence

The webhook system now includes dedicated modules for handling channel lifecycle events (create, answer, bridge, destroy), SMS and MMS inbound messages, call parking states (parked, retrieved, abandoned), and generic object/notification events. These new modules allow users to subscribe to these specific event types via webhooks, with each module defining its own bindings, responders, and event formatting logic.

applications/webhooks/src/modules · high confidence

The notify application source code, including modules for handling fax, deregister, and CNAM request notifications, has been added to the codebase. This includes the application entry point, header files, and utility modules that render email templates and send notifications for various events.

applications/notify · high confidence

The pusher application is now structured with its own build system, including a Makefile, rebar configuration, and dependency definitions for APNS and FCM. The application is now licensed under the Mozilla Public License 2.0, and includes a .gitignore file to exclude build artifacts and a .shipyard.yml for packaging. This change establishes the foundational build and licensing framework for the pusher component.

applications/pusher · high confidence

The SUP tool is now distributed as a standalone escript, allowing users to execute it directly without a full Erlang/OTP installation. The project has also updated its license to the Mozilla Public License 2.0, replacing the previous license terms.

core/sup · high confidence

The trunkstore application is initialized with standard build infrastructure (Makefile, deps.mk), licensing (LICENSE), and build metadata (trunkstore.app.src specifying version 4.0.0 and dependencies). The application includes Erlang modules for the OTP supervisor, application lifecycle, and AMQP listener, alongside maintenance utilities for cache flushing and classifier actions. Example configuration files for carriers, rates, and flat-rate regexes are provided to demonstrate expected data structures for routing and billing.

applications/trunkstore · high confidence

The ecallmgr application is introduced with standard build infrastructure, including a Makefile for compilation, a dependency definition for gproc and lager, and a .gitignore for build artifacts. The component is now licensed under the Mozilla Public License 2.0, and a Shipyard configuration is added to define the package metadata and build requirements for the ecallmgr application.

applications/ecallmgr · high confidence

The ecallmgr application has been restructured with a new \ecallmgr.app.src\ file that defines the application's dependencies, environment settings, and registered processes. The \ecallmgr.hrl\ header file has been updated to version 5.0.0, introducing new record definitions for channels and conferences, and adding support for loopback leg tracking and custom application variables. The \ecallmgr\_app.erl\ module now declares exchanges for various API modules and manages event stream bindings. Additionally, a new \ecallmgr\_balance\_crawler\_statem\ module has been added to handle account balance checks and disconnection of calls when accounts have insufficient funds.

applications/ecallmgr/src, applications/pivot · high confidence

The \rabbitmq-erlang-client\ dependency has been removed from the project. This eliminates the legacy AMQP client codebase, including modules for connection management (\amqp\_connection\, \amqp\_network\_connection\, \amqp\_direct\_connection\), channel handling (\amqp\_channel\, \amqp\_channel\_util\), and RPC utilities (\amqp\_rpc\_client\, \amqp\_rpc\_server\). Users will no longer have access to this specific client library for interacting with RabbitMQ via the AMQP protocol.

(repo-wide) · high confidence

The \karl\_whistle/deps/rabbitmq-erlang-client\ dependency was removed from the project. This eliminates the \amqp\_channel\, \amqp\_connection\, \amqp\_rpc\_client\, and \amqp\_rpc\_server\ modules, along with their associated utility and state management files. Users relying on this specific version of the RabbitMQ Erlang client will need to migrate to an alternative AMQP client library.

_karl\_whistle/deps/rabbitmq-erlang-client, karl\whistle/deps/rabbitmq-server-1.7.2 · high confidence

The \karl\_whistle\ module's build system and dependencies have been removed. This includes the \Emakefile\ and \Makefile\ used to compile the Erlang source, as well as the entire \rabbitmq-erlang-client\ dependency tree, which contained the AMQP client library, common libraries, and associated header files. Additionally, the \application.cfg\ configuration file for the AMQP connection has been deleted, indicating a shift away from the previous RabbitMQ messaging setup.

_karl\whistle · high confidence

The build system has been restructured by moving dependency definitions, CI configuration, formatting rules, and static analysis tools into the make/ directory. This includes a new Makefile.deps for managing third-party Erlang libraries (such as Cowboy, lager, and couchbeam), a ci.mk for continuous integration steps, and dedicated makefiles for code formatting (fmt.mk), spell checking (splchk.mk), and security scanning (pest.mk). These changes streamline the build process by consolidating build logic and ensuring consistent code quality checks across the project.

make · high confidence

The \kazoo\_call\ library has been extracted into its own core module, containing the \kapps\_call\ record, command handling, conference management, and recording logic. This refactoring separates call control logic from the main application, providing a dedicated space for call state, channel variables, and conference profiles. Users will see this as a structural change that improves modularity and maintainability of the call handling subsystem.

_core/kazoo\call · high confidence

The stepswitch application has been refactored into distinct modules for handling outbound calls, local extensions, authentication requests, and resource selection. This change introduces new files such as stepswitch\_bridge, stepswitch\_local\_extension, stepswitch\_originate, and kz\_srs\_util, which handle specific routing and processing logic. The refactoring aims to improve code organization, maintainability, and separation of concerns within the stepswitch module.

applications/stepswitch/src · high confidence

The Teletype application has been reorganized into a new directory structure under \applications/teletype/src\, introducing dedicated modules for core functionality including \teletype\_app\ (application behavior), \teletype\_bindings\ (event routing), \teletype\_farms\_sup\ (rendering pool management), and utility modules for fax and port request handling. The application now depends on a broader set of Kazoo libraries including \kazoo\_data\, \kazoo\_templates\, and \kazoo\_fax\, and registers internal processes such as \teletype\_cache\ and \teletype\_shared\_listener\.

applications/teletype/src · high confidence

Empty .placeholder files have been added to the ebin directories of multiple core applications (including kazoo\_bindings, kazoo\_caches, kazoo\_documents, kazoo\_etsmgr, kazoo\_ips, kazoo\_ledgers, kazoo\_modb, kazoo\_oauth, kazoo\_sip, kazoo\_token\_buckets, kazoo\_translator, kazoo\_web, and kazoo\_xml). Additionally, a header file kazoo\_etsmgr.hrl was added to the include directory of kazoo\_etsmgr, defining macros for ETS table readiness and a KAZOO\_ETSMGR flag. These changes ensure that the ebin directories are tracked by version control, which helps maintain directory structure in repositories that do not track empty directories by default.

(repo-wide) · low confidence

A new header file kz\_fixturedb.hrl is introduced, defining Erlang macros for standard fixture account IDs and database names (master, reseller, parent, and child accounts). This provides consistent, reusable identifiers for test fixtures across the codebase.

_core/kazoo\fixturedb/include · medium confidence

A new .placeholder file was added to the call\_inspector ebin directory. This ensures the directory is tracked by version control, preventing issues with empty directories in some build or deployment systems.

_applications/call\inspector/ebin, applications/cccp/ebin, applications/stats/ebin · medium confidence

Added .placeholder files to the ebin directories of multiple applications (acdc, callflow, cdr, conference, crossbar, ecallmgr, fax, hangups, hotornot, jonny5, media\_mgr, notify, pivot, registrar, spyvsspy, stepswitch, sysconf, trunkstore) to ensure proper directory structure. Additionally, a new default configuration file (settings.config) was added to the ecallmgr/priv directory, defining settings for remote audio scripts, default ringback tones, and authorization behavior.

(repo-wide) · medium confidence

Empty .placeholder files were added to the ebin directories of multiple applications (blackhole, camper, doodle, frontier, konami, milliwatt, omnipresence, pusher, reorder, skel, teletype, and webhooks). This ensures that the ebin directories are tracked by version control, which is a common practice in Erlang/Elixir projects to prevent the loss of compiled output directories in git.

(repo-wide) · high confidence

Empty placeholder files have been added to the ebin directories for the kazoo, kazoo\_amqp, kazoo\_apps, kazoo\_media, and kazoo\_services modules. This ensures these directories exist and are tracked by version control, which is often required for build systems or deployment processes that expect these paths to be present.

(repo-wide) · low confidence

The Blackhole application has been refactored to introduce a new \bh\_context\ record and module for managing session state, including authentication tokens, account IDs, bindings, and metadata. A new \bh\_events\ module handles event validation, subscription, and unsubscription logic, while \blackhole\_bindings\ provides a centralized routing mechanism for module requests and events. The \blackhole\_init\ module now explicitly starts Cowboy listeners for both plaintext and SSL WebSocket connections, and \blackhole\_listener\ manages AMQP event delivery. These changes restructure how the Blackhole app handles WebSocket connections, event routing, and module lifecycle management.

applications/blackhole/src · high confidence

The callflow application has been restructured, introducing new modules for the callflow executor (cf\_exe), its supervisor (cf\_exe\_sup), and the route listener (cf\_listener). The application version has been bumped to 4.0.0, and the module now depends on a comprehensive set of Kazoo core libraries including kazoo\_call, kazoo\_data, and kazoo\_endpoint. This change also includes the addition of maintenance functions for migrating recorded names and menu configurations.

applications/callflow/src · high confidence

The header file kazoo\_caches.hrl has been introduced to centralize type definitions for cache callbacks (callback\_msg, callback\_fun, callback\_funs) and origin tuples (origin\_tuple, origin\_tuples). This change consolidates shared Erlang types into a single include file, making them available to other modules that depend on cache-related interfaces.

_core/kazoo\caches/include · medium confidence

The Crossbar HTTP layer now rejects all requests to API version 1, returning a 410 Gone error with a message instructing clients to upgrade to version 2. This change removes support for the legacy v1 API endpoints, ensuring that all API interactions must use the v2 protocol.

applications/crossbar/src · high confidence

The documentation has been updated with new files for the App Exchange, including financial terms, pricing models, submission guidelines, and workflow states. The announcements file was converted from Org mode to Markdown, and the installation guide was updated with new dependencies and build instructions. The README was updated to reflect current resources and developer links.

doc · high confidence

This large set of changes to the Crossbar modules addresses numerous bugs and adds new capabilities. Key fixes include pagination issues for CDRs, transactions, and webhooks; correcting date and time formatting; and resolving various state transition and validation errors. New features include HTTP PATCH support for multiple resources (e.g., callflows, faxes, webhooks), enhanced filtering and search capabilities, and improved error handling and logging. The changes also involve refactoring to use the \cb\_context\ module, updating schemas, and adding specs and tests for many modules.

applications/crossbar/src/modules · medium confidence

The fax application has been refactored to migrate fax documents to the modern object database (MODB) and improve status reporting. Maintenance commands now support migrating existing faxes to MODB, with an option to override existing documents. The system now tracks and reports fax job status in real-time, including handling pending jobs and error states. Additionally, the application includes new maintenance commands to manage fax jobs, such as restarting or updating specific jobs, and provides endpoints to list pending or active jobs for an account or faxbox.

applications/fax · medium confidence

A new header file, kzsip\_uri.hrl, has been added to the core/kazoo\_sip/include directory. This file defines the KZSIP\_URI\_HRL macro and includes the nklib header, establishing a dedicated header for SIP URI-related definitions within the Kazoo SIP module.

_core/kazoo\sip/include · high confidence

A new header file, kazoo\_web.hrl, has been added to the core/kazoo\_web/include directory. This file defines Erlang macros for common HTTP methods (GET, POST, PUT, DELETE, OPTIONS, HEAD, and PATCH). This change decouples the definition of these HTTP method constants from the crossbar implementation, allowing other parts of the Kazoo web stack to reference these standard methods without depending on the crossbar module.

_core/kazoo\web/include · high confidence

The jonny5 application received a comprehensive update to its channel authorization and accounting logic. The new code introduces support for allotments, which allow accounts to consume a specific amount of resources (such as call minutes or seconds) before being restricted. The authorization flow now checks hard limits (such as call counts, resource consumption, and inbound channels per DID) and soft limits (which allow calls to proceed but are logged). Additionally, the system now handles flat-rate trunk usage, mobile call authorization, and reseller-level limits, ensuring that all these constraints are evaluated during the authorization process.

applications/jonny5 · high confidence

The \core/kazoo\_media\ directory has been reorganized into a standalone Erlang application (\kazoo\_media\), separating media handling logic from the broader Kazoo core. This includes new module structures for media caching (\kz\_media\_cache\_sup\, \kz\_media\_file\_cache\), map-based prompt path resolution (\kz\_media\_map\), and maintenance scripts for migrating and importing prompts. Additionally, the project license has been updated to the Mozilla Public License 2.0.

_core/kazoo\media · high confidence

The \core/kazoo\_services\ module now includes a \LICENSE\ file containing the Mozilla Public License Version 2.0 text, replacing the previous licensing terms. This change updates the legal terms under which the \kazoo\_services\ Erlang application and its associated modules (such as \kz\_services\, \kz\_services\_invoice\, and maintenance scripts) are distributed.

_core/kazoo\services · high confidence

The Konami application has been restructured with new source files including kapi\_konami.erl for API handling, konami\_code\_statem.erl for state machine logic, konami\_config.erl for configuration management, and konami\_event\_listener.erl for event handling. The application now uses gen\_statem instead of gen\_fsm for state management, and includes new modules for handling DTMF sequences, metaflow execution, and event listening. The application version has been updated to 4.0.0.

applications/konami/src · high confidence

The endpoint management logic has been refactored into the new \kazoo\_endpoint\ module, introducing versioned implementations (v4 and v5) to handle endpoint retrieval, caching, and building. This change includes moving endpoint attribute handling, caller ID resolution, and call recording logic into this dedicated module, while also adding support for mobile SMS routing and updated license headers.

_core/kazoo\endpoint · high confidence

The \core/kazoo\_documents\ module has been updated to use the Mozilla Public License 2.0, as evidenced by the addition of the \LICENSE\ file containing the MPL 2.0 text. This change affects the licensing terms for the \kazoo\_documents\ application and its associated source files.

_core/kazoo\documents · high confidence

The AMQP API modules in core/kazoo\_amqp (including kapi\_authn, kapi\_authz, kapi\_bookkeepers, kapi\_call, kapi\_callflow, and others) have been refactored to use the kapi\_definition module. This change introduces a standardized, declarative approach to defining API endpoints, handling message validation, and managing AMQP bindings, replacing the previous ad-hoc implementation patterns.

_core/kazoo\amqp · high confidence

The milliwatt application has been reorganized into the applications/milliwatt directory, including a new .gitignore, .shipyard.yml, Makefile, and deps.mk. The license was updated to MPL 2.0, and the application source (milliwatt.app.src) was created with version 4.0.0. The Erlang source files (milliwatt\_app.erl, milliwatt\_sup.erl, milliwatt\_listener.erl, milliwatt\_route\_req.erl, milliwatt\_echo.erl, milliwatt\_tone.erl, and milliwatt.hrl) were added, establishing the core functionality for handling route requests, echo, and tone actions. The header file defines default values for tone and echo configurations, and the application declares dependencies on kazoo, kazoo\_amqp, kazoo\_apps, kazoo\_call, kazoo\_stdlib, kernel, lager, and stdlib.

applications/milliwatt · medium confidence

The ecallmgr application now includes dedicated event publishers for call, CDR, conference, and presence events. These new modules handle the routing and transformation of internal events into published messages, with specific logic for filtering, node restriction, and payload construction for each event type.

_applications/ecallmgr/src/event\publish · medium confidence

The call control logic in ecallmgr has been restructured to separate concerns: a new \ecallmgr\_call\_control\_listener\ module handles AMQP event listening, while \ecallmgr\_call\_control\ manages the core call state and command queue. A new supervisor hierarchy (\ecallmgr\_call\_sup\ -\> \ecallmgr\_call\_control\_sup\ and \ecallmgr\_call\_control\_listener\_sup\) ensures robust process management for these components. This change improves reliability by isolating the event listener and control processes, allowing for better restart strategies and resource management within the ecallmgr application.

_applications/ecallmgr/src/call\control · high confidence

The phone number management logic has been reorganized into the \core/kazoo\_numbers\ directory, introducing a modular carrier architecture. This change adds header files defining number states, features, and port request statuses, along with a carrier registry (\knm\_carriers.erl\) that dynamically loads and routes requests to specific carrier modules (e.g., \knm\_bandwidth\, \knm\_inum\, \knm\_didww\). Each carrier module implements a standard interface for number search, acquisition, and disconnection, allowing the system to query and provision phone numbers from various external providers while maintaining a consistent internal API.

_core/kazoo\numbers · medium confidence

The registrar application has been restructured, introducing a new build system that compiles a C-based NIF (comp128.so) to implement the GSM A3A8 authentication algorithm. This change adds a Makefile, C source code, and associated headers to support GSM authentication methods. The application now includes a .gitignore, .shipyard.yml, and LICENSE file, and its Erlang source files (e.g., reg\_authn\_req.erl, reg\_route\_req.erl) are updated to use the new accessors and internal modules. The application version is set to 4.0.0.

applications/registrar · high confidence

The \rscrpt\ project has removed the \rabbitmq-codegen\ and \rabbitmq-erlang-client\ dependencies, along with the \amqp\ symlink. This cleanup removes older or unused AMQP-related code and client libraries from the project's dependency tree.

rscrpt · high confidence

The tasks module now uses a shared header file to define consistent field names and status constants. This includes new constants for task states (such as 'executing', 'pending', 'failure', and 'success') and specific field identifiers for task metadata, ensuring uniform data representation across the system.

_core/kazoo\tasks/include · medium confidence

The fixture database for account \account0000000000000000000000001\ has been updated with new and modified test data. This includes a new \attachment-index.csv\ and associated media file symlinks, alongside JSON documents for the account configuration, two SIP devices, two users, a group, a trunk store, and a voicemail box with associated media messages. These changes expand the test coverage for account-level resources and their associated media and configuration data.

_core/kazoo\fixturedb/priv/dbs · high confidence

The webhooks application in \applications/webhooks/src\ has been reorganized into a new modular structure, introducing dedicated modules for the application lifecycle (\webhooks\_app\), channel event handling (\webhooks\_channel\_util\), a disabler for failed hooks (\webhooks\_disabler\), initialization (\webhooks\_init\), listeners (\webhooks\_listener\, \webhooks\_shared\_listener\), maintenance (\webhooks\_maintenance\), and utilities (\webhooks\_util\). This change includes a version bump to 4.0.0 and updates the application's dependencies to include \kazoo\_data\, \kazoo\_events\, and others, while also defining new record types and constants for webhook configuration and failure tracking.

applications/webhooks/src · high confidence

The sysconf application now includes a .gitignore file to exclude build artifacts, a .shipyard.yml for packaging metadata, and a new LICENSE file adopting the Mozilla Public License 2.0. The application's build system (Makefile) and source files (sysconf.app.src, sysconf.hrl, sysconf\_app.erl, sysconf\_sup.erl, and handler modules) have been updated to version 4.0.0, with the .app.src specifying dependencies on kazoo, kazoo\_amqp, kazoo\_apps, kazoo\_stdlib, kernel, and lager.

applications/sysconf · high confidence

1 commit adding/updating tests in rscrpt/deps/rabbitmq-erlang-client/.hg/store/data/tests; Added CSV parsing tests for edge cases; Added EUnit test suite for JSON schema validation and default handling; Added EUnit test suites for AMQP API modules; Added EUnit test suites for amqp\_cron and amqp\_cron\_task; Added EUnit test suites for call inspector components; Added EUnit tests for Kazoo document types; Added EUnit tests for Kazoo performance metrics; Added EUnit tests for kz\_services; Added PropEr property-based tests for the token bucket implementation; Added comprehensive test coverage for the cache module; Added invalid media file fixtures for testing; Added placeholder file for Kazoo ledgers test directory; Added property-based and unit tests for Hotornot rate handling; Added property-based tests for kz\_globals; Added test fixtures and EUnit tests for account configuration and migration; Added test fixtures for Teletype email templates; Added test suite for call and conference handling; Added tests for Duo MFA authentication; Added tests for SIP invite parameter handling and emergency call privacy bypass; Added tests for voicemail account migration; Added unit tests for ACDC, SIP, and Translator modules; Added unit tests for API endpoint method sorting and schema generation; Added unit tests for ASR request handling and provider abstraction; Added unit tests for HTML escaping and HTTP utility functions; Added unit tests for Teletype publishing, rendering, and utility functions; Added unit tests for account ID formatting and plan generation; Added unit tests for attachment error handling and URL formatting utilities; Added unit tests for call recording, attributes, and formatters; Added unit tests for core library modules; Added unit tests for fax SMTP email decoding; Added unit tests for kazoo\_modb\_util; Added unit tests for kz\_util; Added unit tests for media utility functions; Added unit tests for task scheduling, compaction, and services; Added unit tests for the Kazoo bindings module; Added unit tests for the kazoo\_convert library; Added unit tests for the task status and processing state logic; Added unit tests for webhook channel utility and disabler logic.

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• First survey — no prior run to compare against. CAI 44.

• Code Health 80
• Architecture 100
• Maturity 46
• Readiness 72
• Security 30
• Event-Driven 51
• Event Sourcing 100
• Accessibility 66

• 300 commits — 275 feature/other, 25 fixes

• applications/crossbar — 91 commits
• applications/callflow — 22 commits
• applications/ecallmgr — 18 commits
• core/kazoo_amqp — 18 commits
• (root) — 12 commits
• applications/acdc — 10 commits
• core/kazoo_numbers — 9 commits
• core/kazoo_stdlib — 8 commits
• core/kazoo_apps — 7 commits
• applications/pusher — 6 commits
• applications/tasks — 6 commits
• applications/teletype — 6 commits
• .circleci/config.yml — 4 commits
• applications/blackhole — 4 commits
• applications/fax — 4 commits
• core/kazoo_endpoint — 4 commits
• core/kazoo_fixturedb — 4 commits
• core/kazoo_proper — 4 commits
• doc/mkdocs — 4 commits
• scripts/circleci.bash — 4 commits

• fix: Fix dynamic binding handling for kapi_conf module (#6396)
• fix: Fix function name (#6352)
• fix: Fix tickets URL in README (#6668)
• fix: Fixed bug in tasks whereby the results csv was not being generated (#6513)
• fix: Fixes and improvements to compaction jobs and to tasks app (#6276)
• fix: PISTON-1091:Fixed kzs_publish bug where if a document with the same id is recreated kzs_publish should send a doc_created event and not doc_edited event (#6278)
• fix: PISTON-979: fix migrating templates from system into accounts (#6189)
• fix: Revert changes on cf_route_req for e911 issue (#6175)
• fix: [master] fixed circle failing when opening a PR (#6398)
• fix: [master] knm maintenance fixes (#6125)
• fix: ci fixes (#6496)
• fix: document requirements and fix beautify make target (#6293)
• fix: executor fix (#6077)
• fix: fix adding name function name during view validation (#6521)
• fix: fix audit_summary view (#6115)
• fix: fix cb_vmboxes:load_vmbox_summary/1 (#6388)
• fix: fix check-dialyzer script to properly fix full path (#6102)
• fix: fix hold media path in get_fs_key_and_value (#6410)
• fix: fix rm_binding and crash on terminate/2 (#6303)
• fix: fix unbind from conference command (#6074)
• …and 280 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

2600hz/kazoo was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.