We are starting 2026 with a bang!  This release is packed with popular requests: Inventory Bundles, i3D.net Hosting, Meta Horizon IAP, StoreKit 2, Visual Studio Code, and heck - even Roblox! There is something here for everyone!

Compatibility Notes

We prioritize preserving stability and backward compatibility for existing apps. 

As a security improvement, we have changed the response that is returned by the Authentication Service’s Reset Password calls. These calls will now always return a status: 200 response, even if the targeted account does not exist.

A new compatibility flag has been added to control this feature. It is enabled by default for existing apps (to preserve the old behaviour).  For optimal security, app developers should disable this setting.

[ x ] Support legacy reset password failure response (includes reason for failure, for example: "credential not found").

Release Highlights

Bundles (and other Item-related Enhancements)

We have [finally!] added support for Bundles to our Catalog system. Bundles can contain multiple Items and collections of Virtual Currencies. Which means that Bundles can double as a convenient mechanism for Currency Exchange - e.g., to exchange 1 bar for 100 coins.

We have also added the ability to put Catalog Items and Bundles “on sale” via our Promotions system.

Finally, we have enhanced Items (and Bundles) to allow the system to enforce a Maximum Quantity of an Item (or Bundle) that a user can own. 

Bundle features

• Bundles are defined via the Item Catalog service - and managed via the User Items service 
• Bundles can contain multiple Items and/or Currencies [but not other Bundles - this is not Inception!]
• Bundles can be purchased, awarded, and/or traded with others
• Bundles can be awarded anywhere that Items are currently awarded in the system 
• Bundles must be opened to get their contents. A bundle is destroyed upon opening it.

Catalog Promotions

• Promotions may not include special pricing (in virtual currencies) for Items and Bundles
• Promotions can also make Items/Bundles available for sale for a limited time
• As part of this feature, the Item Catalog system can now properly distinguish between free and not-for-sale items.

Max Quantity

• Devs can now set the maximum quantity of an item that can be owned by a user
• Note that this capability is limited to “Stackable” items.  To limit the quantity to 1, set the item stackable and the max quantity to 1.
• Note that when using the Trading APIs, items/bundles with a max quantity set must be traded with the immediate option, as we can’t enforce max quantity if the trade is deferred.  [Max-quantity items can, of course, still be traded by custom means.]

Multiplayer & Hosting

We also have several multiplayer and hosting enhancements in this release!

i3D.net integration

You may not know i3D.net - but chances are you have played games on their servers. Ubisoft, EA, Hi-Rez, and more are among the many companies whose players compete via i3D.net’s high-performance global network and hybrid “bare metal cloud”.

And now, brainCloud devs can too! 

To take advantage of our new i3D.net integration:

• Set up an account with i3D.net - and configure your hosting via i3D Orchestrator
• Configure the i3D.net integration on the App > Design > Integrations > Manage Integrations page
• Create an i3D.net Orchestrator server type via the App > Design > My Servers page
• Link that server type to your Lobby via the App > Design > Multiplayer > Lobbies page

And voila - your brainCloud lobbies will now launch servers on i3D.net!

Faster lobby launches

Whether you are using brainCloud’s built-in hosting or the services of one of our hosting partners, apps can now start launching servers while players are still in the lobby! Depending on how quickly your lobby fills, this can shave 5-20 seconds off launch time!

brainCloud’s v3 Protocol Relay Servers have been updated to support this new feature. Games with custom Room Servers will likely need to make a few modifications to ensure their servers launch (and wait) before players begin connecting.

Game clients aren’t heavily affected, but they may receive fewer launch progress messages as the server would have started launching before the lobby reached the starting state.

Roblox Support [beta!]

brainCloud does Roblox now?!!  Yes, we do!

Late last year, some developers approached us to ask whether brainCloud’s services could be made available to Roblox game developers. We hadn’t really considered it before - but we are always up for a challenge!

We are thrilled to present the culmination of a whirlwind couple of months of hard work. Roblox developers can now access key brainCloud services, including cloud saves, leaderboards, tournaments, gamification, groups, deep data, the item catalog, and more. All core services are available, except RTT itself, as we haven’t yet figured out how to integrate a bidirectional WebSocket in Roblox.

So - Roblox devs - come check us out! Our à la carte feature set and API-based pricing are perfect for games that want to add a feature or two!

In-App Purchases

Devs are always looking for more ways to monetize their apps - while maddeningly, the store APIs keep changing!

We are pleased to bring the following new & improved app store updates to brainCloud:

• Meta Horizon Platform IAP - brainCloud now supports in-app purchases for Meta’s Horizon ecosystem
• Apple StoreKit 2 - brainCloud now supports Apple’s StoreKit 2 APIs
• Google Play One-time Products API - brainCloud also supports Google’s One-time Products API; technically, this was added in a 5.8.5 patch

Visual Studio Code Extension [beta!]

Although this was released late last year, it is still worth mentioning.  For the devs that don’t already know - brainCloud now has an official Visual Studio Code Extension!

The extension securely connects to brainCloud and lets you work on your brainCloud scripts directly in Visual Studio Code. And you get access to all your favorite Visual Studio Code features - including AI assistance!

So look for “brainCloud Cloud Code FS” in the Visual Studio Code marketplace – and be sure to give us a star!

Additional Improvements

brainCloud 5.9 also includes:

• Global File Uploads

  • Our S2S API now supports the uploading of global files
  • Note that these new APIs have not yet been added to our S2S client libraries, but they are available to developers who want to make S2S calls directly.

• Session Durations (Bonus!)

  • Apps that use RTT will now notice that brainCloud is tracking player session times. 
  • These durations can be viewed on the User Activity screen and in the User Context Banner, which shows the average session duration.
  • Note that apps that don’t use RTT can still notify the system that a session is complete by calling the PlayerState.Logout() method when the player leaves the app.

• Tournament Completion Scripts

  • Ever wanted to trigger a custom script when a tournament completes? Now you can!  

• [Improved] Unity Plugin

  • There is an improved Unity Plug-in. It’s more secure - and works better with private brainCloud deployments. 

Portal Changes

We continue to improve our Portal with each release.

Item Catalog

The Item Catalog screens have been completely refactored to not only add support for Bundles but also improve overall workflow.

Promotions & Personal Pricing

The Promotions and Personal Pricing screens have been significantly enhanced to support Items/Bundles and improve the overall workflow.

Cloud Code Editor Improvements

We have added several quality-of-life improvements to our Cloud Code Editor. These improvements include:

• Improved Tab UI: It is now easier to tell which tab is active, and the editor now properly restores the active tab when you return to the Editor from another screen.
• Better sync: the editor now highlights when a script has changed while the user is viewing it. If the script isn’t currently being edited, the view will automatically update to the latest version.
• Control-S, Alt-S - the editor now supports common keyboard shortcuts to save the current script

DataStream Improvements

We have made significant improvements to the User DataStream screen and also added a new Global DataStream screen.

Additional Improvements

The following sections of the portal have also seen significant improvements:

• App > Dashboard

  • Has been improved and reorganized to put the most important information front and center.
  • Includes a new Calendar widget to show currently active events.

• App > Calendar

  • Long-term events (i.e., >365 days) are hidden by default. This allows devs to focus on managing day-to-day events.

• App > Design > Core App Info > Application IDs

  • The new Apple StoreKit2 settings can be found in the Apple tab
  • The new Meta Horizon and Rift settings can be found in the Oculus tab

• App > Design > Cloud Data > Global Properties

  • We improved inline property editing.

• App > Design > Integrations > Manage Integrations

  • The page has been redesigned to be easier to use. 
  • Also includes the new i3D.net integration settings.

• App > Design > Multiplayer > Lobbies

  • Added the new pre-launch option to the lobby Rules tab.

• App > Design > Servers > My Servers

  • Added the ability to create i3D.net server types.

• App > Global > Logs > Job Queue

  • Added the ability to filter by Job Type.

• App > Groups > Groups > Groups

  • Preview Blade - Added the ability to jump to Group Entities and Group Files for the selected group.

• App > Groups > Group Files

  • A new screen that allows portal users to view and manage group-owned files.

• App > Reports > Usage > API Usage

  • File uploads are now displayed separately from File downloads.

• User > Marketplace > Inventory

  • Updated to support Bundles.

• User > Marketplace > Personalized Pricing

  • Updated to support Catalog Promotions. See the Items & Bundles tab in the Offers section.

API Changes

The following changes/additions have affected the brainCloud API:

• Authentication

  • For improved security, the Reset Password APIs - i.e. ResetEmailPassword*() and ResetUniversalId*() now always return status: 200 – even if the accounts targeted do not exist. The old behaviour is still supported via a new compatibility flag, which is enabled by default for existing apps.

• Global File

  • Now supports direct file uploads via the S2S API.  [Before, devs needed to upload User Files via the Client API and migrate them to Global Files.]
  • The process is similar to uploading User Files. Call SysPrepareUpload() to receive an URL that can be used when performing the upload.

• Group

  • Several group-related APIs, including GetMyGroups(), have been enhanced to return the group version field for convenience

• User Items

  • AwardUserItemWithOptions() - Allows item(s) to be awarded to a user without collecting the purchase amount. Includes an optionsJson field that can be used to specify how the system should respond if the player already has the maximum quantity of an item.
  • GetItemsOnPromotion() - Returns a list of items that currently have promotional pricing for the current user
  • GetItemPromotionalDetails() - Get promotional details for the specified item definition
  • PurchaseUserItemWithOptions() - Purchases a quantity of an item from the specified store. Includes an optionsJson field that can be used to specify how the system should respond if the player already has the maximum quantity of an item.
  • OpenBundle() - used to open a bundle, depositing the contents into the user’s inventory.

Client Libraries

All Libraries

