Hi folks,

We wanted to notify you that we have discovered (d’oh!) and fixed (yay!) an error with the RTT Concurrent Connection (i.e. CCx) statistics that brainCloud was collecting for billing purposes.

This error meant that we were undercharging for RTT utilization — and the fix means that the under-charging will stop – and thus, the bills for heavy-usage RTT customers will increase slightly (boo!).

The good news is that we aren’t looking to recoup the years of under-billing. And the better news is that RTT usage pricing is already (and remains) quite inexpensive – so the overall impact on an app’s monthly brainCloud bill is quite small (if anything!):

• Apps whose usage is within the Free CCx counts of their plan won’t see a change at all. 
• For high-usage apps, the average impact is only about 2%. 
• And of course, app’s that aren’t using RTT are not affected at all.

Apologies for the error!

Paul.

—

More information about the defect:

As we were collecting CCx statistics from the multiple RTT Event Servers, we were mistakenly clobbering the server-specific values instead of aggregating them together. This meant that we were actually undercharging by a factor of 3… (i.e. charging only for one server’s worth of connections, while an app’s connections are actually spread across three servers).

Once again – apologies for the error. 

As you are hopefully already aware, our long-awaited Dormant User Account pricing goes into effect for the February 2023 billing cycle… (which invoices on March 1st, 2023).

There are a few additional pricing tweaks, including new bulk-pricing plans, that will become active at that time as well.

Read on for more details!

Dormant User Accounts

brainCloud defines a Dormant User Account as any account where the user hasn’t logged in the app in the past 365 days. These users add no value to your game (e.g. they are probably anonymous and have already uninstalled your app!) – but they do significantly increase costs (including deep data usage) — and slow down your apps. In July 2022, over 50% of brainCloud storage and backup costs were due to dormant accounts!

Beginning with the February 2023 billing cycle, which is invoiced on March 1, 2023, brainCloud apps will be charged $75 / month per Million dormant users (pro-rated). That is not a lot – though for some apps it would be – but ideally we don’t want to collect any Dormant User revenues at all — we are looking for the cost savings! That’s why we have our Auto-deletion service!

For instructions on enabling Auto-Delete to reduce and/or eliminate a Dormant User Account pricing charge, see the bottom section of our previous post.

Hosting Pricing Changes

After some deep-dive usage analysis, we have determined that we need to adjust the costs that we charge for hosting Room and Relay Servers. The current formulas were not accurately reflecting the full costs of providing the service – which need to include:

• server hosting costs
• disk storage costs
• data transfer costs
• cloud service support costs ← which is a percentage on top of all costs that our cloud provider (AWS) charges as part of our support plan

Therefore, beginning with the February 2023 billing cycle, which is invoiced on March 1, 2023, the prices for brainCloud Hosting services are changing as follows:

• Hosting Server markup – will be increased from 15% mark-up to 25% markup
• Hosting Management cost – will increase from 1.5 cents per server hour to 2 cents per server hour

Note – these changes only affect customers using brainCloud’s RelayServer and RoomServer hosting services. Customers not using these services (or using their own GameLift accounts instead) are not impacted.

Deep Data Pricing Reductions

In the good news category, a similar deep-dive analysis has determined that we can safely reduce our deep data pricing!

Therefore, beginning with the February 2023 billing cycle, which is invoiced on March 1, 2023, we are decreasing the Deep Data Storage pricing by 10% – from $0.50 / GB / day -> $0.45 / GB / day!

We are also increasing the included (free!) Deep Data Storage Usage units for Business+ Plan customers from 10GB -> 20GB.

As always, we encourage developers to monitor their deep data usage (especially from Custom Entities), and ensure that unused collections are deleted (i.e. especially in cases where collections were temporary migration collections) – and that apps are making use of our TTL (Time-to-live) feature to automatically clean up temporary entities over time.

New Bulk+ (Pre-purchase) Plans

Finally, brainCloud is introducing four (4) new plans for our highest-volume customers.

These plans allow customers to pre-buy a large quantity of API Requests for a discount – with additional savings on Deep Data Storage, File Transfers, and Dormant User Accounts.

Note that as these are pre-purchase plans; customers are charged the live fee amount at the beginning of the month – and pay for usage for the period at the end of the month as usual. This differs from our regular plans, where all charges are incurred at the end of the month.

The new plans are:

• Bulk+ 100M($955 / month)
  • Includes 100 Million API calls at a savings of $75. Additional API calls start at $9.50 / M.
  • File transfers discounted 3% to $0.145 / GB, and free transfers bumped up to 100 GB.
  • Deep Data Storage discounted 7% to $0.42 / GB / day, and free storage units bumped up to 50 GB.
  • Dormant User pricing discounted 5% to $71.00 / Million
• Bulk+ 250M($2,205 / month)
  • Includes 250 Million API calls at a savings of $250. Additional API calls start at $9.25 / M.
  • File transfers discounted 7% to $0.14 / GB, and free transfers bumped up to 250 GB.
  • Deep Data Storage discounted 13% to $0.39 / GB / day, and free storage units bumped up to 100 GB.
  • Dormant User pricing discounted 10% to $67.50 / Million.
• Bulk+ 500M($4,115 / month)
  • Includes 500 Million API calls at a savings of $650. Additional API calls start at $9.00 / M.
  • File transfers discounted 13% to $0.13 / GB, and free transfers bumped up to 500 GB.
  • Deep Data Storage discounted 24% to $0.34 / GB / day, and free storage units bumped up to 200 GB.
  • Dormant User pricing discounted 15% to $64.00 / Million
• Bulk+ 1B($7,705 / month)
  • Includes 1 Billion API calls at a savings of $1,500. Additional API calls start at $8.50 / M.
  • File transfers discounted 20% to $0.12 / GB, and free transfers bumped up to 1000 GB.
  • Deep Data Storage discounted 33% to $0.30 / GB / day, and free storage units bumped up to 400 GB.
  • Dormant User pricing discounted 20% to $60.00 / Million.

Full specifics for the new plans will be posted to getbraincloud.com in early 2023.

These new plans will become available in time for the March 2023 billing cycle – and depending upon interest – potentially as early as January 2023. Note that when these plans become available, they will include all the pricing changes discussed above (even if they are released before the February billing cycle).

