Introduction
When developers push code from one environment to another, managing shared components is crucial to avoid code overwrites and deployment issues. Without proper management, these issues can lead to delays and instability in the development process. To address this challenge, CloudFulcrum developed a comprehensive solution designed to predict and identify shared components, ensuring a smooth promotion process to integrated environments such as UAT, SIT, Preprod, etc. This blog introduces the concept of the shared component analyzer as a key part of this solution.
Shared Components Problems in Copado
The Challenge of Missing Commits: Have you encountered missing commits when promoting changes back to lower environments? After a production deployment, some commits are not present in the Sandbox. Although the branches contain these commits, the sandboxes do not, leaving them with nothing to merge or deploy. Developers remain unaware of these missing components until an issue arises. The main reason is that the GIT commit history of the feature branch already includes these commits, as the master branch is also created from Production. The diagram below clearly explains the situation that most developers face in their day-to-day work.
Possibility of Overwrites: when two developers (Dev 1 and Dev 2) are working on separate user stories (US-1 and US-2) in parallel, Dev 1 commits changes (C1) to the US-1 feature branch, which are then promoted through the UAT and INT environments before reaching the Master/Prod (Production) branch. Meanwhile, Dev2, working on the US-2 feature branch, unknowingly continues to work on an older branch. They are unaware that they are working on an older version of the file.
How about requiring Dev2 to perform a back-promotion first?
Shared Component Analyzer
Introducing OpsBridge, developed by CloudFulcrum, a sophisticated release orchestration suite designed to transform Salesforce DevOps. It offers a comprehensive range of capabilities that extend beyond traditional DevOps tooling. One of its tools is the Shared Component Analyzer.
The purpose of this analyzer is to create a structured approach to managing shared components within a multi-user story environment. By generating reports, metadata inclusion lists, and creating on-demand solutions, to predict and resolve conflicts early in the development cycle. The goal is to achieve a stable codebase, reduce defects, and improve overall efficiency in the deployment process.
Features of Shared Component Analyzer
The following are the features of the Shared Component Analyzer:
1. Shared Component Matrix Report: This report will show user stories that are in environments like dev1, dev2, or Int but not yet in production. This helps in identifying components that are still under development and need to be monitored for conflicts.
2. Metadata Inclusion List: The inclusion list acts as a filter, containing environment settings and selected metadata types. Using these filters, you can generate a shared component matrix, identifying which components need attention.
3. Shared component list on-demand: Based on a specific user story, you can generate a shared component matrix upon committing changes. This real-time calculation helps in identifying shared components and potential conflicts related to that particular user story.
4. Shared Component Matrix Calculation on Specific Environments: Implements a mandatory check for shared components within the environment setup, ensuring consistency and preventing code conflicts during deployment.
5. Sync changes to User Story via Back Promotion: It involves merging changes made in a specific branch or environment back into the original user story or source environment Via back promotion. This ensures that all environments are up to date with the latest changes and preventing discrepancies.
6. Capture Back Promotion Results on User story: Maintains a record of back-promoted changes on a separate object and link them to the relevant user stories. This helps in managing dependencies and provides traceability of changes across different environments.
Benefits
Reduced code overwrites: Minimize the risk of overwriting code by identifying and managing shared components proactively.
Predict conflicts ahead of promotion: Anticipate potential conflicts before promotion and devise strategies to resolve them efficiently.
Stable codebase with less rework: Achieve a more stable codebase with fewer instances of rework and a lower defect-to-bug ratio.
Ability to capture user story dependencies: Track and manage dependencies between user stories effectively using metadata, ensuring all relationships are accounted for.
Improved auditing and reporting: Enhance auditing and reporting capabilities by identifying dependencies across releases, providing better insights and control.
Scalable solution for Dev Teams: Develop a scalable solution that can grow with the development team’s needs, providing long-term benefits and efficiencies.
Conclusion
Implementing this proposed solution will enable development teams to reduce code conflicts, predict and resolve potential issues early, and maintain a stable and reliable codebase. The structured approach and mandatory checks ensure consistency and reliability, ultimately leading to a more efficient and effective development process. This scalable solution not only addresses current challenges but also prepares the team for future growth and complexities.