• New User Items APIs: AwardUserItemWithOptions(), GetItemsOnPromotion(), GetItemPromotionDetails(), PurchaseUserItemWithOptions(), OpenBundle()

• Exposed Constants:

  • Operation Param
  • Service Name
  • Service Operation
  • Reason Codes
• Updated all copyrights to be correct and consistent.

Unity, C#, and Godot

• Exposed constants were updated to use readyonly struct data structure
• Meta Quest devices will set the platform to OCULUS for brainCloud authentication
• Optimized the response processing, which was more apparent during large responses

Objective-C

• SSKeychain has been deprecated; was updated, and replaced with SAMKeychain

Roblox - Lua (Beta!)

• New brainCloud-roblox Client- Plugin

  • The experience must be “published” to Roblox in order to gain access to the Data store for users to seamlessly log in with Roblox.
  • The experience must be configured with Studio Access to API Services - Enabled.
  • Allow HTTP Requests as well to communicate with brainCloud.

• Known Limitations

  • Real-Time Technology

    • Persistent socket connections to brainCloud servers from Roblox clients and servers are currently limited.

  • Relay Servers

    • Relay-based multiplayer functionality is constrained by the same real-time connection limitations.

  • File and Group File Uploads

    • Multi-part upload streams are not currently supported in Roblox.

  • App Store Service

    • Has not been fully tested or confirmed

  • Authentication

    • Not all identity types have been fully tested.
    • A Universal brainCloud UserId is generated from the Roblox UserId to streamline player login.

S2S Libraries

Example/Demo Libraries

• Cursor Party - i3D support

• Updated Authentication Unity example

  • Added Game Center authentication support
  • Added Steam authentication support
  • Updated Google OpenId support

• New AuthenticationOculus Unity example added

  • Intended for Meta Horizon devices on Windows (via Meta Horizon Link) and Meta Quest
  • Showcases Oculus Authentication
  • Showcases Marketplace support with Consumable, Durable, and Subscription purchases on Meta Quest devices

• New BCFishnet - Collaborative Canvas Unity example added

  • Includes authentication, long-lived lobbies, host merging when the active host drops during gameplay, and join-in-progress support.

• New BCKart - Photon Unity example added

  • Extended an existing Photon sample with brainCloud authentication, lobby management, and leaderboard integration.

Documentation and Tutorials

Documentation

• All the latest API additions and changes have been incorporated into our documentation at docs.braincloudservers.com

Back to school with brainCloud!

Our new Classroom Invites feature makes it easy to set up a class of budding developers. Get organized with our new App Calendar! Plus Steam Ownership Checks, IAP Improvements, Push Optimizations, and more!

Compatibility Notes

brainCloud prioritizes API stability and backward compatibility for apps. The following configuration flags control key brainCloud 5.8 behaviours:

• Compatibility flag: Allow purchases without requiring a developer payload or cached purchase context. Defaults to ON for existing apps, OFF for new apps.
• Steam Platform setting: Steam Verify App Ownership. Defaults to OFF.

Release Highlights

Classroom Invites

We have supercharged our Team Member invitation system. 

Not only can you now invite multiple team members at once, but we have also added the ability to quickly set up a student classroom, with each student getting their own personal app to work on. We even support importing team lists from .csv files.

brainCloud has always been great for student learning - now it’s even easier to get started.

App Calendar

This release adds a new Calendar view for apps. The Calendar automatically surfaces important initiatives like scheduled Redemption and Promotion campaigns.

It’s also a great place to note important dates like Soft Launches, New Feature Releases, Advertising Campaigns, etc.  Just click the [+] button to add a new entry to the calendar.

If you are expecting a significant traffic surge associated with a new launch or promotion, you can give the brainCloud Ops team a heads up!

We will be building upon our Calendar system significantly in the coming releases - so stay tuned!

Improved IOS and Android In-App Purchases

We’ve had some complaints over the years regarding some limitations on the use of In-App Purchase price/item IDs – which are the codes that you define in iTunes Connect or Google Play for various IAP price points for your products.

[Note - the purchase interactions for other stores are different. Only the Apple and Google Play stores are subject to this limitation.] 

The complaint is that developers cannot effectively reuse these codes across products. So if I (a dev) want to sell “Apples” for 1.99, and “Oranges” for 1.99 as well - I need to create two separate codes in the various app stores (“applesregprice” and “orangesregprice”) instead of re-using one shared code between them (e.g. “fruitregprice199”).

The reason for this is due to the context information that we can derive from the receipts. Basically, we are only receiving the IAP item ID from the store - and thus if you re-use the price in multiple places - we cannot tell what product a customer had purchased (and therefore what rewards to award the user). This situation only gets more complicated when Promotions (Sales) are involved.

We’ve been working to address this challenge - and 5.8 offers some relief - in two parts:

• First of all, the AppStore.GetSalesInventory() call now returns a new “payload” field for each IAP product. This field contains important context information that can be used to derive the user's purchase more accurately.
• The client app can now cache this context information to be used when processing a user’s IAP purchase. Simply call the new CachePurchasePayloadContext() method right before performing an Apple App Store or Google Play purchase, and brainCloud will automatically use the additional context information when processing the purchase receipt.

We highly recommend that all devs adjust their IOS and Google Play purchase flows to cache the new payload context. In the meantime, though, processing of the purchase context is optional as long as the new [x] Allow purchases without requiring a developer payload or cached purchase context compatibility flag is checked.  

Steam Ownership Check

brainCloud’s Steam Authentication has been upgraded to [optionally] confirm that the player owns the game that they are logging into.

To enable this validation, go to the Steam settings section of the App > Design > Core App Info > Application IDs page, and enable “Steam Verify App Ownership”.

Local Datastream

Up until this release, our Datastream system was limited to streaming analytics events to external systems (via Segment or Kafka). 

brainCloud 5.8 adds a new Local Datastream feature - that allows datastream events to be cached locally for a period of time (90 days by default) - for use in deeper analytics by brainCloud itself.

We will be building upon this new capability in future releases. Stay tuned!

Additional Improvements

This release includes many other improvements.

These include:

• App Alerts - Max Server Nodes Reached

  • brainCloud will now raise an alert if the “Max Server Nodes” setting is preventing additional servers from launching.  

• App Icon and Deployments

  • We no longer overwrite the App Icon of the target app during deployment. This change allows devs to more effectively use unique icons for different stages of their app [eg. Dev vs. Staging vs. Production] 

• External Authentication Improvement

  • We have extended the External Auth mechanism to allow auth scripts to set the user’s identityData.  

• Push Notification Optimizations

  • We have refactored our Push Notifications framework to improve performance for Apple and Google push notifications. These optimizations affect both push notifications sent to all users and notifications sent to specific user Segments.
  • Note that there were no API changes associated with these optimizations. 

• Security Improvements

  • Several security improvements have been made to the Portal UI and the underlying portal service calls.

• Server Launch

  • Our new Server Launch API allows devs to launch servers outside of Lobby processing.

Portal Changes

We continue to rapidly evolve and improve our Portal. 

Calendar Screen

As introduced in the Feature Highlights section, our new Calendar screen is front-and-center in the Portal - located just under the Dashboard for your apps.

You’ll actually find multiple views of your Calendar entries here - one in the standard Calendar view, but also a List view that presents the entries in a simpler format (that also works for mobile devices).

Additional Improvements

The following additional portal improvements have been made:

• Chart Colors

  • We have adjusted the colors used for dev-defined items (like Products) to be more attractive  

• App > Design > Cloud Data > User Statistics

  • Stats are now displayed in alphabetical order!

• App > Design > Core App Info > Advanced Settings, Compatibility Settings

  • New “Allow purchases without requiring a developer payload or cached purchase context” flag.

• App > Design > Segmentation > Segments

  • The criteria list is now searchable

• App > Design > Promotions > Scheduled

  • Portal users can now Clone scheduled promotions.
  • The preview blade now shows only the IAP Product prices that have changed.  This change applies to Automated Promotions as well.

• App > Reports > Analytics > Product Category

  • A new screen that breaks down how your IAP sales are going on a category basis.

• User > Data > User Files

  • Portal devs can now upload user files directly from the portal. This is useful in some debugging and corrective scenarios.
  • Screen columns were also re-ordered to be more useful

Plus, for our Private Licensees:

• Super > Manage > Manage Members

  • The member list now shows the difference between regular and read-only Super users.
  • The Invite dialog has also been improved to differentiate it from the Team-scoped invite dialog

Note - in addition to the new screens and polish, we have also upgraded the underlying portal tech to React 18 (from 16). With this upgrade comes valuable code and performance improvements (and the reduction of technical debt) - but it does mean that there is a greater than normal chance of regressions across the Portal. Please report any issues to support if you encounter them!

API Changes

The following changes/additions have affected the brainCloud API:

• AppStore

  • New CachePurchasePayloadContext() call added to supplement Apple and Google Play receipt verification - providing additional context.

• Authentication

  • AuthenticateExternal() - the external auth script can now set the custom identityData JSON associated with the identity. 

• Leaderboard

  • Updated SysListLeaderboardConfigs() - now allows devs to specify the divSetId to query on if filterType is ”divisions”.  ← Makes it easy to find all division instances for a particular set

• RoomServer

  • The new RoomServer service has been added to allow direct launching of hosted servers. This service and its APIs are reachable by cloud code and S2S only.
  • The new SysLaunchServer() method is used to launch a server of the named server type (as defined in My Servers). The dev must provide the ID of a callback script to handle events as the server launches.
  • The service also includes additional calls to support server interactions: SysGetRoomMember(), SysRoomEvent(), SysRoomReady(), SysRoomSessionEnded() and SysRoomSessionStarted().

Libraries and Examples

Client Libraries

All Libraries

• New CachePurchasePayloadContext()  call added to the AppStore Service API
• Fixed a discrepancy in RelayService.SetPingInterval() to consistently use seconds instead of milliseconds
• Removed deprecated functions

