tmobile/jazz

This system is a comprehensive serverless platform that manages the full lifecycle of cloud services across AWS and Azure. It provides a centralized API for creating, updating, and deleting serverless functions, APIs, and web applications, while handling associated resources like databases, queues, and CDNs. The platform enforces strict access control and security policies, manages user authentication and permissions, and offers monitoring, logging, and cost tracking capabilities. Additionally, it automates CI/CD pipelines and provides templates for rapid service onboarding.

119 changes.

This period focused on expanding the Jazz platform's core capabilities by introducing numerous new backend services for managing assets, environments, and user permissions, alongside a comprehensive Angular-based frontend. The work established a standardized architecture for serverless service creation, deployment, and monitoring, while simultaneously building out the user interface with new pages for service management, logging, and administration.

28 changes.

This period focused on expanding the platform's support for serverless architectures and cloud-native services. New templates and build pipelines were introduced for Node.js, Python, Go, Java, and C\# across AWS Lambda, Azure Functions, and Angular/React web applications. Additionally, the codebase integrated Bitbucket and GitLab SCM integrations, automated AWS resource teardown, and implemented a secrets management API.

A new Admin Dashboard page has been added, providing a centralized interface for administrators. The dashboard features a 'General' tab displaying system configuration data and a 'Users' tab that lists all users with their status. Administrators can toggle user enablement directly from the list, which triggers an update to the user's status. The page includes loading states, error handling, and pagination support for user lists.

_core/jazz\ui/src/app/pages/admin-dashboard · high confidence

Users can now deploy websites using pre-configured templates for the Angular and React frameworks. Each template includes the necessary configuration files (such as angular.json or package.json), source code, styles, and test files, allowing for automatic deployment of the respective web application.

templates/angular-website-template · high confidence

Users can now scaffold new Azure Functions projects using either C\# or Node.js templates. The C\# template provides a structured project with a handler, logger, config handler, and environment-specific configuration files. The Node.js template includes a similar structure with components for configuration, logging, error handling, and response formatting, along with a basic test file. Both templates include environment-specific configuration files (dev, stg, prod) to support multi-environment deployments.

templates/azure-function-template-nodejs · high confidence

Introduces a new Cognito-based token authorizer for API Gateway, including the main handler, configuration loaders for dev/stg/prod environments, and supporting modules for logging, error handling, and response formatting.

_core/jazz\token-authorizer · high confidence

A new template for building serverless applications in Go has been added to the project. This includes the core application code (main.go), a custom logger and configuration loader, and error handling utilities. The template is configured for AWS Lambda using the aws-lambda-go and spf13/viper libraries, with environment-specific configuration files for dev, staging, and production environments. A basic test suite is also included.

templates/sls-app-template-go · high confidence

The Jazz Login service has been introduced to provide an API for authenticating users against an authentication backend. This includes the main handler (\index.js\) which integrates with Amazon Cognito for credential verification, along with supporting components for configuration, error handling, logging, and response formatting. The service is supported by environment-specific configuration files (dev, stg, prod, test) and a Swagger definition (\swagger.json\) that documents the API contract. A test suite (\test/test.js\) has also been added to verify the handler's behavior.

_core/jazz\login · high confidence

Introduced a new Jenkins build pack for serverless applications, providing an automated build and deployment pipeline. The addition includes a 951-line Groovy-based Jenkinsfile that orchestrates the entire serverless deployment lifecycle, including code checkout, configuration loading, pre-build validation, plugin installation, and event tracking. This enables consistent, automated deployments for serverless workloads within the CI/CD infrastructure.

builds/jenkins-build-pack-sls-app · high confidence

Introduces a new Jenkinsfile in the builds/jenkins-build-pack-function directory, establishing the CI/CD pipeline for building and deploying functions. The file defines the build stages, including code checkout, configuration loading, and environment setup, effectively automating the deployment workflow for services using this build pack.

builds/jenkins-build-pack-function · high confidence

A new Node.js template for Azure Functions is introduced, providing a structured starting point for building APIs. The template includes a modular component architecture with dedicated files for configuration, error handling, logging, and response formatting. It supports environment-specific configuration files (dev, stg, prod) and integrates a configurable logger that respects the LOG\_LEVEL environment variable. Additionally, the template includes a Swagger specification file to document the API, along with a basic test suite and standard project configuration files (.gitignore, .jshintrc).

templates/azure-api-template-nodejs · high confidence

A new \scmFactory.js\ module has been introduced to handle user creation requests for GitLab and Bitbucket. The \ScmFactory\ class routes user creation logic to the appropriate provider based on the \SCM\_TYPE\ configuration, supporting both GitLab and Bitbucket backends.

_core/jazz\usermanagement/scm · high confidence

A new service has been introduced to stream CloudWatch logs to Splunk Cloud. The implementation includes the main handler logic in index.js, which processes and forwards log events, alongside supporting configuration files (deployment-env.yml, global-config.json), sample event data (event.json), and documentation (README.md).

_core/jazz\splunk-kinesis-log-streamer · high confidence

The \core/jazz\_events\ module now includes the full implementation for receiving, validating, and storing platform events. This adds a new service that processes events via a Lambda handler, supporting both GET (retrieval) and POST (creation) operations. The change introduces components for configuration, CRUD operations against DynamoDB and Kinesis, input validation, and error handling, along with the corresponding test suite.

_core/jazz\events · high confidence

A new constants file introduces a mapping between internal field names and their human-readable display names. This includes mappings for API gateway, IAM roles, DynamoDB, Kinesis, and various metrics and code quality indicators, enabling the UI to display more descriptive labels for these data points.

_core/jazz\ui/src/app/core/constants · high confidence

Introduced new starter templates for Go, Java, and Python functions. Each template includes a base handler, a custom logger, and environment-specific configuration loading (dev, stg, prod). Go templates add a Gopkg.toml for dependency management; Java templates provide a BaseRequestHandler and error handling utilities; Python templates include a config loader and logger component. All templates come with basic unit tests and deployment environment configurations.

templates/function-template-go, templates/function-template-java, templates/function-template-python · high confidence

The service overview page has been introduced, providing a detailed view of a service's metadata (namespace, runtime, provider, description, Slack channel, etc.) and a visual progress tracker for creation and deletion states. Users can now edit general service details, including the description and Slack channel, with validation for empty fields. The page also includes a feedback modal for reporting issues and displays status indicators for various service lifecycle stages.

_core/jazz\ui/src/app/pages/service-overview · high confidence

The ACL component now supports managing repository permissions for Bitbucket and GitLab. New modules handle API interactions for both platforms, including adding and removing user permissions, fetching service metadata, and authenticating to obtain tokens. The \ScmUtil\ class provides a unified interface to process SCM permissions based on the configured \SCM\_TYPE\.

_core/jazz\acl/components/scm · high confidence

