April 15, 2024

On Thursday, 12 Oct. 2022, the EMEA a part of the Datastores crew — the crew liable for Slack’s database clusters — was having an onsite day in Amsterdam, the Netherlands. We’re sitting collectively for the primary time after new engineers had joined the crew, when instantly just a few of us had been paged: There was a rise within the variety of failed database queries. We stopped what we had been doing and staged-in to resolve the issue. After investigating the problem with different groups, we found that there was a long-running job (async job), and that it was purging a considerable amount of database data. This brought on an overload on the database cluster. The JobQueue crew — liable for asynchronous jobs — realized that we couldn’t cease the job, however we may disable it fully (this operation known as shimming). This meant that the operating jobs wouldn’t cease, however that no new jobs can be processed. The JobQueue crew put in the shim, and the variety of failed database queries dropped off. Fortunately, this incident didn’t have an effect on our prospects.

The very subsequent day, the Datastores EMEA crew obtained the identical web page. After trying into it, the crew found that the issue was just like the one skilled the day earlier than, however worse. Related actions had been taken to maintain the cluster in working situation, however there was an edge-case bug in Datastores automation which led to failure to deal with a flood of requests. Sadly, this incident did influence some prospects, they usually weren’t capable of load Slack. We disabled particular options to assist scale back the load on the cluster, which helped give room to recuperate. After some time, the job completed, and the database cluster operated usually once more.

On this put up, we’ll describe what brought on the problems, how our datastores are arrange, how we fastened the problems, and the way we’re stopping them from occurring once more.

The set off

One in all Slack’s prospects eliminated numerous customers from their workspace. Eradicating quite a few customers in a single operation will not be one thing prospects do usually; as a substitute, they have a tendency to take away them in small teams as they depart the corporate. Person elimination from Slack is completed by way of an asynchronous job referred to as overlook consumer. When the overlook consumer job began, it led to a spike within the database load. After some time, one of many shards couldn’t address the workload.

Within the determine above, you’ll be able to see a major enhance within the variety of database queries. It is a screenshot of our monitoring dashboard through the incident; it was a necessary software through the incident, and it helped us make educated choices.


Let’s elaborate on some ideas earlier than we take a deep dive into what occurred.

Information storage

The Datastores crew makes use of Vitess to handle Slack’s MySQL clusters. Tables in Vitess are organized into keyspaces. A keyspace is a distributed database. It seems to be like a single MySQL occasion to consumer functions, whereas being distributed throughout a number of schemata of various MySQL cases.

Slack depends on an enormous dataset that doesn’t slot in a single MySQL occasion. Subsequently, we use Vitess to shard the dataset. There are different advantages from having a sharded database for every particular person MySQL occasion that’s a part of the dataset:

  • Quicker backup and restore
  • Smaller backup sizes
  • Blast radius mitigation: in case a shard is down, much less makes use of are impacted
  • Smaller host machines
  • Distributed database question load
  • Improve in write capability

Each keyspace in Vitess consists of shards. Consider a shard like a slice of a keyspace. Every shard shops a key vary of keyspace IDs, they usually collectively signify what known as a partition. Vitess shards the information based mostly on the shards’ partition ranges.

For instance, a “customers” desk will be saved in a keyspace composed of two shards. One shard covers keys within the -80 (hexadecimal key ID) vary, and the opposite one, within the 80- vary. -80 and 80- signify integer numbers beneath and above (2^64)/2, respectively.  Assuming the sharding key’s homogeneously distributed, which means Vitess will retailer half the data in a single shard, and half within the different one. Vitess additionally shops shard metadata internally in order that VTGates can decide the place to seek out the information when a consumer requests it. Within the determine beneath, Vitess receives a SELECT assertion for one of many consumer’s knowledge. It seems to be into the metadata and determines that this consumer’s knowledge is accessible within the shard with vary “80-“:

Question success and replication

Slack is greater than a messaging app, and lots of different options in Slack additionally rely on Vitess. To extend database throughput, in addition to for failure tolerance, every shard has replicas. For every shard we create, there may be one main pill and a number of duplicate tablets. Main tablets are primarily liable for queries modifying the information (DELETE, INSERT, UPDATE aka DML). Replicas are liable for SELECT queries (the first also can fulfill the SELECT queries, however it’s not really helpful as there may be restricted room for scaling). After knowledge is dedicated to the first, it’s distributed to the replicas in the identical shard by way of MySQL replication. The character of replication is that adjustments are dedicated within the main earlier than they’re utilized within the replicas. Underneath low write load and a quick community, the information within the duplicate lags little or no behind the information within the main, However below excessive write load, replicas can lag considerably, resulting in potential reads of stale/old-fashioned knowledge by consumer functions. What quantity of replication lag is appropriate depends on the appliance. At Slack, we take replicas out of service if their replication lag is larger than one hour —- that’s, if the information current on the replicas is lacking adjustments from greater than an hour in the past.