Unreal

• Fixed compatibility with UE 5.6
• Deprecated the FindLobby() function that was still using the in_timeoutsecs parameter, replaced with FindLobby() function without that parameter

Examples

Unity

• Authentication Unity example added iOS Advertising Support as an option to enable full Facebook login
• Marketplace Unity example showcases CachePurchasePayloadContext for Android and iOS in-app purchases
• Tic Tac Toe now supports online matchmaking to find matches in real-time.

Documentation and Tutorials

Documentation

• All the latest API additions and changes have been incorporated into our new doc site at docs.braincloudservers.com !

We sat down with CEO Mohammad Agha and Lead Developer Tri Truong to gain insights into Magmic’s adoption of brainCloud as the primary backend of their games.

Part 1 discussed the decision-making process and benefits of moving to brainCloud.

In Part 2 we discuss the process of migrating their apps to brainCloud.

How did you approach migrating to brainCloud?

We started with an initial pilot of our Scattergories Blitz game.  

It took 2 to 3 months to integrate brainCloud into the game fully. Overall, the transition went smoothly, thanks to brainCloud’s well-documented APIs and responsive support team. 

One of the most essential services we leveraged was the Turn-by-Turn Async Multiplayer system, which was a perfect fit for our game. This feature enabled players to take their turns at their convenience, keeping the gameplay engaging and interactive. Additionally, brainCloud’s flexible backend architecture made it easy to integrate leaderboards, player data management, and matchmaking, ensuring a seamless experience for both new and existing players.

And after the pilot?

After the initial pilot, we began migrating our key titles to brainCloud, including Phase 10, Spite & Malice, Passport Rummy, and Idle Pet Paradise.

The migration process for our key titles proceeded relatively smoothly, with Phase 10 and Passport Rummy taking approximately 1 to 2 months to integrate with brainCloud fully.

For Spite & Malice, we leveraged brainCloud’s Replay Service (i.e. PlaybackStream API) to develop a robust multiplayer function, ensuring a seamless and engaging player experience. This enabled us to implement an asynchronous turn-based system, allowing players to replay past moves and strategize effectively.

In Idle Pet Paradise, we leveraged brainCloud’s Cloud Code to integrate a Web3 platform, enabling blockchain-based interactions such as NFT ownership and in-game asset management.

Did you encounter any hurdles during the migration, and how were they resolved?

During the integration process, one of the challenges we faced was querying large datasets in our game. Handling big data efficiently was initially difficult, as performance and response times became a concern. However, the brainCloud support team was incredibly helpful — they provided us with key insights, including best practices for using Custom Entities and how to optimize queries by adding indexes. With their guidance, we were able to implement a more efficient data structure, which allowed us to develop features related to big data without performance bottlenecks. Their support made a huge difference in overcoming this challenge and ensuring our game runs smoothly at scale.

Was there a specific capability that delivered above and beyond your expectations?

One capability of brainCloud that truly exceeded our expectations is its Real-Time Technology (RTT). It enables us to develop real-time games and instantly send messages to online players, resulting in a smooth and engaging experience. We successfully leveraged RTT in Spite and Malice and Scattergories Blitz to build turn-based gameplay with seamless player interactions.

Was the transition disruptive for your players?

Transitioning to brainCloud has been seamless for our players. When we migrated our backend, we ensured that player accounts, game progress, and in-game purchases remained intact, ensuring no disruption to their experience. brainCloud’s robust authentication and data management tools made the migration smooth, and players were able to continue playing without even noticing the backend change. The reliability of brainCloud also improved server stability, reducing downtime and ensuring a smoother gaming experience overall.

Has brainCloud enabled product improvements that benefit your players?

Absolutely! Moving to brainCloud has allowed us to introduce several new features that enhance the player experience. For example, we leveraged brainCloud’s Real-Time Technology (RTT) to enable faster matchmaking and instant in-game notifications. Additionally, its cloud-based leaderboard and analytics tools helped us fine-tune game balancing and personalize rewards for players. We also improved scalability, ensuring that the game runs smoothly even during peak hours or special events, without lag or connection issues. These improvements have led to increased engagement and a better overall experience for our players.

Has the usage-based pricing of brainCloud been good or bad for you?

Usage-based pricing resulted in significant overall cost savings. Magmic has a library of games in various stages in their life cycle, and usage-based pricing ensures that a game’s costs are proportional to the size of its active player community. 

Usage-based pricing also had an interesting side effect for Magmic: More optimized coding. 

Usage based pricing created an incentive for us to more intelligently make calls in batches so as to reduce the cost. It drove us also to write better server code, to optimize what code resided on the server vs. on the client. By optimizing our code in these areas, we have achieved even greater savings in usage. And the user experience improved too - it’s win:win!

[For more information on cost savings, see Part 1 of this case study.]

Has brainCloud affected your approach to building games?

Before integrating brainCloud, our development team was split into two separate groups — backend and frontend. This separation often led to communication challenges and slowed down feature development, as frontend developers had to wait for back-end engineers to build the necessary infrastructure before implementing new gameplay elements.

After adopting brainCloud, our workflow became much more efficient. Now, each Magmic developer can work seamlessly across both brainCloud and Unity, allowing us to implement new features without bottlenecks or dependencies on a dedicated backend team. This has significantly reduced development time and enabled faster iteration on ideas.

How has brainCloud impacted your team's overall efficiency?

brainCloud has significantly boosted our team’s productivity by streamlining backend development, allowing us to focus on what matters most: building great gameplay experiences. With its powerful backend-as-a-service capabilities, we can quickly implement new features without having to allocate extra resources to backend infrastructure. This has enabled our team to iterate more quickly, experiment with new ideas, and bring features to market faster. 

[Note - start time has been updated from 8pm -> 6:30pm Eastern.]

brainCloud BaaS will be upgraded to MongoDB 8.0 on Monday, July 7th, starting at 6:30 p.m. Eastern. This rolling upgrade may take up to 3 hours to complete. All API and Portal services will be fully available during the upgrade; the portal will NOT be disabled.

[Full disclosure: It will take longer than usual because we are first upgrading to MongoDB 7.0, and then immediately upgrading to MongoDB 8.0.]

Note that all brainCloud Private Instances will be upgraded in the weeks before the end of July 2025.

Compatibility

brainCloud 5.7 has been tested to be fully compatible with MongoDB 8.0.

Important Change (READ THIS!)

MongoDB 8.0 contains an Important Change that brainCloud developers must be aware of.

Starting in MongoDB 8.0, comparisons to null in equality match expressions don't match undefined values.

Consider the following table:

In MongoDB 6, a query for { "name": null } would return all 4 records, as per these conditions:

• The name field is null (_id: 1)
• The name field is undefined or contains an undefined array element (_id: 2 and _id: 3)
• The name field does not exist (_id: 4)

But in MongoDB 8, the query for { "name": null } only returns 2 of the records:

• The name field is null or contains a null array element (_id: 1)
• The name field does not exist (_id: 4)

Note that this change in query behaviour also affects $eq, $in, and $lookup operations.

For full details on MongoDB compatibility changes:

• MongoDB 7 - https://www.mongodb.com/docs/manual/release-notes/7.0-compatibility/
• MongoDB 8 - https://www.mongodb.com/docs/manual/release-notes/8.0-compatibility/

brainCloud Customer Impact

This change only affects brainCloud's list and paging-style calls (which accept custom query JSON) - and ONLY apply if the JSON data itself somehow had undefined values -- which would be pretty unusual.

The affected calls include:

• Custom Entity - GetEntityPage(), SysGetEntityPage()
• Entity - GetList(), GetListCount(), GetPage()
• Global Entity - GetList(), GetListCount(), GetPage(), GetSystemEntityList() GetSystemEntityListCount(), GetSystemEntityPage()
• Group - ListGroupsPage(), GetRandomGroupsMatching(), ReadGroupEntitiesPage(), SysGetRandomGroupsMatching(), SysListGroupsPage(), SysReadGroupEntitiesPage()
• Item Catalog - GetCatalogItemsPage(), SysGetCatalogItemsPage()
• Leaderboard - SysGetLeaderboardConfigsPage()
• Messaging - GetMessagesPage(), SysGetMessagesPage()
• RedemptionCode - SysGetCodeTypePage()
• User - SysGetPage()
• User Items - GetUserItemsPage()

So - this is ONLY an issue if:

• Your app has "undefined" values in its JSON entities
• AND it is querying on those fields with "undefined" values
• AND it is specifically querying those fields for "null" and expects "undefined" values to be included with the query results.

Take action!

If you do feel that this issue may affect your app, reach out to us in support with the following information:

• appId
• category of entity affected (eg, User, Global, Custom, etc).
• entityType field
• field name <- name of the field with undefined values

We may be able to help you prepare the data so that "undefined" fields are replaced with "null" values to ensure that queries continue to work.

This release adds an improved Team Dashboard, Self-Service Delete & Branding, Node Resource Monitoring, Online Matchmaking Improvements, and more. It also readies the platform for MongoDB 8.

Compatibility Notes

All brainCloud releases emphasize preserving stability and backward compatibility for existing apps. That said, developers should be aware of the following changes:

• Lobbies

  • Join In Progress change

    • The system no longer allows additional members to be added to a lobby while it is in the STARTING state. 
    • If Join In Progress is enabled, new members can join once the lobby moves to the ACTIVE state.
    • This change addresses a race condition whereby it was possible for the lobby members to have "readied up" but for a new lobby member to be joined to the lobby in a non-ready state before the associated room instance was completely launched.

Release Highlights

Improved Team Dashboard

We have reworked the Team Dashboard to make it more useful (and prettier!), especially for teams with multiple apps.

Improvements include:

