|Slack Channels||#g_scalability /
||#infrastructure-lounge (Infrastructure Group Channel), #incident-management (Incident Management), #alerts-general (SLO alerting), #mech_symp_alerts (Mechanical Sympathy Alerts)|
The Scalability team is responsible for GitLab and GitLab.com at scale, working on the highest priority scalability items in the application in close coordination with Reliability Engineering teams and providing feedback to other Engineering teams so they can become better at scalability as well.
As its name implies, the Scalability team enhances the availability, reliability and, performance of GitLab by observing the application's capabilities to operate at GitLab.com scale. The Scalability team analyzes application performance on GitLab.com, recognizes bottlenecks in service availability, proposes short term improvements and develops long term plans that help drive the decisions of other Engineering teams.
Short term goals include:
GitLab.com's service level availability is visible on the SLA Dashboard, and we use the General GitLab Dashboard in Grafana to observe the service level indicators (SLIs) of apdex, error ratios, requests per second, and saturation of the services.
These dashboards show lagging indicators for how the services have responded to the demand generated by the application.
We have a leading indicator of application demand. This is shown on the Application Demand Dashboard.
Application demand is used as a way to identify that there may have been an application level change that alters how the application makes requests of the underlying infrastructure. If we observe a change in rate, this tells us that we need to investigate and understand the cause of the change.
We use indicators to track towards our goals. More information can be found on our goals page.
The following people are members of the Scalability Team:
|Rachel Nienaber||Engineering Manager, Scalability|
|Jacob Vosmaer||Staff Backend Engineer, Scalability|
|Sean McGivern||Staff Backend Engineer, Scalability|
|Oswaldo Ferreira||Backend Engineer, Scalability|
|Bob Van Landuyt||Senior Backend Engineer, Scalability|
|Craig Miskell||Site Reliability Engineer, Scalability|
The following members of other functional teams are our stable counterparts:
|Marin Jankovski||Senior Engineering Manager, Infrastructure, Delivery & Scalability|
|André Luís||Frontend Engineering Manager, Create:Source Code, Delivery & Scalability|
We work with all engineering teams across all departments as a representative of GitLab.com as one of the largest GitLab installations, to ensure that GitLab continues to scale in a safe and sustainable way.
The Memory team is a natural counterpart to the Scalability team, but their missions are complementing each other rather than overlap:
|Scalability Team||Memory Team|
|Focused on GitLab.com first, self-managed only when necessary.||Focused on resolving application bottlenecks for all types of GitLab installations.|
|Driven by set SLO objectives, regardless of the nature of the issue.||Focused on application performance and resource consumption, in all environments.|
|Primary concern is preventing disruptions of GitLab.com SLO objectives through changes in the application architecture.||Primary concern is managing the application performance for all types of GitLab installations.|
workflowlabels to the issue. The team will triage the issue and apply these.
If you're working on a feature that will have specific scaling requirements, you can create an issue with the review request template. Some examples are:
This template gives the team the information we need to help you, and will immediately put the issue on our build board with a high priority.
This process is an example of doing something that doesn't scale; as we do more of these, we'll learn what topics can be covered more efficiently by training, documentation, and tooling.
When we observe a situation on GitLab.com that needs to be addressed alongside a stage group, we first raise an issue in the Scalability issue tracker that describes what we are seeing. We try to determine if the problem lies with the action the code is performing, or the way in which it is running on GitLab.com. For example, with queues and workers, we will see if the problem is in what the queue does, or how the worker should run.
If we find that the problem is in what the code is doing, then we engage with the EM/PM of that group to find the right path forward. If work is required from that group, we will create a new issue in the gitlab-org project and use the Availability and Performance Refinement process to highlight this issue.
We prefer to work asynchronously as far as possible but still use synchronous communication where it makes sense to do so.
To that end, we have very few scheduled calls.
Lastly, in order to keep people connected, team members schedule at least one coffee-chat with another team member each week. These are at times that will best suit them as it may be an unusual hour given the various timezones and working hours for each person.
We use Epics, Issues, and Issue Boards to organize our work, as they complement each other.
The single source of truth for all work is Scaling GitLab.com epic. This is considered as the top-level epic from which all other epics are derived.
Epics that are added as children to the top-level epic are used to describe projects that the team undertakes.
Having all projects at this level allows us to use a single list for prioritization and enables us to prioritize work for different services alongside each other. Projects are prioritized in line with the OKRs for the current quarter.
Project status is maintained in the description of the top-level epic so that it is visible at a glance. This is auto-generated. You can watch a short demo of this process to see how to use status labels on the epics to make use of this automation.
Example organization is shown on the diagram below:
Note If you are not seeing the diagram, make sure that you accepted all cookies.
Projects must have the following items in the epic description:
exit criterionlabel in the epic and are linked in the description.
The diagram below describes how the work gets created in the Scalability team, and added to the top-level epic Scaling GitLab.com epic:
Note If you are not seeing the diagram, make sure that you accepted all cookies.
The process contains 6 cyclical stages:
We have automated triage policies defined in the triage-ops project. These perform tasks such as automatically labelling issues, asking the author to add labels, and creating weekly triage issues.
We currently have two weekly triage issues:
Service::Unknownrefinement - lists issues with
Service::Unknownwith the goal of adding a defined service, where possible.
We rotate the triage ownership each month, with the current triage owner responsible for picking the next one (a reminder is added to their last triage issue).
The Scalability team issue boards track the progress of ongoing work. Purpose of some of the more important issue boards are described below:
The Scalability team routinely uses the following set of labels:
team::Scalability label is used in order to allow for easier filtering of
issues applicable to the team that have group level labels applied.
The priority labels allow us to track the issues correctly and raise/lower priority of work based on both external and internal factors.
This means that the highest priority is given to working on issues that improve Gitlab.com SLO's either immediately and directly, or by unblocking other issues to achieve the same.
The Scalability team leverages scoped workflow labels to track different stages of work. They show the progression of work for each issue and allow us to remove blockers or change focus more easily.
The standard progression of workflow is from top to bottom in the table below:
|Problem is identified and effort is needed to determine the correct action or work required.|
|Proposal is created and put forward for review.
SRE looks for clarification and writes up a rough high-level execution plan if required. SRE highlights what they will check and along with soak/review time and developers can confirm.
If there are no further questions or blockers, the issue can be moved into "Ready".
|Proposal is complete and the issue is waiting to be picked up for work.|
|Issue is assigned and work has started.
While in progress, the issue should be updated to include steps for verification that will be followed at a later stage.
|Issue has an MR in review.|
|MR was merged and we are waiting to see the impact of the change to confirm that the initial problem is resolved.|
|Issue is updated with the latest graphs and measurements, this label is applied and issue can be closed.|
There are three other workflow labels of importance:
|Work in the issue is being abandoned due to external factors or decision to not resolve the issue. After applying this label, issue will be closed.|
|Work is not abandoned but other work has higher priority. After applying this label, team Engineering Manager is mentioned in the issue to either change the priority or find more help.|
|Work is blocked due external dependencies or other external factors. Where possible, a blocking issue should also be set. After applying this label, issue will be regularly triaged by the team until the label can be removed.|
The Scalability team uses priority labels as a means to indicate order under which work is next to be picked up. Priorities are roughly defined as:
|Scalability::P1||Issue is blocking other team-members, or blocking other work. As soon as possible after completing ongoing task unless directly communicated otherwise.|
|Scalability::P2||Issue has a large impact, or will create additional work.|
|Scalability::P3||Issue should be completed once other urgent work is done.|
|Scalability::P4||Default priority. A nice-to-have improvement, non-blocking technical debt, or a discussion issue.|
Stage groups use throughput labels to label merge requests in projects in the
gitlab-org group. The Scalability team is not a part of the stage groups, and labels of importance for the team are explained above. When submitting work in gitlab-org group, we apply ~"team::Scalability" and ~"feature::maintenance" to merge requests by default. The latter label is describing work towards refinement of existing functionality which describes majority of the work the team is contributing.
We work from our main epic: Scaling GitLab on GitLab.com.
Most of our work happens on the current in-progress sub epic. This is always prominently visible from the main epic's description.
When choosing something new to work on you can either:
Readycolumn according to the priority labels.