One change to optimize them all: a story about batching on the source side

At CloudQuery, we try to optimize the performance of our syncs so that all of the data is processed as fast as possible. After a last year's move from our custom in-house type system to Apache Arrow, we almost missed one massive opportunity to further optimize our data syncs.

Migration to Apache Arrow

Here's a quick recap on our adoption of Apache Arrow at CloudQuery:

Before Arrow, we used our own type system that only supported around 14 different data types. However, we started hitting limitations in various use cases as we grew the number of supported data sources and destinations. Taking a step back, we decided to adopt Apache Arrow instead building yet another format.

Single resource per message

Prior to our type system migration to Apache Arrow we used to send each resource synced in a separate streaming message over gRPC. Essentially, it looked like this:

When the type system change to Apache Arrow was completed, no significant regressions in performance were detected. That's why we decided that it's good enough and shipped it to all of our plugins.

Turns out having a single resource per message sent is actually tech debt

As we had to do an upstream fix to Apache Arrow every now and then while expanding the support for the nested types and optimizing our codebase, we forgot to pay attention to the following:

Apache Arrow defines a cross language columnar format for flat and hierarchical data

It means that the Apache Arrow data processing is optimized for sending lots of rows at once, but we used it to send a single row at once.

Initially, we packed each resource that we sent over the wire into it's own Apache Arrow record, which contains:

• schema: contains field schema describing how the destination side should decode the data
• data: packed Apache Arrow arrays. This is the place where we can store many entries, but we simply overlooked this in the initial migration.

Particularly, it means that for every resource, or row in Apache Arrow, we would have a whole schema packed in (and unpacked on the destination side), spending tons of extra CPU cycles, RAM & network processing for every resource.

Essentially, to send N resources we would send N Apache Arrow records:

When instead we could be sending a single Apache Arrow record with N rows:

Sending multiple rows in a single record

Once the issue was noticed, we started planning on how to fix this issue and better utilize resources when using Apache Arrow.

We even fell into trap once of collecting wrong metrics. Instead of focusing on the resource consumption savings, we saw that the sync time wasn't affected and we de-prioritized the issue until we retested in the constrained environment.

To implement batching multiple resources in a single message, we had to make the following steps:

1. Ensure that all destination plugins support receiving Apache Arrow records with multiple rows. Initially we developed the destination plugins code with a single resource per message received in mind, and there were some places that needed to be updated.
2. Wait for some time to allow the users to migrate to the newer destination plugin versions. Otherwise, the batching of resources into a single record would be a breaking change and would require users to update the destination plugins along with source plugins right away.
3. Roll out the change to some select source plugins and thoroughly test.
4. Roll out the change to all source plugins.

We implemented destination support along with changes to the test suite to ensure that we don't break anything in the future and then we waited.

Implementation details

We decided to implement a simple batching with the cutoff by timeout and size. So, for each table being synced we collect a batch on the source side into a single Apache Arrow record, and we send it out only after the batch is full or the timeout has passed.

You can see the change in our Go SDK as well as a small follow-up decreasing allocations for logging.

Bugs, bugs, bugs everywhere in the destination plugins

One of the features that the CloudQuery Go SDK provides is out-of-the-box batch writers for destinations. It allows batching the data on the destination side to be written to the destination (file, database, etc.) in a single API call rather than spamming the destination with small writes.

Yes, we thought about batching in the destination processing. No, we didn't put 2 and 2 together at the time. Yes, it happens, and it's OK.

While updating the destination plugins to support Apache Arrow records with multiple rows we had introduced several inconsistencies in our batch writers. Almost all of those were about assuming a single row in the record when deciding to start a new batch. And some were about data size as well.

The final fix for the destination plugins is present in v4.45.6.

Upgrading sources

First we made a change to the PostgreSQL source plugin, introducing the rows_per_record option. It allows to manually select how many database rows would be packed into a single Apache Arrow record to be sent over the wire. After rolling this out we discovered the aforementioned issues with the destination plugins that we had to address first.

After the destination code was fixed we proceeded to test syncs with different settings & decided on a sane default of batching up to 50 rows into the record & sending the records at least once in 5 seconds.

Yes, it involved testing. Lots and lots of testing. Behold the amount of benchmarks we had to run to get here.

We enabled the batching on the source side by default since v4.48.0.

Rolling resource batching to select plugins

AWS source plugin experiments

One of the first plugins to receive the upgrade was the AWS source plugin. We chose this plugin as it's one of the most verbose (in terms of tables amount) and one of our most utilized plugins.

We saw that not only were less resources (CPU cycles, RAM and network bytes) being consumed during each sync, but also the sync time's decreased in the environments that are limited by CPU and network rather than the API response speed.

It wasn't obvious in the environment with only 550 thousand resources as the sync time stayed roughly the same (likely attributed to the AWS API response times):

However, when we were able to collect the data from a large AWS organization (114 million resources), the difference in sync time and resources consumed was drastic:

Additionally, we compared the sync speed in different EC2 instance configurations. You can find the detailed comparison here.

Expanding the roster

After we saw performance improvements with AWS source plugin, we extended the testing to the following list:

• AWS
• Azure
• GCP
• PostgreSQL
• S3

We saw great improvements both in the CPU consumption:

As well as RAM:

GA

We are pleased to announce that all Golang-based CloudQuery plugins now support working with Apache Arrow records with multiple rows!

To enjoy the new smooth experience please use versions no older than the ones listed below.

Wrapping up

Sometimes the huge improvements can be achieved by reading the documentation and making a data shaping change.

The change to introduce batching is a small one, but it had to be rolled out gradually in order not to break user workflows.

So, when making changes like type system switching don't forget to spend a couple of extra weeks reading the fabulous manuals to save some time before uncovering the new technology potential.

Try it yourself

Want to see CloudQuery in action? Schedule a demo with our team or check out the platform documentation to learn more.

Want help getting started? Join the CloudQuery community to connect with other users and experts, or message our team directly here if you have any questions.

Plugins supporting Apache Arrow records with multiple rows

Source plugins

Destination plugins