• New Live Apps widget - displays Daily Active Users, New Users, Revenue, and Purchase Count charts for the last 14 days
• New Recently Active Members widget - so you know who has been online in the system recently

Plus improvements to the look-and-feel of the existing widgets. 

Self-Service Branding

As a backend service, brainCloud provides very little UI for end-users. That said, we do provide a few web screens to:

• Verify email addresses
• Enable password resets
• Unsubscribe from tournament emails

The existing screens were functional but plain. brainCloud’s development community has been wishing for the ability to customize the look-and-feel of those screens.

And in 5.7 you get your wish! We have re-designed the screens and tied them to a new Self-Service Branding feature that controls their look and feel.  Using the new system, developers have a lot more control over the screens, including:

• Separate studio and app branding
• Control of header, background, font, and button colors
• Multiple header layout options
• Add custom buttons to screens
• Optional footer section - with links to privacy page, support, etc.
• And more…

The new App > Design > Self-Service > Branding page customizes this look and feel and features a Live Preview so developers can see how their choices will look in Mobile or Desktop browsers.

Self-Service Account Deletion

We built the branding feature (above) so that we could build this feature properly! 😀  

Some app stores (Google) now require that devs provide an URL for web-based account deletion. We have created this new feature to give developers a head start on that requirement. It’s a complete solution for apps using email identity and/or contact emails. Devs using other forms of authentication can use the new APIs and Portal functionality to satisfy the Google requirement.

Scenario 1 - For email-based accounts (fully automated)

The Self-Service Account Deletion feature provides an URL for end-users to delete their accounts.

To delete their accounts, end-users will:

• Navigate to the provided self-service deletion URL
• Provide the email address associated with their account
• The system will then send an email(s) to that address, with a link to click to delete their account. Note that multiple emails will be sent if there is more than one account associated with an email (which can happen with contact emails).
• The user receives the deletion email and clicks the link. Note that the link for account deletion is valid for a limited period of time ← set to 2 hours currently.
• The user follows the prompts to complete the deletion of their account.

Developers can enable and configure this feature from the new App > Design > Self-Service > Delete Account page.

A few important notes:

• The template used to create the email sent to the user is customized with the other Sendgrid email templates, on the App > Design > Authentication > Email Authentication page.  Instructions for creating a template can be found here.
• CSRs can also manually trigger the sending of the deletion email to users directly from the Portal. Choose “Send Deletion Email…” from the Action menu of the user's User Summary page.

Scenario 2 - API-based Automation (For non-Email Identity Types)

Devs can use this feature and associated APIs to build a custom site for deleting accounts. 

The use case would look something like:

• The custom site would prompt the user for their login info, and then, using brainCloud APIs, log in and retrieve the profileId of the associated account.
• The site would then call the new User.SysCreateSelfServiceDeletionUrlForUser() method to create a deletion URL.
• The site would then redirect the end-user to that URL so the user could complete the deletion steps.

Scenario 3 - Manual Via CSR (Customer Support Representative)

CSRs can support the deletion requirements via the new Design Portal features.

The use case looks something like this:

• A form or customer service application prompts the user for the information to identify their account.
• A CSR looks up the user’s account and navigates to the User Summary page of that user.
• The CSR then clicks the Copy Deletion URL… button on the action menu to create and copy the deletion URL for that user.
• The CSR then sends the end-user a response, with the URL to click on for the user to delete their account.

Node Resource Monitoring

The Server Monitor now allows developers to monitor the resource utilization of individual nodes. Including these metrics marks the Server Monitor’s graduation from [Beta] to official release!

Clicking on a node and selecting the Usage tab displays the following charts:

• Containers - the number of containers running on the node
• CPU - the % cpu utilization of the node (across all containers)
• Memory - the % memory utilization of the node (across all containers)
• Storage - the % storage used by the node

The CPU, Memory, and Storage metrics are retrieved from our New Relic monitoring system. There can be an initial lag of up to 5 minutes for newly launched servers in retrieving these metrics. The Container Count metric is received directly from our Room Server Framework via RTT. Still, there is no history, so the data is retrieved and available only while the Server Monitor screen is displayed.

Additional Improvements

brainCloud 5.7 includes a ton of other improvements as well. These include:

• App Alerts

  • We have added a new alert to warn users when their Tournament auto-claim settings are out of sync with the required compatibility flag.

• Builder API

  • The Builder API has been enhanced to support new Dynamic API Keys, which are dynamically created and are good for only 16 hours
  • Dynamic API keys can be created as part of the new SSO functionality that we have built into the platform.  

• Edgegap Hosting

  • The control of the skip_telemetry option is now configurable by devs. Previously, it was hard-coded  true for faster server launches (but at the expense of perfect placement of servers).

• GameLift Hosting

  • There is a new AWS EventBridge option for more scalable reporting of hosted server status. Configuring this is optional, but highly recommended for production deployments.

• Item Catalog Images (via API)

  • New API methods have been added to allow Item Catalog images to be set via Global or User Files. See the API section for more details.

• Online Matchmaking

  • Has improved support for adding groups of players to a lobby
  • Previously, all players would be placed on the same team if a team was specified in the matchmaking call, but if not, the provided players would be dispersed between the available teams.
  • The extension allows developers to ensure players are placed together on a team without having to specify which team.
  • See the API section for more details.

Portal Changes

This release adds some significant quality-of-life improvements to the Portal.

Live Lock

We have made the live lock more convenient. Devs can now drag the app’s name instead of re-typing it into the confirmation field.

Redemption Codes

We have added additional functionality and polish to the design and monitoring Redemption Code screens:

• App > Design > Marketplace > Redemption Codes

  • Now includes a new Search option
  • The list now shows the number of redemptions redeemed - instead of the number available for redemption…. (which is a bit more consistent when showing expired codes)

• App > Global > Marketplace > Redemption Codes

  • If there has been no activity in the past 30 days, the Campaign Activity widget now displays a new [Show the most recent activity] button, which automatically adjusts the chart's date settings when clicked. 

Personalized Pricing

The User > Marketplace > Personalized Pricing screen has been completely reworked to help developers understand which prices a user sees and why. 

This greatly aids in understanding and debugging automated promotions.

Additional Improvements

The following additional portal improvements have been made:

• Login, Registration, and Recovery

  • The screens for user login, new user registration, and account recovery have been improved

• Team > Manage > Apps

  • The [+ New App] dialog has been redesigned to make selecting supported platforms easier.

  • Platforms are now separated into the following categories:

    • Mobile & Web
    • Desktop & Console
    • Legacy

• Team > Manage > Members

  • The Builder API key permission has changed somewhat. It now indicates whether the team member has permission to create and use Static API Keys. The label has been adjusted to reflect this change.

• Team > Setup > Team Info

  • The Builder API access permissions have been slightly refactored. There are now separate permissions for general access to the Builder API and for allowing the use of static keys.

• App > Design > Admin Tools > Deployment

  • This includes a new option for preserving self-service branding during deployment. Useful if the branding for development and production versions of apps is different (for testing purposes)

• App > Design > Notifications > Settings

  • Now supports deleting Apple Push Notification certificates

• App > Global > Leaderboards > Leaderboards

  • The leaderboard entry preview blade shows the user’s profile image, if available.

• App > Design > Self-Service

  • New section for setting Self-Service feature options. See feature description in the Release Highlights section.

• User > User Browser, Search

  • Searching by email now searches for emails in the Contact Email field and Profile Identities, in addition to the Email Identity

• User > Summary > User Summary

  • Screen action buttons have been reorganized under a new Action menu

  • Includes new actions for the new Self-Service Account Deletion feature:

    • Send Deletion Email…
    • Copy Deletion URL…

• User > Gamification > Milestones

  • Refactored and separated from the old Milestones & Quests screen
  • Supports new filtering and searching options

• User > Gamification > Quests

  • Refactored and separated from the old Milestones & Quests screen
  • Supports new filtering and searching options

API Changes

The following calls have been added to the brainCloud API:

• ItemCatalog

  • Added two new methods (cloud code & S2S-only) for copying image files to the item catalog programmatically:

    • SysCopyItemImageFromGlobalFile() - copies (or moves) a file from Global Files to be used as the image for an Item Catalog entry.
    • SysCopyItemImageFromUserFile() - copies (or moves) a file from User Files to be used as the image for an Item Catalog entry.

• Lobby

  • The lobby matchmaking APIs have been extended to support additional options for team selection when dealing with groups of players (as specified using the otherUserCxIds parameter).

  • This new behaviour is controlled by new special “team names” that can be passed into the teamCode parameters of the API calls:

    • “team1” - all players will be assigned to the specified team (existing functionality)
    • ““ or null - players will be individually (and randomly) assigned to teams that have [x] Auto assign players enabled. Players are NOT guaranteed to be kept together on the same team. (existing functionality)
    • “___” (three underscores) - assign all provided players as a group to any team at random.  Note that only teams with [x] Auto assign players enabled are considered. Players are kept together. (New functionality!)
    • “___:team1,team2,…” - attempt to join `team1`, attempt to join `team2`, etc. until the list is exhausted. Players are kept together. (New functionality!)
  • The FindLobby(), FindLobbyWithPingData(), FindOrCreateLobby(), FindOrCreateLobbyWithPingData(), JoinLobby(), JoinLobbyWithPingData(), SysAddMember(), and SysAddMemberWithPingData() have all been extended to accept these new team codes

• User

  • Added a new S2S call for creating the self-service deletion URL for a user:

    • SysCreateSelfServiceDeletionUrlForUser() 

Client Libraries

All Libraries

• Increased the amount of time the client library waits for a CONNECT message from the Relay Server before resending its connection request. Timeout is now 2 seconds (up from 0.5 seconds).

Unity, C#, and Godot

• Fixed bug that caused empty notification tokens to be saved if an end-user denied push notifications

Unreal

