isledb

type Batch struct {
	// contains filtered or unexported fields
}

type BootstrapView struct {
	Snapshot *Snapshot
	Cursor   ChangeCursor
	Version  Version
}

type CacheStats struct {
	Hits        int64
	Misses      int64
	Bytes       int64
	MaxBytes    int64
	EntryCount  int
	MaxEntries  int
	Evictions   int64
	Corruptions int64
	// Bypasses counts entries too large for the cache's whole budget; they
	// are served without being cached.
	Bypasses int64
	// Failures counts entries that could not be written into the cache; they
	// are served without being cached.
	Failures int64
}

type Change struct {
	Sequence uint64
	// Revision is the lowest view position that holds the change, that of
	// the commit holding it: a Reader at or past it sees it.
	Revision  ViewPosition
	Operation ChangeOperation
	Key       []byte
	Value     []byte
	HasValue  bool
	ExpiresAt time.Time
}

type ChangeBounds struct {
	Oldest  ChangeCursor
	Head    ChangeCursor
	Payload ChangeFeedPayload
}

type ChangeCursor struct {
	// contains filtered or unexported fields
}

type ChangeFeedCleanupStats struct {
	EntriesRetired  int
	BatchesPlanned  int
	BatchesDeleted  int
	BlockedRetained int
	FailedDeletes   int
	Duration        time.Duration
}

type ChangeFeedOptions struct {
	Payload ChangeFeedPayload
}

type ChangeFeedPayload uint8

type ChangeFeedRetentionOptions struct {
	// RetainFor is the minimum age retained. Zero selects seven days.
	RetainFor time.Duration
}

type ChangeOperation uint8

type ChangePage struct {
	Changes []Change
	Next    ChangeCursor
	Head    ChangeCursor
}

type ChangeReadOptions struct {
	MaxChanges int
	MaxBytes   int64
}

type ChangeReader struct {
	// contains filtered or unexported fields
}

type ChangeReaderOptions struct {
	// ReadCache sends reads of change batches, their indexes and blocks,
	// through a regional read cache before storage, as a Reader's SST reads
	// are. The feed's view and manifest entries are read from storage.
	ReadCache ReadCacheOptions
	// Metrics counts the read cache's reads and fallbacks, in
	// ReadCacheReads and ReadCacheFallbacks.
	Metrics *ReaderMetrics
}

type CommitStatus int

type CompactionBlocked struct {
	SourceLevel uint32
	SSTCount    int
	// Critical repeats L0's depth signal, which is a property of the level
	// rather than of whether it could be planned.
	Critical bool
	Reason   string
}

type DB struct {
	// contains filtered or unexported fields
}

type DBOptions struct {
	// Prefix is the database's root path inside the bucket or container.
	Prefix string

	// ChangeFeed enables a durable ordered mutation feed for all future writer
	// commits. Nil leaves a new feed disabled and adopts an already-persisted
	// configuration when reopening a prefix.
	ChangeFeed *ChangeFeedOptions

	// SSTOutput configures newly flushed and compacted SSTs. Zero fields select
	// defaults. This is runtime output policy and is not persisted in CURRENT.
	SSTOutput SSTOutputOptions

	// Policy contains store-wide safety settings persisted by the first writer.
	Policy StorePolicy
}

type DeleterOptions struct {
	// PollInterval is the active-work and initial error-retry cadence. Empty
	// lanes and repeated failures back off to a bounded internal safety
	// interval, while newly created plans and known deadlines can wake
	// reclamation earlier.
	PollInterval time.Duration
	// MaxObjectsPerPass bounds normal work. One immutable SST retirement plan
	// can exceed it because a plan is completed atomically and is independently
	// bounded by MaxRetiredObjectsPerEntry.
	MaxObjectsPerPass int
}

type DiskCacheStats struct {
	// Meta holds SST metadata regions and Bloom filters.
	Meta CacheStats
	// Data holds small SSTs whole and chunks of larger SSTs' data.
	Data CacheStats
	// SSTDrops counts reads that dropped an SST from every cache after
	// finding damaged bytes. Each such read counts, not each SST.
	SSTDrops int64
}

