diff --git a/internal/storagenode/client/log_client.go b/internal/storagenode/client/log_client.go
index ab616f209..1ac3abe58 100644
--- a/internal/storagenode/client/log_client.go
+++ b/internal/storagenode/client/log_client.go
@@ -157,17 +157,6 @@ func (c *LogClient) TrimDeprecated(ctx context.Context, tpid types.TopicID, glsn
 	return nil
 }
 
-func (c *LogClient) LogStreamMetadata(ctx context.Context, tpid types.TopicID, lsid types.LogStreamID) (varlogpb.LogStreamDescriptor, error) {
-	rsp, err := c.rpcClient.LogStreamMetadata(ctx, &snpb.LogStreamMetadataRequest{
-		TopicID:     tpid,
-		LogStreamID: lsid,
-	})
-	if err != nil {
-		return rsp.GetLogStreamDescriptor(), fmt.Errorf("logclient: %w", verrors.FromStatusError(err))
-	}
-	return rsp.GetLogStreamDescriptor(), nil
-}
-
 func (c *LogClient) LogStreamReplicaMetadata(ctx context.Context, tpid types.TopicID, lsid types.LogStreamID) (snpb.LogStreamReplicaMetadataDescriptor, error) {
 	rsp, err := c.rpcClient.LogStreamReplicaMetadata(ctx, &snpb.LogStreamReplicaMetadataRequest{
 		TopicID:     tpid,
diff --git a/internal/storagenode/log_server.go b/internal/storagenode/log_server.go
index 42afb9188..46d3d60f6 100644
--- a/internal/storagenode/log_server.go
+++ b/internal/storagenode/log_server.go
@@ -132,13 +132,3 @@ func (ls logServer) LogStreamReplicaMetadata(_ context.Context, req *snpb.LogStr
 	}
 	return &snpb.LogStreamReplicaMetadataResponse{LogStreamReplica: lsrmd}, nil
 }
-
-func (ls logServer) LogStreamMetadata(_ context.Context, req *snpb.LogStreamMetadataRequest) (*snpb.LogStreamMetadataResponse, error) {
-	lse, loaded := ls.sn.executors.Load(req.TopicID, req.LogStreamID)
-	if !loaded {
-		return nil, errors.New("storage: no such logstream")
-	}
-
-	lsd, err := lse.LogStreamMetadata()
-	return &snpb.LogStreamMetadataResponse{LogStreamDescriptor: lsd}, err
-}
diff --git a/internal/storagenode/logstream/executor.go b/internal/storagenode/logstream/executor.go
index b3541ca43..182342c45 100644
--- a/internal/storagenode/logstream/executor.go
+++ b/internal/storagenode/logstream/executor.go
@@ -497,46 +497,6 @@ func (lse *Executor) metadataDescriptor(state executorState) snpb.LogStreamRepli
 	}
 }
 
-func (lse *Executor) LogStreamMetadata() (lsd varlogpb.LogStreamDescriptor, err error) {
-	atomic.AddInt64(&lse.inflight, 1)
-	defer atomic.AddInt64(&lse.inflight, -1)
-
-	if lse.esm.load() == executorStateClosed {
-		return lsd, verrors.ErrClosed
-	}
-
-	var status varlogpb.LogStreamStatus
-	switch lse.esm.load() {
-	case executorStateAppendable:
-		status = varlogpb.LogStreamStatusRunning
-	case executorStateSealing, executorStateLearning:
-		status = varlogpb.LogStreamStatusSealing
-	case executorStateSealed:
-		status = varlogpb.LogStreamStatusSealed
-	}
-
-	localLWM := lse.lsc.localLowWatermark()
-	localHWM := lse.lsc.localHighWatermark()
-	lsd = varlogpb.LogStreamDescriptor{
-		TopicID:     lse.tpid,
-		LogStreamID: lse.lsid,
-		Status:      status,
-		Head: varlogpb.LogEntryMeta{
-			TopicID:     lse.tpid,
-			LogStreamID: lse.lsid,
-			LLSN:        localLWM.LLSN,
-			GLSN:        localLWM.GLSN,
-		},
-		Tail: varlogpb.LogEntryMeta{
-			TopicID:     lse.tpid,
-			LogStreamID: lse.lsid,
-			LLSN:        localHWM.LLSN,
-			GLSN:        localHWM.GLSN,
-		},
-	}
-	return lsd, nil
-}
-
 func (lse *Executor) Trim(_ context.Context, glsn types.GLSN) error {
 	atomic.AddInt64(&lse.inflight, 1)
 	defer atomic.AddInt64(&lse.inflight, -1)
diff --git a/internal/storagenode/logstream/executor_test.go b/internal/storagenode/logstream/executor_test.go
index d19498c3c..fe00d25ce 100644
--- a/internal/storagenode/logstream/executor_test.go
+++ b/internal/storagenode/logstream/executor_test.go
@@ -113,9 +113,6 @@ func TestExecutor_Closed(t *testing.T) {
 	_, err = lse.Metadata()
 	assert.ErrorIs(t, err, verrors.ErrClosed)
 
-	_, err = lse.LogStreamMetadata()
-	assert.ErrorIs(t, err, verrors.ErrClosed)
-
 	_, err = lse.SubscribeWithGLSN(types.MinGLSN, types.MinGLSN)
 	assert.ErrorIs(t, err, verrors.ErrClosed)
 
diff --git a/pkg/varlog/log.go b/pkg/varlog/log.go
index 2fc096d5d..14248a64b 100644
--- a/pkg/varlog/log.go
+++ b/pkg/varlog/log.go
@@ -13,7 +13,6 @@ import (
 	"github.com/kakao/varlog/pkg/types"
 	"github.com/kakao/varlog/pkg/util/runner"
 	"github.com/kakao/varlog/pkg/util/syncutil/atomicutil"
-	"github.com/kakao/varlog/proto/snpb"
 	"github.com/kakao/varlog/proto/varlogpb"
 )
 
@@ -37,23 +36,6 @@ type Log interface {
 
 	Trim(ctx context.Context, topicID types.TopicID, until types.GLSN, opts TrimOption) error
 
-	// LogStreamMetadata returns metadata of log stream specified by the
-	// arguments tpid and lsid.
-	// It returns the first metadata that is fetched successfully from all
-	// replicas in the log stream.
-	// It returns an error if the log stream does not exist or fails to
-	// fetch metadata from all replicas.
-	//
-	// Deprecated: Use PeekLogStream
-	LogStreamMetadata(ctx context.Context, tpid types.TopicID, lsid types.LogStreamID) (varlogpb.LogStreamDescriptor, error)
-
-	// LogStreamReplicaMetadata returns metadata of log stream replica
-	// specified by the arguments tpid and lsid. It returns the first
-	// successful result among all replicas.
-	//
-	// Deprecated: Use PeekLogStream
-	LogStreamReplicaMetadata(ctx context.Context, tpid types.TopicID, lsid types.LogStreamID) (snpb.LogStreamReplicaMetadataDescriptor, error)
-
 	// PeekLogStream returns the log sequence numbers at the first and the
 	// last. It fetches the metadata for each replica of a log stream lsid
 	// concurrently and takes a result from either appendable or sealed
@@ -191,14 +173,6 @@ func (v *logImpl) Trim(ctx context.Context, topicID types.TopicID, until types.G
 	return v.trim(ctx, topicID, until, opts)
 }
 
-func (v *logImpl) LogStreamMetadata(ctx context.Context, tpid types.TopicID, lsid types.LogStreamID) (varlogpb.LogStreamDescriptor, error) {
-	return v.logStreamMetadata(ctx, tpid, lsid)
-}
-
-func (v *logImpl) LogStreamReplicaMetadata(ctx context.Context, tpid types.TopicID, lsid types.LogStreamID) (snpb.LogStreamReplicaMetadataDescriptor, error) {
-	return v.logStreamReplicaMetadata(ctx, tpid, lsid)
-}
-
 func (v *logImpl) PeekLogStream(ctx context.Context, tpid types.TopicID, lsid types.LogStreamID) (first varlogpb.LogSequenceNumber, last varlogpb.LogSequenceNumber, err error) {
 	return v.peekLogStream(ctx, tpid, lsid)
 }
diff --git a/pkg/varlog/log_mock.go b/pkg/varlog/log_mock.go
index 41b3c623b..7fe132c71 100644
--- a/pkg/varlog/log_mock.go
+++ b/pkg/varlog/log_mock.go
@@ -11,7 +11,6 @@ import (
 	gomock "github.com/golang/mock/gomock"
 
 	types "github.com/kakao/varlog/pkg/types"
-	snpb "github.com/kakao/varlog/proto/snpb"
 	varlogpb "github.com/kakao/varlog/proto/varlogpb"
 )
 
@@ -90,36 +89,6 @@ func (mr *MockLogMockRecorder) Close() *gomock.Call {
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockLog)(nil).Close))
 }
 