We’ve a process to switch an current duplicate pill with a brand new one. To simplify the logic, we will think about it consisting of 4 steps. The first step is to provision the brand new host with all of the dependencies, instruments, safety insurance policies, MySQL, and Vitess. The second step is to attend for the pill to acquire a replica of the information by restoring the latest backup. The third step is to catch-up on replication. After that is achieved, the brand new duplicate can begin serving site visitors. Lastly, the fourth step is to deprovision the outdated duplicate. We’ll talk about the third step — catching up — a bit in additional element beneath.


As soon as the latest backup has been restored, the brand new duplicate has a replica of the dataset; nevertheless, it isn’t updated, because it doesn’t but have the adjustments which have taken place for the reason that backup was taken. Catching up means studying these adjustments from MySQL’s binary log and making use of them to the copy of the information of the brand new duplicate. A reproduction is taken into account caught up as soon as its replication lag is beneath an acceptance threshold. Whereas we’re discussing catch-up right here from the viewpoint of provisioning a brand new duplicate, it’s value noting that replicas are continuously catching as much as any new adjustments that their main could have taken.

What occurred through the incident

With the high-level context, let’s get again to the incident. When you keep in mind, a buyer deleted many customers from their workspace. This motion kicked off the overlook consumer job, which requires unsubscribing every affected consumer from the channels and threads they had been subscribed to. So to delete customers, it’s vital additionally to find and delete data representing every subscription of every consumer to every channel they belong to, and every subscription of every thread they participated in. Because of this an unlimited variety of database queries had been despatched to the a number of Vitess shards. That’s the variety of customers being deleted multiplied by the typical variety of subscribed gadgets per consumer. Sadly, there was one shard that contained 6% of the consumer’s subscription knowledge. When this shard began to get that many requests, we began to see MySQL replication lag within the shard. The rationale behind this lag is that replicas had been having bother maintaining with the first as a result of great amount of information being modified. To make issues worse, the excessive quantity of write load additionally led the Vitess tablets to expire of reminiscence on the shard main, which brought on the kernel to OOM-kill the MySQL course of. To mitigate this, a reproduction was mechanically promoted to main, and a alternative began to happen. As described above, the alternative pill restored knowledge from the final backup, and tried to catch-up with the first. Due to the big quantity of database writes executed on the first, they took a very long time to catch-up, subsequently not with the ability to begin serving site visitors quick sufficient. This was interpreted by our automation because the newly provisioned duplicate not being wholesome, and subsequently needing to be deprovisioned. Within the meantime, excessive write load continued, inflicting the brand new main to additionally run out of reminiscence, leading to its MySQL course of being killed by the kernel. One other duplicate was promoted to main, one other alternative was began, and the cycle repeated.

In different phrases, the shard was in an infinite-loop of the first failing, a reproduction being promoted to main, a alternative duplicate being provisioned, attempting (and failing) to catch-up, and at last getting deprovisioned.

How we fastened it


The Datastores crew broke the alternative loop by provisioning bigger occasion varieties (i.e. extra CPU and reminiscence) replicas manually. This mitigated the OOM-kill of the MySQL course of. Moreover, we resorted to guide provisioning as a substitute of automation-orchestrated alternative of failed hosts to mitigate for the problem through which our automation deprovisioned the replacements as a result of it thought-about them unhealthy, attributable to the truth that they did not catch-up in an inexpensive period of time. This was arduous for the crew as a result of now they should manually provision replicas, along with dealing with the excessive write site visitors.

Neglect Person Job

The “overlook consumer” job had problematic efficiency traits and brought on the database to work a lot more durable than it wanted to. When a “overlook consumer” job was being processed, it gathered the entire channels that the consumer was a member of and issued a “depart channel” job for every of them. The aim of the “depart channel” job was to unsubscribe a consumer from the entire threads that they had been subscribed to in that channel.  Underneath typical circumstances, this job is barely run for one channel at a time when a consumer manually leaves a channel. Throughout this incident nevertheless, there was an enormous inflow of those “depart channel” jobs corresponding to each channel that each consumer being deactivated was a member of.

Along with the sheer quantity of jobs being a lot larger than regular throughout this incident, there have been many inefficiencies within the work being achieved within the “depart channel” job that the crew that owned it recognized and stuck:

  1. First, every job run would question for the entire Person’s subscriptions throughout all channels that they had been a member of although processing was solely being carried out for the one channel that they had been “leaving”.
  2. A associated downside occurred through the subsequent UPDATE queries to mark these subscriptions as inactive. When issuing the database UPDATEs for the thread subscriptions within the to-be-left-channel, the UPDATE question, whereas scoped to the channel ID being processed, included the entire consumer’s thread subscription IDs throughout all channels. For some customers, this was tens of hundreds of subscription IDs which could be very costly for the database to course of.
  3. Lastly, after the UPDATEs accomplished, the “depart channel” job queried for the entire consumer’s thread subscriptions once more to ship an replace to any related purchasers that may replace their unread thread message depend to not embrace threads from the channel that they had simply left.