type Iterator struct {
	// contains filtered or unexported fields
}

type IteratorOptions struct {
	// MinKey is the inclusive lower bound. Nil or empty means the beginning of
	// the keyspace.
	MinKey []byte
	// MaxKey is the exclusive upper bound. Nil or empty means the end of the
	// keyspace.
	MaxKey []byte
}

type KV struct {
	Key   []byte
	Value []byte
}

type KeyRange struct {
	Min []byte
	Max []byte
}

type LSMShape struct {
	// L0 is the newly saved files, which may overlap each other. Its
	// TargetBytes is zero.
	L0 LevelShape
	// L0Depth is the most L0 files covering any one key: the L0 files a
	// read of that key may check, and what L0MaxDepth bounds.
	L0Depth int
	// Levels are L1 and below, in order.
	Levels []LevelShape
}

type LevelShape struct {
	Level uint32
	Files int
	Bytes int64
	// TargetBytes is the size compaction keeps the level near: BaseLevelBytes
	// for L1, LevelGrowthFactor times more for each level below.
	TargetBytes int64
}

type Maintenance struct {
	// contains filtered or unexported fields
}

type MaintenanceOptions struct {
	// IdleInterval is the delay between scans when no maintenance work is
	// immediately available. Known work and pending commands use a shorter
	// internal active cadence. Zero selects the production default.
	IdleInterval time.Duration

	// SSTCompaction controls L0 and leveled SST compaction. Zero fields select
	// production defaults.
	SSTCompaction SSTCompactionOptions

	// ManifestCheckpoint controls the amount of manifest replay work retained
	// between snapshots. Checkpointing is always enabled.
	ManifestCheckpoint ManifestCheckpointOptions

	// ChangeFeedRetention is nil by default, preserving change-feed history
	// indefinitely. When configured, maintenance retires and deletes old feed
	// batches without affecting KV state.
	ChangeFeedRetention *ChangeFeedRetentionOptions

	// Reclamation controls the independently scheduled SST, change-feed, and
	// manifest-metadata physical deletion lanes. Zero fields select defaults.
	Reclamation ReclamationOptions

	// OnCycle is called synchronously by Run after each successful cycle.
	OnCycle func(MaintenanceStats)
	// OnReclamationCycle is called independently after a successful bounded
	// physical deletion pass.
	OnReclamationCycle func(ReclamationCycleStats)
	// OnError is called synchronously by Run when a cycle fails with a
	// recoverable error.
	OnError func(error)
}

type MaintenanceScheduleStats struct {
	Selected              MaintenanceTask
	CompactionSourceLevel uint32
	CompactionWorkUnits   uint32
	CompactionCritical    bool
	CheckpointEligible    bool
	CheckpointUrgent      bool
	ReplayPages           uint64
	ReplayBytes           uint64
	// Blocked lists levels that had work but could not be planned this cycle.
	Blocked []CompactionBlocked
}

type MaintenanceState uint8

type MaintenanceStats struct {
	State MaintenanceState
	// WaitingSince is when the command the writer has yet to answer was
	// staged; zero when State is MaintenanceIdle. A busy database stages a
	// new command almost every cycle, so State alone stays
	// MaintenanceWaitingForWriter even while the writer keeps up; only an
	// old WaitingSince means the writer isn't answering.
	WaitingSince        time.Time
	Scheduling          MaintenanceScheduleStats
	SSTCompaction       SSTCompactionStats
	SSTCleanup          SSTCleanupStats
	ChangeFeedRetention ChangeFeedCleanupStats
	ManifestCheckpoint  ManifestCheckpointStats
	ManifestCleanup     ManifestCleanupStats
	// RejectedCommands counts commands of any kind the writer rejected,
	// in the cycle that reads the writer's answer.
	RejectedCommands int
	Duration         time.Duration
}

type MaintenanceTask uint8

type ManifestCheckpointOptions struct {
	TargetReplayPages uint64
	TargetReplayBytes uint64
}

type ManifestCheckpointStats struct {
	Staged      bool
	ReplayPages uint64
	ReplayBytes uint64
}

type ManifestCleanupStats struct {
	Snapshots ManifestSnapshotCleanupStats
	Pages     ManifestPageCleanupStats
}