• Fixed issue where the WebSocket object is not cleaned up properly on destroy
• Fixed issue with the OnRecv function passing in a reference to the json message, it is now passing a copy of that json message instead of a reference to account for a crash issue happening where the reference points to a null value on rare occasions.
• Fixed bug that caused empty notification tokens to be saved if an end-user denied push notifications (STILL IN PROGRESS)

C++

• Fixed bug that caused empty notification tokens to be saved if an end-user denied push notifications

Java

• Fixed bug that caused empty notification tokens to be saved if an end-user denied push notifications 

JavaScript

• Fixed bug that caused empty notification tokens to be saved if an end-user denied push notifications

Objective-C

• Fixed bug that caused empty notification tokens to be saved if an end-user denied push notifications

Examples

• Invaders Demo greatly improved with Replay Functionality

Documentation and Tutorials

Documentation

• All the latest API additions and changes have been incorporated into our new doc site at docs.braincloudservers.com !

Tutorials

• A new Knowledge Base article discusses how to add a Replay System to your game using brainCloud Playback Streams. Find it here. 
• New Knowledge Base article on creating a custom Room Server Manager (RSM). Find it here.

Marvellous Multiplayer! Release 5.6 brings additional polish and performance to the brainCloud platform, with an emphasis on improved multiplayer services and developer quality-of-life!

Compatibility Notes

There are no API changes in this release. 

There is, however, a change to how often brainCloud retrieves docker images for Hosted Room Servers. brainCloud used to retrieve a fresh image with every container launch - but this is both slow and expensive. Starting in 5.6, if the named image already exists on the node, brainCloud will re-use that image - avoiding the unnecessary "pull" from Docker. For devs who don't set unique tags for each production build, this behavior can be modified so that brainCloud will retrieve a fresh image if the cached image on the node is older than hours. See the Hosted Server Optimizations section for more information.

Release Highlights 

Matchmaking Monitor - Official Release

brainCloud 5.6 marks the official release of our Matchmaking Monitor.

The Matchmaking Monitor is a unique feature of brainCloud that gives developer and designer-friendly insights into an app’s matchmaking performance - and how it impacts the player experience.

This release re-arranges our panels to be more intuitive and mobile-friendly - and adds two new performance metrics: Matches Per Minute and Lobbies Created Per Minute. 

We have also added an Average Steps metric to give developers additional insight when optimizing their matchmaking criteria.

Developers can now click on the Lobby Type panel to trigger a Preview Blade showing its configuration.

The Matchmaking Monitor can be found in the Design Portal under App > Global > Multiplayer > Matchmaking Monitor.

Hosted Server Optimizations

brainCloud has built-in support for hosting Room [i.e., Game] and Relay Servers.

This release brings significant optimizations to hosted server orchestration, including:

• Faster container launches: We have refactored our region and node-locking approaches to speed up the parallel launching of nodes and containers.
• Faster container cleanups: The system will now clean up completed containers faster, making server slots available for new matches sooner. As a bonus, this saves money!
• Optimized image pulls: brainCloud now only retrieves the image for your container once when a new node starts. All subsequent container launches on that node take advantage of the previously retrieved image. This strategy is best for devs who use unique tags [e.g., “1.0.0-1”] for every server build. For devs re-using tags across builds [e.g., “latest”], there is an option to pull a fresh image if the previous image is older than the specified number of hours. This speeds up container launches - and reduces Docker usage - saving money!
• Optimized log retrievals: brainCloud now uses a separate thread to retrieve the logs when cleaning up containers. Also note that by default, brainCloud now only retrieves the logs for containers that complete with a non-zero exit code.

Leaderboard Optimizations

Our Leaderboard system is one of brainCloud’s most popular features. As such, it gets used a lot - by many games in different ways.

A common use case is using our Leaderboards as the basis of Tournaments — both for our built-in Tournament system and for more customized systems that devs have built using Cloud Code. 

Although the system overall performs well, one part of it performs “less well” than the rest: counting all the entries in a leaderboard. Due to MongoDB's limitations, this operation is slower than we’d like. And under some circumstances (e.g., at the end of a tournament, when everyone wants their tournament results), those slowdowns can add up! 

brainCloud 5.6 introduces several improvements to target this very use case:

Leaderboard counts are now being pre-calculated and stored for two high-usage scenarios:

1. Tournament results: When a tournament is completed, and rewards are calculated, we now count and store the total number of players once and use it for batched and real-time processing of tournament rewards.
2. Rotated leaderboards: When a leaderboard rotates, we now count the entries and store them in the leaderboard version history - automatically using that value when the app calls GetGlobalLeaderboardEntryCountByVersion(). 

Both of these improvements are entirely in the background — no changes to Client APIs.

NEVER ROTATION leaderboard cache

The previous two scenarios calculate and store the count for leaderboards that have been completed. Since these leaderboards are no longer live, the number of entries is no longer growing.

The same cannot be said for NEVER rotation leaderboards. These leaderboards are active forever - and can grow to millions of players.  As they do, dynamically counting the entries can take some time.

To improve performance for these leaderboards - we have added a new system that periodically (every 2-5 minutes) counts the number of records and caches the result. This cached count is also dynamically incremented/decremented as new scores are added and deleted. As such - this cached count closely tracks the exact number of entries – though it isn’t guaranteed to be 100% accurate.

When a leaderboard is very large - the difference between 1,500,000 or 1,500,001 isn’t significant…  though apps with this caching enabled should take care to ensure that they can handle the situation where the system says the player’s rank is 1,500,001 – but also says there are only 1,500,000 entries in the leaderboard. [Hint - in that case - artificially inflate the number of entries to 1,500,001 for display purposes.]

Important notes:

• Most apps do not need the NEVER ROTATION cache. Thus, it is turned OFF by default for all apps.
• Our support team must enable the NEVER ROTATION cache on a case-by-case basis.
• After 5.6 is released, our support team will contact teams with apps where we think this should be enabled.
• Contact support if you have questions about whether we should enable it for your app! 

Additional Improvements

brainCloud 5.6 includes a number of smaller improvements as well. These include:

• App Alerts

  • Dangerous Compatibility Flag — We have added a special alert for the "Include shared objects in Owned Custom Entity GetEntityPage queries" compatibility flag, which can significantly slow app performance for apps using Custom Entities. We highly advise that this flag be disabled for all apps. More info here. 
  • Unreachable Web Service — We have added a new alert for when Web Services are not reachable from brainCloud’s servers. This alert may indicate that the target servers are down, the endpoint has changed, or their SSL Cert has expired.

• Database

  • brainCloud now has basic/experimental support for AWS DocumentDB. This is most interesting for our Private Licensees (as an alternative to Atlas) - though we are also considering moving some Public BaaS services to it (e.g., some logs). 

• Logs

  • We have added new Security Log views at the App, User, and Super system levels. These logs mainly capture bad login attempts - at the Client and S2S API levels.

• Relay Server

  • We have added new MD5 and hex dump capabilities to the logging. The two new settings are:

    • PACKET_LOG_ENABLED_WITH_MD5: Set to “true” to enable MD5 hash logging of incoming and outgoing relay packet payloads.
    • PAYLOAD_LOG_AS_HEX: Set to “true” to log the incoming packet payload as a hex dump rather than an ASCII string.
  • The relay server also now exits with a code of 11 if MEMBER_TIMEOUT expires before any players connect. 

Portal Changes

We continue to evolve our Portal. In addition to the Matchmaking Monitor enhancements described above, we have added the following improvements:

Billing Plan Dialog

For users on our Public BaaS, the Billing Plan dialog has been updated to facilitate easier plan comparison and selection. This dialog is accessed from the Team > Manage > Apps page. 

Global Properties

The Global Properties screen (App > Design > Cloud Data > Global Properties), which is used for managing remote config settings for apps, now allows values to be edited inline for convenience. 

Note that JSON-based properties will pop-up a small dialog window for easier editing.

Reference Currency

brainCloud is used by developers across the globe - and thus doesn’t make any assumptions about the base currency that your app uses. The reference price of a Product is simply a number that we sum up when presenting revenues.

Prior releases of brainCloud have displayed a $ next to revenue numbers - which obviously isn’t correct for apps that aren’t using a dollar-based currency.

brainCloud now allows developers to specify the reference currency for apps - so that we can display revenue numbers appropriately.

Navigate to App > Design > Portal > Reference Currency Settings to configure your currency!

Sample Data Mode

Most of our analytics screens now feature Sample Data modes - which are designed to give new devs a feeling for what the screen would display if the related data were available.

Note that when in “Sample Data” mode - the screen contains a prominent brown border with the words “(Sample Data)” after the screen title.

Additional Improvements

In addition, the following additional quality-of-life improvements have been made:

• App > Design > Cloud Code > Web Services 

  • now displays an icon indicating whether the services displayed are reachable by brainCloud

• App > Design > Gamification > XP Levels

  • Changed the default chart display format to Linear (instead of Logarithmic)

• App > Design > Leaderboards > Tournament Templates

  • Greatly improved display and editing of Tournament Prizes!

• App > Design > Multiplayer > Lobbies

  • Re-designed Lobby Preview blade. Now, it shows a summary of the rules.
  • You can also quickly navigate to the associated Server for a Lobby Type from its Preview Blade.

• App > Design > Servers > My Servers

  • Room Servers - Devs can now configure if and how often to refresh Docker images when launching containers. 

• App > Global > Global Data > Custom Entities

  • Added [Apply] button to the editor to allow for easy checkpoint-saving for long editing sessions

• App > Global > Global Data > Global Entities

  • Added [Apply] button to the editor to allow for easy checkpoint-saving for long editing sessions

• App > Global > Leaderboards > Leaderboards

  • The leaderboards page has been updated with improved column order — rank is now placed first, and the score is right after the player’s name.
  • A [Refresh] button was added for convenience.
  • Can now only [Reset] current leaderboards - not prior versions.

