dataloss subcommand based on repository generations

Changes dataloss subcommand to report data loss based on repository
generations. This allows us to report more accurately, including
how many writes a repository is behind at maximum.

The report is not 100% accurate as generations map to mutator calls and
some mutator calls do not indicate unreplicated writes. These are mutators
are mainly for repository housekeeping and do make any changes visible to the
client. The accuracy can be improved by tagging these housekeeping mutators
later as such and ignoring them when it comes to incrementing the generation
of a repository.

Generations guarantee the repository was at least on the stored generation.
As such, the tool might produce false positives in case a replication was
successful but the database record failed to be updated. In case of a failover,
some of the repositories reported as outdated may contain the latest changes.

Since generations are only recorded for repositories that have received
new mutator RPCs, this won't report data loss from repositories that have
failed replication prior to the generations being introduced.

7 files changed, 254 insertions, 238 deletions

diff --git a/changelogs/unreleased/smh-repository-generations-dataloss.yml b/changelogs/unreleased/smh-repository-generations-dataloss.yml
new file mode 100644
index 000000000..1eb3f6a8c
--- /dev/null
+++ b/changelogs/unreleased/smh-repository-generations-dataloss.yml
@@ -0,0 +1,5 @@
+---
+title: Generate data loss report from repository generation info
+merge_request: 2403
+author:
+type: changed
diff --git a/cmd/praefect/subcmd_dataloss.go b/cmd/praefect/subcmd_dataloss.go
index f9c7f2d22..c66ca1a1b 100644
--- a/cmd/praefect/subcmd_dataloss.go
+++ b/cmd/praefect/subcmd_dataloss.go
@@ -74,27 +74,24 @@ func (cmd *datalossSubcommand) Exec(flags *flag.FlagSet, cfg config.Config) erro
 			return fmt.Errorf("error checking: %v", err)
 		}
 
-		mode := "write-enabled"
-		if resp.IsReadOnly {
-			mode = "read-only"
-		}
-
 		cmd.println(0, "Virtual storage: %s", vs)