Added new utility modules in core/jazz\_acl/components/utils to support environment details retrieval, service ID listing from DynamoDB, policy rule creation, input validation, and Vault safe user management. These changes enable the ACL component to fetch environment configurations, scan service IDs, generate access control rules based on user policies, validate API inputs, and manage Vault safe users by adding or removing admin users from safe environments.

_core/jazz\acl/components/utils · high confidence

A new API has been introduced to invoke AWS Lambda functions. This component accepts a function ARN and input JSON, then returns the execution status and payload from the AWS Lambda service. The implementation includes configuration files (\.jshintrc\, \deployment-env.yml\), a README with usage examples, and the core \index.js\ handler that routes requests to either the AWS SDK or a direct HTTP endpoint.

_core/jazz\test-lambda · high confidence

The core/jazz\_ui/src directory has been populated with the foundational files for an Angular 2+ application, including the main entry point (main.ts), polyfills, and global style sheets (main-styles.scss, styles.css, and various partials for Bootstrap, fonts, and page layout). This establishes the base UI framework and styling for the application.

_core/jazz\ui/src · high confidence

The Apigee build module now includes shell scripts (bundle.sh, delete.sh, deploy.sh) and Maven POM files (prepareProxyPom.xml, prepareTargetPom.xml, resolveDependency.xml) that automate the process of building, deploying, and deleting Apigee API proxies. Additionally, a comprehensive set of FreeMarker templates and XML policy definitions have been added to the coreAPI\_default template, providing standardized flow fragments, fault handling, and security policies (such as CORS validation, spike arrest, and threat protection) for new API projects.

builds/jazz-build-module/apigee · high confidence

Introduced a new proxy function that acts as an interface between Apigee API proxies and AWS Lambda functions. The implementation includes input validation for required parameters (region, httpMethod, functionName), structured error handling for various HTTP status codes (400, 401, 403, 404, 500), and logging capabilities. The proxy forwards requests to the specified Lambda function and maps the response or errors back to the API gateway format.

_core/jazz\apigee-proxy-aws · high confidence

Introduced a new Azure API template for C\# that includes a serverless function entry point, a structured logging component, and a configuration handler that reads environment-specific properties (dev, stg, prod). The template also provides a Swagger definition for API documentation and exposes a basic response model, enabling developers to quickly scaffold an Azure Function with built-in logging and config management.

templates/azure-api-template-csharp · high confidence

The \builds/azure-config-pack\ directory now contains a complete set of Azure Functions configuration files, including \function.json\ and \run.csx\ (or \index.js\ for Node.js) for Cosmos DB, cron, Event Hubs, Service Bus, and Blob Storage triggers. This pack provides the necessary bindings and handler logic to support these specific Azure services within the CI/CD workflow.

builds/azure-config-pack · high confidence

Introduced a new CLI tool in builds/jazz\_azure-create-service that automates the creation and management of Azure resources. The package includes a Node.js entry point and a modular component system: a ClientFactory for Azure SDK authentication, a ResourceFactory for provisioning resources (storage, web apps, function apps, CDN), and specific handlers for Cosmos DB, Event Hubs, Service Bus, and Storage Blobs. The tool supports creating API apps, function apps, and web apps, with rollback capabilities on failure.

_builds/jazz\azure-create-service · high confidence

The core/jazz\_assets/components/crud directory now includes new JavaScript modules (create, get, getList, update) that implement full CRUD (Create, Read, Read-All, Update) functionality for the asset catalog. These components handle database interactions for creating, retrieving, listing, and updating asset entries, exposing these capabilities through a unified index module.

_core/jazz\assets/components/crud · high confidence

The \core/jazz\_services/components/crud\ directory now includes new modules for creating, retrieving, updating, and deleting service catalog entries in the DynamoDB-backed service catalog. This introduces the underlying data access layer for service management, supporting operations such as filtering by status and timestamp, paginated listing, and direct item updates.

_core/jazz\services/components/crud · high confidence

Introduced a new AWS Lambda function at core/jazz\_cognito-admin-authorizer that validates AWS Cognito access tokens and enforces admin-level access. The implementation fetches Cognito JWKS, decodes and verifies JWT signatures, and checks the user's email against an admin configuration to generate an API Gateway access policy.

_core/jazz\cognito-admin-authorizer · high confidence

Introduced a new Go-based API template for AWS Lambda, including the main handler, configuration loading, error handling, and logging modules. The template uses the \dep\ tool for dependency management (specified in \Gopkg.toml\ with \github.com/aws/aws-lambda-go\ and \github.com/spf13/viper\), and includes a \.gitignore\ file to exclude the \vendor\ directory.

templates/api-template-go · high confidence

A new Jenkinsfile has been introduced in the builds/jenkins-build-pack-website directory, establishing a CI/CD pipeline for building and deploying websites. The script automates the checkout, validation, and deployment stages for static, Angular, and React applications, integrating with AWS and Azure cloud providers to handle environment-specific configurations and asset uploads.

builds/jenkins-build-pack-website · high confidence

A new service has been introduced to stream CloudWatch logs to an Elasticsearch service. The implementation includes the main handler logic, configuration modules, and utility components, along with supporting files such as a README, deployment environment configuration, and sample event data.

_core/jazz\es-kinesis-log-streamer · high confidence

Users can now generate a new Azure Function project using Node.js. This includes a pre-configured handler in index.js that integrates with a modular architecture (config, logger, response, error-handler components) and provides sample code for logging, configuration retrieval, and error handling.

templates/function-template-nodejs · high confidence

The Node.js serverless application template now includes four new utility components: a configuration loader that dynamically loads environment-specific settings, an error handler that standardizes API Gateway error responses, a logger that supports multiple log levels controlled by environment variables, and a response formatter for consistent API output.

templates/sls-app-template-nodejs/components · high confidence

The templates/sls-app-template-nodejs directory now includes build.slsapp and deployment-env.yml files, establishing the structure for a Node.js serverless application template.

templates/sls-app-template-nodejs · medium confidence

A new login page for the open-source (OSS) version of the application has been introduced, featuring a sign-in form that collects the user's email address and password, along with a verification code input for password reset or registration flows. The component includes client-side validation for the email format and password length, and displays error messages via toast notifications for failed login attempts or service errors.

_core/jazz\ui/src/app/pages/login · high confidence

Added a new set of Python components for the API template, including a logger with configurable log levels and formatting, a configuration manager that loads environment-specific settings (dev, staging, production) from INI files, error handling utilities for common HTTP status codes, and a response builder for JSON payloads.

_core/jazz\slack-event-handler/components, templates/api-template-python/components · high confidence

Introduced a new Python-based API template that provides a complete starting point for serverless functions, including an entry point (index.py) with structured logging, error handling, and configuration management. The template includes supporting files such as a .gitignore, README with setup instructions for Python 2.7, Windows, and 3.6, along with deployment environment configurations and sample event data to facilitate local testing and development.

templates/api-template-python · high confidence