• App > Global > Multiplayer > Server Monitor

  • New details were added to the Server Preview Blade. Now shows custom environment settings and Max Nodes.

• User > User Browser

  • A new button on the User Preview Blade will allow you to view the selected user in a new tab.

• User > Social > Friends

  • The screen now displays the platform that a friend originates from

Plus, there have been significant improvements to the usability of the Design Portal on mobile devices.

API Changes

brainCloud 5.6 has no changes to APIs.

Libraries and Examples

Client Libraries

Release window - Updated Client and S2S libraries are made available within two weeks of the launch of the updated server software. Updated examples are made available in the two weeks after the client lib updates.

Unity

• The default API endpoint changed to api.braincoudservers.com instead of the legacy sharedprod.braincloudservers.com endpoint.

Unreal

• Compression is now enabled by default.
• The default API endpoint changed to api.braincoudservers.com instead of the legacy sharedprod.braincloudservers.com endpoint.

Java

• Implemented gzip compression to allow for requests and/or responses from the server to be compressed (disabled by default)

  • use compressRequests (boolean compressRequests) to compress requests before they are sent to the server
  • use compressResponses (boolean compressResponses) to tell the server to compress responses
  • use enableCompression (boolean enableCompression) to turn on compressed requests AND responses

JavaScript

• Fixed bug in canReconnect() – Previously, only empty (““ or length == 0) anonymous/profile IDs were being detected

  • Now properly checks for null and empty IDs

• Implemented gzip compression to allow for requests and/or responses from the server to be compressed (disabled by default)

  •  use enableCompressRequests = function(compressedRequestsEnabled) to compress requests before they are sent to the server
  • use compressResponses = function(compressedResponsesEnabled) to tell the server to compress responses
  • use enableCompression = function(boolean enableCompression) to turn on compressed requests AND responses

C++

• Implemented GZip compression to allow for requests and/or responses from the server to be compressed (disabled by default)

  • Currently tested on Windows / Linux / MacOS and Android (Still untested on iOS)

Example/Demo Libraries

Unity Examples

• Invaders

  • Username is now displayed on the main menu upon successful authentication

Documentation and Tutorials

Documentation

• All the latest API additions and changes have been incorporated into our doc site at docs.braincloudservers.com !
• We have started migrating our Knowledge Base at help.braincloudservers.com to French!

We sat down with CEO Mohammad Agha and Lead Developer Tri Truong to gain insights into Magmic’s decision to adopt brainCloud as the primary backend for their games.

About Magmic

Established in 2002, Magmic has developed and published over 100 mobile games, many of which have reached #1 in the Card and Board game categories on the App Stores. Some works include Mattel’s Phase 10, Blokus, and Hasbro’s Scattergories. With 250 million game downloads over 18 years, Magmic has a player base of millions of monthly active users. Across Magmic’s game library, the player base has accumulated billions of hours of play. Currently, Magmic is focused on developing AAA quality Free-to-Play casual games aimed at the mid-core market. Magmic games employ a proprietary event management system, full Live Operations capabilities, and a sophisticated Cross-Promotion SDK.

What were the primary challenges you faced before migrating to brainCloud?

We had a highly fragmented backend infrastructure:

• We had different versions of backends that we had to maintain as we were not necessarily updating older games but we had to keep them active. So we had lots of duplication.
• With all the duplicate backends our AWS bill was pushing $30K+ USD per month and that’s not including salaries of a four person backend team.
• When we were developing Texas Hold’Em King Live for the iPhone, we ran into many sync and latency issues with our legacy tech.
• We had different generations of our legacy backend built on different technologies - which required different developer skillsets to maintain. There was just a lot of inefficiency and lack-of-standardization in our backend code.

What tipped you over to deciding to migrate everything to a new BaaS?

We were spending well north of $400K USD per year on hosting fees, and the system wasn’t 100% reliable.  Add to that the management of servers crashing / going down in the middle of the night and we just always seemed to have an issue to deal with.

During the assessment process, were there any features of brainCloud that stood out as especially valuable for your business?

One of the standout features of brainCloud for our business is the Cloud Code functionality: It gives us the flexibility to develop our products in a way that fully meets our specific requirements. With Cloud Code, we can implement custom logic on the server side, streamline workflows, and optimize performance without needing to manage our own backend infrastructure. This has been invaluable for ensuring scalability, maintaining security, and integrating seamlessly with other cloud services and blockchain solutions. Overall, it allows us to stay agile and focus on delivering the best experience to our users.

What was the key feature or aspect of brainCloud that won the bid?

The real-time multiplayer aspects were what we were looking for initially but then we found a host of other features in there that we also found extremely useful, including Leaderboards, Data Downloads, In-App Purchase configuration and management, and User Login and management.

Is there a ballpark estimate that you would feel comfortable saying is a standard “time savings” that you get from having a standardized backend?

Yes, we no longer need to rebuild backend foundation features like authentication, leaderboards, multiplayer, and cloud storage from scratch, which saves us a significant amount of time—easily 2 to 3 months per project. Instead of allocating resources to backend infrastructure, we can focus more on developing innovative features. For example, in MLB Diamond Inc., our developers were able to shift their focus to building new online functions such as PvP gameplay, Marketplace, and Auction systems.

Can you summarize some of the qualitative outcomes of migrating to brainCloud?

We have seen the following benefits:

• Lower Costs: We estimate we are saving approximately $400K USD/year for AWS bill + $300K USD/year in dev salary for a total of $700K USD/year savings across all our titles.
• Higher Revenues: We started doing a lot more sales and player in-app time went up because our system was more reliable, we estimate 15% increase in IAP revenues.
• Server Reliability → DAU Increase: What we see is DAU [Daily Active Users] increasing more smoothly over time since we are experiencing no downtime. Previously it was common to have servers crash at 2AM – and every time the server goes down, the game loses users due to that. That does not happen anymore.
• Development Time: We estimate over 60%+ decrease in time spent on server development, and no more headaches due to server issues or downtime.

What was your top reservation or concern before the migration, and how did brainCloud meet that concern?

Our top concern was, “Will brainCloud do what we need it to do reliably, cheaply, and consistently? The answer was “yes” on all counts. Moving to brainCloud was clearly the right decision.”

Continue with Part 2 of this case study here.

Ready to try brainCloud for yourself?  Create a free account on our Public BaaS - or jump on a call with our Sales Team for more info!

brainCloud 5.5 has something for everyone: Retention Analytics, support for Dart and Flutter, Optimized Group Leaderboards, App Alerts, an Improved Matchmaking Monitor, Improved Security, and more!

Compatibility Notes

We work hard to preserve stability and backward compatibility for existing apps.

Developers should be aware of the following changes:

• Cancelling Find Requests: the LobbyService’s CancelFindRequest() method now requires an entryId be passed into it. This change was technically introduced in 5.4.X, but we note it here for completeness.
• Relay Servers: Significant improvements have been made to how the Relay Servers handle large matches (i.e., matches with more than 30 players). These improvements involve reusing abandoned slot IDs, a behavior change that may impact certain games. Therefore, we made the new software available as the “V3” Relay Server protocol. The protocol APIs themselves have not changed. Most games that work with V2 should work unchanged with V3.
• Group Leaderboards: 5.5 now stores Group Leaderboards in collections separate from regular Player Leaderboards. The older combined storage is still supported and is the default for existing apps. The new compatibility flag controls this behavior: “[x] Store user and group leaderboard scores in the same collection (slower).” This flag is enabled by default for existing apps and disabled for new apps. Changing this value for an existing app will make old group scores (written to the combined collection) inaccessible.

Release Highlights

Retention Analytics

Retention is a metric that indicates how effectively your app engages new users and entices them to return. It is measured over time and represents the percentage of users who return after 1 day, 7 days, etc.  

There are two common variations of retention - Classic Retention and Rolling Retention.

Classic Retention measures the percentage of users who return on a specific day (i.e., D+7 = day 7 - which is 7 days after their account was created). 

Rolling Retention measures the percentage of users who return on that day or any day thereafter.  (i.e., a user who returns on day 7 is also deemed “retained” on all previous days).  

Rolling Retention numbers will always be higher - and will reliably decrease over time – while Classic Retention stats will bump up and down (especially during the first week) - as some users may return on day 3 that didn’t return on day 2, etc.

Classic Retention helps measure the day-to-day engagement for the first week of your app - while Rolling Retention allows for greater generalizations about your app (i.e., 20% of players are still active after 1 week).

brainCloud’s new Retention Analytics screen displays both Rolling Retention and Classic Retention.

As you can see in the image below, the screen is quite dynamic and offers many ways to view this critical metric. 

Note that apps must be LIVE to generate retention analytics. These stats do not make sense for apps under development - so we do not generate them for Dev and Dev+ apps.

Related: Another metric is Churn - which is the percentage of players who stop using your app within a specific timeframe. brainCloud doesn't display it - but it is easy to calculate. Churn is the inverse of Rolling Retention. If your D+7 Rolling Retention is 20%, then the Churn after 1 week is 80%.

App Alerts

brainCloud 5.5 includes our new App Alerts feature. This feature will perform various checks on the health of your app - and display important information regarding its findings in your App Dashboard.

The initial alerts that can be triggered include:

• Apple Push Notifications - Reminders for devs to update their certs
• API Errors - Alerts if error levels are high or rising
• Logging - Alerts if the app is generating excessive logs
• Compatibility flags - Reminder to evaluate and disable unnecessary compatibility flags
• MFA Enforcement - Reminder to enable the new MFA Enforcement feature for live apps

We will continue to evolve and expand upon this feature in coming releases!

Dart and Flutter Support