Feel free to reach out to support if you have further questions about these plans.

This is a small, targeted release with a few key improvements. This is also our last planned release before the December holiday season.

Note that this is a server-only release. There are no changes to the client libraries.

Release Highlights

Client API Blocking

We have added a new feature that makes it easier to secure your app from mischievous players.

Devs have always been able to add an API Pre-hook to block specific calls from the client – but this is painful to set up – and results in additional API counts for the app.

Configuring the new API Blocking feature is as simple as going to the new Design | Cloud API | API Blocking page, and selecting the Services + API Calls to block. Hit SAVE and you are done! (Or more likely, you are once you deploy those changes to your production app.)

We hope this new feature helps our customers to keep ahead of their most competitive (and ill-mannered) players.

Note that this feature requires a Plus plan to activate.

Note also that certain calls, like the Award(), Consume() and Reset() currency calls, may already be blocked from the client depending based on the compatibility settings on the Design | Core App Info | Advanced Settings page.

Leaderboard “Days” rotation increase

This is a small change – but apps using the arbitrary “Days” rotation for their leaderboards can now set the rotation as high as 28 days…. ← the previous limit was 14 days.

Portal Changes

We’ve made the following portal changes:

Design

• Cloud Code | API Blocking
  • A new screen that allows devs to block specified APIs from being callable from the client.

• Leaderboards | 
  • Leaderboards can now be configured with a 28 day rotation.

API Changes

There are no changes to individual API calls, but the new API Blocking feature means that any client API call can now return the following error:

{
  "status_message": "Processing exception (message): Call blocked from client.",
  "reason_code": 40346,
  "status": 403
}

Miscellaneous Changes / Fixes

• Additional Fixes
  • BCLOUD-3305 and BCLOUD-3331 – Improvements to resetting of end-user passwords. Now preventing double-clicks, and waiting until code has been successfully changed to remove the link code.
  • BCLOUD-3109 – Improvements to json response exception reporting from scripts
  • BCLOUD-3295 – Corrected permissions check on app passwords feature
  • BCLOUD-1518 – Fix to lobby screen – disband on start no longer automatically selected
  • BCLOUD-3362 – Fix to serialization issue for cloud code version of LobbyService.GetLobbyInstances()
• Plus miscellaneous fixes and performance enhancements…

brainCloud 4.13 has just dropped. Here’s what it contains…

App Minimum Password Standards

This feature allows developers to set minimum password requirements for the users of their apps.

The following requirements can be set:

• minLength – chars. Default 8
• maxLength – chars. Default is 25 (max is 128).
• minDigits – . Default 1
• minUppercase – . Default 1
• minLowercase – . Default 1
• minSymbols – . Default 1

Feature notes:

• This feature affects users when setting new passwords. Existing passwords already associated with an account are not affected by this feature.
• For symbol enforcement, the following characters are treated as symbols: ~!@#$%^&*_-+=`|(){}[]:;'<>,.?/

If enabled, these standards are automatically enforced by brainCloud when:

• creatingnew accounts
  • using Email or Universal authentication
  • using following User service APIs (if a password is provided – generated passwords will not be verified):
    • SysCreateUserEmailPassword
    • SysCreateUserUniversalId
• attaching new Email or Universal identities
• updating passwords (via reset password and other mechanisms)

Attempting to create an account (or attach an identity) whose password does not meet the requirements will return the new INVALID_PASSWORD_CONTENT ( 550022) reason code.

{
  "status_message": "Processing exception (message): Password should have minimum 1 uppercase character/s",
  "reason_code": 550022
}

Temporary Leaderboards

Apps can now more easily create temporary leaderboards using the SysCreateLeaderboardConfig() call. A new field, expireInMins, has been added to the configuration object to control the lifetime of the leaderboard. Leaderboards set to expire will show an epoch timestamp the expiry field returned from SysGetLeaderboardConfig() and other methods. The system will automatically remove the leaderboard after the specified time has expired.

Technically the clean-up is done nightly, but those are just implementation details.

This provides a convenient method for creating temporary leaderboards, without having to implement a separate process to clean them up.

Note that this functionality is limited to ADHOC and NEVER rotation leaderboards (i.e. leaderboards that don’t rotate).

Resend Verification Emails

For apps with Reject Unverified Email Logins enabled (via the Design | Authentication | Email screen) — the system will now automatically resend the verification email to users when they re-attempt to login.

GameLift-based Relay Servers

We have extended our AWS GameLift integration to include support for Relay Servers.

For instructions on how to configure them, see this article.

Non-consumable IAP Product History

Non-consumable In-App-Purchases can be processed multiple times (unless the “Do not reprocess currencies for non-consumable IAP products in receipts” compatibility flag is enabled).

This can be triggered when an iOS user clicks [Restore Purchases] on an app. Doing so may cause the transaction to be moved from one brainCloud account to another… (for example – if the iOS user is using a different brainCloud account than when they originally made the purchase).

Note that this sort of activity could also theoretically happen if your app has been cracked and users are sending stolen (but valid) receipts into brainCloud.

We have enhanced the system to keep track of all users that have processed a non-consumable IAP item. The processing history can be viewed by clicking on the new View History menu option on the Monitoring | User Monitoring | Transactions screen.

Library Improvements

All client libraries have been updated to include the 4.13 API additions.

Note that some of the listed improvements were included in 4.12 patches previously.

• C++
  • Upgraded WebSockets for RTT with embedded SSL certification
  • Reconnect() method returns a failure if previous connection information is not available
  • Improved build time in Objective-C
  • Improvements for Android Studio builds
  • Added response codes and API calls
• Java
  • Added 502 & 504 response code conditions to retry requests.
  • Reconnect() method returns a failure if previous connection information is not available
• Javascript
  • Reconnect() method returns a failure if previous connection information is not available
• Unity
  • Compressed Responses and Requests are now turned on by default. This should be transparent to your app – but can be disabled by setting EnabledCompressedRequests(false) and EnableCompressedResponses(false).
  • Reconnect() method returns a failure if previous connection information is not available
  • Adding Mac OS support for getting country code while initializing the client
  • Now supports Unity up to 2021.3 LTS