Introduced a new Python template for SLS apps, providing a structured project layout that includes a README with setup and testing instructions, configuration management via environment-specific INI files, a centralized logging utility, standardized error handling, and response formatting helpers.

templates/sls-app-template-python/components · high confidence

The Services page now includes a new \ServicesComponent\ that renders a header, a main content area with a router outlet, and a mobile secondary tab navigation. The component manages a list of services with properties like name, type, domain, and status, and provides filtering capabilities for the service list.

_core/jazz\ui/src/app/pages/services · high confidence

A new event handler has been introduced to process Kinesis records and send notifications to Slack channels. The handler, located in core/jazz\_slack-event-handler, includes the main processing logic (index.js), configuration and utility modules, and failure code definitions. It is designed to intercept specific event types from Kinesis, validate them, and trigger Slack notifications, with supporting files for configuration, logging, and error handling.

_core/jazz\slack-event-handler · high confidence

A new Jenkinsfile has been introduced to the delete-serverless-service-build-pack, implementing a workflow that identifies and deletes disabled CloudFront distributions. The script queries AWS CloudFront for distributions matching the instance prefix that are marked as disabled and in a 'Deployed' status, then proceeds to delete them. This adds a new capability to automatically clean up stale or disabled CDN resources as part of the service deletion or cleanup process.

builds/delete-serverless-service-build-pack · high confidence

Introduced new internal modules to support the ACL system: casbin.js implements the core logic for managing and checking RBAC policies using Casbin and TypeORM; config.js provides environment-based configuration loading; error-handler.js standardizes error responses; logger.js manages log levels; and response.js formats API outputs. These components enable the system to retrieve, add, and remove access policies and verify user permissions against service-specific rules.

_core/jazz\acl/components · high confidence

The admin interface now includes a new set of backend components for managing configuration data. This includes a config loader that retrieves environment-specific settings, a JSON editor utility for modifying nested configuration structures, and CRUD operations (get/post) for interacting with the DynamoDB-backed config catalog. Additionally, supporting modules for error handling, logging, and response formatting have been introduced to support these new capabilities.

_core/jazz\admin/components · high confidence

The \core/jazz\_deployments/components\ directory now contains the foundational modules for the deployment catalog feature. This includes a configuration loader (\config.js\), a full CRUD implementation for DynamoDB (\crud/\), and supporting utilities for logging, error handling, response formatting, and input validation. These components provide the backend logic for creating, reading, updating, and deleting deployment records.

_core/jazz\deployments/components · high confidence

The core helpers module now includes a new CronParserService that validates and constructs cron expressions, a RelaxedJsonService for JSON parsing and pretty-printing, and a SessionStorageService wrapping the browser's sessionStorage API. These additions provide reusable utilities for scheduling, data formatting, and client-side state management.

_core/jazz\ui/src/app/core/helpers · high confidence

Introduced new JavaScript modules in core/jazz\_services/components to support the application's backend logic. This includes config.js for retrieving environment-specific settings, error-handler.js for standardizing API error responses, logger.js for structured logging with configurable levels, response.js for formatting API responses, and utils.js containing helper functions for DynamoDB client initialization and data transformation.

_core/jazz\services/components · high confidence

The core/jazz\_asset-event-handler/components directory now includes three new files: config.js, which retrieves environment-specific settings; error-handler.js, which provides standardized error response objects for various HTTP status codes; and logger.js, which implements a configurable logging system based on environment variables. These components support the asset event handler by centralizing configuration retrieval, error formatting, and logging capabilities.

_core/jazz\asset-event-handler/components · high confidence

The Node.js function template now includes four new utility components: config.js for environment-based configuration loading, error-handler.js for standardized API error responses, logger.js for configurable log level management, and response.js for consistent response formatting. These additions provide built-in support for structured logging, error handling, and configuration management in generated projects.

templates/function-template-nodejs/components · high confidence

New JavaScript modules were added to the authorizer's components directory to standardize internal behavior. The config module provides a helper to load environment-specific settings from JSON files based on the current stage. The error-handler module exports functions to generate standardized error objects for various HTTP status codes (Bad Request, Forbidden, Unauthorized, Not Found, Internal Server Error). The logger module implements a structured logging system that respects a configurable log level (error, warn, info, debug) via environment variables. Finally, the response module provides a helper to wrap data and input into a consistent output format.

_core/jazz\cognito-admin-authorizer/components · high confidence

Introduced new create and update endpoints for managing services. The create operation now accepts deployment\_descriptor, deployment\_accounts, and deployment\_targets fields, while the update operation supports modifying description, region, repository, email, slack channel, tags, endpoints, metadata, and status. These changes enable users to create and modify service configurations with additional metadata and deployment settings.

_core/jazz\create-serverless-service/components/crud · high confidence

A new JavaScript module (index.js) and supporting configuration files (build.api, deployment-env.yml, event.json) were added to the core/jazz\_deployments directory. This introduces the server-side logic for managing deployments, including creating, retrieving, updating, and deleting deployment records via HTTP methods (POST, GET, PUT, DELETE). The implementation includes input validation, error handling, and logging, enabling users to interact with the deployment service through the defined API endpoints.

_core/jazz\deployments · high confidence

The \core/jazz-web\ directory now includes the \3rdpartylicenses.txt\ file listing copyright and license information for dependencies such as core-js, webpack, zone.js, ion-rangeslider, moment, chart.js, and angular2-moment. Additionally, the directory contains the full CSS source (\bootstrap.css\) and minified (\bootstrap.min.css\) stylesheets for Bootstrap v3.3.5, along with the corresponding license file. These files provide the necessary styling and legal attribution for the web application's UI components.

(repo-wide) · high confidence

A new multi-step onboarding experience has been introduced for new users, guiding them through key features of the platform. The flow includes a series of screens with text, images, and embedded videos that explain how to register, create a service, and test APIs. Users can navigate between steps using previous/next buttons or by clicking on the step indicators, and the journey concludes by redirecting to the landing page.

_core/jazz\ui/src/app/pages/user-journey · high confidence

Introduced a new event handler in the core/jazz\_services-handler directory that processes Kinesis events related to service catalog updates. The handler authenticates with the service API, validates incoming events against configured event types and names, and updates the service catalog via CRUD operations. Supporting files include a sample Kinesis event payload, test configuration, and deployment environment settings.

_core/jazz\services-handler · high confidence

New configuration templates for Go, Java, Node.js, and Python have been added to the UI's template store. Each template provides a default YAML structure defining two example functions with their respective handlers, enabling users to quickly scaffold serverless applications in these languages.

_core/jazz\ui/src/config/templates · high confidence

The templates/sls-app-template-nodejs/functions directory now includes two sample serverless functions (function1 and function2), each containing an index.js handler, a test suite, and environment-specific configuration files (dev, stg, prod) that allow users to quickly scaffold and test a Node.js Lambda application structure.

templates/sls-app-template-nodejs/functions · high confidence