type ManifestDeleterOptions struct {
	DeleterOptions
	// AuditInterval controls low-frequency orphan object discovery.
	AuditInterval time.Duration
}

type ManifestPageCleanupStats struct {
	PlansPrepared    int
	PlansScanned     int
	PlansCompleted   int
	PagesMarked      int
	PagesDeleted     int
	Protected        int
	Deferred         int
	Failures         int
	MarkersScanned   int
	MarkersCleared   int
	ObjectsScanned   int
	DeleteAttempts   int
	ReachabilityGETs int
	Duration         time.Duration
}

type ManifestSnapshotCleanupStats struct {
	SnapshotsMarked  int
	DeleteAttempts   int
	SnapshotsDeleted int
	Protected        int
	Deferred         int
	Failures         int
	MarkersScanned   int
	MarkersCleared   int
	ObjectsScanned   int
	Duration         time.Duration
}

type NextView struct {
	// contains filtered or unexported fields
}

type PrefetchOptions struct {
	// Range limits prefetch to visible SSTs whose key span overlaps the range.
	Range KeyRange

	// All must be true to prefetch the full visible keyspace.
	All bool

	// MaxSSTs limits the number of uncached SSTs to download. Zero means no
	// limit.
	MaxSSTs int

	// MaxBytes limits the total bytes to download, each SST's Bloom filter
	// included. Zero means no limit.
	MaxBytes int64

	// Concurrency limits parallel SST downloads. Zero uses a small default.
	Concurrency int
}

type PrefetchStats struct {
	MatchedSSTs int
	CachedSSTs  int
	SkippedSSTs int
	BytesRead   int64
}

type ReadCacheOptions struct {
	// URL is the cache's API, such as https://isledb-cache:8090.
	URL string
	// Token is sent as "Authorization: Bearer <token>". Leave it empty when
	// HTTPClient authenticates with a client certificate.
	Token string
	// HTTPClient carries the requests, for TLS or a custom transport. Nil
	// selects one with connection reuse suited to many concurrent reads.
	HTTPClient *http.Client
	// Timeout is how long a read waits for the cache before reading storage
	// instead. Zero selects 10 seconds. The cache's own wait for read budget
	// should be near it.
	Timeout time.Duration
	// MaxCurrentAge is the oldest copy of CURRENT a refresh takes from the
	// cache; an older one, from a cache that cannot reach storage, is read
	// from storage instead. Zero selects 5 seconds.
	MaxCurrentAge time.Duration
}

type Reader struct {
	// contains filtered or unexported fields
}