• Unreal lib
  • Plugin supports and ready to use in Unreal Engine 5
  • Fixes to engine heartbeat not working as intended (also in 4.12.2 patch)
  • Reconnect() method returns a failure if previous connection information is not available
  • Moved plugin to standalone release in GitHub for use as git submodule (Improved setup in GitHub?)
  • Fixed MacOS build error
  • Added check for failed connection callback

Miscellaneous Improvements

• ACL Permissions fixes
  • Fixes have been applied to several methods in Global, User and Group Entities.
  • Be sure to double-check the ACL permissions of you entity objects if you see issues with your app(s)
• Custom Entity improvements
  • New IncrementSingletonData() API call
  • Improved locking for Custom Entity Singletons
• Deployment improvements
  • Improvements to the web and server components to prevent parallel deployment / import / restore processes
  • Optimizations to cache notifications to reduce the traffic across the api servers
  • Added a fail-safe refresh after deployment to ensure that all caches are updated properly
• Dormant User processing
  • Refactored dormant user deletion to add parallel processing (across datastream servers)
• Global Files
  • Fixes to file versioning during deploys and imports (was also patched late in 4.12)
  • New portal function to manually edit a File’s version on the Design | Custom Config | Global Files page
• Groups
  • The custom data section of Group objects are now indexed on an indexedId field (if it exists). Feel free to set that field, and do searches using it for quick lookups of groups via an alternate id.
• Legacy Flagged Users API
  • We’ve added an API for controlling the users that that appear in the Portal’s flagged users list.
  • This is legacy system, and not super-scaleable – and thus we have named the methods as such.
  • Important: Apps are limited to 1000 flagged users max.
  • The API methods can be found in the GlobalApp service. ← due to the legacy of it’s implementation
  • Do NOT use these APIs for anything other than tagging users to make them easier to look-up in the portal.
• Push Notifications
  • Improvements to performance of Push Notifications sent to all users of an app
• S2S API
  • Significant improvements to S2S locking – prevents lock timeouts in certain situations
• Steam integration improvements
  • Steam purchase transaction ids are now prefixed by the appId of the brainCloud app processing them. This reduces situations where the ids may clash if the same Steam information is being used across both dev and production apps in brainCloud.
  • System now returns more useful information for failed SteamClient validations

Features for Private Licensees

• Portal SSO
  • Improvements to handling of mixed-case email addresses for SSO-connected private deployments
• Azure
  • Improvements to handling of long-lived Azure ServiceBus requests

Portal Changes

We’ve made the following portal changes:

Design Section

• Authentication | Passwords
  • New Passwords screen allows apps to enforce minimum password standards

• Cloud Code | API Hooks
  • Hooks are properly ordered by Service, then Operation in the main screen
  • Also, when selecting a script for a hook, the scrips are now sorted alphabetically by path
• Cloud Code | Scripts
  • Quick Authenticate now ensures it chooses a platform that is enabled
  • Optimizations to the script editor – no longer retrieves all scripts when attempting to run the current script!
• Custom Config | Global Files
  • You can now manually adjust the “version” of a file using by choosing Adjust Version from the Action menu.
• Integrations | Blockchain
  • Added new Ultra App blockchain integration to be used by Ultra licensee apps to enable integration with Ultra’s blockchain services – including Uniqs.

Monitoring

• Global Monitoring | Custom Entities
  • Custom Entity collections now displayed in alphabetical order
• User Monitoring | Transactions
  • The processing history of a non-consumable transaction can now be viewed by choosing the View History option from the action menu. Note that the View History menu option will only be available for transactions that have history to view.

API Changes

The following changes/additions have affected the brainCloud API:

• Blockchain
  • New GetUniqs() call added for retrieving Uniqs from the Ultra blockchain
  • Also new GetBlockchainItems() for other blockchain flavors
• Bridge
  • New VerifySignedJwt() method added to the cloud code bridge to aid in implementing OpenId via External Authentication
  • Added GetSessionForValidatedCredential() method to the client bridge… (was only in the server bridge before)
• Custom Entity Service
  • New IncrementSingletonData() API call
• GlobalApp
  • New methods for controlling the users that appear in the Portal’s flagged users list. This is legacy system, and not super-scaleable – and thus we have named the methods as such. Do NOT use these APIs for anything other than tagging users to make them easier to look-up in the portal.
  • Important: Apps are limited to 1000 flagged users max.
  • The new methods are: SysAddLegacyFlaggedUser(), SysGetLegacyFlaggedUserData(), SysGetLegacyFlaggedUserDataList(), SysRemoveFromLegacyFlaggedUsers(), SysUpdateLegacyFlaggedUser()
• Group Service
  • New cloud code only SysAddGroupMember() call adds the specified member to the group immediately (irregardless of the permissions of the current user)
• Leaderboard Service
  • SysCreateLeaderboardConfig() and SysEditLeaderboardConfig() methods updated to access the new expireInMins field. Select methods like SysGetLeaderboardConfig() now return an expiry field with the calculated epoch expiry.
• RTT
  • New RegisterBlockchainCallback() and DeregisterBlockchainCallback() methods enable registering for real-time blockchain changes
• Script Service
  • Added new cloud code only SysCancelScheduledScriptIfExists() call which as the name implies, cancels a script if it exists – but more importantly, does not return an error if it does not!
  • Added new cloud code only SysCancelUserScriptBatchIfExists() to do the same for batch script processing

Miscellaneous Changes / Fixes

The following issues have been addressed in this release:

• BCLOUD-1257 – Getting NPE When Paginating in the Server logs Page
• BCLOUD-1728 – [Internal] The “Localize in” field stuck when user made a changes and click on Cancel button
• BCLOUD-2050 – [Internal] Cloud Code – Scripts page, when user “Export All Scripts” and single “Export Script” in the TEAM | Audit Log shows duplicate entries for the exported
• BCLOUD-2084 – JoinDivision and SysGetLeaderboardConfig responses to include timestamp division set instance leaderboard was created at
• BCLOUD-2113 – Missing translation “Details for” on Monitoring | Global Monitoring | Redemption Codes page
• BCLOUD-2114 – Missing translation “Error! Invalid search criteria. Please enter a minimum of 3 characters.” on User Monitoring | User Summary – Select User
• BCLOUD-2115 – Missing translation “Code Info” on Monitoring | Global Monitoring | Redemption Codes page
• BCLOUD-2191 – Cache ItemDef collection in app cache
• BCLOUD-2260 – Support locking of singleton custom entities by ownerId
• BCLOUD-2336 – Avoid SendGrid enabled checking (and logging warnings) for User service “create” APIs when notificationTemplateId input is empty string
• BCLOUD-2347 – Issue handling Portal User Emails with mixed cases
• BCLOUD-2349 – Return a 503 response status in the event of Memcached timeouts
• BCLOUD-2351 – Reset password for email and universalId not trimming or lowercasing “externalId” input
• BCLOUD-2352 – Custom Entity SysIncrementData and IncrementData APIs require Sharded versions for sharded custom collections
• BCLOUD-2353 – [Internal] Nintendo is not in alphabetical order in Select User Identity list
• BCLOUD-2375 – [Internal ] Unlock App dialog ignores changes to the application name
• BCLOUD-2376 – Errors in prod-baas for IdentityService ATTACH with Google OpenID
• BCLOUD-2396 – Super / Manage / Apps – Search filter is performing the query against the server on EVERY character that is typed.
• BCLOUD-2433 – Audit logs missing for a number of update and delete Push Notification settings requests from Portal
• BCLOUD-2488 – [Internal] Generate error/warning message when user saves a User Statistics Event without proper Actions
• BCLOUD-2499 – Modify Steam IAP order id generation to incorporate app id
• BCLOUD-2512 – We should have a way of re-sending end-user email verification emails?
• BCLOUD-2525 – PATCH! Need IdentityService.getIdentityData() to be accessible from cloud code scripts!
• BCLOUD-2526 – PATCH – missing CLIENT cloud code proxy for getSessionForValidatedCredential()
• BCLOUD-2528 – [Internal] Design | Cloud Data | Custom Entities, HTTP Status 500 error message pops up when user create “Migrate:true” entity type collection in portal
• BCLOUD-2550 – [Internal ] While IOS platform disabled, the script Quick Authenticate throw exception error message “Processing exception (message): Platform IOS has not been enabled for this app”
• BCLOUD-2558 – Legacy Portal – Cloud Code Scripts (remove usage of the “scripts-read” call).
• BCLOUD-2601 – When Updating Existing Owned Entity(Custom Collection is Sharded) Incorrect Version is Getting Updated in API Response and Global Monitoring – Custom Entities Page
• BCLOUD-2647 – API counts posted for scripts using relative reference to other scripts are failing
• BCLOUD-2652 – Refactor purgeSoon User Purge processing to use Consumers
• BCLOUD-2771 – Email Auth – Resend Verification
• BCLOUD-2781 – Cloud code audit log improvements
• BCLOUD-2785 – Add support for CustomEntity IncrementSingletonData API and locking on all “increment” APIs
• BCLOUD-2786 – Change audit logs to differentiate “App user-enabled” activity for import/deploy versus “Updated app” (generic)
• BCLOUD-2788 – Add new Group service SysAddGroupMember API
• BCLOUD-2790 – Clicking a folder-based script execution entry from the API Usage page (under API Errors) is not redirecting to the correct location in the portal (API Errors).
• BCLOUD-2791 – After a deployment, the system should set a timer for X seconds, and when it expires, trigger a refresh of the app
• BCLOUD-2792 – [Internal] Not able to see newly created app in Admin Tools-Deployment drop-down menu of other app
• BCLOUD-2815 – Change Deploys, Import Configuration and Restore to Checkpoint processing to clear new appCache via prefix rather than looping
• BCLOUD-2821 – New special “indexedId” field in Group Data
• BCLOUD-2861 – Cloud Code – API Explorer – Service script list should be sorted by path+scriptname
• BCLOUD-2865 – [Internal ] Super | Manage | Teams page, previous Team Name is saving in delete dialog text field while attempting to delete different team
• BCLOUD-2866 – [Internal] Design | Cloud Code | Scripts, when user export single script doesn’t logged in the Audit Log
• BCLOUD-2873 – [Internal] Monitoring | User Monitoring | Groups, the ID links don’t use a hand cursor when user hover over to click on the ID links
• BCLOUD-2877 – Legacy Portal: Item Management – Make select virtual currency mandatory before the user enters the $ amount
• BCLOUD-2880 – User batch script with passed in profileIds list to skip null profileId
• BCLOUD-2881 – Enable setting of expiry date to applicable Leaderboard APIs to create or edit leaderboard configs
• BCLOUD-2885 – Nightly purge of leaderboard scores for old versions is including gameId in query (slow)
• BCLOUD-2891 – Legacy Portal – Monitoring / Global Monitoring / Custom Entities – Apply alphabetical order to entity type list.
• BCLOUD-2901 – Total Users value displayed for Super | Manage | Apps isn’t accurate
• BCLOUD-2902 – [Internal] When user entering iTunes IAP Product ID no limitation and after 53 characters cutting off
• BCLOUD-2904 – [Internal] When user entering Configure Platforms fields no limitation and after 56 characters cutting off
• BCLOUD-2908 – Deployment / Import Configuration / Restore to Checkpoint safety measures required to prevent overlap
• BCLOUD-2909 – Core App Info – Admin Tools – Deploy configuration button should be disabled when deployment is in progress
• BCLOUD-2918 – Legacy Portal – API Key Name is Restricted to Numbers, letters and underscore (_) When Adding a New Key in Edit Profile | Permissions | API Keys Tab
• BCLOUD-2921 – Internal – Unlock dialog will display APP ID twice after user selects Cancel on the unlock dialog
• BCLOUD-2923 – [Internal ] Deploying to an app with incorrect app name does not show error, instead upon hovering over Deploy button ( active) shows red icon
• BCLOUD-2948 – Unreal Engine Heartbeat Not Working As Intended
• BCLOUD-2956 – [Internal] French Version – Selecting Group id and Group Name from drop-down menu cut off
• BCLOUD-2958 – Modify Non-Consumable purchase behavior
• BCLOUD-2996 – Legacy Portal – Scripts – API Usage should use new fields returned from the server instead of calculating the values itself.
• BCLOUD-2998 – Legacy Portal – If passwords feature not enabled those password rules should not be displayed on the Reset Password page
• BCLOUD-3000 – Legacy Portal – User Monitoring | Transactions, adjust the View Transaction to show both dataJson and history
• BCLOUD-3002 – Set proper version on target files for deploy
• BCLOUD-3029 – JSON Error App not found error generates when deploying to the same app multiple times
• BCLOUD-3037 – New app-overridable brainCloud property to control audit logging of leaderboard configuration (create, edit) via Sys or post to dynamic APIs
• BCLOUD-3040 – [Legacy] Desing | Gamification – Statistics Event ‘Add User Statistics Event’ pops up dialog has ‘Currencies’, ‘User Statistics’ and ‘Global Statistics’ options are enabled compared to XP Levels page
• BCLOUD-3044 – Add some additional logging around 3rd party authentication
• BCLOUD-3045 – Legacy Portal – Player Selector – Applicable options in search drop-down not working correctly when language is French.
• BCLOUD-3051 – Do some pre-processing on Nintendo externalId
• BCLOUD-3054 – [Legacy] Icon of Platforms ‘Oculus’ and ‘Apple watchOS’ are not shown in User Monitoring >User Summary Logged In From section
• BCLOUD-3067 – GlobalEntity IncrementGlobalEntityData is not enforcing read-only for other users
• BCLOUD-3081 – Entity service Increment User Entity Data APIs are not enforcing read-only for other users