New utility modules have been introduced to the serverless service architecture. These include a configuration loader that resolves environment-specific settings, a cron expression parser and validator, a structured error handler for API Gateway integration, a configurable logging utility, a response formatter, and validators for AWS ARNs and YAML-based deployment descriptors against a whitelist of allowed AWS resources, events, and IAM actions.

_core/jazz\create-serverless-service/components · high confidence

Introduced two new backend services: a service that checks if a specific service name exists in a given domain (querying a DynamoDB table), and an API for logging a user out via AWS Cognito's globalSignOut. Both services include full implementation files, environment-specific configuration, Swagger definitions, and unit tests.

_core/jazz\_is-service-available, core/jazz\logout · high confidence

The Jazz UI component library introduces a new set of SCSS styles under the SMACSS architecture, defining reusable modules for buttons, charts, checkboxes, forms, layout, loaders, modals, sections, text, and utility classes. These styles establish a consistent visual language and layout structure for the UI components.

_core/jazz\ui/src/styles/smacss · high confidence

New JavaScript modules have been added to the core components directory to support the Azure test Lambda. These include config.js for environment-based configuration retrieval, error-handler.js for standardized API error responses, logger.js for configurable logging levels, response.js for consistent output formatting, and utils.js containing validation helpers for AWS ARNs and HTTP endpoints.

_core/jazz\test-lambda/components · medium confidence

The shared-module directory now exports a comprehensive Angular module that aggregates a wide range of UI components, directives, and pipes—including navigation bars, search boxes, filters, metrics displays, and error pages—alongside necessary third-party modules like ngx-dropdown and ng2-charts. This centralizes the availability of these UI building blocks for other parts of the application.

_core/jazz\ui/src/app/shared-module · high confidence

The application now includes a foundational Angular setup with routing, a shared service for global state management, and several utility pipes (orderBy, safeHtml, safeUrl) to handle data sorting and safe HTML/URL binding. The app component integrates idle timeout handling and toast notifications, while the module configuration registers essential services and lazy-loaded feature modules for admin, services, and documentation.

_core/jazz\ui/src/app · high confidence

New configuration files have been added to define the access control system. The global-config.json establishes API endpoints, vault integration, and specific policy rules for managing admin, read, and write permissions across code, deploy, and manage categories. Environment-specific configs (dev, stg, prod) are introduced to handle Casbin database connections and API URLs. Additionally, an RBAC model (rbac\_model.conf) is added to enforce role-based access control, allowing users with write or admin permissions on a matching object to automatically inherit read access.

_core/jazz\acl/config · high confidence

The T-Vault module now provides a complete API for managing secrets, including creating, retrieving, updating, and deleting safes, as well as managing users and roles within those safes. The implementation includes configuration handling, error management, logging, and input validation, enabling users to interact with T-Vault through standardized HTTP endpoints.

_core/jazz\t-vault · high confidence

The Jazz Metrics API now includes core utility and configuration components to support multi-account and multi-provider (AWS, GCP) metric retrieval. This change introduces a new \config.js\ for environment-specific settings, an \error-handler.js\ for standardized API error responses, a \logger.js\ for structured logging, and a \metrics.json\ file defining metric schemas for AWS services (Lambda, API Gateway, S3, CloudFront, DynamoDB) and GCP. Additionally, \utils.js\ provides helper functions to map asset types to correct CloudWatch namespaces and dimensions, while \validation.js\ enforces input constraints on the metrics API payload.

_core/jazz\metrics/components · high confidence

The Jazz Metrics service is introduced as a new core API for retrieving cloud monitoring data. It supports fetching metrics from AWS CloudWatch and Azure Monitor, allowing users to query performance data for specific services and assets across multiple accounts and regions. The service includes validation for headers (including a new service ID header), token generation, and response formatting for both AWS and Azure providers.

_core/jazz\_events-handler, core/jazz\metrics · high confidence

Added a new core API service for managing assets data, providing endpoints to fetch, create, and update asset details for services or resources provisioned in AWS Cloud. The implementation includes a Lambda function handler that processes GET, POST, and PUT requests to interact with an asset table, supporting retrieval by ID or service/domain, as well as creation and updates of asset records.

_core/jazz\assets · high confidence

Added the EnvironmentModule, a new Angular module that encapsulates the environment management feature. This module registers routes for the environment detail page, declares and provides necessary components (such as EnvLogsSectionComponent, EnvironmentDetailComponent, and EnvTryServiceSidebarComponent), and imports shared dependencies like DropdownModule and DatePickerModule. This change consolidates the environment-related UI logic into a dedicated module, improving code organization and enabling Ahead-of-Time (AoT) compilation for the environment feature.

_core/jazz\ui/src/app/environment-module · high confidence

The sls-app build module now includes a new rule-based engine (sbr.groovy) that processes user-provided serverless.yml files by applying configurable rules (serverless-build-rules.yml) to generate a final deployment descriptor. This engine supports template matching with asterisk wildcards, mandatory field enforcement, and value merging. Additionally, a whitelist system (whitelist.yml, whitelist-validator-module.groovy) is introduced to validate AWS resource types, IAM actions, events, and plugins against an approved list, ensuring that only permitted configurations are deployed.

builds/jazz-build-module/sls-app · high confidence

A new Service Access Control page has been added to the Jazz UI, allowing users to configure access controls for a service. The component provides a user interface to manage 'Management Access' (Admin/Read roles), 'Code Access' (Write/Read roles), and 'Deployment Access'. Users can add or remove users, select specific permissions (Admin, Read, Write), and save these changes via the /acl/policies API. The implementation includes the necessary HTML template, SCSS styles, and a basic unit test for the component.

_core/jazz\ui/src/app/pages/service-access-control · high confidence

Added the core implementation for the code quality service, including the main handler, utility functions, and supporting components for configuration, error handling, logging, and response formatting. The service validates input parameters, retrieves code quality metrics, and returns structured reports, with support for environment-specific configuration and standardized error responses.

_core/jazz\codeq · high confidence

Added a new core API service (core/jazz\_acl) that enforces access control policies using Casbin. The service exposes endpoints to add, remove, and retrieve policies for services, as well as to check user permissions for specific services and categories. It also integrates with SCM for permission management and supports secret management via Vault for admin users.

_core/jazz\acl · high confidence

The environment event handler is now available to process events related to jazz environment catalog updates. This includes handling Kinesis records, authenticating with the service catalog, and managing safe creation and policy updates via T-vault. The handler supports different environments (dev, stg, prod) and includes error handling, logging, and failure code definitions.

_core/jazz\environment-event-handler · high confidence

Added new helper modules to the log streamer: a config loader that dynamically loads environment-specific settings, a logger that supports configurable log levels, an error handler that standardizes API error responses, a response formatter, and utility functions for AWS credential management and log parsing.

_core/jazz\es-kinesis-log-streamer/components · high confidence