type ReaderMetrics struct {
	RefreshTotal   prometheus.Counter
	RefreshErrors  prometheus.Counter
	RefreshLatency prometheus.Histogram
	// StaleReads counts reads answered from a view past its refresh time
	// because refreshing it failed.
	StaleReads prometheus.Counter
	// ViewLoaded is the Unix time the published manifest view was loaded;
	// time() minus it is the view's age.
	ViewLoaded prometheus.Gauge
	// ViewOutdatedSince is the Unix time the published view first became
	// outdated in Manual mode, the load time of a newer view not yet
	// published, or 0 when it is the newest loaded: time() minus it climbing
	// toward MaxLag means preparation is falling behind.
	ViewOutdatedSince prometheus.Gauge
	// NextViewPublishes counts NextView.Publish calls by result: published,
	// changed or expired.
	NextViewPublishes *prometheus.CounterVec
	// SafetyPublishes counts views the Reader published itself after MaxLag.
	SafetyPublishes prometheus.Counter
	// DeadSSTsPending is how many SSTs a publish retired that are not yet
	// deleted from the disk cache; one that keeps rising means deletes fall
	// behind compactions.
	DeadSSTsPending prometheus.Gauge

	GetTotal   prometheus.Counter
	GetErrors  prometheus.Counter
	GetHits    prometheus.Counter
	GetMisses  prometheus.Counter
	GetLatency prometheus.Histogram

	ScanTotal   prometheus.Counter
	ScanErrors  prometheus.Counter
	ScanLatency prometheus.Histogram
	ScanResults prometheus.Counter

	ScanLimitTotal   prometheus.Counter
	ScanLimitErrors  prometheus.Counter
	ScanLimitLatency prometheus.Histogram
	ScanLimitResults prometheus.Counter

	BloomFilterErrors prometheus.Counter
	BloomFilterSkips  prometheus.Counter

	SSTRangeReadTotal   prometheus.Counter
	SSTRangeReadErrors  prometheus.Counter
	SSTRangeReadLatency prometheus.Histogram
	SSTRangeReadBytes   prometheus.Counter

	// ReadCacheReads counts reads of SSTs and manifest pages and snapshots
	// the read cache answered; the SSTRangeRead metrics count only SST reads
	// from storage.
	ReadCacheReads prometheus.Counter
	// ReadCacheFallbacks counts those reads that went to storage because the
	// read cache failed, by reason: timeout, unavailable, not_found,
	// size_mismatch, refused or invalid; bypassed, sent straight to storage
	// because the cache had stopped answering; checksum_mismatch, bytes from
	// the cache that failed their checksum and were read again from storage
	// (also counted when the object itself is corrupt, which storage then
	// shows too);
	// or after_damage, a read of an SST found damaged in the last ten
	// minutes, sent to storage.
	ReadCacheFallbacks *prometheus.CounterVec
	// ReadCacheCurrent counts refreshes that asked the read cache for
	// CURRENT, by outcome: relayed, its copy used; too_old or behind, its
	// copy older than MaxCurrentAge or behind the published view; or failed,
	// no answer. All but relayed read CURRENT from storage instead.
	ReadCacheCurrent *prometheus.CounterVec
	// ReadCacheCurrentAge is the age, in seconds, of the last copy of
	// CURRENT the read cache gave.
	ReadCacheCurrentAge prometheus.Gauge
	// ReadCacheDoorbells counts answers to the long poll on the read cache,
	// by result: rang, a newer position, for which a refresh was requested;
	// quiet, none before the cache's timeout; or error.
	ReadCacheDoorbells *prometheus.CounterVec
}

type ReaderOpenOptions struct {
	// CacheDir is the directory for the disk cache. It must be non-empty, may
	// be owned by only one live Reader process at a time, and must remain
	// writable for the Reader's lifetime. Opening logs a warning when the
	// directory's filesystem cannot hold DiskCacheSize.
	CacheDir string

	// DiskCacheSize bounds everything the reader keeps on disk: SST metadata,
	// Bloom filters, small SSTs and chunks of larger SSTs' data. Data is
	// evicted first, and never to make room for more data at the expense of
	// metadata, so bulk data cannot evict what every lookup needs. Zero
	// selects the default (8 GiB).
	DiskCacheSize int64

	// BlockCacheSize is the maximum bytes of SST blocks kept in memory,
	// decoded (checksummed and decompressed). A lookup adds the blocks it
	// reads; a scan, and each seek, adds only the blocks holding the first
	// 64 KiB it reads in each SST and reads the rest into buffers of its own.
	// Zero selects the default (256 MiB). With cgo, it is allocated outside
	// the Go heap.
	BlockCacheSize int64

	// BloomCacheSize is the maximum accounted bytes of parsed Bloom filters
	// kept in memory. Zero selects the default (64 MiB).
	BloomCacheSize int64

	// Views controls manifest freshness. Read-view lifetime is a store policy
	// loaded from the manifest and cannot be extended by a reader.
	Views ReaderViewPolicy

	// ReadCache sends reads of SSTs and manifest pages and snapshots, and
	// refreshes' reads of CURRENT, through a regional read cache (isledb
	// cache) before storage, and refreshes as soon as the cache sees a new
	// commit. Leave URL empty to read storage directly.
	ReadCache ReadCacheOptions

	Metrics *ReaderMetrics
}