brainCloud 4.12 is a targeted release to get Nintendo Switch Authentication support in place before our summer holidays!

Release Highlights

Nintendo Switch Authentication

brainCloud now supports native Nintendo Switch authentication.

There are now Nintendo variants of all the standard Authentication and Identity calls – see the API Changes section for more details.

Note that so far these calls have been added to the Unity Client library only. The Unreal Client libs will be added soon!

Miscellaneous changes

• Bridge-based DEBUG log messages are now free when not debugging!
  Calling the bridge.logDebug() and bridge.logDebugJson() calls have been heavily optimized to do nothing (when not called from the API Explorer or Script Editor) – so we no longer record API counts for these calls. Note that we do still count API counts for debug log calls made from the Logging service itself ← since those calls still go through our full Dispatcher and DispatchHandler systems. So don’t do that – use the bridge methods instead!
• GetUserItemsPage() performance has been improved
  The GetUserItemsPage() / GetUserItemsPageOffset() calls have been refactored to only refresh the items that are being returned by that page call… (instead of unnecessarily refreshing all items during the initial call).
• Improved RTT WebSocket Disconnect Handling in Unreal
  In addition to triggering on websocket disconnects, our Unreal libraries now also use a heartbeat timeout to detect disconnects (useful in platforms like IOS where the disconnect notification can take a while to arrive).
• Improved Country Code, Language Code, and TimeZoneOffset handling
  Both the Unity and Unreal client libraries have been enhanced to detect country code, language code, and timezone offset on more platforms (and we’ll be making more improvements in the future).

Portal Changes

We have made the following portal changes:

Design Section

• Core App Info | Platforms
  • Added Nintendo to the platforms list

Monitoring

• Global Monitoring | Custom Entities
  • Added sortable Updated At column to custom entity list screens
• User Monitoring | Select User
  • Added ability to search by Nintendo (Network Services Account) ID
• User Monitoring | User Summary
  • A user’s Nintendo ID will now be shown in the Credentials section of this screen
• User Monitoring | Custom Entities
  • Added sortable Updated At column to custom entity list screens

Reporting

• Analytics
  • Enhanced to show Nintendo platform players

API Changes

The following changes/additions have affected the brainCloud API:

• BrainCloudWrapper
  • Added AuthenticateNintendo() and SmartSwitchAuthenticateNintendo() calls
• Authentication Service
  • Added AuthenticateNintendo() call
• Identity Service
  • Added AttachNintendoIdentity(), DetachNintendoIdentity() and MergeNintendoIdentity() calls

Miscellaneous Changes / Fixes

• Updated libraries
  • 4.12 version of all client libs are available.
  • The Unity and Unreal libs in particular have significant features and improvements in this release – go grab ’em!
• Documentation updates
  • The latest APIs have been added to the API Reference.
• Important Fixes
  • BCLOUD-2298 – Runstate erroneously set to disabled when executing one of the import/export tasks
  • BCLOUD-2191 – Cache ItemDef collection in app cache
• Plus miscellaneous fixes and performance enhancements.

As you are probably aware – brainCloud’s pricing model is designed to be elastic – in that the cost to you (our customer) is proportional to the costs we incur in running your app(s) on our service.

This model is maintained via the formulas that we use to calculate API counts, deep data usage, hosting costs, etc.  Keeping the model accurate requires periodic assessments to ensure that the components are balanced — and a review was long overdue!

Reviewing the data, here is what we found:

• Dormant account costs! The storage of dormant accounts (i.e. players who haven’t logged into an app for years) is an ever-increasing concern – affecting storage + backup costs, system performance, and deep data costs for all apps.
  Think about it: As an app enters the long-tail of it’s product lifecycle, the cost of hosting that app should go down – not up!
• RTT bulk message sends. When we first developed RTT, we expected much higher usage on a per-connection basis – and thus designed the usage formulas accordingly. It turns out that devs are finding that it’s very convenient to have an RTT connection available even in low-usage situations – which is great! – but ensuring proper cost coverage does necessitate an adjustment to the formula.
• Cloud code API imbalance. Calling brainCloud APIs from within cloud code scripts is more efficient than calling them directly from the client – and our API count formulas reflect that.
  Unfortunately, the existing formula  has a design flaw that unintentionally encourages developers to artificially break their code into smaller and smaller scripts. This is both bad design and less efficient for brainCloud – so we are correcting this.
• Debug logging! Some apps have a surprising amount of debug logging in their scripts — which actually results in more system traffic than you’d think — which is why we charge for the calls — which results in higher costs for our customers.
  In brainCloud 4.12 we’ve optimized the handling of bridge-based DEBUG log message so that we no longer have to charge for them when you aren’t debugging (via the API Explorer / Script Editor).
  
  