The Service Detail page has been restructured with a new template and component implementation. Users now see a dedicated view for individual services, featuring a header with provider-specific watermarks (AWS, Azure), a tabbed interface for Overview, Access Control, Metrics, Cost, and Logs, and a confirmation modal for deleting services. The component also handles error states, loading states, and sidebar interactions for service details.

_core/jazz\ui/src/app/pages/service-detail · high confidence

Added the core implementation for creating serverless services, including input validation for service names, domains, and deployment targets, as well as support for AWS and Azure deployment accounts. The new API endpoint handles service creation requests, validates inputs against configuration, and orchestrates the service onboarding process.

_core/jazz\create-serverless-service · high confidence

Added a new serverless service that provides a REST API interface to delete a serverless service deployed using the Jazz platform. The service accepts a service name, domain, and optional version, and returns a tracking ID to monitor the deletion job status. The implementation includes configuration files for dev, staging, and production environments, along with components for error handling, event logging, and response formatting. The API is defined via a Swagger specification and includes CORS support and security headers.

_core/jazz\delete-serverless-service · high confidence

Added a new Jenkinsfile that automates the service onboarding process, handling input validation, template cloning, and code modification for supported runtimes (Node.js, Python, Java, Go, C\#) and providers (AWS, Azure). The pipeline also includes a branch\_permissions\_payload.json to configure branch restrictions for the master branch.

builds/service-onboarding-build-pack · high confidence

Added the core implementation for the Service Catalog API, including a new index.js file that exposes endpoints for creating, reading, updating, and deleting services. The API supports fetching all services, filtering by query parameters, and searching by name. It also includes validation, error handling, and policy-based access control for service retrieval.

_core/jazz\services · high confidence

Added new Angular services to the core module: AuthenticationService for handling login, logout, and session management; RequestService for standardized HTTP interactions with optional service ID headers; RouteGuard for protecting routes; DataCacheService for local data storage; MessageService for toast notifications; and utility services for field mapping and data manipulation. These services establish the foundational infrastructure for user authentication, API communication, and UI state management within the Jazz UI application.

_core/jazz\ui/src/app/core/services · high confidence

Added a new Service Logs page that displays log entries in a table with columns for timestamp, message, request ID, and log level. The page includes a filter bar with tag-based filtering and an advanced filter component, allowing users to filter logs by various criteria. The log table supports sorting and pagination, and each row can be expanded to show detailed information about the log entry. The component also includes styling for the filter and table layout.

_core/jazz\ui/src/app/pages/service-logs · high confidence

Added a new Angular module (AdminModule) and associated routing configuration to encapsulate the admin section of the application. This includes the main AdminComponent, which serves as a layout wrapper with a header, mobile tab navigation, and a router outlet for child routes. The module registers the AdminComponent, AdminDashboardComponent, and JsonViewerComponent, while providing the AdminUtilsService. The admin route is configured to redirect to the dashboard by default.

_core/jazz\_ui/src/app/admin-module, core/jazz\ui/src/app/pages/admin · high confidence

The \core/jazz\_cognito-authorizer/components\ directory now contains a set of new, modularized JavaScript files that handle specific aspects of the authorization process. This includes \acl-services.js\ for fetching service metadata and checking permissions via an ACL service, \auth-policy.js\ for generating AWS IAM-style policies, \config.js\ for retrieving environment-specific configurations, \error-handler.js\ for standardizing error responses, \logger.js\ for structured logging, \login.js\ for obtaining authentication tokens, and \response.js\ for formatting API responses. These changes restructure the codebase to separate concerns, making the authorizer more maintainable and allowing for easier integration of access control logic.

_core/jazz\cognito-authorizer/components · high confidence

The Jenkinsfile for the API build-pack has been introduced, defining the continuous integration and deployment workflow for API services. This pipeline handles checking out code, loading service metadata, configuring environments (production/development), and executing build stages for AWS and Azure providers, including support for serverless configurations and specific runtime handling.

builds/jenkins-build-pack-api · high confidence

Added a Java template for serverless applications that includes two sample functions (Function1 and Function2) extending a base request handler. The template provides a deployment descriptor (deployment-env.yml) and environment-specific configuration files (dev, prod, stg properties) for each function, allowing runtime code to load distinct configurations per environment. A custom exception hierarchy (BaseException, BadRequestException, etc.) and a Response model are included to standardize error handling and output. Unit tests and a context stub are provided to verify the template's behavior.

templates/sls-app-template-java · high confidence

The Jazz UI project now includes standard Angular CLI configuration files (angular-cli.json, tsconfig.json, tslint.json, karma.conf.js, protractor.conf.js) and a Jenkinsfile\_Platform for automated builds. The Jenkinsfile introduces a new build pipeline that configures AWS CLI, manages CloudFront distribution creation and cache invalidation, and dynamically updates environment configuration files (environment.oss.ts) based on feature flags for services, environment tabs, Slack, TVault, and Azure extensions.

_core/jazz\ui · medium confidence

Added a new 'jazz\_is-slack-channel-available' service that allows users to check if a specific Slack channel exists. The implementation includes the main handler, input validation, and error handling components, along with configuration and logging utilities. The API accepts a 'slack\_channel' parameter and returns a boolean 'is\_available' status by querying Slack's REST API endpoints for both public and private channels.

_core/jazz\is-slack-channel-available · high confidence

The environment-assets page now features a new \EnvAssetsSectionComponent\ that displays assets in a filterable list. Users can select specific asset types (e.g., API Gateway, Lambda, S3) via a horizontal card carousel to filter the main table. The table displays the Provider ID and Last Updated time, with the Provider ID being copyable via a dedicated copy icon. The component also includes a feedback modal for reporting issues and handles empty or error states with specific messaging.

_core/jazz\ui/src/app/pages/environment-assets · high confidence

A new Java API template is introduced, providing a complete starting point for building AWS Lambda functions. The template includes a base request handler that parses API Gateway payloads and a concrete handler example. It features a structured error handling system with specific exception classes (e.g., BadRequestException, NotFoundException) that format errors into a consistent JSON response. Additionally, the template includes configuration for environment-specific properties, a sample event, and a Swagger specification for the API, along with a basic test suite.

templates/api-template-java · high confidence

A new Jenkinsfile and supporting files have been added to the builds/jenkins-delete-resources directory. This pipeline automates the teardown of AWS resources—including IAM roles, API Gateways, S3 buckets, and CloudFront distributions—across multiple AWS accounts and regions. It supports deleting resources for all accounts or specific account IDs, and includes logic to skip deletion of primary account resources in primary regions.

builds/jenkins-delete-resources · high confidence

A new Logs API has been introduced, allowing users to retrieve application logs by specifying service, domain, environment, category, and time range. The implementation includes a new \core/jazz\_logs\ module with components for configuration, error handling, logging, and response formatting. The API supports filtering by log type (e.g., ERROR, INFO) and includes validation for required input parameters. The feature is documented in a new README and includes configuration for Node.js environments.

_core/jazz\logs · high confidence

A new Service Cost page has been added to the application, allowing users to view cost metrics (yearly, monthly, weekly, daily) and apply filters such as environment, method, account, region, time range, and statistics. The page includes a feedback form for reporting issues and displays loading states, empty states, and error messages appropriately.

_core/jazz\ui/src/app/pages/service-cost · high confidence

The Services List page has been introduced to the application, providing a dedicated interface for viewing and managing services. Users can now see a list of services with details such as name, type, platform, namespace, last modified date, and status. The page includes filtering capabilities, allowing users to filter services by type (e.g., api, function, website, custom), status, and other attributes. A search box enables quick searches within the service list. The component also supports sorting and pagination for better navigation through large lists. This page serves as the primary entry point for users to interact with their deployed services.

_core/jazz\ui/src/app/pages/services-list · high confidence

Added a new REST API endpoint for creating public Slack channels. The implementation includes request validation for channel names and user email addresses, error handling for various failure states, and integration with the Slack API to create channels and add members. The service accepts a JSON payload containing a channel name and a list of user emails, returning the created channel's details.

_core/jazz\slack-channel · high confidence

The UI now includes new components for advanced filtering (OSS and internal variants), bar and line graphing, a copy-to-clipboard utility, and a service creation flow. These additions provide users with enhanced filtering capabilities across multiple dimensions, visual data representation through graphs, and a streamlined interface for building new services.

_core/jazz\ui/src/app/secondary-components · high confidence

The core/jazz\_admin module now provides a new API for administrative tasks, allowing authorized users to perform CRUD operations on configuration data. This includes retrieving, adding, and deleting configuration entries via GET, POST, and DELETE methods, with built-in validation and error handling for security and data integrity.

_core/jazz\admin · high confidence

Added a new asset event handler in the core module that processes Kinesis events related to Jazz asset catalog updates. The handler authenticates with the API, processes create and update asset events, and handles resource deletion. It includes utility modules for failure codes and notification messages, along with configuration and deployment files.

_core/jazz\asset-event-handler · high confidence

The builds/jazz-build-module directory now includes a suite of new Groovy modules that handle the build, deployment, and configuration loading for various cloud services. These include modules for managing access control lists (acl-module), deploying to Apigee and AWS API Gateway, handling AWS Lambda events (S3, Kinesis, SQS), deploying Azure Functions, and managing source control (Git/Bitbucket) and environment metadata. The addition of these modules enables the build pipeline to support multi-cloud deployments, event-driven architectures, and automated service onboarding workflows.

builds/jazz-build-module · high confidence

A new service has been added to stream CloudWatch logs to an Elasticsearch service. The implementation includes the main handler logic, configuration files, and supporting components to process and forward log data.

_core/jazz\cloud-logs-streamer · high confidence

The core/jazz\_assets/components directory now includes new modules for configuration, error handling, logging, response formatting, and input validation. These components provide foundational utilities for the assets API, including environment-based configuration loading, standardized error type handling, structured logging, response formatting, and strict validation of input data types, required fields, and allowed values.

_core/jazz\assets/components · high confidence

Added a new event handler for processing deployment-related events. The handler listens for Kinesis records and processes create, update, and delete events by interacting with the API. It includes configuration for service IDs, logging, error handling, and utility functions for event processing.

_core/jazz\deployments-event-handler · high confidence

Added a new email service that enables sending email notifications through AWS SES. The implementation includes the main handler, input validation, and email sending logic, along with supporting components for error handling, configuration, and logging. The service accepts POST requests with sender, recipient, subject, and message content, and returns the message ID upon successful delivery.

_core/jazz\email · high confidence

Added a new set of JavaScript modules in core/jazz\_environments/components to support environment catalog operations. This includes CRUD functions (create, get, getList, update) for interacting with the DynamoDB table, along with a comprehensive validation suite (common, validate\_create\_payload, validate\_update\_payload, validate\_environment) that enforces field requirements, status values, and uneditable fields. Additional utility modules were introduced for configuration, error handling, logging, response formatting, and YAML deployment descriptor validation.

_core/jazz\environments/components · high confidence

The UI application now supports distinct runtime environments for development, internal testing, and open-source (OSS) deployments. New configuration files define environment-specific settings, including API endpoints, tab structures, and feature flags. The OSS environment introduces support for additional runtimes (Node.js 10.x, Python 3.8, Java 11, Go 1.x, C\#) and cloud providers (AWS, Azure, Google Cloud), while the internal environment uses templated placeholders for dynamic configuration.

_core/jazz\ui/src/environments · high confidence

A new \env-deployments-section\ component has been added to the UI, introducing a dedicated view for environment deployments. This includes a table displaying build IDs, commit details, timestamps, and status, along with a built-in feedback form that allows users to report issues directly from the interface.

_core/jazz\ui/src/app/pages/environment-deployment · high confidence

The environment detail page now displays a comprehensive view of an environment, including a header with status indicators, tabs for overview, deployments, code quality, assets, logs, and metrics, along with sidebars for trying the service and viewing details. Additionally, a new Jenkins status page has been introduced to display build status, success, and error states for deployments, allowing users to track and retry builds.

_core/jazz\ui/src/app/pages/environment-detail · high confidence

The environment-logs and environment-codequality pages now feature dedicated UI components that render log tables with expandable rows, filter tags, and advanced filtering options, alongside a code quality section that displays metrics in a carousel and line charts. These new components introduce structured views for environment logs and code quality metrics, replacing previous implementations or adding new capabilities for viewing and filtering this data.

_core/jazz\ui/src/app/pages/environment-logs · high confidence

The landing page has been redesigned with a new layout featuring a header, a hero section highlighting 'Create. Manage. Self-Service.', and a features section detailing serverless capabilities, CI/CD, and monitoring. The page includes a scrollable card component for release calendars and integrates with the authentication service to redirect logged-in users to the services page.

_core/jazz\ui/src/app/pages/landing · high confidence

The Node.js API template now includes four new helper modules: \config.js\ for environment-based configuration loading, \error-handler.js\ for standardized API Gateway error responses, \logger.js\ for structured logging with configurable log levels, and \response.js\ for consistent response formatting. These components replace the previous monolithic or less structured approach, providing reusable utilities for common API development tasks.

templates/api-template-nodejs/components · high confidence

The handler now includes a set of new, modular components to support service catalog operations. A configuration module (config.js) dynamically loads environment-specific settings (dev, stg, prod) from JSON files. CRUD operations are handled by new get.js and update.js files, which construct and send HTTP requests to the service catalog API, with update.js specifically adding a 'Jazz-Service-ID' header. Additionally, an error-handler.js module provides standardized error objects for API Gateway integration, and a logger.js module enables configurable log levels via environment variables.

_core/jazz\services-handler/components · high confidence

The application now includes new primary UI components: a date range picker for selecting start and end dates with time, an amount display component for currency and value, checkbox group components for multi-select filtering, and several button components (primary, secondary, and with icon). These components provide the foundational UI elements for date selection, data display, and user interactions within the primary components directory.

_core/jazz\ui/src/app/primary-components · high confidence

Added a new validation component in core/jazz\_services/components/validation that enforces input integrity for service catalog operations. The update introduces a modular validation suite (common.js, validate\_create\_payload.js, validate\_update\_payload.js, and validate\_service.js) that checks for empty inputs, required fields, disallowed fields, data types, enum values, and specific constraints like non-editable fields during updates. This ensures that all create and update requests are validated against the service field metadata before processing.

_core/jazz\services/components/validation · high confidence

The service-metrics page now features a fully functional metrics dashboard. Users can apply filters for time range, period, and aggregation to view data in a carousel of selectable metrics. The interface includes a loading state, an empty state, and an error state, alongside a line graph visualization of the selected metric's data points.

_core/jazz\ui/src/app/pages/service-metrics · high confidence

New shared utility modules have been added to the codebase, including config.js (for environment-based configuration retrieval), logger.js (for structured logging with level filtering), error-handler.js (for consistent API error formatting), response.js (for standardizing API responses), and utils.js (for common helper functions). These components are now available in the cloud logs streamer, email, and SCM webhook services, enabling consistent behavior and reducing code duplication across these services.

_core/jazz\_cloud-logs-streamer/components, core/jazz\_email/components, core/jazz\scm-webhook/components · medium confidence

The core/jazz\_usermanagement directory now contains the complete implementation for the Jazz platform's user management service. This includes the main handler (index.js) which processes user registration, password reset, password update, and user listing requests. The service integrates with AWS Cognito for user management, utilizes a T-Vault for storing user credentials, and includes utility components for configuration, logging, error handling, and response formatting.

_core/jazz\usermanagement · high confidence

The system now enforces stricter input validation for safe and user management operations, ensuring required fields like 'arn' are present and correctly formatted before processing. Additionally, new utility functions have been introduced to handle Vault API interactions, including token retrieval, safe creation, and role detail processing, improving error handling and data formatting for these operations.

_core/jazz\t-vault/components/utils · high confidence

The UI build process now includes new asset files to support configuration and API documentation. A new base.json file provides the foundational structure for the Jazz API specification, including versioning and base path details. Additionally, a new config.json file introduces environment-specific settings, such as the production flag, base URL, and tab configurations for the UI. These changes ensure the client has the necessary static assets to function correctly, addressing previous build issues.

_core/jazz\ui/src/assets · medium confidence

The UI now uses a centralized configuration system, introducing \configuration.ts\ to define required and optional settings (including e2e credentials) and separate JSON config files (\config.dev.json\, \config.json\, \config.oss.json\) for different environments. Additionally, \toastmessages.ts\ provides a comprehensive set of user-facing error and success messages for various UI interactions such as service creation, login, registration, password reset, and environment updates, ensuring consistent feedback across the application.

_core/jazz\ui/src/config · medium confidence

The environment catalog API now validates the \deployment\_descriptor\ field during PUT requests, rejecting requests with disallowed resource, event, or action types. This change introduces a new validation step that checks the structure and allowed values within the deployment descriptor before updating an environment.

_core/jazz\environments · medium confidence

The environment overview page has been refactored with a new component structure, introducing a dedicated feedback modal for user issues, a redesigned service details section with improved layout for deployment status, endpoints, and account/region selection, and updated styling for better visual consistency and responsiveness.

_core/jazz\ui/src/app/pages/environment-overview · high confidence

Corrects the logic used to identify GitLab webhook events, ensuring that push and tag\_push events are processed correctly. This fix ensures that user information is properly extracted from the event payload, preventing potential errors or missing data in recorded SCM activity.

_core/jazz\scm-webhook · medium confidence

The Cognito authorizer now validates JWT tokens against AWS Cognito and integrates with ACL services to enforce access control, with policy caching disabled.

_core/jazz\cognito-authorizer · medium confidence

The deployment event handler now uses newly extracted, modular components to improve code organization and maintainability. A new config.js file handles environment-specific configuration retrieval, while error-handler.js provides standardized error object generation for API Gateway integration. A logger.js component centralizes log level management and output, and utils.js contains helper functions for processing Kinesis events, constructing service payloads, and managing authentication tokens. These changes restructure the codebase to separate concerns, making the event handler easier to test and maintain.

_core/jazz\deployments-event-handler/components · high confidence

The Node.js API template has been updated to utilize ES6+ features (configured via .jshintrc) and includes a new modular structure with dedicated components for error handling, response formatting, configuration, and logging. The template now provides sample implementations for GET and POST methods, along with a .gitignore file to exclude build artifacts and IDE files from version control.

templates/api-template-nodejs · high confidence

The Python SLS app template has been restructured to include separate configuration files for development, staging, and production environments, each containing distinct configuration values. The template's function handlers now load these environment-specific configurations and utilize a logger module to record sample log messages, providing a clearer view of runtime behavior and environment settings.

templates/sls-app-template-python/functions · high confidence

The log streamer's internal logic has been restructured into distinct, reusable components: a config loader that dynamically loads environment-specific settings, a logger that respects a configurable log level, an error handler that standardizes API Gateway error responses, a response formatter, and a utilities module that handles AWS credential assumption and CloudWatch log group tag retrieval. This change makes the streamer's behavior more maintainable and allows for easier testing and configuration of logging levels and error handling.

_core/jazz\splunk-kinesis-log-streamer/components · medium confidence

The commit introduces several new Angular components and their associated styles to the jazz\_ui application. This includes an OssModule, a DataService, and UI pages for a 404 error state and a test API status check. Additionally, a collection of Bootstrap 3.3.7 SCSS files (alerts, badges, breadcrumbs, buttons, carousel, close icon, code, component animations, dropdowns, forms, glyphicons, and grid) are added to the styles directory. These changes resolve the reported build issue by providing the missing UI assets and styles required for the application to compile and run correctly.

(repo-wide) · high confidence

Added end-to-end tests for login, registration, and service creation workflows; Added initial test suite for the Cognito admin authorizer; Added initial test suite for the Node.js API template; Added initial test suites for cloud logs streamer and Python API template; Added test fixtures and unit tests for the environment event handler; Added tests for asset validation logic; Added tests for user management validation functions; Added unit tests for ACL validation and request processing; Added unit tests for email validation and error handling; Added unit tests for environment validation and YAML configuration; Added unit tests for jazz\_metrics validation and metrics handling; Added unit tests for secret-management API validations; Added unit tests for serverless service creation and validation; Added unit tests for the Lambda handler and HTTP endpoints; Added unit tests for the Slack channel availability check; Added unit tests for the code quality handler; Added unit tests for the jazz asset event handler; Added unit tests for the jazz\_slack-channel module; Added unit tests for the logs API handler; Added unit tests for the platform\_services handler.

Added package.json and pom.xml files for core services (including jazz\_acl, jazz\_admin, jazz\_cognito-authorizer, jazz\_services, jazz\_ui, and others) and templates (api-template-java, api-template-nodejs, angular-website-template, azure-api-template-nodejs, function-template-java), establishing their build configurations and dependencies.

(dependencies) · high confidence

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

• CAI 57 → 55 (-1.8)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 68 → 62 (-6.3)
• Architecture 54 → 61 (+6.9)
• Maturity 67 → 66 (-1.1)
• Readiness 50 → 47 (-3.4)
• Security 69 → 68 (-1.4)

• Change coupling clique: config.js, create.js, delete.js, get.js, getList.js, index.js, update.js, error-handler.js, logger.js, response.js, utils.js (core/jazz_deployments/components/config.js)
• Change coupling: get.js ↔ getList.js (core/jazz_environments/components/crud/get.js)
• Coverage not included — suite not readable by the collector
• Critical CVE: [GHSA redacted] (core/jazz_ui/src/app/primary-components/daterange-picker/ng2-slimscroll/yarn.lock)
• Critical CVE: [GHSA redacted] (core/jazz_ui/src/app/primary-components/daterange-picker/ng2-slimscroll/yarn.lock)
• Critical CVE: [GHSA redacted] (core/jazz_ui/src/app/primary-components/daterange-picker/ng2-slimscroll/yarn.lock)
• Critical CVE: [GHSA redacted] (core/jazz_ui/src/app/primary-components/daterange-picker/ng2-slimscroll/yarn.lock)
• Critical CVE: [GHSA redacted] (core/jazz_ui/src/app/primary-components/daterange-picker/ng2-slimscroll/yarn.lock)
• Critical CVE: [GHSA redacted] (core/jazz_ui/src/app/primary-components/daterange-picker/ng2-slimscroll/yarn.lock)
• Critical CVE: [GHSA redacted] (core/jazz_ui/src/app/primary-components/daterange-picker/ng2-slimscroll/yarn.lock)
• Critical CVE: [GHSA redacted] (core/jazz_ui/src/app/primary-components/daterange-picker/ng2-slimscroll/yarn.lock)
• Critical CVE: [GHSA redacted] (core/jazz_ui/src/app/primary-components/daterange-picker/ng2-slimscroll/yarn.lock)
• Critical CVE: [GHSA redacted] (core/jazz_ui/src/app/primary-components/daterange-picker/ng2-slimscroll/yarn.lock)
• Critical CVE: [GHSA redacted] (core/jazz_ui/src/app/primary-components/daterange-picker/ng2-slimscroll/yarn.lock)
• Critical CVE: [GHSA redacted] (core/jazz_ui/src/app/primary-components/daterange-picker/ng2-slimscroll/yarn.lock)
• Critical CVE: [GHSA redacted] (core/jazz_ui/src/app/primary-components/daterange-picker/ng2-slimscroll/yarn.lock)
• Critical vulnerability: [GHSA redacted] (core/jazz_ui/src/app/primary-components/daterange-picker/ng2-slimscroll/yarn.lock)
• Dependency hygiene not measured — no supported dependency manifest was read
• High CVE: [GHSA redacted] (core/jazz_ui/src/app/primary-components/daterange-picker/ng2-slimscroll/yarn.lock)
• High CVE: [GHSA redacted] (core/jazz_ui/src/app/primary-components/daterange-picker/ng2-slimscroll/yarn.lock)
• …and 39 more

• (anonymous) (cognitive 21) (core/jazz_cognito-authorizer/components/auth-policy.js)
• (anonymous) (cyclomatic 17) (core/jazz_cognito-authorizer/components/auth-policy.js)
• (anonymous)::DatePickerOptions (cognitive 22) (core/jazz_ui/src/app/primary-components/daterange-picker/ng2-datepicker/lib-dist/ng2-datepicker.component.js)
• (anonymous)::DatePickerOptions (cyclomatic 23) (core/jazz_ui/src/app/primary-components/daterange-picker/ng2-datepicker/lib-dist/ng2-datepicker.component.js)
• (anonymous)::generateCalendar (cognitive 45) (core/jazz_ui/src/app/primary-components/daterange-picker/ng2-datepicker/lib-dist/ng2-datepicker.component.js)
• (anonymous)::generateCalendar (cyclomatic 22) (core/jazz_ui/src/app/primary-components/daterange-picker/ng2-datepicker/lib-dist/ng2-datepicker.component.js)
• Assertions commented out: Verify METRICS COUNT for Website (core/jazz_ui/e2e/06-websiteservices/websiteservices.e2e-spec.ts)
• Assertions commented out: Verify METRICS COUNT for Website in Test Branch (core/jazz_ui/e2e/06-websiteservices/websiteservices.e2e-spec.ts)
• Change coupling: env-logs-section.component.ts ↔ advanced-filters.component.ts (core/jazz_ui/src/app/pages/environment-logs/env-logs-section.component.ts)
• Change coupling: env-logs-section.component.ts ↔ service-logs.component.ts (core/jazz_ui/src/app/pages/environment-logs/env-logs-section.component.ts)
• Change coupling: service-logs.component.ts ↔ advanced-filters.component.ts (core/jazz_ui/src/app/pages/service-logs/service-logs.component.ts)
• Change-coupling hub: service-metrics.component.ts → env-logs-section.component.ts, advanced-filters.component.ts, filter-modal.component.ts, metrics-carousel.component.ts (core/jazz_ui/src/app/pages/service-metrics/service-metrics.component.ts)
• ChartjsLinegraphComponent.getOptions (cognitive 20) (core/jazz_ui/src/app/secondary-components/chartjs-linegraph/chartjs-linegraph.component.ts)
• ChartjsLinegraphComponent.getOptions (cyclomatic 18) (core/jazz_ui/src/app/secondary-components/chartjs-linegraph/chartjs-linegraph.component.ts)
• ClassTooLong: CreateServiceComponent (core/jazz_ui/src/app/secondary-components/create-service/oss/create-service.component.ts)
• ClassTooLong: EnvLogsSectionComponent (core/jazz_ui/src/app/pages/environment-logs/env-logs-section.component.ts)
• ClassTooLong: EnvOverviewSectionComponent (core/jazz_ui/src/app/pages/environment-overview/env-overview-section.component.ts)
• ClassTooLong: ServiceCostComponent (core/jazz_ui/src/app/pages/service-cost/service-cost.component.ts)
• ClassTooLong: ServiceLogsComponent (core/jazz_ui/src/app/pages/service-logs/service-logs.component.ts)
• ClassTooLong: ServiceMetricsComponent (core/jazz_ui/src/app/pages/service-metrics/service-metrics.component.ts)
• …and 297 more

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

tmobile/jazz 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.