type ReaderViewPolicy struct {
	// RefreshAfter is how often the Reader refreshes its manifest view in the
	// background. Reads never wait for a refresh; they use the last view
	// published. A failed refresh is retried about every 30 seconds, or
	// RefreshAfter if shorter. Each Reader refreshes on its own schedule with a
	// random phase, so readers started together do not refresh in step. Zero
	// selects one minute; values under one second are rejected.
	RefreshAfter time.Duration

	// Manual leaves publishing newer views to the application. The Reader
	// still loads every RefreshAfter and renews an unchanged view, but keeps
	// a newer one unpublished until the application publishes it, or until
	// the published view has been outdated for MaxLag, when it publishes the
	// newest view itself. Refresh still publishes at once.
	Manual bool

	// MaxLag bounds, in Manual mode, how long the published view may stay
	// outdated. Zero selects 5 minutes, or a quarter of the store's
	// MaxPinnedViewAge if that is shorter. A value set explicitly must be
	// below half the MaxPinnedViewAge.
	MaxLag time.Duration
}

type ReclamationCycleStats struct {
	Family     ReclamationFamily
	SST        SSTCleanupStats
	ChangeFeed ChangeFeedCleanupStats
	Manifest   ManifestCleanupStats
	Duration   time.Duration
}

type ReclamationFamily string

type ReclamationOptions struct {
	// MaxConcurrentDeletes is shared by all physical deletion lanes.
	MaxConcurrentDeletes int

	SST        DeleterOptions
	ChangeFeed DeleterOptions
	Manifest   ManifestDeleterOptions
}

type SSTCleanupStats struct {
	SSTsPlanned          int
	PlansPrepared        int
	PlansScanned         int
	PlansCompleted       int
	DeleteAttempts       int
	SSTsDeleted          int
	DeferredPlans        int
	Failures             int
	OrphanPlansScanned   int
	OrphanObjectsScanned int
	OrphanCandidates     int
	OrphansDeleted       int
	// Writer L0 merge intents looked at, settled ones removed, and abandoned
	// ones resolved into deletion plans.
	IntentsScanned  int
	IntentsSettled  int
	IntentsResolved int
}

type SSTCompactionOptions struct {
	// ReadConcurrency bounds concurrent input-SST reads within one job.
	ReadConcurrency int
	// ScratchDir is the base directory for transient compaction input SSTs.
	// Empty uses the current user's operating-system cache directory, with a
	// per-user temporary-directory fallback. IsleDB creates an
	// isolated per-store, per-fence session below it, removes abandoned sessions
	// from older fence epochs on startup, and removes the current session on
	// graceful close. Individual files are removed as their readers close.
	ScratchDir string
	// L0TriggerSSTs starts L0 compaction at this many files.
	L0TriggerSSTs int
	// BaseLevelBytes is the target size of L1.
	BaseLevelBytes int64
	// LevelGrowthFactor scales the target size of each successive level. It
	// must be at least 2.
	LevelGrowthFactor int
	// TargetSSTBytes is the approximate output-file size. Encoding settings
	// come from DBOptions.SSTOutput.
	TargetSSTBytes int64
	// L0ToBaseRatio is the share of the L1 bytes that L0 overlaps which L0
	// must hold before it merges into L1. Below it, new L0 files merge with
	// each other instead, so L1 is not rewritten for a little new data. Zero
	// selects 1: L0 merges into L1 once it holds as many bytes as it would
	// rewrite there.
	L0ToBaseRatio float64
	// L0MaxDepth is the number of L0 files covering one key that makes L0
	// merge into L1 whatever its size, bounding the files a lookup checks.
	// Zero selects 16.
	L0MaxDepth int
	// L0MaxAge is the age of L0's oldest data that makes L0 merge into L1
	// whatever its size, so a database that stops being written drains L0.
	// Zero selects 30 minutes.
	L0MaxAge time.Duration
}

