Introduction
Understanding organizationsUnderstanding componentsManage organizationsManage componentsManage component Jira integrations
Set up your first organizationUnderstanding users and teamsUnderstanding role-based access controlManage usersManage teamsConfigure role-based access controlRBAC permissions reference
Understanding authentication in CloudBees UnifySet up multifactor authenticationConfigure SAML single sign-onConfigure OIDC authenticationConfigure network security policiesNetwork security reference
Understanding platform configurationUnderstanding environmentsManage properties and secretsManage environmentsTrack environment inventoryConfigure containersSet up preconfigured actionsConfigure notifications
Accessibility policy referenceShared responsibility model referenceSubscription and services agreementSupport policiesSupported browsers and external tools
Introduction
Understanding feature managementUnderstanding Configuration as CodeGet started with feature managementCreate and manage feature flagsConfigure feature flag targetingOrganize feature flagsImplement feature flag governanceConfiguration as Code reference
Understanding flag impressions and activity statusUnderstanding flag healthUnderstanding code referencesReview and clean up feature flagsSet up code references
Understanding Jira integration for feature flagsSet up the Jira integrationLink Jira tickets to feature flags
Understanding multiple SDK keysBuild your first mobile app with feature flagsBuild your first feature-flagged web applicationBuild your first feature-flagged backend serviceInstall client-side SDKsInstall server-side SDKsConfigure multiple SDK keysMobile SDK referenceWeb SDK referenceBackend SDK referenceClient SDK referenceFlag implementation reference
Introduction
Understanding CI workflowsCreate a build workflowCreate and manage workflowsCreate reusable workflowsTest and validate containers in workflowsCheck out source codeTrigger workflows remotelyWorkflow syntax referenceJobs syntax referenceSteps syntax referenceServices syntax reference
Monitor workflow runsView test results in runsView evidence in runsView deployments in runsManage workflow artifactsPublish test resultsPublish evidence itemsGenerate a software bill of materialsManage ServiceNow change requests
Configure workflow credentialsConfigure AWS credentialsConfigure container registry credentialsConfigure Git credentialsIntegrate external secret providers
Understanding GitHub Actions integrationSet up GitHub Actions integrationDisplay GitHub Actions workflows and runsRegister GHA build artifactsPublish GHA deployed artifactsPublish GHA test resultsPublish GHA evidence itemsTrigger CloudBees workflows from GitHub ActionsScan with GitHub Actions
Understanding CloudBees CI and Jenkins® integrationConnect CI and Jenkins controllersMonitor CI and Jenkins buildsRegister CI build artifactsRegister CI deployed artifactsPublish CI test resultsConfigure CI security scanningCI and Jenkins integration reference
Build and publish container imagesUnderstanding external CI/CD integrationsRun external CI/CD jobsExternal CI/CD action reference
Introduction
Understanding release orchestrationManage applicationsCreate deployer workflowsCreate staged workflowsCreate and manage releasesOrchestrate multi-workflow releasesRelease management reference
Understanding artifact managementRegister and track artifactsStore and retrieve artifactsPromote artifactsGenerate a software bill of materialsArtifact management reference
Deploy with HelmDeploy to KubernetesContainer deployment reference
Deploy to AWSAWS deployment reference
Deploy with enterprise platformsExecute remote deployment commandsEnterprise deployment reference
Verify deployments with New RelicDeployment verification reference

Set up code references

4 minute read

Set up code references to track where feature flags are used in your source code. CloudBees Unify scans the repositories linked to your application’s components and displays all locations where each flag is referenced, making it easier to understand flag usage and safely remove flags that are no longer needed. For an overview of how code references work, refer to Understanding code references.

Prerequisites

Before setting up code references, ensure the following are in place:

Requirement Description

SCM integration

A configured GitHub integration. Refer to Configure source code management.

Component(s)

One or more components created in your organization. Each component is connected to a repository via an SCM integration. Components represent the services, libraries, or modules that contain your feature flag code. Refer to Understanding components.

Application

An application that groups components together. Code references scan the repository associated with each linked component. Refer to Manage applications.

Feature flag

At least one feature flag created in CloudBees Unify. Refer to Create and manage feature flags.

Network access

Network connectivity between CloudBees Unify and your source code repository (for self-hosted repositories).

Step 1: Create or verify your SCM integration

If you have not already done so, create an SCM integration to connect CloudBees Unify to your source code repositories.

  1. Navigate to Settings  Integrations.

  2. Select GitHub.

  3. Follow the integration setup wizard to authenticate and connect.

  4. Verify that your repository appears in the list of available repositories.

Refer to Configure source code management for detailed instructions.

Step 2: Create components