The details of these changes (and when they take affect) are described below. How these changes affect your app depend upon the details of how your app is using brainCloud.

Impact to apps

Established apps with lots of custom entities will likely see their monthly bills significantly reduced as the Auto-Delete feature removes the abandoned accounts – greatly reducing their deep data usage.  That’s provided that the devs enable Auto-delete of course.

Apps that choose to retain all (or a selected portion) of their dormant users will see a proportionate increase in monthly costs as we start to charge for Dormant Users.

Apps that don’t use a lot of scripts (and there are tons of them) won’t see much of a difference at all. Apps with scripts that make lots of API calls will see a modest increase due to the rebalancing – which may be somewhat offset by the DEBUG log savings.

We hope that folks understand that we make these changes with the best intentions of ensuring a better alignment between the costs that we incur and the costs to you – to ensure a healthy service for everyone!

Pricing changes

As of brainCloud 4.12 (targeted for release on July 20, 2022), we are introducing the following change:

1. We are eliminating the charge for bridge-based DEBUG log messages  – when not actually debugging in the API Explorer or Script Editor.
   We have optimized the pipeline for DEBUG log messages called directly from the bridge service – so that these are now essentially no-ops, and thus we no longer need to charge for them. This is a significant cost reduction for some devs who like to leave the debug calls in place (and who wouldn’t?) – and a greater convenience for all devs – who no longer need to comment these calls out to reduce costs.

As of September 1, 2022, we are introducing the following changes:

1. We are re-balancing the # of free API calls that you get with every Cloud Code script call – from 3 -> 2 calls. Note that every call after the two free calls continues to cost 1/2 an API count.
   This corrects an imbalance from our original formula, that had the unintended side-effect of making some devs think that we were encouraging them to artificially break up their code into multiple smaller scripts. (Hint: We would never intentionally encourage devs to break up their code for reasons that don’t make sense from a design or runtime perspective!)
   
   
2. We are adjusting the ratio used to convert from bulk RTT message sends to API Counts from 1000:1 -> 100:1. 
   This looks like a big change, but the message send traffic will still only adds up to a few dollars per month for even the most active apps on the platform. Still – it ensures we are covered should anybody choose to build the next Twitter on brainCloud!
   
   

Finally, as of January 1, 2023, we will be introducing billing for Dormant User Accounts.

brainCloud defines a Dormant User Account as any account where the user hasn’t logged in the app in the past 365 days.  These users add no value to your game (e.g. they’re probably anonymous and have already uninstalled your app!) – but they do significantly increase costs (including deep data usage) — and slow down your apps. Currently over 50% of brainCloud storage and backup costs is due to dormant accounts.

Starting January 1, 2023, brainCloud apps will be charged $75 / month per Million dormant users (pro-rated). That is not a lot – though for some apps it would be – but ideally we don’t want to collect any Dormant User revenues at all — we’re looking for the cost savings! That’s why we have our Auto-deletion service!

Auto-Deletion

The Auto-Deletion service (configured via the Design | Core App Info | Auto-Delete Users screen) is designed to keep dormant users from piling up.

We know deleting user accounts is scary – so we have made it very flexible – allowing you customize:

• which accounts get deleted <- you can define exclusions for users who have made purchases, attached an e-mail address, have virtual currencies greater than a certain balancer, etc.
• if (and when) users are notified – notify users in advance by email <- requires an attached Sendgrid account
• whether the accounts are archived for some time – you can optionally archive an export of a users data to a Custom Entity collection before deleting the account (just in case) <- requires a Plus plan

Note that depending upon the options you choose, some billing charges apply as Auto-delete removes accounts:

• +1 Bulk API Count for each user deleted
• +1 Email Sent API Count for each email notification sent
• Plus deep data charges for temporarily archiving player data…

In summary

As always, our goal when designing our pricing models is to ensure that the pricing you are charged reflects the costs that we incur in providing the service.

We feel this approach aligns with our interests. The more server resources your apps consume, the higher our costs, and the higher the price to you. But the more efficiently you can build your app, the lower our costs, and the lower the pricing for you. It’s a win-win – and we are on the same side!

If you have any questions or feedback, please reach out to us via the Green Chat widget. We are always happy to hear from you!

brainCloud 4.11 has dropped. Here is what it contains.

Release Highlights

Redemption Code Enhancements

brainCloud 4.11 adds significant customization abilities to the Redemption Code service.

Developers can now write and configure scripts to programmatically handle the processing of redemption codes. These scripts can even incorporate asynchronous processing so that redemption processing can work with off-board fulfillment systems (i.e. delivery of virtual or physical goods via a 3rd party system).

brainCloud 4.11 also adds the ability to generate groups of redemption codes – in two code formats*:

• StructuredGuid – which is a standard GUID-format (i.e. “be0cc83f-024b-4dce-b50c-035ca51e99ae”)
• FiveByFive – which is a 5×5 alphanumeric code (i.e. “a1c2b-a82k3-d82h3-48sw7-8a82d”)

Note – Additional code types may be added in the future.

Simply choose the format of codes that you want – and the quantity – and an email will be sent to you with the generated set of codes.

With this – the following API calls have been added:

• GenerateCodes() – generates a set of codes, and emails them to the specified user
• GenerateCodesInline() – generates a set of codes, and returns them directly in the API call… (limited to max of 100 codes generated at a time)
• ProcessAsynchronousResponse() – used in asynchronous custom processing scripts to tell the Redemption Code service the updated status of the specified code.

Division Management API

brainCloud adds a new API for the creation and management of Divisions – accessible via S2S and cloud code.

The following new methods are available:

• SysCreateDivisionSetConfig()
• SysDeleteDivisionSetConfig()
• SysEditDivisionSetConfig()
• SysListDivisionSetConfigs()
• SysReadDivisionSetConfig()

Note that the JoinDivision() and SysGetLeaderboardConfig() calls have also been enhanced to return a new createdAt field (for division leaderboard instances only) that indicates the date+time that that particular division set instance was created. 

Relay Server Fixes / Improvements

We have improved the robustness of the relay server and added support for customizable timeouts.

The following timeout values are now supported:

• MEMBER_TIMEOUT – Number of seconds within which a member needs to initially join the game. They will be automatically dropped if they don’t join within this time. Default is 30 seconds.
• CONNECTION_TIMEOUT – Number of seconds a connection can be idle (i.e. no activity from the client) before the server drops it. Default is 10 seconds.
• RESEND_TIMEOUT – Number of seconds of resending the same packet before the player is dropped for “too many packet drops”. Default is 10 seconds.

Note – these improvements are only available for the v2 Relay Protocol servers.

Unity Client Improvements

We have made significant improvements to how the Unity Client processes timeouts and connection errors – especially in times of high server load. These improvements will be applied to the other client libraries in the coming months.

In addition, our latest libs address a WebSocket change in the 2021+ versions of Unity.

As always, for best performance, we encourage all developers to upgrade to the latest client libraries. So be sure to grab the 4.11 libs!

Unity Plug-in Changes

The Unity Plug-in has been enhanced to accept Builder API keys in the password field during login. This is to assist our private licensees who are transitioning to Single-Sign-On usage.

New Unity Authentication Example

We have totally re-written the Unity Authentication example – from OnGUI to Unity UI – to better illustrate how authentication works – including our recently added AuthenticateAdvanced() call.

We even have new docs and a video to go with it. Check it out! 

Additional Features

• Added new Ultra Blockchain Service for our Ultra.io partner
• Auto-Delete Users – we are finally introducing the Auto Deletion service that we teased way back in brainCloud 4.5.5! (Hey – we’ve been busy! 🙂 ) Anyway, this service allows your app to automatically delete users who haven’t logged in for a given period of time (e.g. 1 year) – with useful exceptions, like folks who have monetized, reached a certain level, etc. You can even choose to save a backup of a deleted user for X days. Deleting dormant users saves data and speeds up your app – and saves you $$$ as well!
• Backup Deleted Users for X days. If you enable the Auto-Delete feature (above), you also get the benefit of backing up deleted users for X days when they are deleted via the playerState.Delete() method as well.
• Improved caching of AppStore product items
• Updated Facebook Graph API to version 10 (technically introduced earlier in a 4.10 patch)
• Added missing DELETE (with query parm) APIs to HTTPClient…
• Added the missing SmartSwitch calls to the Java library.
• Added the missing SaveDataHelper calls to the Android C++ library.
• The format of individual User Exportshave been updated:
  • new appId, profileId and time fields added to the top-level of the export for easy searching
  • gameId / appId and playerId / ownerId fields removed from sub-data components (redundant)
  • now excluding the following data: playerActivty, groups (we still export the list of groups the player was a member of, just not the data of the groups themselves), sentEvent, matchedOwned, matchHistory, playbackStreams and playbackStreamsTargetUser

Features for Private Licensees

The following features are of particular interest to customers who are licensing private instances of brainCloud:

• SSO status of Team Members now shown in the Super | Manage | Users and Team | Manage | Members pages.
• To better support private licensees moving to SSO, both the Unity Plug-in and our TeamAdmin APIs now support Builder API Keys as passwords. This behaviour is controlled by the new portalSSOTeamAdminAPI brainCloud property.

Portal Changes

We have made a few tweaks for 4.11… (though admittedly most of our web efforts are directed at Portal-X, the next-generation portal for brainCloud 5…)

Design

• Cloud Data | Custom Entities
  • Custom index Keys JSON is now properly pretty-printed
• Integrations | Blockchain
  • Added support for the Ultra Blockchain Service (for customers on our Ultra.io licensee’s platform)
• Marketplace | Redemption Codes
  • Redemption Code type screen updated to support linking in a custom Redemption Script for automating the redemption process.
  • Added a Generate Codes function to allow for easy generation of codes in several formats.

Monitoring

• Global Monitoring | Recent Errors
  • Added a Host Name field to error logs – convenient for tracking down certain errors
• Global Monitoring | Redemption Codes
  • Updated the Redemption Code monitoring screen to support the new asynchronous processing states.
• User Monitoring | User Summary
  • Updated the Select User search screen to support Ultra ID lookup

Reporting

• Reporting | API Errors
  • Fixed the error percentage calculations 
• Reporting | API Usage
  • Hosting Hours now only shows two digits after the decimal place

Team

• Manage | Members
  • A Team Member SSO status will be shown in private licensee deployments that support SSO.

Super (private licensees only)

• Manage | Users
  • A Team Member’s SSO status will be shown in private licensee deployments that support SSO.

API Changes

The following changes/additions have affected the brainCloud API:

• AppStore
  • VerifyPurchase() – we are now bubbling up more errors from the transactionResultCode up to the overall resultCode. (Basically, everything except for RESULT_FAILED_ALREADY_PROCESSED should bubble up). You still want to check the individual transaction details for receipts with multiple transactions, including ensuring that processedCount > 0. 
• BlockChain
  • Added methods to support minting NFTs (from Redemption Codes) on a Blockchain service. These methods are MintNFTFromRedemptionCode() , which of course starts the minting process, and GetTransaction() – which checks the status of a minting operation.
• CustomEntity
  • Reminder that we added UpdateEntityFieldsSharded() and SysUpdateEntityFieldsSharded() as a patch in 4.10. It is important to use these variants of the UpdateEntityFields() call if you plan to shard your Custom Entity collections <- which is recommended for large collections for best performance. (Ask a support tech to shard the collections for you!)
  • Also a reminder that GetEntityPage() and GetEntityPageOffset() have been enhanced to allow devs to specify whether they want the queries to accommodate entities not owned by the current player. There is a related compatibility flag that all apps should have set to disabled – unless you have a specific reason to enable it. More info here.
• HTTPClient
  • Added query string support to all relevant HTTP methods that were missing it – including PostMultipartResponseJson(), PostJsonOffboard(), PatchJsonResponseJson(), PatchTextResponseText(), Delete() and DeleteJsonResponseJson()
• Leaderboard
  • SysGetLeaderboardConfig() response now includes, for division set leaderboards only, a new createdAt field, which is the date+time in millis when the instance leaderboard was created.
• PlayerState
  • DeleteUser() call will save a backup copy of the deleted user – if player backups are configured on the Design | Core App Info | Auto-Delete Users screen