type SSTCompactionStats struct {
	Jobs       int
	InputSSTs  int
	OutputSSTs int
	// ForcedLevelCreations counts prerequisite drain jobs whose staged manifest
	// command targets a previously absent level. Ordinary size-driven creation
	// of the next level is not included. DeepestForcedLevel records the greatest
	// such destination and is meaningful when the count is non-zero. As with all
	// command-producing maintenance stats, the writer must apply the command
	// before the level is visible.
	ForcedLevelCreations int
	DeepestForcedLevel   uint32
	// OutputBytes is the total size of the SSTs the cycle's jobs published. It
	// includes files a metadata-only job relocated between levels, so it is not
	// the amount of data compaction actually moved through the object store.
	OutputBytes int64
	// MovedJobs and MovedBytes are the metadata-only subset. A plan whose
	// sources do not overlap each other and overlap nothing in the destination
	// publishes the same immutable files at a new level. They are never
	// rewritten or re-uploaded, but may be read for checksum verification; that
	// cost is included in ReadBytes.
	MovedJobs  int
	MovedBytes int64
	// ReadBytes is what compaction pulled from the object store: the inputs of
	// every rewrite, plus the sources of any move that was checksum-verified.
	// It is the GET side of the cost; RewrittenBytes is the PUT side.
	ReadBytes int64
	// L0Merges is the subset of Jobs that merged new L0 files with each other
	// rather than into L1.
	L0Merges int
	// RewrittenBytes is what compaction genuinely wrote, and the figure that
	// tracks object-store cost and write amplification. Reading OutputBytes
	// instead overstates both, by the whole of MovedBytes.
	RewrittenBytes int64
	// OversizedJobs is the subset of Jobs whose inputs were over the size
	// that fits one manifest entry, run because the destination level could
	// not be drained first. Its last output can be far over TargetSSTBytes.
	OversizedJobs int
	// The figures above count a job when it runs. The writer can still
	// reject its command; RejectedJobs and RejectedBytes count those, in the
	// cycle that reads the writer's answer. The rejected outputs are deleted
	// as orphans.
	RejectedJobs  int
	RejectedBytes int64
}

type SSTEncodingOptions struct {
	Compression     string
	BlockBytes      int
	BloomBitsPerKey int
}

type SSTInfo struct {
	ID             string
	Level          int
	Size           int64
	BloomSize      int64
	MinKey, MaxKey []byte
}

type SSTOutputOptions struct {
	L0        SSTEncodingOptions
	Compacted SSTEncodingOptions
}

type Snapshot struct {
	// contains filtered or unexported fields
}

type StorePolicy struct {
	// MaxPinnedViewAge is the longest time a loaded manifest view may remain
	// readable. Zero selects DefaultMaxPinnedViewAge.
	MaxPinnedViewAge time.Duration
}

type ValueOptions struct {
	// MaxKeyBytes is the largest accepted key size. It cannot exceed 65527
	// bytes because the memtable appends an 8-byte sequence suffix to keys.
	MaxKeyBytes int

	// MaxValueBytes is the largest accepted value size.
	MaxValueBytes int64
}

type Version struct {
	// contains filtered or unexported fields
}

type ViewPosition uint64

type Writer struct {
	// contains filtered or unexported fields
}

type WriterFlushOptions struct {
	// Interval is the background flush cadence. Zero disables background flush.
	// A failed background commit is retried, with a delay that doubles from
	// Interval up to 30 seconds.
	Interval time.Duration
}

type WriterL0MergeOptions struct {
	// TargetBytes is the held bytes that start a merge and the approximate
	// size of the merged file. Zero selects the default, 64 MiB. The writer
	// holds up to twice this much.
	TargetBytes int64

	// MaxAge is how long a committed file is held before what is held is
	// merged whatever its size. Zero selects the default, five minutes.
	MaxAge time.Duration
}

type WriterMaintenanceOptions struct {
	// PollInterval is how often the writer checks for commands from a
	// maintenance process; the next flush applies them, so a slow mailbox never
	// delays commits. Zero selects the default.
	PollInterval time.Duration
}

type WriterMemtableOptions struct {
	// TargetBytes is the approximate active memtable size that triggers rotation.
	// Rotation does not publish data by itself; Flush, background flush, or Close
	// publishes frozen memtables as SSTs. Zero selects the default.
	TargetBytes int64

	// MaxPendingMemtables limits frozen memtables that are queued or currently
	// flushing. When the limit is reached, writes return ErrBackpressure before
	// accepting another mutation. Zero selects the default.
	MaxPendingMemtables int
}