-		cmd.println(1, "Current %s primary: %s", mode, resp.CurrentPrimary)
-		if resp.PreviousWritablePrimary == "" {
-			fmt.Fprintln(cmd.output, "    No data loss as the virtual storage has not encountered a failover")
-			continue
-		}
-
-		cmd.println(1, "Previous write-enabled primary: %s", resp.PreviousWritablePrimary)
-		if len(resp.OutdatedNodes) == 0 {
-			cmd.println(2, "No data loss from failing over from %s", resp.PreviousWritablePrimary)
+		cmd.println(1, "Primary: %s", resp.Primary)
+		if len(resp.Repositories) == 0 {
+			cmd.println(1, "All repositories are up to date!")
 			continue
 		}
 
-		cmd.println(2, "Nodes with data loss from failing over from %s:", resp.PreviousWritablePrimary)
-		for _, odn := range resp.OutdatedNodes {
-			cmd.println(3, "%s: %s", odn.RelativePath, strings.Join(odn.Nodes, ", "))
+		cmd.println(1, "Outdated repositories:")
+		for _, r := range resp.Repositories {
+			cmd.println(2, "%s:", r.RelativePath)
+			for _, s := range r.Storages {
+				plural := ""
+				if s.BehindBy > 1 {
+					plural = "s"
+				}
+
+				cmd.println(3, "%s is behind by %d change%s or less", s.Name, s.BehindBy, plural)
+			}
 		}
 	}
 
diff --git a/cmd/praefect/subcmd_dataloss_test.go b/cmd/praefect/subcmd_dataloss_test.go
index 569cf7caa..4c24741b9 100644
--- a/cmd/praefect/subcmd_dataloss_test.go
+++ b/cmd/praefect/subcmd_dataloss_test.go
@@ -5,9 +5,12 @@ import (
 	"context"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"gitlab.com/gitlab-org/gitaly/internal/praefect/config"
+	"gitlab.com/gitlab-org/gitaly/internal/praefect/datastore"
+	"gitlab.com/gitlab-org/gitaly/internal/praefect/nodes"
+	"gitlab.com/gitlab-org/gitaly/internal/praefect/service/info"
+	"gitlab.com/gitlab-org/gitaly/internal/testhelper"
 	"gitlab.com/gitlab-org/gitaly/proto/go/gitalypb"
 )
 
@@ -26,117 +29,92 @@ func (m mockPraefectInfoService) EnableWrites(ctx context.Context, r *gitalypb.E
 }
 
 func TestDatalossSubcommand(t *testing.T) {
-	mockSvc := &mockPraefectInfoService{}
-	ln, clean := listenAndServe(t, []svcRegistrar{registerPraefectInfoServer(mockSvc)})
+	mgr := &nodes.MockManager{
+		GetShardFunc: func(vs string) (nodes.Shard, error) {
+			var primary string
+			switch vs {
+			case "virtual-storage-1":
+				primary = "gitaly-1"
+			case "virtual-storage-2":
+				primary = "gitaly-4"
+			default:
+				t.Error("unexpected virtual storage")
+			}
+
+			return nodes.Shard{Primary: &nodes.MockNode{StorageName: primary}}, nil
+		},
+	}
+
+	gs := datastore.NewMemoryRepositoryStore(map[string][]string{
+		"virtual-storage-1": {"gitaly-1", "gitaly-2", "gitaly-3"},
+		"virtual-storage-2": {"gitaly-4"},
+	})
+
+	ctx, cancel := testhelper.Context()
+	defer cancel()
+
+	require.NoError(t, gs.SetGeneration(ctx, "virtual-storage-1", "repository-1", "gitaly-1", 1))
+	require.NoError(t, gs.SetGeneration(ctx, "virtual-storage-1", "repository-1", "gitaly-2", 0))
+
+	require.NoError(t, gs.SetGeneration(ctx, "virtual-storage-1", "repository-2", "gitaly-2", 0))
+	require.NoError(t, gs.SetGeneration(ctx, "virtual-storage-1", "repository-2", "gitaly-3", 0))
+
+	ln, clean := listenAndServe(t, []svcRegistrar{
+		registerPraefectInfoServer(info.NewServer(mgr, config.Config{}, nil, gs))})
 	defer clean()
 	for _, tc := range []struct {
 		desc            string
 		args            []string
 		virtualStorages []*config.VirtualStorage
-		datalossCheck   func(context.Context, *gitalypb.DatalossCheckRequest) (*gitalypb.DatalossCheckResponse, error)
 		output          string
 		error           error
 	}{
 		{
 			desc:  "positional arguments",
-			args:  []string{"-virtual-storage=test-virtual-storage", "positional-arg"},
+			args:  []string{"-virtual-storage=virtual-storage-1", "positional-arg"},
 			error: UnexpectedPositionalArgsError{Command: "dataloss"},
 		},
 		{
-			desc: "no failover",
-			args: []string{"-virtual-storage=test-virtual-storage"},
-			datalossCheck: func(ctx context.Context, req *gitalypb.DatalossCheckRequest) (*gitalypb.DatalossCheckResponse, error) {
-				assert.Equal(t, "test-virtual-storage", req.GetVirtualStorage())
-				return &gitalypb.DatalossCheckResponse{
-					CurrentPrimary: "test-current-primary",
-				}, nil
-			},
-			output: `Virtual storage: test-virtual-storage
-  Current write-enabled primary: test-current-primary
-    No data loss as the virtual storage has not encountered a failover
-`,
-		},
-		{
-			desc: "no data loss",
-			args: []string{"-virtual-storage=test-virtual-storage"},
-			datalossCheck: func(ctx context.Context, req *gitalypb.DatalossCheckRequest) (*gitalypb.DatalossCheckResponse, error) {
-				assert.Equal(t, "test-virtual-storage", req.GetVirtualStorage())
-				return &gitalypb.DatalossCheckResponse{
-					PreviousWritablePrimary: "test-previous-primary",
-					IsReadOnly:              false,
-					CurrentPrimary:          "test-current-primary",
-				}, nil
-			},
-			output: `Virtual storage: test-virtual-storage
-  Current write-enabled primary: test-current-primary
-  Previous write-enabled primary: test-previous-primary
-    No data loss from failing over from test-previous-primary
-`,
-		},
-		{
 			desc: "data loss",
-			args: []string{"-virtual-storage=test-virtual-storage"},
-			datalossCheck: func(ctx context.Context, req *gitalypb.DatalossCheckRequest) (*gitalypb.DatalossCheckResponse, error) {
-				assert.Equal(t, "test-virtual-storage", req.GetVirtualStorage())
-				return &gitalypb.DatalossCheckResponse{
-					PreviousWritablePrimary: "test-previous-primary",
-					IsReadOnly:              true,
-					CurrentPrimary:          "test-current-primary",
-					OutdatedNodes: []*gitalypb.DatalossCheckResponse_Nodes{
-						{RelativePath: "repository-1", Nodes: []string{"gitaly-2", "gitaly-3"}},
-						{RelativePath: "repository-2", Nodes: []string{"gitaly-1"}},
-					},
-				}, nil
-			},
-			output: `Virtual storage: test-virtual-storage
-  Current read-only primary: test-current-primary
-  Previous write-enabled primary: test-previous-primary
-    Nodes with data loss from failing over from test-previous-primary:
-      repository-1: gitaly-2, gitaly-3
-      repository-2: gitaly-1
+			args: []string{"-virtual-storage=virtual-storage-1"}, output: `Virtual storage: virtual-storage-1
+  Primary: gitaly-1
+  Outdated repositories:
+    repository-1:
+      gitaly-2 is behind by 1 change or less
+      gitaly-3 is behind by 2 changes or less
+    repository-2:
+      gitaly-1 is behind by 1 change or less
 `,
 		},
 		{
 			desc:            "multiple virtual storages",
-			virtualStorages: []*config.VirtualStorage{{Name: "test-virtual-storage-2"}, {Name: "test-virtual-storage-1"}},
-			datalossCheck: func(ctx context.Context, req *gitalypb.DatalossCheckRequest) (*gitalypb.DatalossCheckResponse, error) {
-				return &gitalypb.DatalossCheckResponse{
-					PreviousWritablePrimary: "test-previous-primary",
-					IsReadOnly:              true,
-					CurrentPrimary:          "test-current-primary",
-					OutdatedNodes: []*gitalypb.DatalossCheckResponse_Nodes{
-						{RelativePath: "repository-1", Nodes: []string{"gitaly-2", "gitaly-3"}},
-						{RelativePath: "repository-2", Nodes: []string{"gitaly-1"}},
-					},
-				}, nil
-			},
-			output: `Virtual storage: test-virtual-storage-1
-  Current read-only primary: test-current-primary
-  Previous write-enabled primary: test-previous-primary
-    Nodes with data loss from failing over from test-previous-primary:
-      repository-1: gitaly-2, gitaly-3
-      repository-2: gitaly-1
-Virtual storage: test-virtual-storage-2
-  Current read-only primary: test-current-primary
-  Previous write-enabled primary: test-previous-primary
-    Nodes with data loss from failing over from test-previous-primary:
-      repository-1: gitaly-2, gitaly-3
-      repository-2: gitaly-1
+			virtualStorages: []*config.VirtualStorage{{Name: "virtual-storage-2"}, {Name: "virtual-storage-1"}},
+			output: `Virtual storage: virtual-storage-1
+  Primary: gitaly-1
+  Outdated repositories:
+    repository-1:
+      gitaly-2 is behind by 1 change or less
+      gitaly-3 is behind by 2 changes or less
+    repository-2:
+      gitaly-1 is behind by 1 change or less
+Virtual storage: virtual-storage-2
+  Primary: gitaly-4
+  All repositories are up to date!
 `,
 		},
 	} {
 		t.Run(tc.desc, func(t *testing.T) {
-			mockSvc.DatalossCheckFunc = tc.datalossCheck
 			cmd := newDatalossSubcommand()
 			output := &bytes.Buffer{}
 			cmd.output = output
 
 			fs := cmd.FlagSet()
 			require.NoError(t, fs.Parse(tc.args))
-			require.Equal(t, tc.error, cmd.Exec(fs, config.Config{
+			err := cmd.Exec(fs, config.Config{
 				VirtualStorages: tc.virtualStorages,
 				SocketPath:      ln.Addr().String(),
-			}))
+			})
+			require.Equal(t, tc.error, err, err)
 			require.Equal(t, tc.output, output.String())
 		})
 	}
diff --git a/internal/praefect/service/info/dataloss.go b/internal/praefect/service/info/dataloss.go
index 9c6a898ba..5ce72ce7f 100644
--- a/internal/praefect/service/info/dataloss.go
+++ b/internal/praefect/service/info/dataloss.go
@@ -8,37 +8,38 @@ import (
 )
 
 func (s *Server) DatalossCheck(ctx context.Context, req *gitalypb.DatalossCheckRequest) (*gitalypb.DatalossCheckResponse, error) {
-	shard, err := s.nodeMgr.GetShard(req.VirtualStorage)
+	shard, err := s.nodeMgr.GetShard(req.GetVirtualStorage())
 	if err != nil {
 		return nil, err
 	}
 
-	if shard.PreviousWritablePrimary == nil {
-		return &gitalypb.DatalossCheckResponse{
-			CurrentPrimary: shard.Primary.GetStorage(),
-			IsReadOnly:     shard.IsReadOnly,
-		}, nil
-	}
-
-	repos, err := s.queue.GetOutdatedRepositories(ctx, req.GetVirtualStorage(), shard.PreviousWritablePrimary.GetStorage())
+	outdatedRepos, err := s.rs.GetOutdatedRepositories(ctx, req.GetVirtualStorage())
 	if err != nil {
 		return nil, err
 	}
 
-	outdatedNodes := make([]*gitalypb.DatalossCheckResponse_Nodes, 0, len(repos))
-	for repo, nodes := range repos {
-		outdatedNodes = append(outdatedNodes, &gitalypb.DatalossCheckResponse_Nodes{
-			RelativePath: repo,
-			Nodes:        nodes,
+	pbRepos := make([]*gitalypb.DatalossCheckResponse_Repository, 0, len(outdatedRepos))
+	for relativePath, storages := range outdatedRepos {
+		pbStorages := make([]*gitalypb.DatalossCheckResponse_Repository_Storage, 0, len(storages))
+		for name, behindBy := range storages {
+			pbStorages = append(pbStorages, &gitalypb.DatalossCheckResponse_Repository_Storage{
+				Name:     name,
+				BehindBy: int64(behindBy),
+			})
+		}
+
+		sort.Slice(pbStorages, func(i, j int) bool { return pbStorages[i].Name < pbStorages[j].Name })
+
+		pbRepos = append(pbRepos, &gitalypb.DatalossCheckResponse_Repository{
+			RelativePath: relativePath,
+			Storages:     pbStorages,
 		})
 	}
 
-	sort.Slice(outdatedNodes, func(i, j int) bool { return outdatedNodes[i].RelativePath < outdatedNodes[j].RelativePath })
+	sort.Slice(pbRepos, func(i, j int) bool { return pbRepos[i].RelativePath < pbRepos[j].RelativePath })
 
 	return &gitalypb.DatalossCheckResponse{
-		PreviousWritablePrimary: shard.PreviousWritablePrimary.GetStorage(),
-		CurrentPrimary:          shard.Primary.GetStorage(),
-		IsReadOnly:              shard.IsReadOnly,
-		OutdatedNodes:           outdatedNodes,
+		Primary:      shard.Primary.GetStorage(),
+		Repositories: pbRepos,
 	}, nil
 }
diff --git a/proto/go/gitalypb/praefect.pb.go b/proto/go/gitalypb/praefect.pb.go
index 4841823a7..06703bb14 100644
--- a/proto/go/gitalypb/praefect.pb.go
+++ b/proto/go/gitalypb/praefect.pb.go
@@ -221,15 +221,13 @@ func (m *DatalossCheckRequest) GetVirtualStorage() string {
 }
 
 type DatalossCheckResponse struct {
-	VirtualStorage          string `protobuf:"bytes,1,opt,name=virtual_storage,json=virtualStorage,proto3" json:"virtual_storage,omitempty"`
-	PreviousWritablePrimary string `protobuf:"bytes,2,opt,name=previous_writable_primary,json=previousWritablePrimary,proto3" json:"previous_writable_primary,omitempty"`
-	CurrentPrimary          string `protobuf:"bytes,3,opt,name=current_primary,json=currentPrimary,proto3" json:"current_primary,omitempty"`
-	// whether the virtual storage is currently in read-only mode
-	IsReadOnly           bool                           `protobuf:"varint,4,opt,name=is_read_only,json=isReadOnly,proto3" json:"is_read_only,omitempty"`
-	OutdatedNodes        []*DatalossCheckResponse_Nodes `protobuf:"bytes,5,rep,name=outdated_nodes,json=outdatedNodes,proto3" json:"outdated_nodes,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}                       `json:"-"`
-	XXX_unrecognized     []byte                         `json:"-"`
-	XXX_sizecache        int32                          `json:"-"`
+	// current primary storage
+	Primary string `protobuf:"bytes,1,opt,name=primary,proto3" json:"primary,omitempty"`
+	// repositories with data loss
+	Repositories         []*DatalossCheckResponse_Repository `protobuf:"bytes,2,rep,name=repositories,proto3" json:"repositories,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}                            `json:"-"`
+	XXX_unrecognized     []byte                              `json:"-"`
+	XXX_sizecache        int32                               `json:"-"`
 }
 
 func (m *DatalossCheckResponse) Reset()         { *m = DatalossCheckResponse{} }
@@ -257,88 +255,118 @@ func (m *DatalossCheckResponse) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_DatalossCheckResponse proto.InternalMessageInfo
 
-func (m *DatalossCheckResponse) GetVirtualStorage() string {
+func (m *DatalossCheckResponse) GetPrimary() string {
 	if m != nil {
-		return m.VirtualStorage
+		return m.Primary
 	}
 	return ""
 }
 
-func (m *DatalossCheckResponse) GetPreviousWritablePrimary() string {
+func (m *DatalossCheckResponse) GetRepositories() []*DatalossCheckResponse_Repository {
 	if m != nil {
-		return m.PreviousWritablePrimary
+		return m.Repositories
 	}
-	return ""
+	return nil
 }
 
-func (m *DatalossCheckResponse) GetCurrentPrimary() string {
-	if m != nil {
-		return m.CurrentPrimary
-	}
-	return ""
+type DatalossCheckResponse_Repository struct {
+	// relative path of the repository with outdated replicas
+	RelativePath string `protobuf:"bytes,1,opt,name=relative_path,json=relativePath,proto3" json:"relative_path,omitempty"`
+	// storages on which the repository is outdated
+	Storages             []*DatalossCheckResponse_Repository_Storage `protobuf:"bytes,2,rep,name=storages,proto3" json:"storages,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}                                    `json:"-"`
+	XXX_unrecognized     []byte                                      `json:"-"`
+	XXX_sizecache        int32                                       `json:"-"`
+}
+
+func (m *DatalossCheckResponse_Repository) Reset()         { *m = DatalossCheckResponse_Repository{} }
+func (m *DatalossCheckResponse_Repository) String() string { return proto.CompactTextString(m) }
+func (*DatalossCheckResponse_Repository) ProtoMessage()    {}
+func (*DatalossCheckResponse_Repository) Descriptor() ([]byte, []int) {
+	return fileDescriptor_d32bf44842ead735, []int{5, 0}
 }
 
-func (m *DatalossCheckResponse) GetIsReadOnly() bool {
+func (m *DatalossCheckResponse_Repository) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_DatalossCheckResponse_Repository.Unmarshal(m, b)
+}
+func (m *DatalossCheckResponse_Repository) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_DatalossCheckResponse_Repository.Marshal(b, m, deterministic)
+}
+func (m *DatalossCheckResponse_Repository) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_DatalossCheckResponse_Repository.Merge(m, src)
+}
+func (m *DatalossCheckResponse_Repository) XXX_Size() int {
+	return xxx_messageInfo_DatalossCheckResponse_Repository.Size(m)
+}
+func (m *DatalossCheckResponse_Repository) XXX_DiscardUnknown() {
+	xxx_messageInfo_DatalossCheckResponse_Repository.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DatalossCheckResponse_Repository proto.InternalMessageInfo
+
+func (m *DatalossCheckResponse_Repository) GetRelativePath() string {
 	if m != nil {
-		return m.IsReadOnly
+		return m.RelativePath
 	}
-	return false
+	return ""
 }
 
-func (m *DatalossCheckResponse) GetOutdatedNodes() []*DatalossCheckResponse_Nodes {
+func (m *DatalossCheckResponse_Repository) GetStorages() []*DatalossCheckResponse_Repository_Storage {
 	if m != nil {
-		return m.OutdatedNodes
+		return m.Storages
 	}
 	return nil
 }
 
-type DatalossCheckResponse_Nodes struct {
-	// relative path of the repository with outdated nodes
-	RelativePath string `protobuf:"bytes,1,opt,name=relative_path,json=relativePath,proto3" json:"relative_path,omitempty"`
-	// nodes whose copy of the repository is not up to date
-	Nodes                []string `protobuf:"bytes,2,rep,name=nodes,proto3" json:"nodes,omitempty"`
+type DatalossCheckResponse_Repository_Storage struct {
+	// name of the storage
+	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
+	// behind_by indicates how many generations this storage is behind.
+	BehindBy             int64    `protobuf:"varint,2,opt,name=behind_by,json=behindBy,proto3" json:"behind_by,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
 }
 
-func (m *DatalossCheckResponse_Nodes) Reset()         { *m = DatalossCheckResponse_Nodes{} }
-func (m *DatalossCheckResponse_Nodes) String() string { return proto.CompactTextString(m) }
-func (*DatalossCheckResponse_Nodes) ProtoMessage()    {}
-func (*DatalossCheckResponse_Nodes) Descriptor() ([]byte, []int) {
-	return fileDescriptor_d32bf44842ead735, []int{5, 0}
+func (m *DatalossCheckResponse_Repository_Storage) Reset() {
+	*m = DatalossCheckResponse_Repository_Storage{}
+}
+func (m *DatalossCheckResponse_Repository_Storage) String() string { return proto.CompactTextString(m) }
+func (*DatalossCheckResponse_Repository_Storage) ProtoMessage()    {}
+func (*DatalossCheckResponse_Repository_Storage) Descriptor() ([]byte, []int) {
+	return fileDescriptor_d32bf44842ead735, []int{5, 0, 0}
 }
 
-func (m *DatalossCheckResponse_Nodes) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_DatalossCheckResponse_Nodes.Unmarshal(m, b)
+func (m *DatalossCheckResponse_Repository_Storage) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_DatalossCheckResponse_Repository_Storage.Unmarshal(m, b)
 }
-func (m *DatalossCheckResponse_Nodes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_DatalossCheckResponse_Nodes.Marshal(b, m, deterministic)
+func (m *DatalossCheckResponse_Repository_Storage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_DatalossCheckResponse_Repository_Storage.Marshal(b, m, deterministic)
 }
-func (m *DatalossCheckResponse_Nodes) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_DatalossCheckResponse_Nodes.Merge(m, src)
+func (m *DatalossCheckResponse_Repository_Storage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_DatalossCheckResponse_Repository_Storage.Merge(m, src)
 }
-func (m *DatalossCheckResponse_Nodes) XXX_Size() int {
-	return xxx_messageInfo_DatalossCheckResponse_Nodes.Size(m)
+func (m *DatalossCheckResponse_Repository_Storage) XXX_Size() int {
+	return xxx_messageInfo_DatalossCheckResponse_Repository_Storage.Size(m)
 }
-func (m *DatalossCheckResponse_Nodes) XXX_DiscardUnknown() {
-	xxx_messageInfo_DatalossCheckResponse_Nodes.DiscardUnknown(m)
+func (m *DatalossCheckResponse_Repository_Storage) XXX_DiscardUnknown() {
+	xxx_messageInfo_DatalossCheckResponse_Repository_Storage.DiscardUnknown(m)
 }
 
-var xxx_messageInfo_DatalossCheckResponse_Nodes proto.InternalMessageInfo
+var xxx_messageInfo_DatalossCheckResponse_Repository_Storage proto.InternalMessageInfo
 
-func (m *DatalossCheckResponse_Nodes) GetRelativePath() string {
+func (m *DatalossCheckResponse_Repository_Storage) GetName() string {
 	if m != nil {
-		return m.RelativePath
+		return m.Name
 	}
 	return ""
 }
 
-func (m *DatalossCheckResponse_Nodes) GetNodes() []string {
+func (m *DatalossCheckResponse_Repository_Storage) GetBehindBy() int64 {
 	if m != nil {
-		return m.Nodes
+		return m.BehindBy
 	}
-	return nil
+	return 0
 }
 
 type RepositoryReplicasRequest struct {
@@ -629,7 +657,8 @@ func init() {
 	proto.RegisterType((*EnableWritesResponse)(nil), "gitaly.EnableWritesResponse")
 	proto.RegisterType((*DatalossCheckRequest)(nil), "gitaly.DatalossCheckRequest")
 	proto.RegisterType((*DatalossCheckResponse)(nil), "gitaly.DatalossCheckResponse")
-	proto.RegisterType((*DatalossCheckResponse_Nodes)(nil), "gitaly.DatalossCheckResponse.Nodes")
+	proto.RegisterType((*DatalossCheckResponse_Repository)(nil), "gitaly.DatalossCheckResponse.Repository")
+	proto.RegisterType((*DatalossCheckResponse_Repository_Storage)(nil), "gitaly.DatalossCheckResponse.Repository.Storage")
 	proto.RegisterType((*RepositoryReplicasRequest)(nil), "gitaly.RepositoryReplicasRequest")
 	proto.RegisterType((*RepositoryReplicasResponse)(nil), "gitaly.RepositoryReplicasResponse")
 	proto.RegisterType((*RepositoryReplicasResponse_RepositoryDetails)(nil), "gitaly.RepositoryReplicasResponse.RepositoryDetails")
@@ -640,57 +669,55 @@ func init() {
 func init() { proto.RegisterFile("praefect.proto", fileDescriptor_d32bf44842ead735) }
 
 var fileDescriptor_d32bf44842ead735 = []byte{
-	// 790 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x56, 0xdd, 0x6e, 0xe2, 0x46,
-	0x14, 0x96, 0x09, 0x6c, 0xc9, 0x09, 0xb0, 0xec, 0x2c, 0xbb, 0xb0, 0xee, 0x76, 0x43, 0x1c, 0xb5,
-	0x41, 0x6a, 0x02, 0x11, 0xa9, 0x54, 0xa9, 0x77, 0xcd, 0xcf, 0x45, 0x72, 0x91, 0x20, 0x23, 0x35,
-	0x52, 0x6f, 0xac, 0xc1, 0x3e, 0x81, 0x69, 0x1d, 0x8f, 0x3b, 0x33, 0x50, 0x71, 0xdb, 0xab, 0xbe,
-	0x41, 0x1f, 0xa0, 0x57, 0x7d, 0x91, 0xbe, 0x41, 0xd5, 0xa7, 0xe8, 0x0b, 0xf4, 0xaa, 0xb2, 0x3d,
-	0x76, 0xf9, 0x31, 0x89, 0xc4, 0xde, 0x31, 0xe7, 0xfb, 0xce, 0x77, 0xe6, 0x9c, 0xf9, 0x3c, 0x03,
-	0xd4, 0x42, 0x41, 0xf1, 0x01, 0x5d, 0xd5, 0x0d, 0x05, 0x57, 0x9c, 0xbc, 0x18, 0x33, 0x45, 0xfd,
-	0xb9, 0x09, 0x3e, 0x0b, 0x74, 0xcc, 0xac, 0xc8, 0x09, 0x15, 0xe8, 0x25, 0x2b, 0xeb, 0x0f, 0x03,
-	0x3e, 0x0c, 0x51, 0x7d, 0x3b, 0x55, 0x13, 0x2e, 0x98, 0xa2, 0x8a, 0xcd, 0x70, 0xa8, 0xb8, 0xa0,
-	0x63, 0xb4, 0xf1, 0xa7, 0x29, 0x4a, 0x45, 0x4e, 0xe0, 0xe5, 0x8c, 0x09, 0x35, 0xa5, 0xbe, 0x23,
-	0x13, 0xa4, 0x65, 0xb4, 0x8d, 0xce, 0xee, 0x79, 0xf1, 0xd7, 0x3f, 0x8f, 0x0d, 0xbb, 0xa6, 0x41,
-	0x9d, 0x45, 0x0e, 0xa1, 0x2a, 0xd0, 0x8f, 0x85, 0x9c, 0x90, 0xaa, 0x49, 0xab, 0x10, 0x91, 0xed,
-	0x4a, 0x1a, 0x1c, 0x50, 0x35, 0x21, 0x67, 0xf0, 0x86, 0x2e, 0x96, 0xcc, 0x94, 0x77, 0x62, 0x72,
-	0x83, 0xe6, 0xec, 0xc7, 0x3a, 0x80, 0xfd, 0x8d, 0x5b, 0x95, 0x21, 0x0f, 0x24, 0x5a, 0x97, 0xf0,
-	0xfa, 0x2a, 0xa0, 0x23, 0x1f, 0xef, 0x05, 0x53, 0x28, 0xb7, 0x6b, 0xc1, 0x7a, 0x0b, 0x8d, 0x65,
-	0x15, 0xad, 0x7e, 0x05, 0x8d, 0x4b, 0xaa, 0xa8, 0xcf, 0xa5, 0xbc, 0x98, 0xa0, 0xfb, 0xe3, 0x96,
-	0xf2, 0x7f, 0x17, 0xe0, 0xcd, 0x8a, 0x4e, 0x52, 0x80, 0x1c, 0x6d, 0x10, 0x5a, 0x1b, 0xf2, 0x37,
-	0xf0, 0x2e, 0x14, 0x38, 0x63, 0x7c, 0x2a, 0x9d, 0x9f, 0xa3, 0x61, 0x8c, 0x7c, 0x74, 0x42, 0xc1,
-	0x1e, 0xa9, 0x98, 0xeb, 0x81, 0x37, 0x53, 0xc2, 0xbd, 0xc6, 0x07, 0x09, 0x1c, 0x15, 0x71, 0xa7,
-	0x42, 0x60, 0xa0, 0xb2, 0x8c, 0x64, 0xea, 0x35, 0x1d, 0x4e, 0x89, 0x6d, 0xa8, 0x30, 0xe9, 0x08,
-	0xa4, 0x9e, 0xc3, 0x03, 0x7f, 0xde, 0x2a, 0xb6, 0x8d, 0x4e, 0xd9, 0x06, 0x26, 0x6d, 0xa4, 0xde,
-	0x5d, 0xe0, 0xcf, 0xc9, 0x0d, 0xd4, 0xf8, 0x54, 0x79, 0x54, 0xa1, 0xe7, 0x04, 0xdc, 0x43, 0xd9,
-	0x2a, 0xb5, 0x77, 0x3a, 0x7b, 0xfd, 0xc3, 0x6e, 0x62, 0xbc, 0x6e, 0x6e, 0x9b, 0xdd, 0xdb, 0x88,
-	0x6a, 0x57, 0xd3, 0xd4, 0x78, 0x69, 0x9e, 0x43, 0x29, 0xfe, 0xb1, 0x6e, 0x20, 0x23, 0xc7, 0x40,
-	0x0d, 0x28, 0x25, 0x05, 0x0b, 0xed, 0x9d, 0xce, 0xae, 0x9d, 0x2c, 0xac, 0x3b, 0x78, 0x67, 0x63,
-	0xc8, 0x25, 0x53, 0x5c, 0xcc, 0x6d, 0x0c, 0x7d, 0xe6, 0xd2, 0xcc, 0x04, 0x7d, 0x00, 0x91, 0x81,
-	0xb1, 0xe8, 0x5e, 0x9f, 0xa4, 0x1b, 0x5d, 0x48, 0x5b, 0x60, 0x59, 0xbf, 0x17, 0xc0, 0xcc, 0x53,
-	0xd4, 0xe7, 0x75, 0x0b, 0x9f, 0xa4, 0x23, 0x4c, 0xf4, 0xbe, 0xca, 0xd1, 0x5b, 0x49, 0x5a, 0x80,
-	0x2e, 0x51, 0x51, 0xe6, 0x4b, 0x3b, 0x15, 0x21, 0x03, 0x28, 0x0b, 0x4d, 0x8f, 0x1b, 0xdb, 0x56,
-	0x30, 0x53, 0x31, 0x5d, 0x78, 0xb5, 0x06, 0x6f, 0x33, 0x09, 0x62, 0x42, 0xd9, 0x8d, 0x0e, 0x51,
-	0x4e, 0x1f, 0xb5, 0xc1, 0xb2, 0xb5, 0xf5, 0x97, 0x01, 0xcd, 0x0b, 0x1e, 0x48, 0x26, 0x15, 0x06,
-	0xee, 0xfc, 0x23, 0xbe, 0x0d, 0xf2, 0x39, 0xd4, 0x14, 0x15, 0x63, 0x54, 0x19, 0x3b, 0x29, 0x56,
-	0x4d, 0xa2, 0x29, 0xed, 0x4b, 0x78, 0x25, 0xf0, 0x01, 0x05, 0x06, 0xee, 0xea, 0xdd, 0x51, 0xcf,
-	0x80, 0x94, 0xfc, 0x35, 0x34, 0x3d, 0x26, 0xe3, 0x4f, 0x44, 0xa0, 0xcb, 0x03, 0x97, 0xf9, 0x3e,
-	0xa3, 0x8a, 0xf1, 0x40, 0x5b, 0xfa, 0xad, 0x86, 0xed, 0x65, 0xd4, 0xfa, 0xc7, 0x80, 0xd6, 0x7a,
-	0x5f, 0xfa, 0xec, 0x8f, 0x81, 0x44, 0xe3, 0x71, 0xf2, 0xbc, 0x5a, 0x8f, 0x10, 0x7b, 0xd1, 0xaf,
-	0x47, 0xf0, 0x52, 0xf7, 0xb5, 0x32, 0x45, 0xdd, 0xee, 0x85, 0x8e, 0x92, 0x93, 0x48, 0x36, 0xed,
-	0x2c, 0xe3, 0x26, 0xad, 0xfd, 0xdf, 0x73, 0x46, 0xff, 0x00, 0x7b, 0xd1, 0x59, 0x3b, 0x3f, 0xf0,
-	0x91, 0xc3, 0xbc, 0xb8, 0x9f, 0xa2, 0xbd, 0x1b, 0x85, 0x6e, 0xf8, 0xe8, 0xda, 0xcb, 0x1f, 0x54,
-	0x29, 0x7f, 0x50, 0xfd, 0x5f, 0x8a, 0xf0, 0x7a, 0xa0, 0x5f, 0x90, 0xeb, 0xe0, 0x81, 0x0f, 0x51,
-	0xcc, 0x98, 0x8b, 0x04, 0x81, 0xac, 0xdb, 0x8f, 0x1c, 0x3c, 0x65, 0xcd, 0xf8, 0xf0, 0x4d, 0xeb,
-	0x79, 0xf7, 0x5a, 0xe5, 0x7f, 0x7f, 0xeb, 0x14, 0xcb, 0x85, 0xba, 0x41, 0x28, 0xd4, 0x57, 0xa7,
-	0x4d, 0xf6, 0x53, 0x85, 0x0d, 0xfe, 0x32, 0xdb, 0x9b, 0x09, 0x2b, 0x05, 0x0a, 0xa7, 0x06, 0xf9,
-	0x0e, 0xaa, 0x4b, 0x57, 0x12, 0x79, 0xbf, 0xe1, 0xa6, 0x4a, 0xc4, 0x3f, 0x7b, 0xf2, 0x1e, 0x5b,
-	0xd8, 0xfa, 0x10, 0x2a, 0x8b, 0x2f, 0x06, 0xf9, 0x34, 0x4d, 0xcc, 0x79, 0x8d, 0xcc, 0xf7, 0xf9,
-	0xe0, 0x92, 0xa8, 0x51, 0x2f, 0x10, 0x05, 0xcd, 0x0d, 0xef, 0x1d, 0xf9, 0x22, 0x95, 0x78, 0xfa,
-	0xed, 0x36, 0x8f, 0x9e, 0xe5, 0xad, 0x56, 0x3d, 0x3f, 0xfd, 0x3e, 0xca, 0xf1, 0xe9, 0xa8, 0xeb,
-	0xf2, 0xc7, 0x5e, 0xf2, 0xf3, 0x84, 0x8b, 0x71, 0x2f, 0x51, 0xea, 0xc5, 0xff, 0x1b, 0x7a, 0x63,
-	0xae, 0xd7, 0xe1, 0x68, 0xf4, 0x22, 0x0e, 0x9d, 0xfd, 0x17, 0x00, 0x00, 0xff, 0xff, 0x9f, 0x63,
-	0x92, 0x96, 0x7e, 0x08, 0x00, 0x00,
+	// 754 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x56, 0x4d, 0x6e, 0xd3, 0x40,
+	0x14, 0x96, 0xd3, 0xd0, 0xa6, 0x2f, 0x69, 0x9b, 0x4e, 0xff, 0x82, 0x5b, 0xda, 0xd4, 0x08, 0x1a,
+	0x89, 0x36, 0xa9, 0x52, 0x24, 0x24, 0x76, 0xf4, 0x67, 0x51, 0x54, 0x41, 0xe5, 0x48, 0x20, 0xb1,
+	0x89, 0xc6, 0xce, 0x34, 0x19, 0x70, 0x3c, 0x66, 0x66, 0x52, 0x29, 0x5b, 0x56, 0xdc, 0x80, 0x03,
+	0xb0, 0xe2, 0x0c, 0x88, 0x2d, 0x37, 0xe0, 0x18, 0x5c, 0x80, 0x15, 0xb2, 0x3d, 0x76, 0x1d, 0xc7,
+	0x69, 0x51, 0xd8, 0x79, 0xde, 0xcf, 0xf7, 0xe6, 0x7b, 0xdf, 0x9b, 0x19, 0xc3, 0xa2, 0xc7, 0x31,
+	0xb9, 0x22, 0xb6, 0xac, 0x7b, 0x9c, 0x49, 0x86, 0x66, 0xbb, 0x54, 0x62, 0x67, 0xa8, 0x83, 0x43,
+	0x5d, 0x65, 0xd3, 0x4b, 0xa2, 0x87, 0x39, 0xe9, 0x84, 0x2b, 0xe3, 0x9b, 0x06, 0xdb, 0x2d, 0x22,
+	0x5f, 0x0c, 0x64, 0x8f, 0x71, 0x2a, 0xb1, 0xa4, 0xd7, 0xa4, 0x25, 0x19, 0xc7, 0x5d, 0x62, 0x92,
+	0x8f, 0x03, 0x22, 0x24, 0x3a, 0x80, 0xa5, 0x6b, 0xca, 0xe5, 0x00, 0x3b, 0x6d, 0x11, 0x7a, 0x2a,
+	0x5a, 0x55, 0xab, 0xcd, 0x1f, 0xe7, 0x3f, 0xff, 0xdc, 0xd7, 0xcc, 0x45, 0xe5, 0x54, 0x59, 0xe8,
+	0x21, 0x2c, 0x70, 0xe2, 0x04, 0x40, 0x6d, 0x0f, 0xcb, 0x5e, 0x25, 0xe7, 0x07, 0x9b, 0xa5, 0xc8,
+	0x78, 0x89, 0x65, 0x0f, 0x1d, 0xc1, 0x1a, 0x4e, 0x96, 0x8c, 0x91, 0x67, 0x82, 0xe0, 0x55, 0x9c,
+	0xb1, 0x1f, 0x63, 0x17, 0x76, 0x26, 0x6e, 0x55, 0x78, 0xcc, 0x15, 0xc4, 0x38, 0x85, 0x95, 0x33,
+	0x17, 0x5b, 0x0e, 0x79, 0xcb, 0xa9, 0x24, 0x62, 0x3a, 0x0a, 0xc6, 0x3a, 0xac, 0x8e, 0xa2, 0x28,
+	0xf4, 0x33, 0x58, 0x3d, 0xc5, 0x12, 0x3b, 0x4c, 0x88, 0x93, 0x1e, 0xb1, 0x3f, 0x4c, 0x09, 0xff,
+	0x23, 0x07, 0x6b, 0x29, 0x9c, 0xb0, 0x00, 0xaa, 0xc0, 0x9c, 0xc7, 0x69, 0x1f, 0xf3, 0x61, 0x08,
+	0x60, 0x46, 0x4b, 0x74, 0x01, 0x25, 0x4e, 0x3c, 0x26, 0xa8, 0x64, 0x9c, 0x12, 0x51, 0xc9, 0x55,
+	0x67, 0x6a, 0xc5, 0x66, 0xad, 0x1e, 0x0a, 0x5c, 0xcf, 0x84, 0xab, 0x9b, 0x51, 0xc6, 0xd0, 0x1c,
+	0xc9, 0xd6, 0xbf, 0x6b, 0x00, 0x37, 0xce, 0x71, 0xc9, 0xb4, 0x0c, 0xc9, 0x2e, 0xa0, 0xa0, 0xc8,
+	0x45, 0xd5, 0x0f, 0xff, 0xb5, 0x7a, 0x3d, 0x92, 0x29, 0x46, 0xd0, 0x9f, 0xc3, 0x5c, 0x34, 0x30,
+	0x08, 0xf2, 0x2e, 0xee, 0xab, 0x96, 0x99, 0xc1, 0x37, 0xda, 0x84, 0x79, 0x8b, 0xf4, 0xa8, 0xdb,
+	0x69, 0x5b, 0xc3, 0x60, 0x80, 0x66, 0xcc, 0x42, 0x68, 0x38, 0x1e, 0x1a, 0xaf, 0xe1, 0x7e, 0x82,
+	0x19, 0xf1, 0x1c, 0x6a, 0xe3, 0x58, 0xea, 0x26, 0x40, 0x4c, 0x35, 0xec, 0x62, 0xb1, 0x89, 0xa2,
+	0x8d, 0x26, 0xd2, 0x12, 0x51, 0xc6, 0xd7, 0x1c, 0xe8, 0x59, 0x88, 0x4a, 0x95, 0x57, 0xa3, 0xaa,
+	0x14, 0x9b, 0x4f, 0x33, 0xf0, 0x52, 0x49, 0x09, 0xd7, 0x29, 0x91, 0x98, 0x3a, 0xe2, 0x46, 0xcb,
+	0x4b, 0x28, 0x70, 0x15, 0xae, 0x3a, 0x39, 0x1d, 0x60, 0x8c, 0xa2, 0xdb, 0xb0, 0x3c, 0xe6, 0x9e,
+	0xa6, 0x13, 0x48, 0x87, 0x82, 0xed, 0x8b, 0x28, 0x06, 0x7d, 0x75, 0x6e, 0xe3, 0xb5, 0xf1, 0x4b,
+	0x83, 0x8d, 0x13, 0xe6, 0x0a, 0x2a, 0x24, 0x71, 0xed, 0xe1, 0x7f, 0x9c, 0x00, 0xf4, 0x08, 0x16,
+	0x25, 0xe6, 0x5d, 0x22, 0xe3, 0xe8, 0xb0, 0xd8, 0x42, 0x68, 0x8d, 0xc2, 0x9e, 0xc0, 0x32, 0x27,
+	0x57, 0x84, 0x13, 0xd7, 0x4e, 0xdf, 0x10, 0xe5, 0xd8, 0x11, 0x05, 0x3f, 0x83, 0x8d, 0x0e, 0x15,
+	0xfe, 0xa9, 0x6d, 0x73, 0x62, 0x33, 0xd7, 0xa6, 0x8e, 0x43, 0xb1, 0xa4, 0xcc, 0xad, 0xe4, 0xab,
+	0x5a, 0xad, 0x60, 0xae, 0x2b, 0xb7, 0x39, 0xea, 0x35, 0x7e, 0x6b, 0x50, 0x19, 0xe7, 0xa5, 0xb4,
+	0xdf, 0x07, 0xe4, 0xb7, 0xa7, 0x9d, 0x75, 0x3e, 0xca, 0xbe, 0xc7, 0x4c, 0x9e, 0x91, 0x3d, 0x58,
+	0x52, 0xbc, 0x52, 0x5d, 0x54, 0x74, 0x4f, 0x94, 0x15, 0x1d, 0xf8, 0xb0, 0x11, 0xb3, 0x38, 0x36,
+	0xa4, 0x76, 0xc3, 0x39, 0x0e, 0xdf, 0x86, 0xa2, 0xaf, 0x75, 0xfb, 0x3d, 0xb3, 0xda, 0xb4, 0x13,
+	0xf0, 0xc9, 0x9b, 0xf3, 0xbe, 0xe9, 0x25, 0xb3, 0xce, 0x3b, 0xd9, 0x8d, 0xba, 0x97, 0xdd, 0xa8,
+	0xe6, 0xa7, 0x3c, 0xac, 0x5c, 0xaa, 0x77, 0xe2, 0xdc, 0xbd, 0x62, 0x2d, 0xc2, 0xaf, 0xa9, 0x4d,
+	0x10, 0x01, 0x34, 0x3e, 0x7e, 0x68, 0xf7, 0xb6, 0xd1, 0x0c, 0xc4, 0xd7, 0x8d, 0xbb, 0xa7, 0xd7,
+	0x28, 0xfc, 0xf9, 0x52, 0xcb, 0x17, 0x72, 0x65, 0x0d, 0x61, 0x28, 0xa7, 0xbb, 0x8d, 0x76, 0x22,
+	0x84, 0x09, 0xf3, 0xa5, 0x57, 0x27, 0x07, 0xa4, 0x0a, 0xe4, 0x0e, 0x35, 0xf4, 0x06, 0x16, 0x46,
+	0xae, 0x24, 0xb4, 0x35, 0xe1, 0xa6, 0x0a, 0xc1, 0x1f, 0xdc, 0x7a, 0x8f, 0x25, 0xb6, 0xde, 0x82,
+	0x52, 0xf2, 0x5d, 0x40, 0x9b, 0x51, 0x62, 0xc6, 0x9b, 0xa3, 0x6f, 0x65, 0x3b, 0x47, 0x40, 0xb5,
+	0x72, 0x0e, 0x49, 0xd8, 0x98, 0xf0, 0xaa, 0xa1, 0xc7, 0x11, 0xc4, 0xed, 0x2f, 0xb4, 0xbe, 0x77,
+	0x67, 0x5c, 0xba, 0xea, 0xf1, 0xe1, 0x3b, 0x3f, 0xc7, 0xc1, 0x56, 0xdd, 0x66, 0xfd, 0x46, 0xf8,
+	0x79, 0xc0, 0x78, 0xb7, 0x11, 0x22, 0x35, 0x82, 0xbf, 0x83, 0x46, 0x97, 0xa9, 0xb5, 0x67, 0x59,
+	0xb3, 0x81, 0xe9, 0xe8, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xe5, 0x56, 0xd8, 0xc4, 0x64, 0x08,
+	0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
diff --git a/proto/praefect.proto b/proto/praefect.proto
index 22c2d61b7..1e2f4ef45 100644
--- a/proto/praefect.proto
+++ b/proto/praefect.proto
@@ -74,19 +74,25 @@ message DatalossCheckRequest {
 }
 
 message DatalossCheckResponse {
-  message Nodes {
-    // relative path of the repository with outdated nodes
+  message Repository {
+    message Storage {
+      // name of the storage
+      string name = 1;
+      // behind_by indicates how many generations this storage is behind.
+      int64 behind_by = 2;
+    }
+
+    // relative path of the repository with outdated replicas
     string relative_path = 1;
-    // nodes whose copy of the repository is not up to date
-    repeated string nodes = 2;
+    // storages on which the repository is outdated
+    repeated Storage storages = 2;
   }
 
-  string virtual_storage = 1;
-  string previous_writable_primary = 2;
-  string current_primary = 3;
-  // whether the virtual storage is currently in read-only mode
-  bool is_read_only = 4;
-  repeated Nodes outdated_nodes = 5;
+  // current primary storage
+  string primary = 1;
+
+  // repositories with data loss
+  repeated Repository repositories = 2;
 }
 
 message RepositoryReplicasRequest{
diff --git a/ruby/proto/gitaly/praefect_pb.rb b/ruby/proto/gitaly/praefect_pb.rb
index 1ad2ce827..cd8fb9abb 100644
--- a/ruby/proto/gitaly/praefect_pb.rb
+++ b/ruby/proto/gitaly/praefect_pb.rb
@@ -22,15 +22,16 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
     optional :virtual_storage, :string, 1
   end
   add_message "gitaly.DatalossCheckResponse" do
-    optional :virtual_storage, :string, 1
-    optional :previous_writable_primary, :string, 2
-    optional :current_primary, :string, 3
-    optional :is_read_only, :bool, 4
-    repeated :outdated_nodes, :message, 5, "gitaly.DatalossCheckResponse.Nodes"
+    optional :primary, :string, 1
+    repeated :repositories, :message, 2, "gitaly.DatalossCheckResponse.Repository"
   end
-  add_message "gitaly.DatalossCheckResponse.Nodes" do
+  add_message "gitaly.DatalossCheckResponse.Repository" do
     optional :relative_path, :string, 1
-    repeated :nodes, :string, 2
+    repeated :storages, :message, 2, "gitaly.DatalossCheckResponse.Repository.Storage"
+  end
+  add_message "gitaly.DatalossCheckResponse.Repository.Storage" do
+    optional :name, :string, 1
+    optional :behind_by, :int64, 2
   end
   add_message "gitaly.RepositoryReplicasRequest" do
     optional :repository, :message, 1, "gitaly.Repository"
@@ -65,7 +66,8 @@ module Gitaly
   EnableWritesResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.EnableWritesResponse").msgclass
   DatalossCheckRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.DatalossCheckRequest").msgclass
   DatalossCheckResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.DatalossCheckResponse").msgclass
-  DatalossCheckResponse::Nodes = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.DatalossCheckResponse.Nodes").msgclass
+  DatalossCheckResponse::Repository = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.DatalossCheckResponse.Repository").msgclass
+  DatalossCheckResponse::Repository::Storage = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.DatalossCheckResponse.Repository.Storage").msgclass
   RepositoryReplicasRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.RepositoryReplicasRequest").msgclass
   RepositoryReplicasResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.RepositoryReplicasResponse").msgclass
   RepositoryReplicasResponse::RepositoryDetails = Google::Protobuf::DescriptorPool.generated_pool.lookup("gitaly.RepositoryReplicasResponse.RepositoryDetails").msgclass