Dart is a client-optimized language for developing fast apps on any platform. Developed by Google, Dart is similar to JavaScript but is simpler, faster, and more user-friendly.  When paired with the Flutter UI framework - it is a highly productive foundation for building cross-platform applications.

brainCloud 5.5 includes our new Dart client library, which supports all of brainCloud's features and services - including RTT and Relay Comms.  You can find the source for the library on GitHub - and the package itself on pub.dev, the official package repository for Dart and Flutter apps.

Security Improvements

Security has always been a key concern for the brainCloud Platform - and this release makes two key platform improvements in this area.

Brute Force Protection for User Accounts

A brute force attack is a hacking method that uses trial and error (often in a sequential organized fashion) to crack passwords or login credentials.  

brainCloud’s new Brute Force Attack Protection feature thwarts these attacks by blocking the ability to login to an end-user account after an escalating number of bad attempts – similar to how your smartphone makes you wait between login attempts when you get the password wrong.

The feature is enabled and configured on the new App > Design > Security > User screen.

It works like this:

• brainCloud counts the number of bad login attempts in a row for end-user (e.g., player) accounts. Bad logins increment the count. Good logins reset the count to zero.
• If the # of bad attempts exceeds one of the escalating thresholds, the account becomes “blocked,” during which both good and bad login attempts are rejected… ← this is key - if we allow “good” login attempts while blocked, we won’t stop the attack!
• Note that while the account is blocked - the block time does not extend with each new login attempt - if we did, the lock time would quickly escalate to an unworkable value. So login attempts while blocked are essentially ignored - though we do increment the bad login count appropriately. We do NOT extend the “blocked until” time while the account is blocked.
• Eventually, the “block” will timeout - after which - the next login attempt will be considered. If it’s good - the user will log in - and the bad login count will be cleared to 0.  If the login attempt is bad, the count will increment - and become “blocked” again for a duration appropriate to the new threshold level.
• If Sendgrid integration is enabled - the user can enable emails that will be sent to the user each time the account becomes “blocked” due to this feature.

Important - during the period that logins are “blocked” - both bad and good logins are rejected. Note that anonymous reconnects are by default NOT blocked - so users already logged into a device are not inconvenienced by the attacker’s activity.

Unblocking End-user accounts

The User Summary page has been enhanced to show additional information regarding bad login attempts. See the Portal Updates section for more details.

What about Brute Force Protection for Portal Accounts? 
brainCloud already provides this sort of protection for Portal accounts. And the new Team MFA Enforcement feature (below) makes these accounts even more secure! 

Team MFA Enforcement

This feature adds additional protection to a developer’s Team Member (i.e., Portal) Accounts. 

brainCloud has long supported MFA authentication for Portal Accounts - but now Team Administrators can make MFA mandatory for all Team Members. This is done via the Team > Setup > Team Info screen.

Once enabled, only Portal Users using MFA will be allowed to log into the team.  

Team members not using MFA can configure it from the Team Selection screen by clicking the Enable MFA or the [Edit Security] button.

Note that for Private Licensees, SSO-based Portal Users are treated as MFA-enabled - as it is assumed that MFA is provided by their SSO solution.

Additional Improvements

Release 5.5 includes a ton of other improvements as well. These include:

• API Improvements

  • New APIs have been added to the AppStore, Authentication, and Lobby services. See the API Changes section for more details.

• [Refresh] App Metrics

  • App metrics are daily processes that aggregate and calculate various statistics about your app - such as API Usage, sales aggregation, retention data, etc.
  • In some rare circumstances - the calculation of those metrics may be interrupted.
  • To re-trigger the calculation of the metrics - navigate to App > Design > Admin Tools > Cache and click [ Refresh Metrics ]

• Client-Server Protocol

  • We have improved our protocol handling so that client retry attempts are now properly compressed (when applicable)

• [Optimized] Group Leaderboards

  • Before 5.5 brainCloud, player- and group-based leaderboards were stored in the same collections. This is not optimal - especially when dealing with large [sharded] leaderboards. brainCloud now stores player-based leaderboards and group-based leaderboards separately.  
  • A new compatibility flag controls this behavior. When enabled, the flag preserves the old behavior. The flag is enabled by default for existing apps and disabled for new apps.

• Hosted Servers

  • A new "Retrieve Logs" option was added, which determines whether the logs from successful room/relay server sessions will be retrieved. By default logs will only be retrieved if the container exited with a non-zero result.

• Matchmaking Monitor

  • The Matchmaking Monitor has been enhanced to show stats for how fast players are launched into actual matches.  ← Before the stats stopped at being added to a Lobby

• Portal SSO and Builder API

  • The Builder API has been enhanced to support dynamic authentication as an OAuth SSO Provider
  • This allows Private and Platform Licensees to build custom applications that use brainCloud’s Portal Accounts for authentication - and access brainCloud’s Builder API via new dynamic [and temporary] API keys
  • Note that this SSO Provider is for portal accounts only - not the end-user accounts of brainCloud apps [that is a future feature under consideration]

• S2S IP Security for Room and Relay Servers

  • brainCloud can now dynamically restrict the S2S interfaces associated with Room and Relay servers to the IP addresses of the currently running servers.
  • To enable this feature - go to App > Design > Servers > My Servers, choose the appropriate server type, and enable IP Security.  

• Relay Server Improvements

  • Improvements for when dealing with larger player counts
  • Ability to restrict relay comms to less than 40 players (now defaults to max of 32 for webgl compatibility)
  • Improved disconnect handling
  • Note that the above improvements are all made available via the “V3” version of the Relay Server. The behavioural changes are very subtle and shouldn’t impact the great majority of apps. We highly recommend that devs using “V2” upgrade to “V3” in their test apps (no API changes) and upgrade production when convenient.

Portal Updates

We continue to rapidly evolve the Design Portal.

Team Menu

The flag to enable Team MFA Enforcement has been added to the Team > Setup > Team Info screen.

App Menu

App Dashboard

The new App Alerts section is front and center on the App Dashboard.

We have also added your Client Library version to the App Profile section.

Cloud Code (rendered view)

We’ve added an option to view the rendered version of a cloud code script.  If the [x] Show Rendered option is enabled, the editor shows a read-only view of the script with all included scripts shown inline. This view matches the version of the script that brainCloud keeps cached for runtime execution.

Security

This release consolidates App-related Security sections under App > Design > Security.  

You will find the old settings from App > Design > Core App Info > Security here, as well as the new Brute-Force Protection settings. 

Matchmaking Monitor

The Matchmaking Monitor has been enhanced with a new screen that shows a summary of matchmaking activity across all lobby types.

Click on any row to navigate to the detailed monitoring charts for that Lobby Type.

The details screen has been enhanced to show how long it takes for matches to launch on servers.

The time displayed includes the time it takes to spin up a container (on-demand) - as well as the time to cold-launch a node (server) for the container to run upon (if applicable).

Blocked Users

The User Browser (preview blade) and User Summary screens now show information about Bad Login Attempts and whether a user has been blocked. There are also controls that allow a Team Member to [UNBLOCK] the user and/or [Reset] the bad login attempt count.

Retention Analytics

The new Retention Analytics screen can be found at App > Reports > Analytics > Retention.

Previous day usage

In addition to Today and Yesterday - the API Usage and API Errors screens now include a tab labeled “Previous,” - which displays the stats for the day before yesterday.

API Changes

The following changes and additions have been made to the brainCloud API:

• AppStore Service

  • New API for rewarding products (without a corresponding purchase)
  • New API for recording a purchase (for cases where purchase is handled by custom client code).

• Authentication Service

  • Password reset calls are now accessible from cloud code
  • New GetServerVersion() call available to retrieve the brainCloud server version before authenticating.  This is useful for our example apps.

• Bridge (cloud-code only)

  • New DeleteSessionCacheObject() method - useful if you only need a session cache object temporarily - like when passing information from a pre- to post-hook script.

• Event Service

  • New SendEventToProfiles() method allows for sending the same event to multiple users

• Friend Service

  • New GetProfileInfoForCredentialIfExists() method is the same as GetProfileInfoForCredential() - but skips writing the log entry if the credential doesn’t exist

• Group Service

  • The UpdateGroupAcl() and UpdateGroupEntityAcl() methods are now available from the client libs; previously, they were cloud-code only.

• Identity Service

  • The GetIdentityStatus() method is now available from the client libs

• Leaderboard Service

  • The PostScoreToDynamicGroupLeaderboardUsingConfig() method is now available from the client libs. This method should be used instead of PostScoreToDynamicGroupLeaderboardUTC() and PostScoreToDynamicGroupLeaderboardDaysUTC().

• Lobby Service

  • The CancelFindRequest() method now requires an entryId as a parameter. The entryId is included in the response from the various Find Lobby API calls.
  • New SYS APIs: SysCreateLobby(), SysCreateLobbyWithPingData(), SysGetLobbyData(), SysAddMember(), SysAddMemberWithPingData(), SysRemoveMember(), SysUpdateSettings()

• Mail Service

  • New SendAdvancedEmailByAddresses() method for sending a single email with multiple addresses in the “to:” list.

• PlaybackStream Service

  • The ProtectStreamUntil() method has been added to the client libs. This allows a developer to keep a playback stream around for longer than the default – which is currently 150 days in our Public BaaS.  Extending specific streams is helpful for games that use the streams for ghost replays - and want to keep “featured replays” around longer.

• [New!] Report Service

  • SysGetLatestReport() - returns the data from the latest generated report (of the specified type).
  • SysGetReportForStartDate() - returns the data from the specified report.

Libraries and Examples

Release window - Updated Client and S2S libraries are made available within two weeks of the launch of the updated server software. Updated examples are made available in the two weeks after the client lib updates.

Client Libraries

All Libraries

• All new and missing methods were added as described in the API Changes section.