• RedemptionCode
  • Added the following new methods: GenerateCodes(), GenerateCodeInline() and ProcessAsynchronousResponse()
• Tournaments
  • Added new Division Management API calls – SysCreateDivisionSetConfig(), SysDeleteDivisionSetConfig(), SysEditDivisionSetConfig(), SysListDivisionSetConfigs(), SysReadDivisionSetConfigs()
  • JoinDivision() response now includes a createdAt field, which is the date+time in millis when the division set instance leaderboard was created
• User
  • The optionsJson parameter for SysGetUserExport() API now supports the ability to exclude specific custom entity collections

Miscellaneous Changes / Fixes

• Updated libraries
  • All libraries have been updated with the latest API enhancements. Go get ’em!
• Documentation updates
  • All new APIs have been added to the API Reference.
  • There’s a new document and video for the Unity Authentication Example.
• Important Fixes
  • BCLOUD-2091 – Unity Error re: Runtime of WebSocket-native.jslib not being defined
  • BCLOUD-1461 – Swart Switch calls are missing for Java
  • BCLOUD-1718 – Reset Univeral ID API shouldn’t throw a no-session error
  • BCLOUD-1562 – Treat a blank queue guard setting as “any” rather than “stop”
  • BCLOUD-1631 – Return TLS_VERSION_INVALID for RTT connection attempts that don’t meet TLS version requirements
  • BCLOUD-1876 – Long-lived lobby instances are getting “stuck”
  • BCLOUD-2077 – Gamification – XP Levels: Min Points validation is broken/unenforced when editing and existing XP level
  • BCLOUD-1806 – Swapping between child/parent profiles in the Unlock dialog displays the incorrect app name
• Plus miscellaneous fixes and performance enhancements…

Our DevOps team had to update brainCloud set of NAT gateways for brainCloud’s Public BaaS (i.e. portal.braincloudservers.com).  This only affects developers who have whitelisted these IPs for security purposes.

The updated list of outgoing IPs is:

• 204.236.224.149
• 34.233.118.83
• 54.152.153.10
• 44.206.200.165

Apologies for the short notice and inconvenience.

The Challenge

Last week we became aware of a potential issue when using GetEntityPage() with owned entities.

The issue is related to how brainCloud handles ACL permissions. As you may or may not know, all entities in brainCloud support ACL permissions – and you can set the global accessibility of an object by setting the acl.other permission to one of the following:

• 0 = no access
• 1 = read-only access
• 2 = read + write access 

In loose terms, any object with acl.other != 0 is shared with (or accessible by) all users of the app.

This has large implications when dealing with Owned Custom Entities and the GetEntityPage() call – because by the previous default – the call would look for all entities that meet the search criteria that:

• Are owned by the current user
• Are accessible by the current user

Owned is simple – we simply add “ownerId”: to the query provided by the developer. 

Accessible is not so simple – the database must look at all of the objects that the player doesn’t own, and specifically examine each objects ACL to see if acl.other != 0 !!!  This is incredibly slow, and exponentially so!  Especially since 99.9% of the time, a developer is only looking for the entities owned by the current user!

The Solution

To address this issue, we are changing to the default behaviour of `GetEntityPage() so that it no longer considers shared entities (by default) for Owned Custom Entities.

Thus, a query with the following criteria will now only return objects that are owned by the current user:

{
  "pagination": {
      "rowsPerPage": 50,
      "pageNumber": 1
  },
  "searchCriteria": {
      "data.position": "defense"
  },
  "sortCriteria": {
  }
}

Going forward, if an app wants to modify this default behaviour to include accessible (i.e. shared) objects that are owned by other users – they can add the new ownedOnly: false option.  For example:

{
   "pagination": {
     "rowsPerPage": 50,
     "pageNumber": 1
   },
   "searchCriteria": {
     "data.position": "defense"
   },
   "sortCriteria": {
   },
   "options": {
     "ownedOnly": false
   }
}

Compatibility Flag

Because this is a change to the previous brainCloud behaviour, we have introduced a new compatibility flag. When enabled, the following flag preserves the old functionality – where both objects owned and accessible by the user will be returned.

The new compatibility flag can be found in the Design | Core App Info | Advanced Settings page:

[ x ] Include shared objects in Owned Custom Entity GetEntityPage queries (warning: can be slow). Can be overwritten by specifying ‘ownedOnly’ in query context ‘options’.

When enabled, the default for ownedOnly is false – and when disabled, the default for ownedOnly is true.

We believe strongly that this new-and-improved GetEntityPage behaviour is the better + safer default – and thus highly recommend that all developers whose owned queries are only expecting objects owned by the current user go to this compatibility flag and immediately “uncheck” it to enable the new behaviour!

Remember – this option does not affect queries for Un-owned Custom Entities. It also does not affect Sys calls. So both of those scenarios will continue to return objects not owned by the current user – regardless of the compatibility setting.

If you have any questions – please reach out to the support team.

Cheers!

A quick reminder that usage of the following features have always required activation of a Plus Plan for live apps:

• RTT – used for Chat, Lobbies, Presence, etc
• Hosting – spinning up custom Room and Relay Servers
• Deep Data – used for Custom Entities and Messaging

In 4.9.5 (and earlier) there were scenarios where these restrictions were not being enforced. 

We have addressed those scenarios in 4.10 – and as noted in the 4.10 release notes – we will enable the feature flag to begin properly enforcing these restrictions tomorrow – April 5th, 2022 – at approximately 9am Eastern.

Starting tomorrow, developers can expect that attempting to access these features (like enabling RTT, creating a custom entity, connecting to a chat channel, sending a message, etc.) without an active Plus Plan, will result in a run-time licensing error.

To quickly update your app to a plus plan, simply:

• Navigate to Team | Manage | Apps
• Select Change Plan from the action menu associated with the app
• Click on the Plus Plans tab
• Choose the plan to switch to
• And click [Choose Plan]

brainCloud will then swap your app to the new plan. 

Note that your charges will be adjusted automatically, with the first few days of April charged to the old plan, and the rest of the month charged to the new plan – with the live fees pro-rated accordingly.

If you have questions or issues, feel free to reach out via the support widget.