-// LogStreamMetadata mocks base method.
-func (m *MockLog) LogStreamMetadata(arg0 context.Context, arg1 types.TopicID, arg2 types.LogStreamID) (varlogpb.LogStreamDescriptor, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "LogStreamMetadata", arg0, arg1, arg2)
-	ret0, _ := ret[0].(varlogpb.LogStreamDescriptor)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// LogStreamMetadata indicates an expected call of LogStreamMetadata.
-func (mr *MockLogMockRecorder) LogStreamMetadata(arg0, arg1, arg2 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LogStreamMetadata", reflect.TypeOf((*MockLog)(nil).LogStreamMetadata), arg0, arg1, arg2)
-}
-
-// LogStreamReplicaMetadata mocks base method.
-func (m *MockLog) LogStreamReplicaMetadata(arg0 context.Context, arg1 types.TopicID, arg2 types.LogStreamID) (snpb.LogStreamReplicaMetadataDescriptor, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "LogStreamReplicaMetadata", arg0, arg1, arg2)
-	ret0, _ := ret[0].(snpb.LogStreamReplicaMetadataDescriptor)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// LogStreamReplicaMetadata indicates an expected call of LogStreamReplicaMetadata.
-func (mr *MockLogMockRecorder) LogStreamReplicaMetadata(arg0, arg1, arg2 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LogStreamReplicaMetadata", reflect.TypeOf((*MockLog)(nil).LogStreamReplicaMetadata), arg0, arg1, arg2)
-}
-
 // PeekLogStream mocks base method.
 func (m *MockLog) PeekLogStream(arg0 context.Context, arg1 types.TopicID, arg2 types.LogStreamID) (varlogpb.LogSequenceNumber, varlogpb.LogSequenceNumber, error) {
 	m.ctrl.T.Helper()
diff --git a/pkg/varlog/operations.go b/pkg/varlog/operations.go
index 445e71417..d757c60a5 100644
--- a/pkg/varlog/operations.go
+++ b/pkg/varlog/operations.go
@@ -6,7 +6,6 @@ import (
 	"strings"
 	"sync"
 
-	"github.com/pkg/errors"
 	"go.uber.org/multierr"
 
 	"github.com/kakao/varlog/pkg/types"
@@ -99,56 +98,6 @@ func (v *logImpl) appendTo(ctx context.Context, tpid types.TopicID, lsid types.L
 	return res, nil
 }
 
-func (v *logImpl) logStreamMetadata(ctx context.Context, tpID types.TopicID, lsID types.LogStreamID) (lsd varlogpb.LogStreamDescriptor, err error) {
-	replicas, ok := v.replicasRetriever.Retrieve(tpID, lsID)
-	if !ok {
-		return varlogpb.LogStreamDescriptor{}, errNoLogStream
-	}
-
-	for _, replica := range replicas {
-		cl, cerr := v.logCLManager.GetOrConnect(ctx, replica.StorageNodeID, replica.Address)
-		if cerr != nil {
-			err = multierr.Append(err, cerr)
-			continue
-		}
-		lsd, cerr = cl.LogStreamMetadata(ctx, tpID, lsID)
-		if cerr != nil {
-			err = multierr.Append(err, cerr)
-			continue
-		}
-		if lsd.Status.Deleted() {
-			err = multierr.Append(err, errors.Errorf("invalid status: %s", lsd.Status.String()))
-			continue
-		}
-		return lsd, nil
-	}
-	return lsd, err
-}
-
-func (v *logImpl) logStreamReplicaMetadata(ctx context.Context, tpID types.TopicID, lsID types.LogStreamID) (snpb.LogStreamReplicaMetadataDescriptor, error) {
-	replicas, ok := v.replicasRetriever.Retrieve(tpID, lsID)
-	if !ok {
-		return snpb.LogStreamReplicaMetadataDescriptor{}, errNoLogStream
-	}
-
-	var err error
-	for _, replica := range replicas {
-		cl, cerr := v.logCLManager.GetOrConnect(ctx, replica.StorageNodeID, replica.Address)
-		if cerr != nil {
-			err = multierr.Append(err, cerr)
-			continue
-		}
-
-		lsrmd, cerr := cl.LogStreamReplicaMetadata(ctx, tpID, lsID)
-		if cerr != nil {
-			err = multierr.Append(err, cerr)
-			continue
-		}
-		return lsrmd, nil
-	}
-	return snpb.LogStreamReplicaMetadataDescriptor{}, err
-}
-
 func (v *logImpl) peekLogStream(ctx context.Context, tpid types.TopicID, lsid types.LogStreamID) (first varlogpb.LogSequenceNumber, last varlogpb.LogSequenceNumber, err error) {
 	replicas, ok := v.replicasRetriever.Retrieve(tpid, lsid)
 	if !ok {
diff --git a/pkg/varlogtest/log.go b/pkg/varlogtest/log.go
index 70b4de447..8cd860bfb 100644
--- a/pkg/varlogtest/log.go
+++ b/pkg/varlogtest/log.go
@@ -3,17 +3,13 @@ package varlogtest
 import (
 	"context"
 	"io"
-	"path/filepath"
 	"sync"
 
-	"github.com/gogo/protobuf/proto"
 	"github.com/pkg/errors"
 
-	"github.com/kakao/varlog/internal/storagenode/volume"
 	"github.com/kakao/varlog/pkg/types"
 	"github.com/kakao/varlog/pkg/varlog"
 	"github.com/kakao/varlog/pkg/verrors"
-	"github.com/kakao/varlog/proto/snpb"
 	"github.com/kakao/varlog/proto/varlogpb"
 )
 
@@ -273,90 +269,6 @@ func (c *testLog) Trim(ctx context.Context, topicID types.TopicID, until types.G
 	panic("not implemented")
 }
 
-func (c *testLog) LogStreamMetadata(_ context.Context, topicID types.TopicID, logStreamID types.LogStreamID) (varlogpb.LogStreamDescriptor, error) {
-	if err := c.lock(); err != nil {
-		return varlogpb.LogStreamDescriptor{}, err
-	}
-	defer c.unlock()
-
-	topicDesc, ok := c.vt.topics[topicID]
-	if !ok {
-		return varlogpb.LogStreamDescriptor{}, errors.New("no such topic")
-	}
-
-	if !topicDesc.HasLogStream(logStreamID) {
-		return varlogpb.LogStreamDescriptor{}, errors.New("no such log stream")
-	}
-
-	logStreamDesc, ok := c.vt.logStreams[logStreamID]
-	if !ok {
-		return varlogpb.LogStreamDescriptor{}, errors.New("no such log stream")
-	}
-
-	logStreamDesc = *proto.Clone(&logStreamDesc).(*varlogpb.LogStreamDescriptor)
-	head, tail := c.vt.peek(topicID, logStreamID)
-	logStreamDesc.Head = head //nolint:staticcheck
-	logStreamDesc.Tail = tail
-	return logStreamDesc, nil
-}
-
-func (c *testLog) LogStreamReplicaMetadata(_ context.Context, tpid types.TopicID, lsid types.LogStreamID) (snpb.LogStreamReplicaMetadataDescriptor, error) {
-	if err := c.lock(); err != nil {
-		return snpb.LogStreamReplicaMetadataDescriptor{}, err
-	}
-	defer c.unlock()
-
-	topicDesc, ok := c.vt.topics[tpid]
-	if !ok {
-		return snpb.LogStreamReplicaMetadataDescriptor{}, errors.New("no such topic")
-	}
-
-	if !topicDesc.HasLogStream(lsid) {
-		return snpb.LogStreamReplicaMetadataDescriptor{}, errors.New("no such log stream")
-	}
-
-	lsd, ok := c.vt.logStreams[lsid]
-	if !ok {
-		return snpb.LogStreamReplicaMetadataDescriptor{}, errors.New("no such log stream")
-	}
-
-	snid := lsd.Replicas[0].StorageNodeID
-	snmd, ok := c.vt.storageNodes[snid]
-	if !ok {
-		return snpb.LogStreamReplicaMetadataDescriptor{}, errors.New("no such storage node")
-	}
-
-	snpath := snmd.Storages[0].Path
-	dataPath := filepath.Join(snpath, volume.LogStreamDirName(tpid, lsid))
-
-	n := len(c.vt.globalLogEntries[tpid])
-	lastGLSN := c.vt.globalLogEntries[tpid][n-1].GLSN
-	head, tail := c.vt.peek(tpid, lsid)
-	return snpb.LogStreamReplicaMetadataDescriptor{
-		LogStreamReplica: varlogpb.LogStreamReplica{
-			StorageNode: varlogpb.StorageNode{
-				StorageNodeID: snid,
-			},
-			TopicLogStream: varlogpb.TopicLogStream{
-				TopicID:     tpid,
-				LogStreamID: lsid,
-			},
-		},
-		Status:              varlogpb.LogStreamStatusRunning,
-		Version:             c.vt.version,
-		GlobalHighWatermark: lastGLSN,
-		LocalLowWatermark: varlogpb.LogSequenceNumber{
-			GLSN: head.GLSN,
-			LLSN: head.LLSN,
-		},
-		LocalHighWatermark: varlogpb.LogSequenceNumber{
-			GLSN: tail.GLSN,
-			LLSN: tail.LLSN,
-		},
-		Path: dataPath,
-	}, nil
-}
-
 func (c *testLog) PeekLogStream(ctx context.Context, tpid types.TopicID, lsid types.LogStreamID) (first varlogpb.LogSequenceNumber, last varlogpb.LogSequenceNumber, err error) {
 	if err = c.lock(); err != nil {
 		return first, last, err
diff --git a/pkg/varlogtest/varlogtest_test.go b/pkg/varlogtest/varlogtest_test.go
index f3d15ed8b..a585b084c 100644
--- a/pkg/varlogtest/varlogtest_test.go
+++ b/pkg/varlogtest/varlogtest_test.go
@@ -141,17 +141,6 @@ func TestVarlogTest(t *testing.T) {
 		topicID := topicIDs[i]
 		logStreamID := addLogStream(topicID)
 
-		logStreamDesc, err := vlg.LogStreamMetadata(context.Background(), topicID, logStreamID) //nolint:staticcheck
-		require.NoError(t, err)
-		require.Equal(t, varlogpb.LogEntryMeta{
-			TopicID:     topicID,
-			LogStreamID: logStreamID,
-		}, logStreamDesc.Head) //nolint:staticcheck
-		require.Equal(t, varlogpb.LogEntryMeta{
-			TopicID:     topicID,
-			LogStreamID: logStreamID,
-		}, logStreamDesc.Tail)
-
 		first, last, err := vlg.PeekLogStream(context.Background(), topicID, logStreamID)
 		require.NoError(t, err)
 		require.True(t, first.Invalid())
diff --git a/proto/snpb/log_io.pb.go b/proto/snpb/log_io.pb.go
index 4ffe34be9..c6cad26d0 100644
--- a/proto/snpb/log_io.pb.go
+++ b/proto/snpb/log_io.pb.go
@@ -832,67 +832,66 @@ func init() {
 func init() { proto.RegisterFile("proto/snpb/log_io.proto", fileDescriptor_7692726f23e518ee) }
 
 var fileDescriptor_7692726f23e518ee = []byte{
-	// 949 bytes of a gzipped FileDescriptorProto
+	// 932 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x57, 0x41, 0x6f, 0xe3, 0x44,
-	0x14, 0x8e, 0x13, 0x77, 0xd3, 0xbc, 0x74, 0x57, 0xbb, 0x53, 0x96, 0x4d, 0xbd, 0x6c, 0x1c, 0x59,
-	0xb0, 0x2a, 0x12, 0xb5, 0x51, 0x11, 0x5a, 0x90, 0x8a, 0x04, 0xa1, 0x5d, 0x54, 0xe1, 0x2d, 0xc8,
-	0xa9, 0xf6, 0x80, 0x04, 0x95, 0x1d, 0x0f, 0xc6, 0xea, 0xc4, 0x63, 0x6c, 0x07, 0x29, 0xe2, 0x07,
-	0x70, 0xdd, 0x9f, 0x80, 0xf8, 0x0d, 0x1c, 0xb8, 0x70, 0xdf, 0xe3, 0x5e, 0x90, 0x38, 0xa0, 0x1c,
-	0xd2, 0x1f, 0x81, 0xd8, 0x13, 0x9a, 0xf1, 0xd8, 0xb1, 0x5b, 0x47, 0x6d, 0x04, 0x39, 0x6c, 0x6f,
-	0x9e, 0x99, 0xf7, 0xbe, 0x79, 0xf3, 0xbd, 0xcf, 0x6f, 0xde, 0xc0, 0xbd, 0x30, 0xa2, 0x09, 0x35,
-	0xe2, 0x20, 0x74, 0x0c, 0x42, 0xbd, 0x13, 0x9f, 0xea, 0x7c, 0x06, 0xb5, 0x7f, 0xb0, 0x23, 0x42,
-	0x3d, 0x9d, 0xad, 0x28, 0x3b, 0x9e, 0x9f, 0x7c, 0x37, 0x76, 0xf4, 0x21, 0x1d, 0x19, 0x1e, 0xf5,
-	0xa8, 0xc1, 0x6d, 0x9c, 0xf1, 0xb7, 0x7c, 0x94, 0x42, 0xb0, 0xaf, 0xd4, 0x57, 0xb9, 0xef, 0x51,
-	0xea, 0x11, 0x3c, 0xb7, 0xc2, 0xa3, 0x30, 0x99, 0x88, 0xc5, 0x7b, 0x29, 0x70, 0xe8, 0x18, 0x23,
-	0x9c, 0xd8, 0xae, 0x9d, 0xd8, 0x62, 0x61, 0x93, 0x07, 0x51, 0x9e, 0xd4, 0x7e, 0xa9, 0xc3, 0xcd,
-	0x4f, 0xc2, 0x10, 0x07, 0xae, 0x85, 0xbf, 0x1f, 0xe3, 0x38, 0x41, 0x03, 0x58, 0x4f, 0x68, 0xe8,
-	0x0f, 0x4f, 0x7c, 0xb7, 0x23, 0xf5, 0xa4, 0xed, 0xb5, 0xfe, 0x07, 0xb3, 0xa9, 0xda, 0x3c, 0x66,
-	0x73, 0x87, 0xfb, 0x2f, 0xa7, 0xea, 0xdb, 0x85, 0x60, 0x4f, 0xed, 0x53, 0x9b, 0x1a, 0xe9, 0x8e,
-	0x46, 0x78, 0xea, 0x19, 0xc9, 0x24, 0xc4, 0xb1, 0x2e, 0x8c, 0xad, 0x26, 0x47, 0x3a, 0x74, 0x91,
-	0x0b, 0x37, 0xd9, 0xe9, 0xe3, 0x24, 0xc2, 0xf6, 0x88, 0x21, 0xd7, 0x39, 0xf2, 0xc7, 0xb3, 0xa9,
-	0xda, 0x36, 0xa9, 0x37, 0xe0, 0xf3, 0x1c, 0x7d, 0xe7, 0x72, 0xf4, 0x82, 0x83, 0xd5, 0x26, 0xf9,
-	0xc0, 0x45, 0x1d, 0x68, 0x86, 0xf6, 0x84, 0x50, 0xdb, 0xed, 0x34, 0x7a, 0x8d, 0xed, 0x0d, 0x2b,
-	0x1b, 0xa2, 0x3d, 0x68, 0x3a, 0xf6, 0xf0, 0x74, 0x1c, 0xc6, 0x1d, 0xb9, 0xd7, 0xd8, 0x6e, 0xef,
-	0xbe, 0xa1, 0x0b, 0xfe, 0x33, 0xb6, 0xf4, 0x41, 0x42, 0x23, 0xdb, 0xc3, 0x47, 0xd4, 0xc5, 0x7d,
-	0xf9, 0xf9, 0x54, 0xad, 0x59, 0x99, 0x8b, 0xf6, 0x35, 0x6c, 0x64, 0x1c, 0xc5, 0x63, 0x92, 0xa0,
-	0x47, 0x20, 0x33, 0x1a, 0x39, 0x3d, 0xed, 0xdd, 0x07, 0x17, 0xa0, 0x4c, 0xea, 0x1d, 0x04, 0x49,
-	0x34, 0x79, 0x82, 0x13, 0x5b, 0x60, 0x71, 0x07, 0xf4, 0x1a, 0xac, 0xe1, 0x28, 0xa2, 0x11, 0x3f,
-	0x7e, 0xcb, 0x4a, 0x07, 0xda, 0xe7, 0x70, 0x2b, 0x87, 0x0f, 0x69, 0x10, 0x63, 0xf4, 0x21, 0x34,
-	0x23, 0xbe, 0x55, 0xdc, 0x91, 0x78, 0xb8, 0x5b, 0x7a, 0x41, 0x2e, 0x7a, 0x31, 0x98, 0x2c, 0x56,
-	0x61, 0xaf, 0x3d, 0xab, 0x43, 0xdb, 0xc2, 0x76, 0x9e, 0xce, 0xc7, 0x20, 0x7b, 0x24, 0x0e, 0x78,
-	0xac, 0x72, 0x7f, 0x77, 0x36, 0x55, 0xe5, 0xcf, 0xcc, 0xc1, 0xd1, 0xcb, 0xa9, 0xfa, 0xf0, 0x72,
-	0xa6, 0x99, 0xa5, 0xc5, 0xfd, 0x4b, 0xb2, 0xa8, 0xaf, 0x4c, 0x16, 0x8d, 0x15, 0xc8, 0x42, 0xfb,
-	0x4d, 0x82, 0x8d, 0x94, 0x12, 0x41, 0xef, 0xff, 0xc5, 0xc9, 0x63, 0x90, 0x09, 0xc3, 0xa9, 0xcf,
-	0x71, 0xcc, 0x2b, 0xe3, 0x98, 0x1c, 0x87, 0xf9, 0x97, 0x75, 0x2b, 0x15, 0x74, 0xab, 0xfd, 0x5d,
-	0x87, 0xdb, 0x83, 0xb1, 0x13, 0x0f, 0x23, 0xdf, 0xc1, 0x59, 0x4a, 0x9f, 0x02, 0xb0, 0xed, 0x4f,
-	0x1c, 0xec, 0xf9, 0xd9, 0x21, 0x1e, 0xcd, 0xa6, 0x6a, 0x8b, 0x85, 0xd6, 0x67, 0x93, 0x4b, 0x9c,
-	0xa4, 0xc5, 0xa0, 0xb8, 0x13, 0xfa, 0x12, 0xd6, 0x39, 0x2e, 0x0e, 0x5c, 0x71, 0xa4, 0xf7, 0x59,
-	0x8a, 0x99, 0xd9, 0x41, 0xe0, 0x2e, 0x81, 0xd9, 0x64, 0x30, 0x07, 0x81, 0x5b, 0x12, 0x4d, 0x63,
-	0x65, 0xa2, 0x91, 0x57, 0x21, 0x9a, 0xdf, 0x25, 0xb8, 0x53, 0x60, 0xfe, 0x95, 0x53, 0xce, 0x3f,
-	0x75, 0x40, 0x79, 0xfc, 0xc7, 0xf4, 0x1a, 0x54, 0xf7, 0xa7, 0x00, 0x64, 0x2e, 0xfb, 0xc6, 0x5c,
-	0xf6, 0xe6, 0x72, 0xb2, 0xe7, 0xf4, 0xb5, 0x48, 0x51, 0xf6, 0x24, 0x93, 0xbd, 0x3c, 0x97, 0xbd,
-	0xb9, 0x8c, 0xec, 0x39, 0x66, 0x93, 0xa4, 0xb2, 0xd7, 0x06, 0xb0, 0x59, 0xa2, 0x5e, 0x88, 0x67,
-	0x0f, 0x5a, 0x8c, 0x26, 0xcc, 0xae, 0x06, 0x71, 0x77, 0x6c, 0x2d, 0xbc, 0x3b, 0x44, 0x5d, 0x5f,
-	0x27, 0x62, 0xac, 0xfd, 0x2a, 0xc1, 0xdd, 0xe3, 0xc8, 0x1f, 0xed, 0xe3, 0x30, 0xc2, 0x43, 0x3b,
-	0xc1, 0xab, 0xbd, 0xb1, 0x33, 0xa5, 0xd7, 0xff, 0x9b, 0xd2, 0xb5, 0x3f, 0x24, 0xe8, 0xe4, 0x29,
-	0x7d, 0x22, 0x9a, 0x8f, 0x57, 0x5f, 0x8d, 0xda, 0x8f, 0xb0, 0x55, 0x71, 0x2c, 0x91, 0xe9, 0x6f,
-	0xe0, 0x6e, 0x21, 0x04, 0x17, 0x33, 0x29, 0x84, 0x09, 0x8d, 0x44, 0xd6, 0xdf, 0xac, 0xca, 0x7a,
-	0x0a, 0xb5, 0x9f, 0xdb, 0x0a, 0x01, 0x6c, 0x92, 0x8b, 0x4b, 0xda, 0x5f, 0x12, 0xa8, 0xb9, 0x8b,
-	0x85, 0x43, 0xe2, 0x0f, 0xed, 0x6b, 0xc4, 0xed, 0x4f, 0x12, 0xf4, 0x16, 0x1f, 0x4f, 0x70, 0x3c,
-	0x04, 0x54, 0x08, 0x25, 0x4a, 0xad, 0x04, 0xc1, 0x46, 0xa9, 0x5d, 0x5a, 0x04, 0x75, 0x81, 0xeb,
-	0xdb, 0xe4, 0x9c, 0xe5, 0xee, 0x4c, 0x86, 0x35, 0x93, 0x7a, 0x87, 0x5f, 0xa0, 0x4f, 0xe1, 0x46,
-	0xda, 0x76, 0x21, 0xa5, 0xb2, 0x17, 0xe3, 0xa4, 0x2b, 0xf7, 0xab, 0xfb, 0x34, 0x1e, 0xb1, 0x56,
-	0x43, 0x1f, 0x81, 0xcc, 0x1a, 0x11, 0xd4, 0x29, 0x99, 0x15, 0xda, 0x35, 0x65, 0xab, 0x62, 0x25,
-	0x77, 0x3f, 0x82, 0x56, 0x5e, 0x57, 0xd0, 0x83, 0x92, 0xe5, 0xf9, 0x26, 0x41, 0xe9, 0x2e, 0x5a,
-	0xce, 0xd0, 0xde, 0x95, 0xd0, 0x31, 0xb4, 0x0b, 0x75, 0x0a, 0xa9, 0xd5, 0x2e, 0xf9, 0xe5, 0xa1,
-	0xf4, 0x16, 0x1b, 0x14, 0x50, 0x8f, 0xe0, 0x56, 0xb9, 0x4e, 0x21, 0xad, 0xe4, 0x57, 0x59, 0xc4,
-	0x94, 0xd7, 0xf5, 0xf4, 0x51, 0xa3, 0x67, 0x8f, 0x1a, 0xfd, 0x80, 0x3d, 0x6a, 0xb4, 0x1a, 0x9a,
-	0x14, 0x0a, 0xc8, 0xb9, 0x0c, 0xa2, 0x77, 0xae, 0x94, 0xe8, 0x6c, 0x8f, 0x9d, 0x2b, 0x5a, 0xe7,
-	0x84, 0xbb, 0x70, 0xe7, 0xc2, 0x4f, 0x8e, 0xde, 0xaa, 0x46, 0x39, 0xbf, 0xd9, 0xc3, 0xcb, 0xcc,
-	0xb2, 0x5d, 0xfa, 0x7b, 0xcf, 0x67, 0x5d, 0xe9, 0xc5, 0xac, 0x2b, 0x3d, 0x3b, 0xeb, 0xd6, 0x7e,
-	0x3e, 0xeb, 0x4a, 0x2f, 0xce, 0xba, 0xb5, 0x3f, 0xcf, 0xba, 0xb5, 0xaf, 0xb4, 0x85, 0x3f, 0x51,
-	0xfe, 0xaa, 0x74, 0x6e, 0xf0, 0xef, 0xf7, 0xfe, 0x0d, 0x00, 0x00, 0xff, 0xff, 0xd3, 0xeb, 0xda,
-	0xd5, 0x6a, 0x0e, 0x00, 0x00,
+	0x14, 0x8e, 0x1d, 0x77, 0xd3, 0xbc, 0x74, 0x57, 0xcb, 0x94, 0x65, 0x53, 0x2f, 0x1b, 0x47, 0x16,
+	0x42, 0x45, 0xa2, 0x36, 0x2a, 0x42, 0x0b, 0x52, 0x91, 0x20, 0xb4, 0x8b, 0x2a, 0xbc, 0x05, 0x39,
+	0xd5, 0x1e, 0x90, 0xa0, 0xb2, 0xe3, 0xc1, 0x58, 0x9d, 0x78, 0x8c, 0xed, 0x20, 0x45, 0xfc, 0x00,
+	0xae, 0xfb, 0x13, 0x10, 0xbf, 0x81, 0x03, 0x17, 0xee, 0x7b, 0xdc, 0x0b, 0x12, 0x07, 0x94, 0x43,
+	0xf2, 0x23, 0x10, 0x2b, 0x0e, 0x68, 0xc6, 0x63, 0xc7, 0x6e, 0x13, 0x6d, 0x23, 0xc8, 0x61, 0x7b,
+	0xf3, 0xcc, 0xbc, 0xf7, 0xf9, 0xbd, 0xef, 0x7d, 0x7a, 0xf3, 0x06, 0xee, 0x46, 0x31, 0x4d, 0xa9,
+	0x99, 0x84, 0x91, 0x6b, 0x12, 0xea, 0x9f, 0x05, 0xd4, 0xe0, 0x3b, 0xa8, 0xf5, 0xbd, 0x13, 0x13,
+	0xea, 0x1b, 0xec, 0x44, 0xdd, 0xf3, 0x83, 0xf4, 0xdb, 0x91, 0x6b, 0x0c, 0xe8, 0xd0, 0xf4, 0xa9,
+	0x4f, 0x4d, 0x6e, 0xe3, 0x8e, 0xbe, 0xe1, 0xab, 0x0c, 0x82, 0x7d, 0x65, 0xbe, 0xea, 0x3d, 0x9f,
+	0x52, 0x9f, 0xe0, 0xb9, 0x15, 0x1e, 0x46, 0xe9, 0x58, 0x1c, 0xde, 0xcd, 0x80, 0x23, 0xd7, 0x1c,
+	0xe2, 0xd4, 0xf1, 0x9c, 0xd4, 0x11, 0x07, 0xdb, 0x3c, 0x88, 0xea, 0xa6, 0xfe, 0xb3, 0x0c, 0x37,
+	0x3f, 0x8e, 0x22, 0x1c, 0x7a, 0x36, 0xfe, 0x6e, 0x84, 0x93, 0x14, 0xf5, 0x61, 0x33, 0xa5, 0x51,
+	0x30, 0x38, 0x0b, 0xbc, 0xb6, 0xd4, 0x95, 0x76, 0x37, 0x7a, 0xef, 0x4f, 0x27, 0x5a, 0xe3, 0x94,
+	0xed, 0x1d, 0x1f, 0x3e, 0x9f, 0x68, 0x6f, 0x95, 0x82, 0x3d, 0x77, 0xce, 0x1d, 0x6a, 0x66, 0x7f,
+	0x34, 0xa3, 0x73, 0xdf, 0x4c, 0xc7, 0x11, 0x4e, 0x0c, 0x61, 0x6c, 0x37, 0x38, 0xd2, 0xb1, 0x87,
+	0x3c, 0xb8, 0xc9, 0xb2, 0x4f, 0xd2, 0x18, 0x3b, 0x43, 0x86, 0x2c, 0x73, 0xe4, 0x8f, 0xa6, 0x13,
+	0xad, 0x65, 0x51, 0xbf, 0xcf, 0xf7, 0x39, 0xfa, 0xde, 0x8b, 0xd1, 0x4b, 0x0e, 0x76, 0x8b, 0x14,
+	0x0b, 0x0f, 0xb5, 0xa1, 0x11, 0x39, 0x63, 0x42, 0x1d, 0xaf, 0x5d, 0xef, 0xd6, 0x77, 0xb7, 0xec,
+	0x7c, 0x89, 0x0e, 0xa0, 0xe1, 0x3a, 0x83, 0xf3, 0x51, 0x94, 0xb4, 0x95, 0x6e, 0x7d, 0xb7, 0xb5,
+	0xff, 0xba, 0x21, 0xf8, 0xcf, 0xd9, 0x32, 0xfa, 0x29, 0x8d, 0x1d, 0x1f, 0x9f, 0x50, 0x0f, 0xf7,
+	0x94, 0xa7, 0x13, 0xad, 0x66, 0xe7, 0x2e, 0xfa, 0x57, 0xb0, 0x95, 0x73, 0x94, 0x8c, 0x48, 0x8a,
+	0x1e, 0x80, 0xc2, 0x68, 0xe4, 0xf4, 0xb4, 0xf6, 0xef, 0x5f, 0x82, 0xb2, 0xa8, 0x7f, 0x14, 0xa6,
+	0xf1, 0xf8, 0x11, 0x4e, 0x1d, 0x81, 0xc5, 0x1d, 0xd0, 0xab, 0xb0, 0x81, 0xe3, 0x98, 0xc6, 0x3c,
+	0xfd, 0xa6, 0x9d, 0x2d, 0xf4, 0xcf, 0xe0, 0x56, 0x01, 0x1f, 0xd1, 0x30, 0xc1, 0xe8, 0x03, 0x68,
+	0xc4, 0xfc, 0x57, 0x49, 0x5b, 0xe2, 0xe1, 0xee, 0x18, 0x25, 0xb9, 0x18, 0xe5, 0x60, 0xf2, 0x58,
+	0x85, 0xbd, 0xfe, 0x44, 0x86, 0x96, 0x8d, 0x9d, 0xa2, 0x9c, 0x0f, 0x41, 0xf1, 0x49, 0x12, 0xf2,
+	0x58, 0x95, 0xde, 0xfe, 0x74, 0xa2, 0x29, 0x9f, 0x5a, 0xfd, 0x93, 0xe7, 0x13, 0xed, 0xcd, 0x17,
+	0x33, 0xcd, 0x2c, 0x6d, 0xee, 0x5f, 0x91, 0x85, 0xbc, 0x36, 0x59, 0xd4, 0xd7, 0x20, 0x0b, 0xfd,
+	0x57, 0x09, 0xb6, 0x32, 0x4a, 0x04, 0xbd, 0xff, 0x17, 0x27, 0x0f, 0x41, 0x21, 0x0c, 0x47, 0x9e,
+	0xe3, 0x58, 0x57, 0xc6, 0xb1, 0x38, 0x0e, 0xf3, 0xaf, 0xea, 0x56, 0x2a, 0xe9, 0x56, 0xff, 0x4b,
+	0x86, 0xdb, 0xfd, 0x91, 0x9b, 0x0c, 0xe2, 0xc0, 0xc5, 0x79, 0x49, 0x1f, 0x03, 0xb0, 0xdf, 0x9f,
+	0xb9, 0xd8, 0x0f, 0xf2, 0x24, 0x1e, 0x4c, 0x27, 0x5a, 0x93, 0x85, 0xd6, 0x63, 0x9b, 0x2b, 0x64,
+	0xd2, 0x64, 0x50, 0xdc, 0x09, 0x7d, 0x01, 0x9b, 0x1c, 0x17, 0x87, 0x9e, 0x48, 0xe9, 0x3d, 0x56,
+	0x62, 0x66, 0x76, 0x14, 0x7a, 0x2b, 0x60, 0x36, 0x18, 0xcc, 0x51, 0xe8, 0x55, 0x44, 0x53, 0x5f,
+	0x9b, 0x68, 0x94, 0x75, 0x88, 0xe6, 0x37, 0x09, 0x5e, 0x29, 0x31, 0xff, 0xd2, 0x29, 0xe7, 0x6f,
+	0x19, 0x50, 0x11, 0xff, 0x29, 0xbd, 0x06, 0xdd, 0xfd, 0x31, 0x00, 0x99, 0xcb, 0xbe, 0x3e, 0x97,
+	0xbd, 0xb5, 0x9a, 0xec, 0x39, 0x7d, 0x4d, 0x52, 0x96, 0x3d, 0xc9, 0x65, 0xaf, 0xcc, 0x65, 0x6f,
+	0xad, 0x22, 0x7b, 0x8e, 0xd9, 0x20, 0x99, 0xec, 0xf5, 0x3e, 0x6c, 0x57, 0xa8, 0x17, 0xe2, 0x39,
+	0x80, 0x26, 0xa3, 0x09, 0xb3, 0xab, 0x41, 0xdc, 0x1d, 0x3b, 0x4b, 0xef, 0x0e, 0xd1, 0xd7, 0x37,
+	0x89, 0x58, 0xeb, 0xbf, 0x48, 0x70, 0xe7, 0x34, 0x0e, 0x86, 0x87, 0x38, 0x8a, 0xf1, 0xc0, 0x49,
+	0xf1, 0x7a, 0x6f, 0xec, 0x5c, 0xe9, 0xf2, 0x7f, 0x53, 0xba, 0xfe, 0xbb, 0x04, 0xed, 0xa2, 0xa4,
+	0x8f, 0xc4, 0xf0, 0xf1, 0xf2, 0xab, 0x51, 0xff, 0x01, 0x76, 0x16, 0xa4, 0x25, 0x2a, 0xfd, 0x35,
+	0xdc, 0x29, 0x85, 0xe0, 0x61, 0x26, 0x85, 0x28, 0xa5, 0xb1, 0xa8, 0xfa, 0x1b, 0x8b, 0xaa, 0x9e,
+	0x41, 0x1d, 0x16, 0xb6, 0x42, 0x00, 0xdb, 0xe4, 0xf2, 0x91, 0xfe, 0xa7, 0x04, 0x5a, 0xe1, 0x62,
+	0xe3, 0x88, 0x04, 0x03, 0xe7, 0x1a, 0x71, 0xfb, 0xa3, 0x04, 0xdd, 0xe5, 0xe9, 0x09, 0x8e, 0x07,
+	0x80, 0x4a, 0xa1, 0xc4, 0x99, 0x95, 0x20, 0xd8, 0xac, 0x8c, 0x4b, 0xcb, 0xa0, 0x2e, 0x71, 0x7d,
+	0x9b, 0x5c, 0xb0, 0xdc, 0xff, 0xa7, 0x0e, 0x1b, 0x16, 0xf5, 0x8f, 0x3f, 0x47, 0x9f, 0xc0, 0x8d,
+	0x6c, 0xec, 0x42, 0xea, 0xc2, 0x59, 0x8c, 0x93, 0xae, 0xde, 0x5b, 0x3c, 0xa7, 0xf1, 0x88, 0xf5,
+	0x1a, 0xfa, 0x10, 0x14, 0x36, 0x88, 0xa0, 0x76, 0xc5, 0xac, 0x34, 0xae, 0xa9, 0x3b, 0x0b, 0x4e,
+	0x0a, 0xf7, 0x13, 0x68, 0x16, 0x7d, 0x05, 0xdd, 0xaf, 0x58, 0x5e, 0x1c, 0x12, 0xd4, 0xce, 0xb2,
+	0xe3, 0x1c, 0xed, 0x1d, 0x09, 0x9d, 0x42, 0xab, 0xd4, 0xa7, 0x90, 0xb6, 0xd8, 0xa5, 0xb8, 0x3c,
+	0xd4, 0xee, 0x72, 0x83, 0x12, 0xea, 0x09, 0xdc, 0xaa, 0xf6, 0x29, 0xa4, 0x57, 0xfc, 0x16, 0x36,
+	0x31, 0xf5, 0x35, 0x23, 0x7b, 0xd4, 0x18, 0xf9, 0xa3, 0xc6, 0x38, 0x62, 0x8f, 0x1a, 0xbd, 0x86,
+	0xc6, 0xa5, 0x06, 0x72, 0xa1, 0x82, 0xe8, 0xed, 0x2b, 0x15, 0x3a, 0xff, 0xc7, 0xde, 0x15, 0xad,
+	0xf3, 0x64, 0x7a, 0x07, 0x4f, 0xa7, 0x1d, 0xe9, 0xd9, 0xb4, 0x23, 0x3d, 0x99, 0x75, 0x6a, 0x3f,
+	0xcd, 0x3a, 0xd2, 0xb3, 0x59, 0xa7, 0xf6, 0xc7, 0xac, 0x53, 0xfb, 0x52, 0x5f, 0x2a, 0xef, 0xe2,
+	0xbd, 0xe7, 0xde, 0xe0, 0xdf, 0xef, 0xfe, 0x1b, 0x00, 0x00, 0xff, 0xff, 0xa5, 0x66, 0xf8, 0x83,
+	0x04, 0x0e, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -913,7 +912,6 @@ type LogIOClient interface {
 	SubscribeTo(ctx context.Context, in *SubscribeToRequest, opts ...grpc.CallOption) (LogIO_SubscribeToClient, error)
 	TrimDeprecated(ctx context.Context, in *TrimDeprecatedRequest, opts ...grpc.CallOption) (*types.Empty, error)
 	LogStreamReplicaMetadata(ctx context.Context, in *LogStreamReplicaMetadataRequest, opts ...grpc.CallOption) (*LogStreamReplicaMetadataResponse, error)
-	LogStreamMetadata(ctx context.Context, in *LogStreamMetadataRequest, opts ...grpc.CallOption) (*LogStreamMetadataResponse, error)
 }
 
 type logIOClient struct {
@@ -1024,15 +1022,6 @@ func (c *logIOClient) LogStreamReplicaMetadata(ctx context.Context, in *LogStrea
 	return out, nil
 }
 
-func (c *logIOClient) LogStreamMetadata(ctx context.Context, in *LogStreamMetadataRequest, opts ...grpc.CallOption) (*LogStreamMetadataResponse, error) {
-	out := new(LogStreamMetadataResponse)
-	err := c.cc.Invoke(ctx, "/varlog.snpb.LogIO/LogStreamMetadata", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
 // LogIOServer is the server API for LogIO service.
 type LogIOServer interface {
 	Append(context.Context, *AppendRequest) (*AppendResponse, error)
@@ -1041,7 +1030,6 @@ type LogIOServer interface {
 	SubscribeTo(*SubscribeToRequest, LogIO_SubscribeToServer) error
 	TrimDeprecated(context.Context, *TrimDeprecatedRequest) (*types.Empty, error)
 	LogStreamReplicaMetadata(context.Context, *LogStreamReplicaMetadataRequest) (*LogStreamReplicaMetadataResponse, error)
-	LogStreamMetadata(context.Context, *LogStreamMetadataRequest) (*LogStreamMetadataResponse, error)
 }
 
 // UnimplementedLogIOServer can be embedded to have forward compatible implementations.
@@ -1066,9 +1054,6 @@ func (*UnimplementedLogIOServer) TrimDeprecated(ctx context.Context, req *TrimDe
 func (*UnimplementedLogIOServer) LogStreamReplicaMetadata(ctx context.Context, req *LogStreamReplicaMetadataRequest) (*LogStreamReplicaMetadataResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method LogStreamReplicaMetadata not implemented")
 }
-func (*UnimplementedLogIOServer) LogStreamMetadata(ctx context.Context, req *LogStreamMetadataRequest) (*LogStreamMetadataResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method LogStreamMetadata not implemented")
-}
 
 func RegisterLogIOServer(s *grpc.Server, srv LogIOServer) {
 	s.RegisterService(&_LogIO_serviceDesc, srv)
@@ -1188,24 +1173,6 @@ func _LogIO_LogStreamReplicaMetadata_Handler(srv interface{}, ctx context.Contex
 	return interceptor(ctx, in, info, handler)
 }
 
-func _LogIO_LogStreamMetadata_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(LogStreamMetadataRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(LogIOServer).LogStreamMetadata(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/varlog.snpb.LogIO/LogStreamMetadata",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(LogIOServer).LogStreamMetadata(ctx, req.(*LogStreamMetadataRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
 var _LogIO_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "varlog.snpb.LogIO",
 	HandlerType: (*LogIOServer)(nil),
@@ -1226,10 +1193,6 @@ var _LogIO_serviceDesc = grpc.ServiceDesc{
 			MethodName: "LogStreamReplicaMetadata",
 			Handler:    _LogIO_LogStreamReplicaMetadata_Handler,
 		},
-		{
-			MethodName: "LogStreamMetadata",
-			Handler:    _LogIO_LogStreamMetadata_Handler,
-		},
 	},
 	Streams: []grpc.StreamDesc{
 		{
diff --git a/proto/snpb/log_io.proto b/proto/snpb/log_io.proto
index 01c8a1dd3..138374353 100644
--- a/proto/snpb/log_io.proto
+++ b/proto/snpb/log_io.proto
@@ -183,6 +183,4 @@ service LogIO {
   rpc TrimDeprecated(TrimDeprecatedRequest) returns (google.protobuf.Empty) {}
   rpc LogStreamReplicaMetadata(LogStreamReplicaMetadataRequest)
     returns (LogStreamReplicaMetadataResponse) {}
-  rpc LogStreamMetadata(LogStreamMetadataRequest)
-    returns (LogStreamMetadataResponse) {}
 }
diff --git a/proto/snpb/mock/snpb_mock.go b/proto/snpb/mock/snpb_mock.go
index 65154d24b..21a3d3763 100644
--- a/proto/snpb/mock/snpb_mock.go
+++ b/proto/snpb/mock/snpb_mock.go
@@ -380,26 +380,6 @@ func (mr *MockLogIOClientMockRecorder) Append(arg0, arg1 interface{}, arg2 ...in
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Append", reflect.TypeOf((*MockLogIOClient)(nil).Append), varargs...)
 }
 
-// LogStreamMetadata mocks base method.
-func (m *MockLogIOClient) LogStreamMetadata(arg0 context.Context, arg1 *snpb.LogStreamMetadataRequest, arg2 ...grpc.CallOption) (*snpb.LogStreamMetadataResponse, error) {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "LogStreamMetadata", varargs...)
-	ret0, _ := ret[0].(*snpb.LogStreamMetadataResponse)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// LogStreamMetadata indicates an expected call of LogStreamMetadata.
-func (mr *MockLogIOClientMockRecorder) LogStreamMetadata(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LogStreamMetadata", reflect.TypeOf((*MockLogIOClient)(nil).LogStreamMetadata), varargs...)
-}
-
 // LogStreamReplicaMetadata mocks base method.
 func (m *MockLogIOClient) LogStreamReplicaMetadata(arg0 context.Context, arg1 *snpb.LogStreamReplicaMetadataRequest, arg2 ...grpc.CallOption) (*snpb.LogStreamReplicaMetadataResponse, error) {
 	m.ctrl.T.Helper()
@@ -538,21 +518,6 @@ func (mr *MockLogIOServerMockRecorder) Append(arg0, arg1 interface{}) *gomock.Ca
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Append", reflect.TypeOf((*MockLogIOServer)(nil).Append), arg0, arg1)
 }
 
-// LogStreamMetadata mocks base method.
-func (m *MockLogIOServer) LogStreamMetadata(arg0 context.Context, arg1 *snpb.LogStreamMetadataRequest) (*snpb.LogStreamMetadataResponse, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "LogStreamMetadata", arg0, arg1)
-	ret0, _ := ret[0].(*snpb.LogStreamMetadataResponse)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// LogStreamMetadata indicates an expected call of LogStreamMetadata.
-func (mr *MockLogIOServerMockRecorder) LogStreamMetadata(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LogStreamMetadata", reflect.TypeOf((*MockLogIOServer)(nil).LogStreamMetadata), arg0, arg1)
-}
-
 // LogStreamReplicaMetadata mocks base method.
 func (m *MockLogIOServer) LogStreamReplicaMetadata(arg0 context.Context, arg1 *snpb.LogStreamReplicaMetadataRequest) (*snpb.LogStreamReplicaMetadataResponse, error) {
 	m.ctrl.T.Helper()
diff --git a/proto/varlogpb/metadata.pb.go b/proto/varlogpb/metadata.pb.go
index eb0cd3ae6..0a16ae245 100644
--- a/proto/varlogpb/metadata.pb.go
+++ b/proto/varlogpb/metadata.pb.go
@@ -318,12 +318,6 @@ type LogStreamDescriptor struct {
 	LogStreamID github_com_kakao_varlog_pkg_types.LogStreamID `protobuf:"varint,2,opt,name=log_stream_id,json=logStreamId,proto3,casttype=github.com/kakao/varlog/pkg/types.LogStreamID" json:"logStreamId"`
 	Status      LogStreamStatus                               `protobuf:"varint,3,opt,name=status,proto3,enum=varlog.varlogpb.LogStreamStatus" json:"status,omitempty"`
 	Replicas    []*ReplicaDescriptor                          `protobuf:"bytes,4,rep,name=replicas,proto3" json:"replicas,omitempty"`
-	// Deprecated: The members - head and tail are not used by the metadata
-	// repository. It exists here just since the LogStreamDescriptor is used
-	// elsewhere other than the metadata repository. It leads to misusing the
-	// LogStreamDescriptor.
-	Head LogEntryMeta `protobuf:"bytes,5,opt,name=head,proto3" json:"head,omitempty"`
-	Tail LogEntryMeta `protobuf:"bytes,6,opt,name=tail,proto3" json:"tail,omitempty"`
 }
 
 func (m *LogStreamDescriptor) Reset()         { *m = LogStreamDescriptor{} }
@@ -387,20 +381,6 @@ func (m *LogStreamDescriptor) GetReplicas() []*ReplicaDescriptor {
 	return nil
 }
 
-func (m *LogStreamDescriptor) GetHead() LogEntryMeta {
-	if m != nil {
-		return m.Head
-	}
-	return LogEntryMeta{}
-}
-
-func (m *LogStreamDescriptor) GetTail() LogEntryMeta {
-	if m != nil {
-		return m.Tail
-	}
-	return LogEntryMeta{}
-}
-
 // ReplicaDescriptor represents a storage node and directory where a log stream
 // replica exists.
 type ReplicaDescriptor struct {
@@ -1019,101 +999,99 @@ func init() {
 func init() { proto.RegisterFile("proto/varlogpb/metadata.proto", fileDescriptor_eb4411772ca3492a) }
 
 var fileDescriptor_eb4411772ca3492a = []byte{
-	// 1503 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x58, 0xcf, 0x6f, 0x1a, 0x47,
-	0x1b, 0x66, 0x61, 0x8d, 0xf1, 0x60, 0x6c, 0x3c, 0x71, 0x2c, 0x3e, 0xbe, 0x84, 0x45, 0xd6, 0xf7,
-	0x45, 0x4e, 0xd4, 0x40, 0xe3, 0x2a, 0x52, 0x94, 0xa8, 0x6d, 0x8c, 0xa1, 0x8e, 0x25, 0x82, 0xa3,
-	0x01, 0x37, 0x4a, 0x0f, 0x45, 0x03, 0x3b, 0x59, 0x56, 0x5e, 0x76, 0xb7, 0xbb, 0x43, 0x12, 0x1f,
-	0x7a, 0xab, 0xaa, 0xca, 0xa7, 0xa8, 0x3d, 0xb4, 0x17, 0x4b, 0x91, 0xda, 0x4b, 0xa5, 0xfe, 0x11,
-	0x3d, 0xe6, 0x98, 0x63, 0x7b, 0x21, 0x12, 0xbe, 0x54, 0xee, 0x7f, 0x90, 0x53, 0x35, 0xb3, 0xb3,
-	0xb0, 0x0b, 0x38, 0x8e, 0x9b, 0x56, 0x95, 0x7a, 0x62, 0x7e, 0x3d, 0xef, 0x3b, 0xef, 0xf3, 0x3e,
-	0xf3, 0xce, 0x2c, 0xe0, 0xa2, 0xed, 0x58, 0xd4, 0x2a, 0x3e, 0xc2, 0x8e, 0x61, 0x69, 0x76, 0xab,
-	0xd8, 0x25, 0x14, 0xab, 0x98, 0xe2, 0x02, 0x1f, 0x87, 0x8b, 0xde, 0x44, 0xc1, 0x9f, 0xcf, 0x2a,
-	0x9a, 0x65, 0x69, 0x06, 0x29, 0xf2, 0xe9, 0x56, 0xef, 0x61, 0x91, 0xea, 0x5d, 0xe2, 0x52, 0xdc,
-	0xb5, 0x3d, 0x44, 0xf6, 0xaa, 0xa6, 0xd3, 0x4e, 0xaf, 0x55, 0x68, 0x5b, 0xdd, 0xa2, 0x66, 0x69,
-	0xd6, 0x68, 0x25, 0xeb, 0x79, 0xde, 0x58, 0xcb, 0x5b, 0xbe, 0xfa, 0x6b, 0x14, 0xc0, 0xbb, 0xc2,
-	0x67, 0x99, 0xb8, 0x6d, 0x47, 0xb7, 0xa9, 0xe5, 0xc0, 0xeb, 0x20, 0x85, 0x6d, 0xdb, 0xd0, 0x89,
-	0xda, 0xd4, 0x4d, 0x95, 0x3c, 0xc9, 0x48, 0x79, 0x69, 0x4d, 0x2e, 0xa5, 0x8f, 0xfb, 0xca, 0xbc,
-	0x98, 0xd8, 0x66, 0xe3, 0x28, 0xd4, 0x83, 0x18, 0xa4, 0x5c, 0x6a, 0x39, 0x58, 0x23, 0x4d, 0xd3,
-	0x52, 0x89, 0x9b, 0x89, 0xe6, 0x63, 0x6b, 0xc9, 0xf5, 0x4b, 0x85, 0xb1, 0x30, 0x0a, 0x75, 0x6f,
-	0x55, 0xcd, 0x52, 0xc9, 0xc8, 0x6b, 0x69, 0xf9, 0x79, 0x5f, 0x91, 0x98, 0x0b, 0x77, 0x34, 0xed,
-	0xa2, 0x50, 0x0f, 0x3e, 0x00, 0x49, 0xc3, 0xd2, 0x9a, 0x2e, 0x75, 0x08, 0xee, 0xba, 0x99, 0x18,
-	0x77, 0xf0, 0xbf, 0x09, 0x07, 0x55, 0x4b, 0xab, 0xf3, 0x25, 0x01, 0xf3, 0x50, 0x98, 0x07, 0x86,
-	0x3f, 0xe9, 0xa2, 0x40, 0x1b, 0xde, 0x01, 0x71, 0x6a, 0xd9, 0x7a, 0xdb, 0xcd, 0xc8, 0xdc, 0x6a,
-	0x7e, 0xc2, 0x6a, 0x83, 0x4d, 0x07, 0x2c, 0x2e, 0x08, 0x8b, 0x02, 0x87, 0xc4, 0xef, 0x4d, 0xf9,
-	0xb7, 0x67, 0x8a, 0xb4, 0xfa, 0x4d, 0x14, 0x9c, 0x9f, 0x1a, 0x28, 0xbc, 0x0b, 0xe6, 0x83, 0x3c,
-	0x71, 0x76, 0x93, 0xeb, 0x17, 0x5e, 0x47, 0x53, 0x69, 0xfe, 0x79, 0x5f, 0x89, 0xbc, 0xf0, 0xfc,
-	0x45, 0x50, 0x32, 0x40, 0x0a, 0xbc, 0x09, 0xe2, 0x2e, 0xc5, 0xb4, 0xc7, 0xf8, 0x96, 0xd6, 0x16,
-	0xd6, 0x57, 0x5f, 0x67, 0xa8, 0xce, 0x57, 0x22, 0x81, 0x80, 0xcb, 0x60, 0xc6, 0xc6, 0xb4, 0xe3,
-	0x31, 0x39, 0x87, 0xbc, 0x0e, 0xac, 0x83, 0x64, 0xdb, 0x21, 0x98, 0x92, 0x26, 0xd3, 0x57, 0x46,
-	0xe6, 0xfb, 0xcb, 0x16, 0x3c, 0xf1, 0x15, 0x7c, 0x49, 0x15, 0x1a, 0xbe, 0xf8, 0x4a, 0x2b, 0x6c,
-	0x77, 0x8c, 0x5b, 0x0f, 0xc6, 0x26, 0x9e, 0xbe, 0x54, 0x24, 0x14, 0xe8, 0x0b, 0x56, 0xee, 0x83,
-	0x25, 0xb1, 0x9b, 0x00, 0x21, 0x10, 0xc8, 0xcc, 0x31, 0x27, 0x62, 0x0e, 0xf1, 0x36, 0x1b, 0xeb,
-	0xb9, 0x44, 0xe5, 0x31, 0xc9, 0x88, 0xb7, 0xd9, 0x6e, 0xa9, 0x45, 0xb1, 0x91, 0x89, 0xf1, 0x41,
-	0xaf, 0x23, 0x0c, 0x7f, 0x29, 0x83, 0x73, 0x53, 0xd2, 0x0e, 0x3f, 0x05, 0x09, 0x9e, 0x96, 0xa6,
-	0xae, 0x72, 0xfb, 0x33, 0xa5, 0xcd, 0x41, 0x5f, 0x99, 0xe5, 0xb9, 0xdc, 0x2e, 0x1f, 0xf7, 0x95,
-	0x59, 0x3e, 0xbd, 0xad, 0xbe, 0xea, 0x2b, 0x97, 0x03, 0xa7, 0x67, 0x0f, 0xef, 0x61, 0xff, 0x64,
-	0x16, 0xed, 0x3d, 0xad, 0x48, 0xf7, 0x6d, 0xe2, 0x16, 0x04, 0x0e, 0xf9, 0x28, 0xe8, 0x82, 0xd4,
-	0x48, 0x91, 0xcc, 0x49, 0x94, 0x3b, 0xd9, 0x19, 0xf4, 0x95, 0xe4, 0x70, 0x3f, 0xdc, 0x51, 0x72,
-	0x28, 0x36, 0xee, 0xec, 0xea, 0xe9, 0xce, 0x02, 0x78, 0x14, 0x44, 0xc3, 0x1b, 0xc3, 0x94, 0xc7,
-	0x78, 0xca, 0xf3, 0x27, 0x9f, 0x80, 0xb1, 0x84, 0x97, 0x41, 0xc2, 0x21, 0xb6, 0xa1, 0xb7, 0xb1,
-	0xaf, 0xf3, 0x49, 0xb9, 0x20, 0x6f, 0x41, 0x40, 0xe9, 0x32, 0x53, 0x3a, 0x1a, 0x22, 0xe1, 0x36,
-	0x90, 0x3b, 0x04, 0xab, 0x99, 0x19, 0xae, 0x8c, 0x8b, 0xd3, 0xbc, 0x57, 0x4c, 0xea, 0xec, 0xb3,
-	0xda, 0x32, 0x14, 0xc7, 0x02, 0x83, 0xbc, 0x63, 0x75, 0x75, 0x4a, 0xba, 0x36, 0xdd, 0x47, 0xdc,
-	0x04, 0x33, 0x45, 0xb1, 0x6e, 0x64, 0xe2, 0x67, 0x32, 0xc5, 0x20, 0x41, 0x53, 0xac, 0x2f, 0x84,
-	0xf0, 0x45, 0x14, 0x2c, 0x4d, 0x44, 0x00, 0x3f, 0x07, 0x8b, 0xc1, 0x33, 0x37, 0x52, 0xc3, 0xee,
-	0xa0, 0xaf, 0xa4, 0x02, 0x07, 0x84, 0xa7, 0x2a, 0x15, 0x38, 0x5f, 0x3c, 0x59, 0xc5, 0xd3, 0x93,
-	0x15, 0xb2, 0x81, 0xc2, 0x16, 0xe0, 0x87, 0x60, 0x29, 0xe4, 0x9e, 0xcb, 0x9d, 0x29, 0x65, 0xae,
-	0x74, 0xee, 0xb8, 0xaf, 0x2c, 0x06, 0x56, 0xdf, 0xc3, 0xb4, 0x83, 0xc6, 0x07, 0xe0, 0x65, 0x30,
-	0xc7, 0x8a, 0xb4, 0x07, 0x8c, 0x71, 0xe0, 0xfc, 0x71, 0x5f, 0x49, 0xb0, 0x41, 0x8e, 0x18, 0xb6,
-	0x04, 0x0d, 0x3f, 0x46, 0xc1, 0xe2, 0x58, 0xc1, 0xfa, 0xdb, 0xcf, 0xc2, 0xed, 0xb1, 0x4a, 0x74,
-	0x61, 0x7a, 0x09, 0xf5, 0x24, 0x59, 0x02, 0xac, 0x74, 0xba, 0x61, 0x79, 0x9a, 0x93, 0xf5, 0x7d,
-	0xa6, 0x74, 0x57, 0xd4, 0xd9, 0xe5, 0x51, 0xb5, 0x1e, 0xe5, 0xfe, 0xec, 0x27, 0x29, 0x50, 0xf4,
-	0x05, 0x57, 0x3f, 0x49, 0x20, 0x19, 0x48, 0xdf, 0x3f, 0x2d, 0x96, 0x0c, 0x98, 0xc5, 0xaa, 0xea,
-	0x10, 0xd7, 0xe3, 0x71, 0x0e, 0xf9, 0x5d, 0xb1, 0xdd, 0xdf, 0x25, 0xb0, 0xc0, 0x89, 0x1c, 0x46,
-	0xf5, 0xaf, 0xac, 0x72, 0x22, 0xda, 0x9f, 0x25, 0x90, 0x1e, 0x2e, 0x11, 0x07, 0xfb, 0xaf, 0xbe,
-	0x42, 0xef, 0x83, 0xb4, 0x47, 0xdf, 0x28, 0x48, 0x1e, 0x61, 0x72, 0x5d, 0x99, 0x2e, 0xe1, 0xe1,
-	0x86, 0xc6, 0xac, 0x2e, 0xd0, 0xd0, 0xac, 0x7f, 0x16, 0x25, 0xb0, 0xc4, 0xc6, 0xc8, 0x67, 0x3d,
-	0x62, 0xb6, 0x49, 0xad, 0xd7, 0x6d, 0x11, 0x07, 0x7e, 0x04, 0x64, 0xc3, 0x70, 0x4d, 0xf1, 0xb8,
-	0x5a, 0x1f, 0xf4, 0x15, 0xb9, 0x5a, 0xad, 0xd7, 0x5e, 0xf5, 0x95, 0x4b, 0x6f, 0x40, 0x5a, 0xb5,
-	0x5e, 0x43, 0x1c, 0xcf, 0xec, 0x68, 0xcc, 0x4e, 0x74, 0x64, 0x67, 0xeb, 0x8d, 0xed, 0x6c, 0x71,
-	0x3b, 0x0c, 0x2f, 0xf6, 0xfa, 0x32, 0x0a, 0xe6, 0x83, 0x35, 0x17, 0xd6, 0x27, 0xa4, 0x75, 0x23,
-	0x20, 0xad, 0x3f, 0xa9, 0x27, 0x75, 0xba, 0x9e, 0x6e, 0x8f, 0xe9, 0xe9, 0x2d, 0xaf, 0x49, 0x9f,
-	0x99, 0xd8, 0xdb, 0x31, 0x33, 0xcc, 0x94, 0xfc, 0x76, 0x99, 0x12, 0x0c, 0x63, 0x90, 0xf0, 0x09,
-	0x86, 0xb7, 0x80, 0xcc, 0xde, 0xfc, 0x42, 0xbf, 0xa7, 0xdc, 0x7e, 0x09, 0x5f, 0x6a, 0x88, 0x83,
-	0xd8, 0x13, 0x89, 0x15, 0x7d, 0xce, 0xdd, 0x3c, 0xe2, 0x6d, 0xe1, 0xe2, 0x6b, 0x19, 0xa4, 0x36,
-	0xad, 0x6e, 0x57, 0xa7, 0x9b, 0x96, 0x49, 0xc9, 0x13, 0x0a, 0xb7, 0xc0, 0xec, 0x23, 0xe2, 0xb8,
-	0xba, 0xe5, 0xeb, 0xed, 0xea, 0x9b, 0x65, 0xee, 0x63, 0x0f, 0x84, 0x7c, 0x34, 0x6c, 0x81, 0x85,
-	0x8e, 0xae, 0x75, 0x9a, 0x8f, 0x31, 0x25, 0x4e, 0x17, 0x3b, 0x7b, 0x42, 0x77, 0xb7, 0x58, 0x69,
-	0xbc, 0xa3, 0x6b, 0x9d, 0xfb, 0xfe, 0xc4, 0x19, 0x68, 0x4e, 0x75, 0x82, 0x40, 0xe8, 0x80, 0xe5,
-	0x36, 0xdf, 0x3d, 0x25, 0x6a, 0x93, 0x65, 0xa0, 0xd9, 0x22, 0x9a, 0xee, 0xe7, 0x91, 0x89, 0x04,
-	0x6e, 0xfa, 0xf3, 0x0c, 0x5f, 0x62, 0xb3, 0x67, 0x70, 0x07, 0x87, 0xd6, 0xb7, 0x0c, 0xd7, 0xe4,
-	0x68, 0x68, 0x00, 0x38, 0xe6, 0x93, 0x98, 0xaa, 0xc8, 0xf8, 0x07, 0x83, 0xbe, 0x92, 0x0e, 0x79,
-	0xac, 0x98, 0xea, 0x19, 0xfc, 0xa5, 0x43, 0xfe, 0x2a, 0xa6, 0x1a, 0x8e, 0xd0, 0x18, 0x45, 0x38,
-	0x33, 0x25, 0xc2, 0xea, 0xd9, 0x22, 0xac, 0x86, 0x23, 0xac, 0xfa, 0x11, 0xae, 0xfe, 0x10, 0x05,
-	0x2b, 0xfe, 0xc7, 0x1e, 0x22, 0xb6, 0xe5, 0xea, 0xd4, 0x72, 0xf6, 0x79, 0xfd, 0x7b, 0x00, 0x66,
-	0x83, 0x17, 0x9d, 0xb7, 0x83, 0xf8, 0xf0, 0x86, 0x8b, 0x9b, 0xfe, 0xd5, 0xb6, 0x76, 0xba, 0x7f,
-	0x71, 0xa7, 0x09, 0x0c, 0xbc, 0x06, 0x12, 0x0e, 0x7e, 0x48, 0x9b, 0x3d, 0xc7, 0x10, 0x0f, 0x9e,
-	0x15, 0x56, 0x3e, 0x10, 0x7e, 0x48, 0x77, 0x51, 0x95, 0xdd, 0x4c, 0x8e, 0xd7, 0x44, 0x5e, 0xc3,
-	0x31, 0x38, 0xc4, 0x6e, 0x37, 0xd9, 0xa5, 0x27, 0x9e, 0x3a, 0x1e, 0xe4, 0xde, 0xe6, 0x86, 0xaa,
-	0x3a, 0x1c, 0x62, 0xb7, 0x59, 0x13, 0xf9, 0x0d, 0xb8, 0x0a, 0xe2, 0x06, 0xc1, 0x2a, 0x71, 0x78,
-	0xc6, 0x12, 0xde, 0xdb, 0xc2, 0x1b, 0x41, 0xe2, 0x17, 0xfe, 0x1f, 0xcc, 0x1a, 0x04, 0x3b, 0x26,
-	0x71, 0x38, 0xcd, 0x89, 0x52, 0x92, 0x99, 0x12, 0x43, 0xc8, 0x6f, 0x5c, 0xf9, 0x56, 0x1a, 0x7e,
-	0xa2, 0x8c, 0x3e, 0x98, 0xe0, 0xfb, 0xe0, 0xbf, 0xf5, 0xc6, 0x0e, 0xda, 0xd8, 0xaa, 0x34, 0x6b,
-	0x3b, 0xe5, 0x4a, 0xb3, 0xde, 0xd8, 0x68, 0xec, 0xd6, 0x9b, 0x68, 0xb7, 0x56, 0xdb, 0xae, 0x6d,
-	0xa5, 0x23, 0xd9, 0x0b, 0x07, 0x87, 0xf9, 0xcc, 0xe4, 0x87, 0x56, 0xcf, 0x34, 0x75, 0x53, 0x3b,
-	0x09, 0x5e, 0xae, 0x54, 0x2b, 0x8d, 0x4a, 0x39, 0x2d, 0x9d, 0x00, 0x2f, 0x13, 0x83, 0x50, 0xa2,
-	0x66, 0xe5, 0xaf, 0xbe, 0xcf, 0x45, 0xae, 0x7c, 0x17, 0x05, 0x8b, 0x63, 0xef, 0x7a, 0x78, 0x0d,
-	0x2c, 0x55, 0xeb, 0x93, 0xbb, 0xc9, 0x1e, 0x1c, 0xe6, 0x57, 0xc6, 0xbf, 0x01, 0xc4, 0x5e, 0x42,
-	0x90, 0x7a, 0x65, 0xa3, 0xca, 0x20, 0xd2, 0x54, 0x48, 0x9d, 0x60, 0x83, 0x41, 0x8a, 0x20, 0x1d,
-	0x86, 0x54, 0xca, 0xe9, 0x68, 0xf6, 0x3f, 0x07, 0x87, 0xf9, 0xf3, 0x53, 0x10, 0x44, 0x0d, 0xfb,
-	0xf0, 0xa3, 0x8c, 0x4d, 0xf5, 0x21, 0x62, 0x84, 0xd7, 0xc1, 0xb9, 0x11, 0x64, 0xb7, 0xe6, 0x6f,
-	0x4c, 0xf6, 0xa8, 0x19, 0x03, 0xed, 0x9a, 0xae, 0xb7, 0x35, 0x41, 0xcd, 0x63, 0x90, 0x0c, 0x3c,
-	0x2d, 0xe1, 0xbb, 0x60, 0xb9, 0xb1, 0x73, 0x6f, 0x7b, 0x73, 0x92, 0x98, 0x95, 0x83, 0xc3, 0x3c,
-	0x0c, 0x2c, 0xf5, 0x49, 0x19, 0x47, 0x8c, 0x32, 0x33, 0x8e, 0x08, 0xe5, 0xa4, 0x74, 0xfb, 0xf9,
-	0x20, 0x27, 0xbd, 0x18, 0xe4, 0xa4, 0xa7, 0x47, 0xb9, 0xc8, 0xb3, 0xa3, 0x9c, 0xf4, 0xe2, 0x28,
-	0x17, 0xf9, 0xe5, 0x28, 0x17, 0xf9, 0xe4, 0xe4, 0xa3, 0x1a, 0xfa, 0xcf, 0xa7, 0x15, 0xe7, 0xfd,
-	0xf7, 0xfe, 0x08, 0x00, 0x00, 0xff, 0xff, 0x8f, 0x39, 0x2a, 0xe0, 0x0c, 0x12, 0x00, 0x00,
+	// 1465 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x58, 0xcb, 0x6f, 0x1b, 0x45,
+	0x1c, 0xce, 0xda, 0x9b, 0xc4, 0x19, 0xc7, 0x89, 0x33, 0x4d, 0x23, 0x63, 0x5a, 0xaf, 0x15, 0x41,
+	0x95, 0x56, 0xd4, 0xa6, 0x41, 0x95, 0xaa, 0x56, 0x40, 0xe3, 0xd8, 0xa4, 0x91, 0x5c, 0xa7, 0x1a,
+	0x3b, 0x54, 0xe5, 0x80, 0x35, 0xf6, 0x4e, 0xd7, 0xab, 0xac, 0x77, 0x97, 0xdd, 0x71, 0xdb, 0x1c,
+	0xb8, 0x71, 0x40, 0x39, 0x55, 0x70, 0x80, 0x4b, 0xa4, 0x4a, 0x70, 0x41, 0xe2, 0x8f, 0xe0, 0xd8,
+	0x63, 0x8f, 0x70, 0x71, 0x25, 0xe7, 0x82, 0xc2, 0x85, 0x73, 0x4f, 0x68, 0x66, 0x67, 0xed, 0xdd,
+	0xb5, 0xd3, 0x36, 0x14, 0x84, 0xc4, 0xc9, 0xf3, 0xfa, 0x7e, 0x8f, 0xef, 0xf7, 0xcd, 0x63, 0x0d,
+	0xce, 0xdb, 0x8e, 0x45, 0xad, 0xe2, 0x03, 0xec, 0x18, 0x96, 0x66, 0xb7, 0x8a, 0x5d, 0x42, 0xb1,
+	0x8a, 0x29, 0x2e, 0xf0, 0x71, 0xb8, 0xe8, 0x4d, 0x14, 0xfc, 0xf9, 0xac, 0xa2, 0x59, 0x96, 0x66,
+	0x90, 0x22, 0x9f, 0x6e, 0xf5, 0xee, 0x17, 0xa9, 0xde, 0x25, 0x2e, 0xc5, 0x5d, 0xdb, 0x43, 0x64,
+	0x2f, 0x6b, 0x3a, 0xed, 0xf4, 0x5a, 0x85, 0xb6, 0xd5, 0x2d, 0x6a, 0x96, 0x66, 0x8d, 0x56, 0xb2,
+	0x9e, 0xe7, 0x8d, 0xb5, 0xbc, 0xe5, 0xab, 0xbf, 0xc5, 0x00, 0xbc, 0x2d, 0x7c, 0x96, 0x89, 0xdb,
+	0x76, 0x74, 0x9b, 0x5a, 0x0e, 0xbc, 0x0a, 0x52, 0xd8, 0xb6, 0x0d, 0x9d, 0xa8, 0x4d, 0xdd, 0x54,
+	0xc9, 0xa3, 0x8c, 0x94, 0x97, 0xd6, 0xe4, 0x52, 0xfa, 0xb8, 0xaf, 0xcc, 0x8b, 0x89, 0x6d, 0x36,
+	0x8e, 0x42, 0x3d, 0x88, 0x41, 0xca, 0xa5, 0x96, 0x83, 0x35, 0xd2, 0x34, 0x2d, 0x95, 0xb8, 0x99,
+	0x58, 0x3e, 0xbe, 0x96, 0x5c, 0xbf, 0x50, 0x88, 0xa4, 0x51, 0xa8, 0x7b, 0xab, 0x6a, 0x96, 0x4a,
+	0x46, 0x5e, 0x4b, 0xcb, 0x4f, 0xfb, 0x8a, 0xc4, 0x5c, 0xb8, 0xa3, 0x69, 0x17, 0x85, 0x7a, 0xf0,
+	0x1e, 0x48, 0x1a, 0x96, 0xd6, 0x74, 0xa9, 0x43, 0x70, 0xd7, 0xcd, 0xc4, 0xb9, 0x83, 0x77, 0xc6,
+	0x1c, 0x54, 0x2d, 0xad, 0xce, 0x97, 0x04, 0xcc, 0x43, 0x61, 0x1e, 0x18, 0xfe, 0xa4, 0x8b, 0x02,
+	0x6d, 0x78, 0x0b, 0xcc, 0x50, 0xcb, 0xd6, 0xdb, 0x6e, 0x46, 0xe6, 0x56, 0xf3, 0x63, 0x56, 0x1b,
+	0x6c, 0x3a, 0x60, 0x71, 0x41, 0x58, 0x14, 0x38, 0x24, 0x7e, 0xaf, 0xcb, 0xbf, 0x3f, 0x51, 0xa4,
+	0xd5, 0x6f, 0x63, 0xe0, 0xec, 0xc4, 0x44, 0xe1, 0x6d, 0x30, 0x1f, 0xe4, 0x89, 0xb3, 0x9b, 0x5c,
+	0x3f, 0xf7, 0x32, 0x9a, 0x4a, 0xf3, 0x4f, 0xfb, 0xca, 0xd4, 0x33, 0xcf, 0xdf, 0x14, 0x4a, 0x06,
+	0x48, 0x81, 0xd7, 0xc1, 0x8c, 0x4b, 0x31, 0xed, 0x31, 0xbe, 0xa5, 0xb5, 0x85, 0xf5, 0xd5, 0x97,
+	0x19, 0xaa, 0xf3, 0x95, 0x48, 0x20, 0xe0, 0x32, 0x98, 0xb6, 0x31, 0xed, 0x78, 0x4c, 0xce, 0x21,
+	0xaf, 0x03, 0xeb, 0x20, 0xd9, 0x76, 0x08, 0xa6, 0xa4, 0xc9, 0xf4, 0x95, 0x91, 0x79, 0x7c, 0xd9,
+	0x82, 0x27, 0xbe, 0x82, 0x2f, 0xa9, 0x42, 0xc3, 0x17, 0x5f, 0x69, 0x85, 0x45, 0xc7, 0xb8, 0xf5,
+	0x60, 0x6c, 0xe2, 0xf1, 0x73, 0x45, 0x42, 0x81, 0xbe, 0x60, 0xe5, 0x2e, 0x58, 0x12, 0xd1, 0x04,
+	0x08, 0x81, 0x40, 0x66, 0x8e, 0x39, 0x11, 0x73, 0x88, 0xb7, 0xd9, 0x58, 0xcf, 0x25, 0x2a, 0xcf,
+	0x49, 0x46, 0xbc, 0xcd, 0xa2, 0xa5, 0x16, 0xc5, 0x46, 0x26, 0xce, 0x07, 0xbd, 0x8e, 0x30, 0xfc,
+	0x67, 0x0c, 0x9c, 0x99, 0x50, 0x76, 0xf8, 0x39, 0x48, 0xf0, 0xb2, 0x34, 0x75, 0x95, 0xdb, 0x9f,
+	0x2e, 0x6d, 0x0e, 0xfa, 0xca, 0x2c, 0xaf, 0xe5, 0x76, 0xf9, 0xb8, 0xaf, 0xcc, 0xf2, 0xe9, 0x6d,
+	0xf5, 0x45, 0x5f, 0xb9, 0x18, 0xd8, 0x3d, 0x7b, 0x78, 0x0f, 0xfb, 0x3b, 0xb3, 0x68, 0xef, 0x69,
+	0x45, 0xba, 0x6f, 0x13, 0xb7, 0x20, 0x70, 0xc8, 0x47, 0x41, 0x17, 0xa4, 0x46, 0x8a, 0x64, 0x4e,
+	0x62, 0xdc, 0xc9, 0xce, 0xa0, 0xaf, 0x24, 0x87, 0xf1, 0x70, 0x47, 0xc9, 0xa1, 0xd8, 0xb8, 0xb3,
+	0xcb, 0xaf, 0x76, 0x16, 0xc0, 0xa3, 0x20, 0x1a, 0x5e, 0x1b, 0x96, 0x3c, 0xce, 0x4b, 0x9e, 0x3f,
+	0x79, 0x07, 0x44, 0x0a, 0x5e, 0x06, 0x09, 0x87, 0xd8, 0x86, 0xde, 0xc6, 0xbe, 0xce, 0xc7, 0xe5,
+	0x82, 0xbc, 0x05, 0x01, 0xa5, 0xcb, 0x4c, 0xe9, 0x68, 0x88, 0x14, 0x94, 0x7f, 0x15, 0x03, 0x4b,
+	0x63, 0x6b, 0xe1, 0x97, 0x60, 0x31, 0xa8, 0xee, 0x11, 0xef, 0xbb, 0x83, 0xbe, 0x92, 0x0a, 0x48,
+	0x91, 0x93, 0x92, 0x0a, 0x28, 0x99, 0xd3, 0x52, 0x7c, 0x35, 0x2d, 0x21, 0x1b, 0x28, 0x6c, 0x01,
+	0x7e, 0x0c, 0x96, 0x42, 0xee, 0xb9, 0xb0, 0x58, 0x4d, 0xe6, 0x4a, 0x67, 0x8e, 0xfb, 0xca, 0x62,
+	0x60, 0xf5, 0x1d, 0x4c, 0x3b, 0x28, 0x3a, 0x00, 0x2f, 0x82, 0x39, 0x76, 0x1c, 0x7a, 0xc0, 0x38,
+	0x07, 0xce, 0x1f, 0xf7, 0x95, 0x04, 0x1b, 0xe4, 0x88, 0x61, 0x4b, 0xd0, 0xf0, 0x53, 0x0c, 0x2c,
+	0x46, 0x8e, 0x86, 0x7f, 0x5d, 0x75, 0x37, 0x23, 0x7b, 0xfe, 0xdc, 0xe4, 0xc3, 0xca, 0x2b, 0x7e,
+	0x09, 0xb0, 0x43, 0xca, 0x0d, 0x0b, 0xc1, 0x1c, 0x3f, 0x49, 0xa7, 0x4b, 0xb7, 0xc5, 0x89, 0xb6,
+	0x3c, 0x3a, 0x17, 0xdf, 0xb3, 0xba, 0x3a, 0x25, 0x5d, 0x9b, 0xee, 0x9f, 0x5e, 0xb3, 0x81, 0xe3,
+	0x55, 0x70, 0xf5, 0xb3, 0x04, 0x92, 0x81, 0xf2, 0xfd, 0xd7, 0x62, 0xc9, 0x80, 0x59, 0xac, 0xaa,
+	0x0e, 0x71, 0x3d, 0x1e, 0xe7, 0x90, 0xdf, 0x15, 0xe1, 0xfe, 0x21, 0x81, 0x05, 0x4e, 0xe4, 0x30,
+	0xab, 0xff, 0xe5, 0x79, 0x22, 0xb2, 0xfd, 0x45, 0x02, 0xe9, 0xe1, 0x12, 0xb1, 0xb1, 0xff, 0xe9,
+	0xcb, 0xea, 0x2e, 0x48, 0x7b, 0xf4, 0x8d, 0x92, 0xe4, 0x19, 0x26, 0xd7, 0x95, 0xc9, 0x12, 0x1e,
+	0x06, 0x14, 0xb1, 0xba, 0x40, 0x43, 0xb3, 0xfe, 0x5e, 0x94, 0xc0, 0x12, 0x1b, 0x23, 0x5f, 0xf4,
+	0x88, 0xd9, 0x26, 0xb5, 0x5e, 0xb7, 0x45, 0x1c, 0xf8, 0x09, 0x90, 0x0d, 0xc3, 0x35, 0xc5, 0x33,
+	0x66, 0x7d, 0xd0, 0x57, 0xe4, 0x6a, 0xb5, 0x5e, 0x7b, 0xd1, 0x57, 0x2e, 0xbc, 0x06, 0x69, 0xd5,
+	0x7a, 0x0d, 0x71, 0x3c, 0xb3, 0xa3, 0x31, 0x3b, 0xb1, 0x91, 0x9d, 0xad, 0xd7, 0xb6, 0xb3, 0xc5,
+	0xed, 0x30, 0xbc, 0x88, 0xf5, 0x79, 0x0c, 0xcc, 0x57, 0x2d, 0xad, 0x62, 0x52, 0x67, 0x9f, 0x3d,
+	0xc2, 0x60, 0x7d, 0x4c, 0x5a, 0xd7, 0x02, 0xd2, 0xfa, 0x9b, 0x7a, 0x52, 0x27, 0xeb, 0xe9, 0x66,
+	0x44, 0x4f, 0x6f, 0x78, 0x21, 0xf9, 0xcc, 0xc4, 0xdf, 0x8c, 0x99, 0x61, 0xa5, 0xe4, 0x37, 0xab,
+	0x94, 0x60, 0x18, 0x83, 0x84, 0x4f, 0x30, 0xbc, 0x01, 0x64, 0xf6, 0xba, 0x16, 0xfa, 0x3d, 0x3f,
+	0xe9, 0xc2, 0x1c, 0x56, 0xa2, 0x94, 0xf0, 0xa5, 0x86, 0x38, 0x88, 0x3d, 0x46, 0xd8, 0xa1, 0xcf,
+	0xb9, 0x9b, 0x47, 0xbc, 0x2d, 0x5c, 0x7c, 0x23, 0x83, 0xd4, 0xa6, 0xd5, 0xed, 0xea, 0x74, 0xd3,
+	0x32, 0x29, 0x79, 0x44, 0xe1, 0x16, 0x98, 0x7d, 0x40, 0x1c, 0x57, 0xb7, 0x7c, 0xbd, 0x5d, 0x7e,
+	0xbd, 0xca, 0x7d, 0xea, 0x81, 0x90, 0x8f, 0x86, 0x2d, 0xb0, 0xd0, 0xd1, 0xb5, 0x4e, 0xf3, 0x21,
+	0xa6, 0xc4, 0xe9, 0x62, 0x67, 0x4f, 0xe8, 0xee, 0x06, 0x3b, 0x1a, 0x6f, 0xe9, 0x5a, 0xe7, 0xae,
+	0x3f, 0x71, 0x0a, 0x9a, 0x53, 0x9d, 0x20, 0x10, 0x3a, 0x60, 0xb9, 0xcd, 0xa3, 0xa7, 0x44, 0x6d,
+	0xb2, 0x0a, 0x34, 0x5b, 0x44, 0xd3, 0xfd, 0x3a, 0x32, 0x91, 0xc0, 0x4d, 0x7f, 0x9e, 0xe1, 0x4b,
+	0x6c, 0xf6, 0x14, 0xee, 0xe0, 0xd0, 0xfa, 0x96, 0xe1, 0x9a, 0x1c, 0x0d, 0x0d, 0x00, 0x23, 0x3e,
+	0x89, 0xa9, 0x8a, 0x8a, 0x7f, 0x34, 0xe8, 0x2b, 0xe9, 0x90, 0xc7, 0x8a, 0xa9, 0x9e, 0xc2, 0x5f,
+	0x3a, 0xe4, 0xaf, 0x62, 0xaa, 0xe1, 0x0c, 0x8d, 0x51, 0x86, 0xd3, 0x13, 0x32, 0xac, 0x9e, 0x2e,
+	0xc3, 0x6a, 0x38, 0xc3, 0xaa, 0x9f, 0xe1, 0xea, 0x8f, 0x31, 0xb0, 0xe2, 0x7f, 0x56, 0x21, 0x62,
+	0x5b, 0xae, 0x4e, 0x2d, 0x67, 0x9f, 0x9f, 0x7f, 0xf7, 0xc0, 0x6c, 0xf0, 0xa2, 0xf3, 0x22, 0x98,
+	0x19, 0xde, 0x70, 0x33, 0xa6, 0x7f, 0xb5, 0xad, 0xbd, 0xda, 0xbf, 0xb8, 0xd3, 0x04, 0x06, 0x5e,
+	0x01, 0x09, 0x07, 0xdf, 0xa7, 0xcd, 0x9e, 0x63, 0x88, 0x07, 0xcf, 0x0a, 0x3b, 0x3e, 0x10, 0xbe,
+	0x4f, 0x77, 0x51, 0x95, 0xdd, 0x4c, 0x8e, 0xd7, 0x44, 0x5e, 0xc3, 0x31, 0x38, 0xc4, 0x6e, 0x37,
+	0xd9, 0xa5, 0x27, 0x9e, 0x3a, 0x1e, 0xe4, 0xce, 0xe6, 0x86, 0xaa, 0x3a, 0x1c, 0x62, 0xb7, 0x59,
+	0x13, 0xf9, 0x0d, 0xb8, 0x0a, 0x66, 0x0c, 0x82, 0x55, 0xe2, 0xf0, 0x8a, 0x25, 0xbc, 0xb7, 0x85,
+	0x37, 0x82, 0xc4, 0x2f, 0x7c, 0x17, 0xcc, 0x1a, 0x04, 0x3b, 0x26, 0x71, 0x38, 0xcd, 0x89, 0x52,
+	0x92, 0x99, 0x12, 0x43, 0xc8, 0x6f, 0x5c, 0xfa, 0x4e, 0x1a, 0x7e, 0x0c, 0x8c, 0x3e, 0x4d, 0xe0,
+	0x87, 0xe0, 0xed, 0x7a, 0x63, 0x07, 0x6d, 0x6c, 0x55, 0x9a, 0xb5, 0x9d, 0x72, 0xa5, 0x59, 0x6f,
+	0x6c, 0x34, 0x76, 0xeb, 0x4d, 0xb4, 0x5b, 0xab, 0x6d, 0xd7, 0xb6, 0xd2, 0x53, 0xd9, 0x73, 0x07,
+	0x87, 0xf9, 0xcc, 0xf8, 0x27, 0x4d, 0xcf, 0x34, 0x75, 0x53, 0x3b, 0x09, 0x5e, 0xae, 0x54, 0x2b,
+	0x8d, 0x4a, 0x39, 0x2d, 0x9d, 0x00, 0x2f, 0x13, 0x83, 0x50, 0xa2, 0x66, 0xe5, 0xaf, 0x7f, 0xc8,
+	0x4d, 0x5d, 0xfa, 0x3e, 0x06, 0x16, 0x23, 0x2f, 0x68, 0x78, 0x05, 0x2c, 0x55, 0xeb, 0xe3, 0xd1,
+	0x64, 0x0f, 0x0e, 0xf3, 0x2b, 0xd1, 0xd7, 0xb6, 0x88, 0x25, 0x04, 0xa9, 0x57, 0x36, 0xaa, 0x0c,
+	0x22, 0x4d, 0x84, 0xd4, 0x09, 0x36, 0x18, 0xa4, 0x08, 0xd2, 0x61, 0x48, 0xa5, 0x9c, 0x8e, 0x65,
+	0xdf, 0x3a, 0x38, 0xcc, 0x9f, 0x9d, 0x80, 0x20, 0x6a, 0xd8, 0x87, 0x9f, 0x65, 0x7c, 0xa2, 0x0f,
+	0x91, 0x23, 0xbc, 0x0a, 0xce, 0x8c, 0x20, 0xbb, 0x35, 0x3f, 0x30, 0xd9, 0xa3, 0x26, 0x02, 0xda,
+	0x35, 0x5d, 0x2f, 0x34, 0x41, 0xcd, 0x43, 0x90, 0x0c, 0x3c, 0x2d, 0xe1, 0xfb, 0x60, 0xb9, 0xb1,
+	0x73, 0x67, 0x7b, 0x73, 0x9c, 0x98, 0x95, 0x83, 0xc3, 0x3c, 0x0c, 0x2c, 0xf5, 0x49, 0x89, 0x22,
+	0x46, 0x95, 0x89, 0x22, 0x42, 0x35, 0x29, 0xdd, 0x7c, 0x3a, 0xc8, 0x49, 0xcf, 0x06, 0x39, 0xe9,
+	0xf1, 0x51, 0x6e, 0xea, 0xc9, 0x51, 0x4e, 0x7a, 0x76, 0x94, 0x9b, 0xfa, 0xf5, 0x28, 0x37, 0xf5,
+	0xd9, 0xc9, 0x5b, 0x35, 0xf4, 0xef, 0x4a, 0x6b, 0x86, 0xf7, 0x3f, 0xf8, 0x2b, 0x00, 0x00, 0xff,
+	0xff, 0x6c, 0x3e, 0x87, 0x81, 0x76, 0x11, 0x00, 0x00,
 }
 
 func (this *MetadataDescriptor) Equal(that interface{}) bool {
@@ -1268,12 +1246,6 @@ func (this *LogStreamDescriptor) Equal(that interface{}) bool {
 			return false
 		}
 	}
-	if !this.Head.Equal(&that1.Head) {
-		return false
-	}
-	if !this.Tail.Equal(&that1.Tail) {
-		return false
-	}
 	return true
 }
 func (this *ReplicaDescriptor) Equal(that interface{}) bool {
@@ -1694,26 +1666,6 @@ func (m *LogStreamDescriptor) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
-	{
-		size, err := m.Tail.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
-		}
-		i -= size
-		i = encodeVarintMetadata(dAtA, i, uint64(size))
-	}
-	i--
-	dAtA[i] = 0x32
-	{
-		size, err := m.Head.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
-		}
-		i -= size
-		i = encodeVarintMetadata(dAtA, i, uint64(size))
-	}
-	i--
-	dAtA[i] = 0x2a
 	if len(m.Replicas) > 0 {
 		for iNdEx := len(m.Replicas) - 1; iNdEx >= 0; iNdEx-- {
 			{
@@ -1809,21 +1761,21 @@ func (m *TopicDescriptor) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	var l int
 	_ = l
 	if len(m.LogStreams) > 0 {
-		dAtA6 := make([]byte, len(m.LogStreams)*10)
-		var j5 int
+		dAtA4 := make([]byte, len(m.LogStreams)*10)
+		var j3 int
 		for _, num1 := range m.LogStreams {
 			num := uint64(num1)
 			for num >= 1<<7 {
-				dAtA6[j5] = uint8(uint64(num)&0x7f | 0x80)
+				dAtA4[j3] = uint8(uint64(num)&0x7f | 0x80)
 				num >>= 7
-				j5++
+				j3++
 			}
-			dAtA6[j5] = uint8(num)
-			j5++
+			dAtA4[j3] = uint8(num)
+			j3++
 		}
-		i -= j5
-		copy(dAtA[i:], dAtA6[:j5])
-		i = encodeVarintMetadata(dAtA, i, uint64(j5))
+		i -= j3
+		copy(dAtA[i:], dAtA4[:j3])
+		i = encodeVarintMetadata(dAtA, i, uint64(j3))
 		i--
 		dAtA[i] = 0x1a
 	}
@@ -2280,10 +2232,6 @@ func (m *LogStreamDescriptor) ProtoSize() (n int) {
 			n += 1 + l + sovMetadata(uint64(l))
 		}
 	}
-	l = m.Head.ProtoSize()
-	n += 1 + l + sovMetadata(uint64(l))
-	l = m.Tail.ProtoSize()
-	n += 1 + l + sovMetadata(uint64(l))
 	return n
 }
 
@@ -3058,72 +3006,6 @@ func (m *LogStreamDescriptor) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
-		case 5:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Head", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowMetadata
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthMetadata
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthMetadata
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := m.Head.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 6:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Tail", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowMetadata
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthMetadata
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthMetadata
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := m.Tail.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipMetadata(dAtA[iNdEx:])
diff --git a/proto/varlogpb/metadata.proto b/proto/varlogpb/metadata.proto
index 660008a7d..54e0e7f5a 100644
--- a/proto/varlogpb/metadata.proto
+++ b/proto/varlogpb/metadata.proto
@@ -84,15 +84,6 @@ message LogStreamDescriptor {
   ];
   LogStreamStatus status = 3;
   repeated ReplicaDescriptor replicas = 4 [(gogoproto.nullable) = true];
-
-  // Deprecated: The members - head and tail are not used by the metadata
-  // repository. It exists here just since the LogStreamDescriptor is used
-  // elsewhere other than the metadata repository. It leads to misusing the
-  // LogStreamDescriptor.
-  LogEntryMeta head = 5
-    [(gogoproto.nullable) = false, (gogoproto.jsontag) = "head,omitempty"];
-  LogEntryMeta tail = 6
-    [(gogoproto.nullable) = false, (gogoproto.jsontag) = "tail,omitempty"];
 }
 
 enum LogStreamStatus {
diff --git a/testdata/varlogctl/addlogstream.0.golden.json b/testdata/varlogctl/addlogstream.0.golden.json
index 802b6c849..2b19a489a 100644
--- a/testdata/varlogctl/addlogstream.0.golden.json
+++ b/testdata/varlogctl/addlogstream.0.golden.json
@@ -1 +1 @@
-{"topicId":1,"logStreamId":1,"replicas":[{"storageNodeId":1,"storageNodePath":"/tmp","dataPath":""},{"storageNodeId":2,"storageNodePath":"/tmp","dataPath":""}],"head":{},"tail":{}}
\ No newline at end of file
+{"topicId":1,"logStreamId":1,"replicas":[{"storageNodeId":1,"storageNodePath":"/tmp","dataPath":""},{"storageNodeId":2,"storageNodePath":"/tmp","dataPath":""}]}
\ No newline at end of file
diff --git a/testdata/varlogctl/getlogstream.0.golden.json b/testdata/varlogctl/getlogstream.0.golden.json
index 802b6c849..2b19a489a 100644
--- a/testdata/varlogctl/getlogstream.0.golden.json
+++ b/testdata/varlogctl/getlogstream.0.golden.json
@@ -1 +1 @@
-{"topicId":1,"logStreamId":1,"replicas":[{"storageNodeId":1,"storageNodePath":"/tmp","dataPath":""},{"storageNodeId":2,"storageNodePath":"/tmp","dataPath":""}],"head":{},"tail":{}}
\ No newline at end of file
+{"topicId":1,"logStreamId":1,"replicas":[{"storageNodeId":1,"storageNodePath":"/tmp","dataPath":""},{"storageNodeId":2,"storageNodePath":"/tmp","dataPath":""}]}
\ No newline at end of file
diff --git a/testdata/varlogctl/listlogstreams.1.golden.json b/testdata/varlogctl/listlogstreams.1.golden.json
index b14d5d2b2..54564947b 100644
--- a/testdata/varlogctl/listlogstreams.1.golden.json
+++ b/testdata/varlogctl/listlogstreams.1.golden.json
@@ -1 +1 @@
-[{"topicId":1,"logStreamId":1,"replicas":[{"storageNodeId":1,"storageNodePath":"/tmp","dataPath":""},{"storageNodeId":2,"storageNodePath":"/tmp","dataPath":""}],"head":{},"tail":{}}]
\ No newline at end of file
+[{"topicId":1,"logStreamId":1,"replicas":[{"storageNodeId":1,"storageNodePath":"/tmp","dataPath":""},{"storageNodeId":2,"storageNodePath":"/tmp","dataPath":""}]}]
\ No newline at end of file
diff --git a/testdata/varlogctl/unseal.0.golden.json b/testdata/varlogctl/unseal.0.golden.json
index 802b6c849..2b19a489a 100644
--- a/testdata/varlogctl/unseal.0.golden.json
+++ b/testdata/varlogctl/unseal.0.golden.json
@@ -1 +1 @@
-{"topicId":1,"logStreamId":1,"replicas":[{"storageNodeId":1,"storageNodePath":"/tmp","dataPath":""},{"storageNodeId":2,"storageNodePath":"/tmp","dataPath":""}],"head":{},"tail":{}}
\ No newline at end of file
+{"topicId":1,"logStreamId":1,"replicas":[{"storageNodeId":1,"storageNodePath":"/tmp","dataPath":""},{"storageNodeId":2,"storageNodePath":"/tmp","dataPath":""}]}
\ No newline at end of file
diff --git a/tests/it/cluster/client_test.go b/tests/it/cluster/client_test.go
index 229e2c814..1ed67a82c 100644
--- a/tests/it/cluster/client_test.go
+++ b/tests/it/cluster/client_test.go
@@ -202,21 +202,6 @@ func TestClientAppend(t *testing.T) {
 	// })
 
 	for _, logStreamID := range clus.LogStreamIDs(topicID) {
-		lsd, err := client.LogStreamMetadata(context.Background(), topicID, logStreamID) //nolint:staticcheck
-		require.NoError(t, err)
-		require.Equal(t, topicID, lsd.TopicID)
-		require.Equal(t, logStreamID, lsd.LogStreamID)
-
-		require.Equal(t, types.MinLLSN, lsd.Head.LLSN)          //nolint:staticcheck
-		require.GreaterOrEqual(t, lsd.Head.GLSN, types.MinGLSN) //nolint:staticcheck
-		require.Equal(t, topicID, lsd.Head.TopicID)             //nolint:staticcheck
-		require.Equal(t, logStreamID, lsd.Head.LogStreamID)     //nolint:staticcheck
-
-		require.GreaterOrEqual(t, lsd.Tail.LLSN, types.MinLLSN)
-		require.GreaterOrEqual(t, lsd.Tail.GLSN, types.MinGLSN)
-		require.Equal(t, topicID, lsd.Tail.TopicID)
-		require.Equal(t, logStreamID, lsd.Tail.LogStreamID)
-
 		first, last, err := client.PeekLogStream(context.Background(), topicID, logStreamID)
 		require.NoError(t, err)
 		require.Equal(t, types.MinLLSN, first.LLSN)