2018-05-30 15:05:30 +00:00
# WAL Disk Format
2024-12-09 11:45:46 +00:00
This document describes the official Prometheus WAL format.
2018-07-20 06:26:12 +00:00
The write ahead log operates in segments that are numbered and sequential,
2024-12-09 11:45:46 +00:00
and are limited to 128MB by default.
## Segment filename
The sequence number is captured in the segment filename,
e.g. `000000` , `000001` , `000002` , etc. The first unsigned integer represents
the sequence number of the segment, typically encoded with six digits.
## Segment encoding
This section describes the segment encoding.
A segment encodes an array of records. It does not contain any header. A segment
is written to pages of 32KB. Only the last page of the most recent segment
2018-05-30 15:05:30 +00:00
may be partial. A WAL record is an opaque byte slice that gets split up into sub-records
should it exceed the remaining space of the current page. Records are never split across
2018-06-18 11:52:57 +00:00
segment boundaries. If a single record exceeds the default segment size, a segment with
a larger size will be created.
2024-12-09 11:45:46 +00:00
2018-08-02 21:46:45 +00:00
The encoding of pages is largely borrowed from [LevelDB's/RocksDB's write ahead log. ](https://github.com/facebook/rocksdb/wiki/Write-Ahead-Log-File-Format )
2018-05-30 15:05:30 +00:00
2024-12-09 11:45:46 +00:00
### Records encoding
Each record fragment is encoded as:
2018-05-30 15:05:30 +00:00
2018-06-18 11:52:57 +00:00
```
2018-05-30 15:05:30 +00:00
┌───────────┬──────────┬────────────┬──────────────┐
│ type < 1b > │ len < 2b > │ CRC32 < 4b > │ data < bytes > │
└───────────┴──────────┴────────────┴──────────────┘
2018-06-18 11:52:57 +00:00
```
2018-05-30 15:05:30 +00:00
2024-12-09 11:45:46 +00:00
The initial type byte is made up of three components: a 3-bit reserved field,
a 1-bit zstd compression flag, a 1-bit snappy compression flag, and a 3-bit type flag.
2024-11-26 11:48:17 +00:00
```
┌─────────────────┬──────────────────┬────────────────────┬──────────────────┐
│ reserved < 3bit > │ zstd_flag < 1bit > │ snappy_flag < 1bit > │ type_flag < 3bit > │
└─────────────────┴──────────────────┴────────────────────┴──────────────────┘
```
2024-12-09 11:45:46 +00:00
The lowest 3 bits within the type flag represent the record type as follows:
2018-07-20 06:26:12 +00:00
* `0` : rest of page will be empty
* `1` : a full record encoded in a single fragment
* `2` : first fragment of a record
* `3` : middle fragment of a record
* `4` : final fragment of a record
2024-12-09 11:45:46 +00:00
After the type byte, 2-byte length and then 4-byte checksum of the following data are encoded.
All float values are represented using the [IEEE 754 format ](https://en.wikipedia.org/wiki/IEEE_754 ).
### Record types
2018-05-30 15:05:30 +00:00
2024-12-09 11:45:46 +00:00
In the following sections, all the known record types are described. New types,
can be added in the future.
2018-05-30 15:05:30 +00:00
2024-12-09 11:45:46 +00:00
#### Series records
2018-05-30 15:05:30 +00:00
2018-07-20 06:26:12 +00:00
Series records encode the labels that identifies a series and its unique ID.
2018-05-30 15:05:30 +00:00
2018-06-18 11:52:57 +00:00
```
2018-05-30 15:05:30 +00:00
┌────────────────────────────────────────────┐
│ type = 1 < 1b > │
├────────────────────────────────────────────┤
│ ┌─────────┬──────────────────────────────┐ │
│ │ id < 8b > │ n = len(labels) < uvarint > │ │
│ ├─────────┴────────────┬─────────────────┤ │
│ │ len(str_1) < uvarint > │ str_1 < bytes > │ │
│ ├──────────────────────┴─────────────────┤ │
│ │ ... │ │
│ ├───────────────────────┬────────────────┤ │
│ │ len(str_2n) < uvarint > │ str_2n < bytes > │ │
│ └───────────────────────┴────────────────┘ │
│ . . . │
└────────────────────────────────────────────┘
2018-06-18 11:52:57 +00:00
```
2018-05-30 15:05:30 +00:00
2024-12-09 11:45:46 +00:00
#### Sample records
2018-05-30 15:05:30 +00:00
Sample records encode samples as a list of triples `(series_id, timestamp, value)` .
Series reference and timestamp are encoded as deltas w.r.t the first sample.
2019-03-21 09:21:50 +00:00
The first row stores the starting id and the starting timestamp.
The first sample record begins at the second row.
2018-05-30 15:05:30 +00:00
2018-06-18 11:52:57 +00:00
```
2018-05-30 15:05:30 +00:00
┌──────────────────────────────────────────────────────────────────┐
│ type = 2 < 1b > │
├──────────────────────────────────────────────────────────────────┤
2019-03-21 09:21:50 +00:00
│ ┌────────────────────┬───────────────────────────┐ │
│ │ id < 8b > │ timestamp < 8b > │ │
│ └────────────────────┴───────────────────────────┘ │
2018-05-30 15:05:30 +00:00
│ ┌────────────────────┬───────────────────────────┬─────────────┐ │
│ │ id_delta < uvarint > │ timestamp_delta < uvarint > │ value < 8b > │ │
│ └────────────────────┴───────────────────────────┴─────────────┘ │
│ . . . │
└──────────────────────────────────────────────────────────────────┘
2018-06-18 11:52:57 +00:00
```
2018-05-30 15:05:30 +00:00
2024-12-09 11:45:46 +00:00
#### Tombstone records
2018-05-30 15:05:30 +00:00
Tombstone records encode tombstones as a list of triples `(series_id, min_time, max_time)`
and specify an interval for which samples of a series got deleted.
2018-06-18 11:52:57 +00:00
```
2018-05-30 15:05:30 +00:00
┌─────────────────────────────────────────────────────┐
│ type = 3 < 1b > │
├─────────────────────────────────────────────────────┤
│ ┌─────────┬───────────────────┬───────────────────┐ │
│ │ id < 8b > │ min_time < varint > │ max_time < varint > │ │
│ └─────────┴───────────────────┴───────────────────┘ │
│ . . . │
└─────────────────────────────────────────────────────┘
2018-06-18 11:52:57 +00:00
```
2021-05-06 20:53:52 +00:00
2024-12-09 11:45:46 +00:00
#### Exemplar records
2021-05-06 20:53:52 +00:00
2024-12-09 11:45:46 +00:00
Exemplar records encode exemplars as a list of triples `(series_id, timestamp, value)`
2021-05-06 20:53:52 +00:00
plus the length of the labels list, and all the labels.
The first row stores the starting id and the starting timestamp.
Series reference and timestamp are encoded as deltas w.r.t the first exemplar.
The first exemplar record begins at the second row.
See: https://github.com/OpenObservability/OpenMetrics/blob/main/specification/OpenMetrics.md#exemplars
```
┌──────────────────────────────────────────────────────────────────┐
2022-03-15 17:03:45 +00:00
│ type = 4 < 1b > │
2021-05-06 20:53:52 +00:00
├──────────────────────────────────────────────────────────────────┤
│ ┌────────────────────┬───────────────────────────┐ │
│ │ id < 8b > │ timestamp < 8b > │ │
│ └────────────────────┴───────────────────────────┘ │
│ ┌────────────────────┬───────────────────────────┬─────────────┐ │
│ │ id_delta < uvarint > │ timestamp_delta < uvarint > │ value < 8b > │ │
│ ├────────────────────┴───────────────────────────┴─────────────┤ │
│ │ n = len(labels) < uvarint > │ │
│ ├──────────────────────┬───────────────────────────────────────┤ │
│ │ len(str_1) < uvarint > │ str_1 < bytes > │ │
│ ├──────────────────────┴───────────────────────────────────────┤ │
│ │ ... │ │
│ ├───────────────────────┬──────────────────────────────────────┤ │
│ │ len(str_2n) < uvarint > │ str_2n < bytes > │ │ │
│ └───────────────────────┴────────────────┴─────────────────────┘ │
│ . . . │
└──────────────────────────────────────────────────────────────────┘
```
2022-07-19 08:58:52 +00:00
2024-12-09 11:45:46 +00:00
#### Metadata records
2022-07-19 08:58:52 +00:00
Metadata records encode the metadata updates associated with a series.
```
┌────────────────────────────────────────────┐
2022-07-19 12:52:02 +00:00
│ type = 6 < 1b > │
2022-07-19 08:58:52 +00:00
├────────────────────────────────────────────┤
│ ┌────────────────────────────────────────┐ │
│ │ series_id < uvarint > │ │
│ ├────────────────────────────────────────┤ │
│ │ metric_type < 1b > │ │
│ ├────────────────────────────────────────┤ │
│ │ num_fields < uvarint > │ │
│ ├───────────────────────┬────────────────┤ │
│ │ len(name_1) < uvarint > │ name_1 < bytes > │ │
│ ├───────────────────────┼────────────────┤ │
│ │ len(val_1) < uvarint > │ val_1 < bytes > │ │
│ ├───────────────────────┴────────────────┤ │
│ │ . . . │ │
│ ├───────────────────────┬────────────────┤ │
│ │ len(name_n) < uvarint > │ name_n < bytes > │ │
│ ├───────────────────────┼────────────────┤ │
│ │ len(val_n) < uvarint > │ val_n < bytes > │ │
│ └───────────────────────┴────────────────┘ │
│ . . . │
└────────────────────────────────────────────┘
```
2024-12-09 11:45:46 +00:00
#### Histogram records
Histogram records encode the integer and float native histogram samples.
A record with the integer native histograms with the exponential bucketing:
```
┌───────────────────────────────────────────────────────────────────────┐
│ type = 7 < 1b > │
├───────────────────────────────────────────────────────────────────────┤
│ ┌────────────────────┬───────────────────────────┐ │
│ │ id < 8b > │ timestamp < 8b > │ │
│ └────────────────────┴───────────────────────────┘ │
│ ┌────────────────────┬──────────────────────────────────────────────┐ │
│ │ id_delta < uvarint > │ timestamp_delta < uvarint > │ │
│ ├────────────────────┴────┬─────────────────────────────────────────┤ │
│ │ counter_reset_hint < 1b > │ schema < varint > │ │
│ ├─────────────────────────┴────┬────────────────────────────────────┤ │
│ │ zero_threshold (float) < 8b > │ zero_count < uvarint > │ │
│ ├─────────────────┬────────────┴────────────────────────────────────┤ │
│ │ count < uvarint > │ sum (float) < 8b > │ │
│ ├─────────────────┴─────────────────────────────────────────────────┤ │
│ │ positive_spans_num < uvarint > │ │
│ ├─────────────────────────────────┬─────────────────────────────────┤ │
│ │ positive_span_offset_1 < varint > │ positive_span_len_1 < uvarint32 > │ │
│ ├─────────────────────────────────┴─────────────────────────────────┤ │
│ │ . . . │ │
│ ├───────────────────────────────────────────────────────────────────┤ │
│ │ negative_spans_num < uvarint > │ │
│ ├───────────────────────────────┬───────────────────────────────────┤ │
│ │ negative_span_offset < varint > │ negative_span_len < uvarint32 > │ │
│ ├───────────────────────────────┴───────────────────────────────────┤ │
│ │ . . . │ │
│ ├───────────────────────────────────────────────────────────────────┤ │
│ │ positive_bkts_num < uvarint > │ │
│ ├─────────────────────────┬───────┬─────────────────────────────────┤ │
│ │ positive_bkt_1 < varint > │ . . . │ positive_bkt_n < varint > │ │
│ ├─────────────────────────┴───────┴─────────────────────────────────┤ │
│ │ negative_bkts_num < uvarint > │ │
│ ├─────────────────────────┬───────┬─────────────────────────────────┤ │
│ │ negative_bkt_1 < varint > │ . . . │ negative_bkt_n < varint > │ │
│ └─────────────────────────┴───────┴─────────────────────────────────┘ │
│ . . . │
└───────────────────────────────────────────────────────────────────────┘
```
A records with the Float histograms:
```
┌───────────────────────────────────────────────────────────────────────┐
│ type = 8 < 1b > │
├───────────────────────────────────────────────────────────────────────┤
│ ┌────────────────────┬───────────────────────────┐ │
│ │ id < 8b > │ timestamp < 8b > │ │
│ └────────────────────┴───────────────────────────┘ │
│ ┌────────────────────┬──────────────────────────────────────────────┐ │
│ │ id_delta < uvarint > │ timestamp_delta < uvarint > │ │
│ ├────────────────────┴────┬─────────────────────────────────────────┤ │
│ │ counter_reset_hint < 1b > │ schema < varint > │ │
│ ├─────────────────────────┴────┬────────────────────────────────────┤ │
│ │ zero_threshold (float) < 8b > │ zero_count (float) < 8b > │ │
│ ├────────────────────┬─────────┴────────────────────────────────────┤ │
│ │ count (float) < 8b > │ sum (float) < 8b > │ │
│ ├────────────────────┴──────────────────────────────────────────────┤ │
│ │ positive_spans_num < uvarint > │ │
│ ├─────────────────────────────────┬─────────────────────────────────┤ │
│ │ positive_span_offset_1 < varint > │ positive_span_len_1 < uvarint32 > │ │
│ ├─────────────────────────────────┴─────────────────────────────────┤ │
│ │ . . . │ │
│ ├───────────────────────────────────────────────────────────────────┤ │
│ │ negative_spans_num < uvarint > │ │
│ ├───────────────────────────────┬───────────────────────────────────┤ │
│ │ negative_span_offset < varint > │ negative_span_len < uvarint32 > │ │
│ ├───────────────────────────────┴───────────────────────────────────┤ │
│ │ . . . │ │
│ ├───────────────────────────────────────────────────────────────────┤ │
│ │ positive_bkts_num < uvarint > │ │
│ ├─────────────────────────────┬───────┬─────────────────────────────┤ │
│ │ positive_bkt_1 (float) < 8b > │ . . . │ positive_bkt_n (float) < 8b > │ │
│ ├─────────────────────────────┴───────┴─────────────────────────────┤ │
│ │ negative_bkts_num < uvarint > │ │
│ ├─────────────────────────────┬───────┬─────────────────────────────┤ │
│ │ negative_bkt_1 (float) < 8b > │ . . . │ negative_bkt_n (float) < 8b > │ │
│ └─────────────────────────────┴───────┴─────────────────────────────┘ │
│ . . . │
└───────────────────────────────────────────────────────────────────────┘
```