type WriterMetrics struct {
	FlushTotal        prometheus.Counter
	FlushErrors       prometheus.Counter
	FlushLatency      prometheus.Histogram
	FlushBytes        prometheus.Counter
	PutTotal          prometheus.Counter
	PutErrors         prometheus.Counter
	BackPressureTotal prometheus.Counter
	DeleteTotal       prometheus.Counter

	// CommittedSequence is the highest change sequence committed to object
	// storage and visible to readers. A writer sets it on open from the
	// manifest, then after each memtable it commits.
	CommittedSequence prometheus.Gauge

	// OldestUncommitted is the Unix time the oldest write not yet committed
	// was accepted, or 0 when every write is committed: time() minus it is how
	// long writes have waited to become durable.
	OldestUncommitted prometheus.Gauge

	// L0MergeTotal counts merged L0 files the writer uploaded; L0MergeErrors
	// counts merge attempts that failed and are retried.
	L0MergeTotal  prometheus.Counter
	L0MergeErrors prometheus.Counter
	// L0MergeBytes is the bytes of merged L0 files uploaded: the writer's
	// share of write amplification.
	L0MergeBytes prometheus.Counter
	// L0MergeSkippedBytes is the bytes of flushes committed without a held
	// copy because the writer already held as much as it may.
	L0MergeSkippedBytes prometheus.Counter
	// L0MergeHeldBytes is the bytes of committed flushes the writer holds
	// for merging.
	L0MergeHeldBytes prometheus.Gauge
	// L0MergePublished counts merges that replaced their files in L0;
	// L0MergeRefused counts merges the manifest refused because their files
	// were no longer a run in L0; L0MergeDropped counts held runs and
	// unpublished merges the writer gave up because a maintenance command
	// took their files.
	L0MergePublished prometheus.Counter
	L0MergeRefused   prometheus.Counter
	L0MergeDropped   prometheus.Counter

	// MaintenancePublishDelay is the seconds from when maintenance staged a
	// command to when the writer published it to the manifest, applied or
	// rejected. The command is stamped by maintenance's clock and published
	// by the writer's.
	MaintenancePublishDelay prometheus.Histogram
	// MaintenanceApplyLatency is the seconds each attempt to publish a
	// command took, by outcome: applied, rejected or failed. A failed
	// attempt is tried again.
	MaintenanceApplyLatency *prometheus.HistogramVec
}

type WriterOptions struct {
	// OwnerID is the stable writer identity stored in the writer fence.
	// Empty means a process-local ID is generated.
	OwnerID string

	// Memtable controls in-memory write buffering before SST creation.
	Memtable WriterMemtableOptions

	// Flush controls background flushing. A zero Interval disables auto-flush.
	Flush WriterFlushOptions

	// Maintenance controls discovery of commands staged by a maintenance
	// process using the same object-store prefix.
	Maintenance WriterMaintenanceOptions

	// Values controls key/value limits. Values are stored inline in SSTs.
	Values ValueOptions

	// L0Merge controls the writer merging the small L0 files it commits into
	// larger ones from memory.
	L0Merge WriterL0MergeOptions

	// OnFlushError is called when a commit or a maintenance apply fails: on
	// the first failure and at most once a minute while failures continue.
	// Failures are always retried, even ones that need an operator, such as
	// missing permissions. Nil logs a warning instead. It runs on its own
	// goroutine, may call Writer.Close, and may run after Close returns.
	OnFlushError func(error)

	// Metrics receives optional writer observations. Nil disables metrics.
	Metrics *WriterMetrics
}

type WriterState struct {
	// Epoch is the Writer's fence epoch (see Writer.Epoch).
	Epoch  uint64
	Status WriterStatus
	// Accepted is the highest sequence handed to a write; Committed the
	// highest one in object storage. Accepted - Committed writes are pending.
	Accepted  uint64
	Committed uint64
	// PendingMemtables counts memtables not yet committed, the one taking
	// writes included; ErrBackpressure comes when the frozen ones reach
	// MaxPendingMemtables.
	PendingMemtables int
	// PendingBytes is their approximate in-memory size, before compression.
	PendingBytes int64
	// OldestUncommitted is when the oldest write not yet committed was
	// accepted; zero when nothing is pending.
	OldestUncommitted time.Time
}

type WriterStatus int