Contemplating that these steps wanted to happen for each channel of each consumer being deleted, it turns into fairly apparent why the database had bother serving the load.

To mitigate the issue through the incident, the crew optimized the “depart channel” job. As a substitute of querying for all subscriptions throughout all channels, the job was up to date to each question for less than the subscriptions within the channel being processed and solely embrace these subscription IDs within the subsequent UPDATEs.

Moreover, the crew recognized that the ultimate step to inform the purchasers about their new thread subscription state was pointless for deactivated customers who couldn’t be related anyhow in order that work was skipped within the “overlook consumer” state of affairs solely.

Consumer crew

As a last resort to take care of the consumer expertise and let our customers proceed utilizing Slack, the consumer crew briefly disabled the Thread View from the Slack consumer. This motion diminished the quantity of learn queries towards Vitess. This meant that fewer queries hit the replicas. Disabling the characteristic was solely a brief mitigation. At Slack, our customers’ expertise is the highest precedence, so the characteristic was enabled once more as quickly because it was secure to take action.

How are we stopping it from occurring once more?


Are you able to recall the actual edge-case challenge that the crew encountered with replacements through the incident? The crew swiftly acknowledged its significance and promptly resolved it, prioritizing it as a high concern.

Moreover fixing this challenge, the Datastores crew has began to adapt the throttling mechanism and the circuit breaker pattern, which have confirmed to be efficient in safeguarding the database from question overload. By implementing these measures, the Datastores crew is ready to proactively forestall purchasers from overwhelming the database with extreme queries.

Within the occasion that the tablets throughout the database infrastructure turn into unhealthy or expertise efficiency points, we will take motion to restrict or cancel queries directed on the affected shard. This strategy helps to alleviate the pressure on the unhealthy replicas and ensures that the database stays secure and responsive. As soon as the tablets have been restored to a wholesome state, regular question operations can resume with out compromising the general system efficiency.

Throttling mechanisms play a vital position in controlling the speed at which queries are processed, permitting the database to handle its assets successfully and prioritize essential operations. As a result of it is a essential a part of stopping overload, the Datastores crew has  been contributing associated options and bug fixes to Vitess [1, 2, 3, 4, 5, 6, 7]. This is likely one of the constructive outcomes of this incident.

Along with throttling, the crew has adopted the circuit breaker sample, which acts as a fail-safe mechanism to guard the database from cascading failures. This sample includes monitoring the well being and responsiveness of the replicas and, within the occasion of an unhealthy state being detected, briefly halting the circulate of queries to that particular shard. By doing so, the crew can isolate and include any points, permitting time for the replicas to recuperate or for alternate assets to be utilized.

The mix of throttling mechanisms and the circuit breaker sample supplies the Datastores crew with a strong protection towards potential overload and helps to take care of the soundness and reliability of the database. These proactive measures be sure that the system can effectively deal with consumer requests whereas safeguarding the general efficiency and availability of the database infrastructure.

Neglect Person Job

After the mud settled from the incident, the crew that owned the “overlook consumer” job took the optimizations additional by restructuring it to make life a lot simpler for the database. The “depart channel” job is suitable when a consumer is definitely leaving a single channel. Nonetheless, throughout “overlook consumer”, issuing a “depart channel” concurrently for all channels {that a} consumer is a member of causes pointless database rivalry.

As a substitute of issuing a “depart channel” job for every channel {that a} consumer was a member of, the crew launched a brand new job to unsubscribe a consumer from all of their threads. “Neglect consumer” was up to date to enqueue only a single new “unsubscribe from all threads” job which resulted in a lot decrease rivalry throughout “overlook consumer” job runs.

Moreover, the Neglect Person job began to adapt the exponential back-off algorithm and the circuit breaker pattern. This implies jobs which are getting failed will address the state of the dependencies (like database) and can cease retrying.


The incidents that occurred on October twelfth and thirteenth, 2022 highlighted a few of the challenges confronted by the Datastores EMEA crew and the groups operating asynchronous jobs at Slack. The incident was triggered by a major variety of customers being faraway from a workspace, resulting in a spike in write requests  and overwhelming the Vitess shards.

The incident resulted in replicas being unable to meet up with the first, and the first crashing, resulting in an infinite loop of replacements and additional pressure on the system. The Datastores crew mitigated the problem by manually provisioning replicas with extra reminiscence to interrupt the alternative loop.

The crew liable for the Neglect Person job performed a vital position in stopping the job liable for the database write requests and optimizing the queries, lowering the load on the first database.

To stop comparable incidents sooner or later, the Datastores crew has applied throttling mechanisms and the circuit breaker sample to proactively forestall overwhelming the database with extreme queries. They’ve additionally tailored the exponential back-off algorithm to make sure failed jobs address the state of dependencies and cease retrying.

Total, these measures applied by the Datastores crew, the crew proudly owning the overlook consumer job and the crew offering async job infrastructure assist safeguard the soundness and reliability of Slack’s database infrastructure, making certain a clean consumer expertise and mitigating the influence of comparable incidents.