UrbanCode Velocity

Introducing UrbanCode Velocity plug-ins

Plug-in driven integrations are a central concept in UrbanCode Velocity – underpinning its power as a data aggregation, analysis, and reporting platform. UrbanCode Velocity plug-ins belong to a new generation of plug-ins designed to streamline installation and operation. As such, there are some key differences to point out.

UrbanCode Velocity uses a containerized microservices architecture. This means that the installation process for UrbanCode Velocity plug-ins is notably different than, for instance, what would be expected for a system level executable installation file. Containerization means that plug-ins are not run directly from a host operating system but from containerized instances or pods managed by a containerization platform. Runtime instances or pods are created from images, which serve as a sort of template. These images are available from the Docker Hub repository. UrbanCode Velocity retrieves images from this repository and creates instances as needed. This approach has the advantage of enabling UrbanCode Velocity to manage its own plug-in installation and versioning without interrupting the user.

UrbanCode Velocity is designed to use Kubernetes as its containerization platform. An Argo Workflow Engine is used to manage plug-in workflow. A Kubernetes pod starts when a plug-in task is requested and sends the results to UrbanCode Velocity. When complete, the container containing the plug-in ends.

Benefits of containerized UrbanCode Velocity plug-ins

Using container technology provides several benefits for using UrbanCode Velocity plug-ins.

  • Plug-ins are dynamically loaded when needed from the Docker Hub storage location. There is no need to install and update plug-ins manually. The latest version of the plug-in is always loaded. However, you can specify use of an earlier version.
  • Plug-ins are independent of operating system platform.
  • Plug-ins run in a separate memory from UrbanCode Velocity.

Plug-in types

There are currently three types of plug-in integration for UrbanCode Velocity:

These plug-ins use webhook to integrate with a defined UrbanCode Velocity endpoint. The webhook is used to trigger data collection events for UrbanCode Velocity.

Scheduled Events
These plug-ins are based on an event defined by the plug-in. Queries are performed to determine when to send and update data from the integrated service.

Also referred to as quality handlers, these plug-ins integrate functions to parse a specific file type and create a metric document that UrbanCode Velocity can display with other value stream management and portfolio views.


UrbanCode Velocity integrates external applications and data by way of plug-in driven integrations. Typically, integrations correspond to some data collection scope. One natural scope is by application instance. Suppose there is an application “A”, and that, for whatever reason (perhaps because different teams or business units are involved), there are two separate instances of this application that run on different servers. In this scenario, two integrations should be created per application instance, in which both integrations use the same plug-in (plug-in A). However, the scope of data might warrant separate integrations even for a single instance of an application. For instance, users might manage separate integrations, or webhooks might be scoped for integrations.

Integrating quality handler type plug-ins

Jmeter, Junit, and TwistLock are examples of quality handler plug-ins. Two methods available to invoke parser functions: use the UrbanCode Velocity Jenkins plug-in to run tasks that invoke Jenkins jobs or REST calls.

  • A Jenkins server plug-in is available to streamline the integration of Velocity with Jenkins or directly from Jenkins Server Plugin Manager. In your freestyle job or pipeline use the UCV-Upload Metrics file to UrbanCode Velocity step and complete the required fields. This enables your build job to upload coverage result files to UrbanCode Velocity.
  • The REST call uses a POST method with the UrbanCode Velocity quality data input as well as a multipart/form data that includes information about the payload.

Integrating endpoint type plug-ins

SonarQube is an example endpoint type of plug-in. You can define the integration from the UrbanCode Velocity user interface. On the Integration page, locate the plug-in and click Add Integration.

A dialog box opens, where you enter the appropriate configuration information. The following graphic shows the configuration properties for a SonarQube integration. The properties vary based on the integration.

Data flow between the integrated service and UrbanCode Velocity is accomplished by using a webhook. Whenever a project analysis finishes, a notification is sent to a specific integration in UrbanCode Velocity, which then collects data. The webhook design is a common and often preferred pattern for integrations because it ensures that network traffic is kept to a minimal. It is important to note the prerequisite of certificate validation and trust, meaning that the Velocity server name must match the common name on its certificate and that the webhook application recognizes the certificate as trusted.

Integrating schedule events type plug-ins

Azure DevOps, Jira, and Rally are example of schedule event type plug-ins. For scheduled event plugs-ins, the integration is defined by creating an UrbanCode value stream. A value stream map contains the properties that define the plug-in integration. The value stream map is a JSON file that contains configuration properties used to define the integration. You download the map within the UrbanCode Velocity user interface, make the appropriate changes for the integration, and upload the JSON file to the UrbanCode Velocity server.

To get started, visit the UrbanCode Velocity plug-in page to view available plug-ins.