Brave Browser 1.83.x Release #2 Checklist Comprehensive Guide
Hey guys! Releasing a new version of Brave Browser is a big deal, and to make sure everything goes smoothly, we have a super detailed checklist. This article is all about the release checklist for 1.83.x - Release #2. Think of this as our roadmap to delivering a stable and awesome browsing experience. This guide provides a comprehensive walkthrough, ensuring every step is meticulously followed. Let's dive in and see what it takes to get a Brave Browser release out the door!
Prerequisites: Laying the Groundwork for a Solid Release
Before we even think about pushing out a new release, there's some crucial housekeeping to take care of. These prerequisites are the foundation of a stable release. It’s like making sure all the ingredients are fresh before you start cooking – you want the final product to be perfect, right? We need to double-check everything from the previous release and make sure QA has given it the thumbs up. If there are any lingering issues, we create a master GitHub issue to keep track of them. This ensures that no stone is left unturned and all potential problems are addressed before moving forward. A thorough review of the previous release helps identify and rectify any recurring issues, contributing to a more robust and reliable browser version. Addressing these issues proactively prevents them from cascading into the new release, maintaining the browser's stability and user experience. This meticulous approach is essential for upholding Brave's reputation for quality and security.
Ensuring Executable Integrity and Security Consultation
Next up, we need to ensure that the Release Candidate (RC) executable installs and launches without a hitch on x86 platforms. Think of this as a test run to catch any last-minute hiccups. Ideally, we check all three platforms (Win 10 x86 being the priority), but if time is tight, one solid check is usually enough. This step is vital to ensure compatibility and a seamless user experience across different systems. After ensuring the executable's integrity, we consult with the security team. This is super important because we need to make sure all security issues have been addressed. If there's a zero-day vulnerability being exploited, we might even use the critical feature to force users to update ASAP. This proactive security measure safeguards users from potential threats and vulnerabilities. The security team’s insights are crucial for identifying and mitigating any potential risks, ensuring the browser remains a secure platform for all users. This rigorous security review is a testament to Brave's commitment to user safety and data protection.
Communication and Beta Channel Considerations
Communication is key, so we touch base with the PR team (@catherinecorre) to give them a heads-up on release timing, screenshots, and other deliverables. This ensures they're ready to spread the word about the awesome new release! This collaborative approach ensures that all stakeholders are aligned and informed, contributing to a successful launch. Coordinating with the PR team ensures that the release is effectively communicated to the public, highlighting new features and improvements. A well-coordinated PR strategy can significantly boost user adoption and satisfaction. Finally, when we're pushing out a chromium bump (especially for zero-day chromium releases), we make sure that BETA builds have also been started and pushed publicly. This is a quick check to avoid any delays that could leave users vulnerable. We aim to get the BETA out within ~24 hours to stick to our 1-day SLA promise. This commitment to rapid response in critical situations underscores Brave's dedication to user security and timely updates.
Release Notes to Staging: Documenting the Journey
Alright, now let's talk about release notes. These are like the highlights reel for the new version, showing off all the cool stuff we've been working on. First, we go through all the closed issues in GitHub and mark them as either release-notes/exclude or release-notes/include. This helps us curate a clear and concise list of changes for the users. This meticulous categorization ensures that the release notes accurately reflect the updates and improvements in the new version. Including relevant issues and excluding irrelevant ones helps maintain clarity and focus in the documentation. Next, we commit these release notes to CHANGELOG_DESKTOP.md in the brave-browser master branch. This is a must-do before running the release to production Jenkins build job. This step ensures that the changelog is up-to-date and ready for the official release. Maintaining a comprehensive changelog is crucial for transparency and helps users understand the changes and improvements in each version. Lastly, we stage the release notes to https://github.com/brave/brave-browser/releases/. This makes them easily accessible for anyone interested in the details of the release. Staging the release notes on GitHub provides a centralized location for users to access the information, promoting transparency and ease of communication.
Certification and Builds: Getting Ready for Prime Time
Time to get certified and build those binaries! We upload the builds to Omaha test channels (86-r-test, 64-r-test, test(mac)). This is like the dress rehearsal before the main show. Uploading to test channels allows for thorough testing and validation in a controlled environment. This step is critical for identifying and resolving any potential issues before the public release. We want to make sure everything is working perfectly before it goes live. Simultaneously, we log into Fastly and clear the CDN cache for updates-cdn.bravesoftware.com and updates.bravesoftware.com. Clearing the CDN cache ensures that users get the latest version of the browser without any delays or caching issues. This step is crucial for a smooth and seamless update experience for users. A clean cache ensures that the most recent updates are promptly delivered, enhancing user satisfaction and minimizing potential disruptions.
Test Staging for Updates: Putting It Through Its Paces
Now comes the fun part – testing! We install a prior version of Brave and update it via the test channels (86-r-test, 64-r-test, test(macOS)). This simulates the real-world update process, allowing us to catch any update-related issues. Testing the update process in a staging environment helps identify and resolve any potential problems before the public release. This proactive approach ensures a smooth and trouble-free update experience for users. We confirm that the version matches our expectations. It’s like checking the recipe to make sure we followed it correctly. Verifying the version ensures that the update has been successfully applied and that users will receive the intended changes. This step is crucial for maintaining consistency and reliability in the update process. Finally, we create a QA summary and sign-off report under #release via Slack. This provides a centralized record of the testing process and sign-off, ensuring accountability and transparency. Documenting the QA process and sign-off provides a clear audit trail and ensures that all necessary checks have been completed. This thorough testing and documentation process is vital for ensuring the stability and reliability of the release.
Release to Production Download Locations: The Grand Unveiling
Okay, the moment we've all been waiting for – releasing to production! We start by publishing the GitHub release (removing the 'pre-release' checkmark). This makes the release officially available to the public. Publishing the GitHub release signals the official availability of the new version to the community. This step is a key milestone in the release process, marking the culmination of all the hard work and preparation. Then, we upload the Mac/Win build to Omaha production channels (x86-rel, x64-rel, stable(mac)). This is like launching the rocket – the new version is now heading to users! Uploading builds to production channels ensures that the new version is accessible to users through the browser's update mechanism. This step is crucial for widespread adoption of the new release. Simultaneously, we sign Linux builds and upload them to S3 repositories. Linux users, we haven't forgotten about you! Signing and uploading Linux builds ensures that Linux users can securely access and install the new version. This step demonstrates Brave's commitment to supporting a diverse range of platforms. We also upload the Mac .dmg and .pkg to the S3 bucket (i.e., aws s3 cp ./Brave-Browser-Dev.dmg s3://brave-browser-downloads/latest/Brave-Browser-Dev.dmg --acl public-read). This provides an alternative download method for Mac users. Providing multiple download options enhances accessibility and ensures that users can easily obtain the new version. Finally, we upload the Windows stub and silent installer to the S3 bucket using a similar command to the Mac dmg above (i.e., BraveBrowserSetup.exe, BraveBrowserSetup32.exe, BraveBrowserSilentSetup.exe, BraveBrowserSilentSetup32.exe). This provides additional installation options for Windows users. Offering stub and silent installers caters to different user preferences and simplifies the installation process.
Clear Production Fastly Cache: Ensuring Speedy Delivery
To make sure everyone gets the latest and greatest, we need to clear the Fastly cache. We clear the cache for brave-browser-downloads.s3.brave.com, brave-browser-apt-release.s3.brave.com, and brave-browser-rpm-release.s3.brave.com. This ensures that users download the newest version of Brave without any caching hiccups. Clearing the Fastly cache ensures that users receive the most up-to-date files, preventing any issues related to outdated cached content. This step is crucial for a smooth and reliable download and update experience. A clean cache guarantees that users benefit from the latest features, improvements, and security updates. This proactive cache management is a key component of a successful release.
Updates Testing on Production: Real-World Scenarios
Now we wait for confirmation that live updates are working. This is like checking the engine after a test drive – we want to make sure everything is purring smoothly. Monitoring live updates is critical for identifying any issues that may arise in the real-world update process. This step helps ensure a seamless transition for users to the new version. We specifically ensure that delta upgrades are working on both Win x64 & Win x86 platforms. Delta upgrades are smaller and faster, so it’s important to make sure they’re functioning correctly. Verifying delta upgrades ensures that users receive updates efficiently, minimizing download sizes and installation times. This optimization enhances the user experience and reduces the strain on bandwidth. To do this, we create the needed registry keys. Creating registry keys enables logging, which is essential for verifying the delta upgrade process. This step allows for detailed analysis and troubleshooting of any potential issues. Then, we upgrade and check C:\ProgramData\BraveSoftware\Update\Log\BraveUpdate.log to confirm that a x64 delta or x86 delta upgrade has occurred. Checking the log file provides concrete evidence of whether a delta upgrade was successfully performed. This step ensures that the upgrade process is functioning as expected and that users are receiving the correct updates. We also wait for confirmation that macOS and Linux live updates are working. Covering all platforms is key to a successful release. Verifying updates across all supported platforms ensures a consistent and reliable experience for all Brave users. This comprehensive testing approach demonstrates Brave's commitment to cross-platform compatibility and quality.
Verifying Linux Downloads and Installs
For Linux, we ensure that following https://brave.com/linux downloads/installs the expected release (version we just published/released). This verifies that the Linux installation process is functioning correctly. Verifying the Linux installation process ensures that Linux users can easily and securely install the new version. This step is crucial for maintaining a positive user experience on the Linux platform.
Download & Install stub binaries from https://brave.com: The Final Check
We download the stub installer from https://brave.com on Win x64 (https://laptop-updates.brave.com/latest/winx64), Win x86 (https://laptop-updates.brave.com/latest/winia32), and the .dmg binary from https://brave.com on macOS (https://laptop-updates.brave.com/latest/osx). This final check ensures that the download links are working and serving the correct files. Verifying the download links and binaries ensures that users can easily access and install the new version of Brave. This step is a crucial final check before announcing the release. This step is like the final inspection before shipping the product, making sure everything is in order.
Announcements: Spreading the Word
Time to shout it from the rooftops! We publish the release notes to GitHub and https://www.brave.com/latest. This gives users a clear overview of what’s new and improved. Publishing release notes on GitHub and the Brave website ensures that users have access to detailed information about the new version. This step promotes transparency and helps users understand the changes and improvements. We also announce the release on https://community.brave.com/ (@Hollons) and https://www.reddit.com/r/brave_browser/ (@Hollons). Engaging with the community is a great way to get feedback and answer questions. Announcing the release on community platforms allows for direct engagement with users, fostering a sense of community and providing opportunities for feedback. This step is crucial for building relationships with users and gathering valuable insights. We also notify #announcements of the latest release with a link to the release notes. Keeping the team informed is essential for a coordinated launch. Notifying the team ensures that everyone is aware of the release and can contribute to a successful launch. This internal communication is vital for maintaining alignment and efficiency. For 0-day and critical releases, we go the extra mile and announce the release on Twitter (https://twitter.com/brave (@rebron)) and Facebook (https://www.facebook.com/BraveSoftware (@rebron)). This ensures that the message reaches a wider audience in urgent situations. Announcing critical releases on social media platforms ensures that users are promptly informed of important updates and security fixes. This step is crucial for protecting users from potential threats.
Closing and Creating Milestones: Wrapping Up and Looking Ahead
We set a release date (if missing) and close the appropriate milestone under https://github.com/brave/brave-browser/milestones and https://github.com/brave/brave-core/milestones. This keeps our project management tidy and organized. Closing milestones ensures that projects are properly tracked and that progress is accurately recorded. This step is crucial for maintaining organization and transparency in the development process. Finally, we create milestones under b-b & b-c if needed. Planning for the future is just as important as celebrating the present. Creating milestones sets the stage for future development and ensures that the project continues to move forward. This proactive planning is essential for sustained growth and innovation.
Enabling Logging for Delta Upgrades on Windows: The Techy Details
For those of you who want to get into the nitty-gritty, here’s how to enable logging to check delta upgrades on Win x64 & Win x86. This is a more technical section, so feel free to skip it if it’s not your cup of tea. Providing technical details allows advanced users to delve deeper into the upgrade process and troubleshoot any potential issues. This transparency fosters trust and empowers users to take control of their browsing experience. Once Brave is installed and you're ready to run through an upgrade, the following registry keys need to be added using Powershell:
Win x64
New-Item –Path "HKLM:\SOFTWARE\WOW6432Node\BraveSoftware" –Name UpdateDev
New-ItemProperty -Path "HKLM:\SOFTWARE\WOW6432Node\BraveSoftware\UpdateDev" -Name "IsEnabledLogToFile" -Value ”1” -PropertyType "DWord"
Win x86
New-Item –Path "HKLM:\SOFTWARE\BraveSoftware" –Name UpdateDev
New-ItemProperty -Path "HKLM:\SOFTWARE\BraveSoftware\UpdateDev" -Name "IsEnabledLogToFile" -Value ”1” -PropertyType "DWord"
Note: You'll need to run Powershell as an Administrator or you'll get an error message. Running PowerShell as an administrator ensures that the necessary permissions are granted to modify the registry. This step is crucial for successfully enabling logging. Once you've created the above registry keys, update Brave via brave://settings/help and you should see a log file created under the following directory:
C:\ProgramData\BraveSoftware\Update\Log\
You'll see something similar to the following under BraveUpdate.log, which indicates that the brave_installer-delta-x64.exe was used for the upgrade:
x64 example
[02/22/22 19:48:16.672][BraveUpdate:goopdate][2304:3864][Running installer][C:\Program Files (x86)\BraveSoftware\Update\Install\{EA78FFA4-26E6-459D-9D48-03CA7B5750EE}\brave_installer-delta-x64.exe][][{AFE6A462-C574-4B8A-AF43-4CC60DF4563B}]
x86 example
[02/22/22 20:04:57.790][BraveUpdate:goopdate][9384:9404][Running installer][C:\Program Files\BraveSoftware\Update\Install\{0700DFFF-3AD1-406E-9622-B46E1D93C408}\brave_installer-delta-ia32.exe][][{AFE6A462-C574-4B8A-AF43-4CC60DF4563B}]
So, there you have it, guys! A comprehensive checklist for releasing Brave Browser 1.83.x - Release #2. It's a lot of work, but it's all worth it to deliver a top-notch browsing experience. By following these steps diligently, we ensure that each release is stable, secure, and packed with the latest features and improvements. This commitment to quality and user satisfaction is what sets Brave apart.