braincloud-csharp (C#/Unity/Godot)

• Created overloaded FindLobby functions that do not require timeoutSecs parameter. Original functions have been deprecated.
• Improved country/region code retrieval for UWP with Windows.Globalization
• Improved error-handling for Relay Comms ordered packet IDs management
• Fixed issue with WebSocket in WebGL on iOS where the browser resets due to running out of memory

braincloud-unreal-plugin (Unreal)

• Implemented request/response compression

• RTT bug fixes/improvements

  • Fixed issue where the disconnect callback wasn't being triggered in a situation where RTT connection is lost from internet connection becoming unavailable (tested by not sending heartbeat messages)
  • Fixed issue where calling EnableRTT twice before a connection is established causes connection issues, the function is now safeguarded from double calls
  • Fixed issue where received RTT messages were incorrectly processing special characters / non-ASCII characters

braincloud-js (JavaScript)

• Fixed bug in attachAdvancedIdentity function

  • The conditional statement for optional externalAuthName was not checking for authenticationSubType correctly

braincloud-dart

• A brand new library with full support for all brainCloud APIs - including RTT and RelayComms

• The source can be found in the following github repos:

  • braincloud-dart - the core dart library. No flutter dependencies.
  • braincloud-dart-persistence - An add-in library that utilizes Flutter to implement the persistence required by the brainCloud wrapper. It is highly recommended that devs use this with the core library.

• The packages can be found on pub.dev at the following locations:

  • braincloud - the core library package
  • braincloud_data_persistence - (see description above)

S2S Libraries

No changes in this release.

Examples

All examples will be updated to use brainCloud 5.5 in the coming weeks (generally 2-4 weeks after release).

Documentation and Tutorials

BootCamp

• No changes

Documentation

• All the latest API additions and changes have been incorporated into our docs.

brainCloud 5.4.1 isn't a full release - but there have been enough tweaks and improvements to warrant a page describing them.

Features and Improvements

PlaybackStream Protect API

brainCloud 5.4 added Sys APIs for PlaybackStreams - to make them more convenient for use as ghost players, community members in hub worlds, etc.

A challenge, however, is that PlaybackStreams are automatically deleted 90 days after creation. This may not be desirable in all use cases.

To address this, we have added new APIs to "protect" a stream from automatic deletion for a number of days. This API can be called periodically to keep specific playback streams around in perpetuity...  (For example - a cloud code script could be written to run daily to protect the "featured" replays of the system for days into the future).

The new calls are ProtectStreamUntil() and SysProtectStreamUntil().

Apple Receipt Validation Improvements (and a new warning)

We have addressed a scenario where brainCloud was not validating the bundle id for old legacy-style receipts -- even if the bundle Id has been correctly entered on the App > Design > Core App Info > Application IDs page. This has been fixed.

That said - we remind devs that the Bundle ID field, although optional, does allow brainCloud to further validate that the receipt provided is from proper app. It is highly recommended that developers using Apple's AppStore for In-App Purchases fill in this value!

To encourage the use of the field, we have added a new warning for Apple purchases made without validating the bundle ID. The warning includes the bundle ID present in the used receipt.

The message looks like this:

Purchase security warning - iTunes bundle id should be set for greater security. Purchase with bundle id '' still processed.

You can search for these warnings using the following log filter:

• service: appStore
• operation: VERIFY_PURCHASE

We have added a new warning message to the system as a reminder to fill it in and as a confirmation of what bundle ID was currently used. Developers can use the warning to confirm what value should be entered on the page and look for fraudulent entries.

View Leaderboard and Group users in a separate tab

We have expanded our UI paradigm to allow viewing users in a separate browser tab - without otherwise losing the context of where the team member is in the Portal. 

For now we have added this feature to just the Leaderboard and Group screens - but we'll be adding more support in coming releases.

Miscellaneous fixes and improvements

Server fixes and improvements

• BCLOUD-7437 - Fixes to user rate limiting
• BCLOUD-8468 - Server request-response log - add incoming IP to ERROR MESSAGE instead of RESPONSE
• BCLOUD-8869 - Add support for existing filters to the export functionality
• BCLOUD-9262 - Performance improvement: now reading shard count at beginning of matchmaking run
• BCLOUD-9285 - Change to the "never" Global Entity expiry value to prevent issues in javascript
• BCLOUD-9315 - Added new PlaybackStream APIs: ProtectStreamUntil, SysProtectStreamUntil
• BCLOUD-9356 - Modified support for CANCEL_FIND_REQUEST to require an entryId to work; without it the call is a no-op
• BCLOUD-9357 - Increment user's failedRedemptionsTotal for each RedeemCode attempt after being locked out
• BCLOUD-9358 - Removing support for lobby entry queue v2 (everyone is on v3 now)
• BCLOUD-9378 - PortalX is loading uppercase email address and the Server is not automatically lowercasing it
• BCLOUD-9379 - Spelling mistake in Amazon IAP error message
• BCLOUD-9386 - Global Entities count on list screen including expired entities
• BCLOUD-9390 - Bug fix for treating a full team as a full lobby during lobby join
• BCLOUD-9393 - Builder API Create a cloud code script returned error
• BCLOUD-9398 - Builder API Team Level - Fix for out-of-date updatedAt value
• BCLOUD-9400 - Request/Response entry pairs not matching on sequenceId
• BCLOUD-9411 - Log all APP packetId-related errors as APP WARNING (not APP ERROR)
• BCLOUD-9425 - Added missing ENV variables for Edgegap servers
• BCLOUD-9447 - Compress cached last response if size is greater than maxLastResponseSizeBytes
• BCLOUD-9483 - Add pre-truncated request size to log when truncating it
• BCLOUD-9508 - Updated billing logging
• BCLOUD-9513 - Billing fixes… (had mistakenly treated some values at bytes instead of straight counts)
• BCLOUD-9528 - less strict on Lobby RemoveMember and UpdateSettings
• BCLOUD-9532 - optional (via brainCloud Property) logging of downloads
• BCLOUD-9542 - Validate range parameter in file servlet rather than passing on to CDN
• BCLOUD-9568 - Added ‘skip_telemetry’ parameter to Edgegap session creation
• BCLOUD-9581 - Added legacy sandbox receipt bundle id validation

Portal-X fixes and improvements

• BCLOUD-9336 - Fix issue in displaying brainCloud properties that have been overridden 
• BCLOUD-9361 - Hide RTT session chart on App Dashboard if RTT is not enabled
• BCLOUD-9365 - When creating global entities, the entity type should be selected by default
• BCLOUD-9370 - Fixed sort order in Server Monitor screen
• BCLOUD-9371 - Fixed percentage errors display in Script Usage panel
• BCLOUD-9377 - Added toast message failures during Export Configuration
• BCLOUD-9385 - Fixed Global Entities Export
• BCLOUD-9405 - Improvements to Universal Search SCREEN results presentation
• BCLOUD-9406 - Global Files - fixed issues around recovery folder
• BCLOUD-9407 - Updates and fixes to user request+response logs
• BCLOUD-9408 - Add the ability to view player/group in a new window/tab
• BCLOUD-9414 - Fix to display job results for all run states except Scheduled
• BCLOUD-9426 - Show “Loading…” for screen title text when loading screen data
• BCLOUD-9438 - Fixed issue with modal popup when no folders are present.
• BCLOUD-9439 - Fix issues in Global Files File Path & File Tree
• BCLOUD-9512 - Fixed Number (decimal) field issue in brainCloud Properties Dialogs
• BCLOUD-9582 - Addressed vulnerability CVE-2022-25927
• Plus - fixed formatting of available funds value in Team Billing info

brainCloud BaaS will be upgraded to MongoDB 6.0 on Wednesday, September 25th, starting at 8pm Eastern.  It is a rolling upgrade that may take up to 3 hours to complete.  All API and Portal services will be fully available during the upgrade. The Portal will NOT be disabled.

Note that all brainCloud Private Instances will be upgraded in the following weeks - before October 31st, 2024.

brainCloud 5.4 has been tested to be fully compatible with MongoDB 6.0.

That said, MongoDB 6.0 contains an Important Change that brainCloud developers must be aware of:

In MongoDB 6.0, $regex Find Queries No Longer Ignore Invalid Regex.  This means that while invalid $regex expressions were ignored in MongoDB 5.0 -- in MongoDB 6.0, the same query will return an error.

For example, in MongoDB 5.0, the following query, which includes an invalid regex option (i.e., "bad"), returns a successful database response with a document.

In MongoDB 6.0, that same query returns an error from the database - thus, brainCloud also returns an error.

This change only affects brainCloud's list and paging-style calls (which accept custom query JSON) - and ONLY apply if the developer-provided queries have invalid $regex or $options.  These calls include:

• Custom Entity - GetEntityPage(), SysGetEntityPage()
• Entity - GetList(), GetListCount(), GetPage()
• Global Entity - GetList(), GetListCount(), GetPage(), GetSystemEntityList() GetSystemEntityListCount(), GetSystemEntityPage()
• Group - ListGroupsPage(), GetRandomGroupsMatching(), ReadGroupEntitiesPage(), SysGetRandomGroupsMatching(), SysListGroupsPage(), SysReadGroupEntitiesPage()
• Item Catalog - GetCatalogItemsPage(), SysGetCatalogItemsPage()
• Leaderboard - SysGetLeaderboardConfigsPage()
• Messaging - GetMessagesPage(), SysGetMessagesPage()
• RedemptionCode - SysGetCodeTypePage()
• User - SysGetPage()
• User Items - GetUserItemsPage()

So - in summary:

• If your app isn't using $regex expressions in your query - you have nothing to worry about
• If your app is using VALID $regex expressions and valid $options - you have nothing to worry about
• If your app is using INVALID $regex expressions or $options - then brainCloud may now flag that error

A description of MongoDB 6.0 $regex and $options can be found here.

Feel free to reach out to brainCloud Support if you have questions.