Components represent the logical parts of your application that can be built, deployed, and released independently.

  1. Navigate to Components.

  2. Select Create component.

  3. Select a repository.

    The repository’s default organization is pre-selected; you may change it if needed.

  4. Select Create components.

  5. Repeat for each component in your application.

Match your component names to the actual services or modules in your codebase. This makes it easier to understand which code reference belongs to which part of your application.

Refer to Understanding components for more details.

An application groups components together. CloudBees Unify scans the repository associated with each linked component for code references.

  1. Navigate to Applications.

  2. Select Create application.

  3. Enter an Application name (for example, E-commerce Platform).

  4. (Optional) Enter a Description.

  5. (Optional) Select Add environment to link environments where your application is deployed.

  6. (Optional) Select Add repository to enable workflow orchestration (deployer workflows, staged workflows):

    1. Select a repository from the list.

    2. Select Add.

      The application-level repository link is for workflow orchestration, not code references. Code references scan the repositories linked to each component.

  7. Select Add component:

    1. Select a component from the list.

    2. Select Add.

    3. Repeat to add all components that contain feature flag code.

  8. Select Create.

Code references require components to be linked to the application.

  • Each component is already connected to a repository via an SCM integration.

  • CloudBees Unify scans each component’s repository for flag references.

  • The application-level repository link is optional and used for workflow orchestration, not code references.

Refer to Manage applications for more details on managing applications.

Step 4: Verify code references appear

After linking components to the application, confirm that code references are working.

  1. Navigate to Feature management  Flags.

  2. Select a feature flag that exists in your codebase.

  3. Select the Flag health tab.

  4. Scroll to the Code References section.

The page displays the following information:

  • A count of references found (for example, "Review affected code (5 references)").

  • Filters for repositories, branches, and file types.

  • A list of files and line numbers where the flag is referenced.

Troubleshoot

No repositories linked to this application

Cause: No components are linked to the application or the components have no connected repositories.

Solution:

  1. Navigate to Applications and select your application.

  2. Select Vertical ellipsis and then Edit.

  3. Select Add component and link components that have repositories connected.

  4. Select Save.

  5. Verify each component has a repository connected via an SCM integration.

Flag is not referenced in any linked repositories

Possible causes:

  • The flag key in your code does not match the flag key in CloudBees Unify.

  • Component repositories have not been scanned yet (scans may take a few minutes).

  • The flag is not used in the linked components' code.

  • Network connectivity issues prevent CloudBees Unify from accessing component repositories.

Solutions:

  1. Verify the flag key matches exactly (case-sensitive).

  2. Wait a few minutes and refresh the page to allow scanning to complete.

  3. Check that the flag is actually referenced in the component’s codebase:

    1. Search your codebase for the flag key.

    2. Verify the file is in a repository linked to a component.

  4. For self-hosted repositories, verify network connectivity between CloudBees Unify and component repositories.

No matching references found (with filters applied)

Cause: Your current filter settings exclude all references.

Solution:

  1. Clear or adjust your filters:

    1. Repository filter: Select "All" or the specific repository.

    2. Branch filter: Select "main" or your default branch.

    3. File extension filter: Select "All" or the relevant file types.

  2. Select Apply filters.

Code references are not updating

Possible causes:

  • The search is encountering errors when accessing the repository.

  • Repository authentication has expired.

  • CloudBees Unify does not have permission to access the repository.

Solutions:

  1. Verify your SCM integration is still authenticated:

    1. Navigate to Settings  Integrations.

    2. Check the status of your SCM integration.

    3. Re-authenticate if needed.

  2. Check repository permissions:

    1. Ensure CloudBees Unify has read access to the repository.

    2. Verify the GitHub access token or OAuth app has the required scopes.

  3. Contact your CloudBees Unify administrator if the issue persists.

Code references appear under the wrong component

Cause: The component linked to the application does not match the actual component using the flag.

Solution:

  1. Navigate to Applications and select your application.

  2. Select Vertical ellipsis and then Edit.

  3. Verify the correct components are linked.

  4. Add any missing components using Add component.

  5. Select Save.

Best practices

The following practices help ensure code references are accurate and complete.

Organize components by deployment unit

Create components that match how your application is actually deployed:

  • Microservices: One component per service.

  • Monolith: One component for the entire application, or separate components for major modules.

  • Multi-repo: One component per repository, or group related repositories.

This makes code references more meaningful and easier to navigate.

Use consistent flag naming

Use a consistent naming convention for feature flags in your code and in CloudBees Unify:

  • Use the same casing (kebab-case, snake_case, camelCase, and so on).

  • Avoid special characters that might be interpreted differently.

  • Document your naming convention for your team.

Review code references before removing flags

Before deleting a feature flag:

  1. Check the Code References section in Flag health.

  2. Verify all references have been removed from the codebase.

  3. Consider the impact on deployed versions that may still reference the flag.

Review and clean up feature flags