github.com/muhammadn/cortex@v1.9.1-0.20220510110439-46bb7000d03d/docs/guides/glossary.md (about)

     1  ---
     2  title: "Glossary"
     3  linkTitle: "Glossary"
     4  weight: 999
     5  slug: glossary
     6  ---
     7  
     8  ### Blocks storage
     9  
    10  The blocks storage is a Cortex storage engine based on Prometheus TSDB, which only requires an object store (eg. AWS S3, Google GCS, ...) as backend storage.
    11  
    12  For more information, please refer to the [Cortex blocks storage](../blocks-storage/_index.md) documentation.
    13  
    14  ### Chunks storage (deprecated)
    15  
    16  The chunks storage is a Cortex storage engine which requires both an index store (eg. AWS DynamoDB, Google BigTable, Cassandra, ...) and an object store (eg. AWS S3, Google GCS, ...) as backend storage.
    17  
    18  The chunks storage is deprecated. You're encouraged to use the [blocks storage](#blocks-storage) instead.
    19  
    20  ### Chunk
    21  
    22  A chunk is an object containing compressed timestamp-value pairs.
    23  
    24  When running Cortex with the chunks storage, a single chunk object contains timestamp-value pairs for a single series, while when running Cortex with the [blocks storage](#blocks-storage) a single chunk contains timestamp-value pairs for several series.
    25  
    26  ### Churn
    27  
    28  Churn is the frequency at which series become idle.
    29  
    30  A series become idle once it's not exported anymore by the monitored targets. Typically, series become idle when the monitored target itself disappear (eg. the process or node gets terminated).
    31  
    32  ### Flushing
    33  
    34  Series flushing is the operation run by ingesters to offload time series from memory and store them in the long-term storage.
    35  
    36  ### HA Tracker
    37  
    38  The HA Tracker is a feature of Cortex distributor which is used to deduplicate received series coming from two (or more) Prometheus servers configured in HA pairs.
    39  
    40  For more information, please refer to the guide "[Config for sending HA Pairs data to Cortex](../guides/ha-pair-handling.md)".
    41  
    42  ### Hand-over
    43  
    44  Series hand-over is an operation supported by ingesters to transfer their state, on shutdown, to a new ingester in the `JOINING` state. Hand-over is typically used during [ingesters rollouts](./ingesters-rolling-updates.md) and is only supported by the Cortex chunks storage.
    45  
    46  For more information, please refer to the guide "[Ingesters rolling updates](./ingesters-rolling-updates.md)".
    47  
    48  ### Hash ring
    49  
    50  The hash ring is a distributed data structure used by Cortex for sharding, replication and service discovery. The hash ring data structure gets shared across Cortex replicas via gossip or a key-value store.
    51  
    52  For more information, please refer to the [Architecture](../architecture.md#the-hash-ring) documentation.
    53  
    54  ### Org
    55  
    56  _See [Tenant](#tenant)._
    57  
    58  ### Ring
    59  
    60  _See [Hash ring](#hash-ring)._
    61  
    62  ### Sample
    63  
    64  A sample is a single timestamped value in a time series.
    65  
    66  For example, given the series `node_cpu_seconds_total{instance="10.0.0.1",mode="system"}` its stream of values (samples) could be:
    67  
    68  ```
    69  # Display format: <value> @<timestamp>
    70  11775 @1603812134
    71  11790 @1603812149
    72  11805 @1603812164
    73  11819 @1603812179
    74  11834 @1603812194
    75  ```
    76  
    77  ### Schema config
    78  
    79  The schema (or schema config) is a configuration file used by the Cortex chunks storage to configure the backend index and chunks store, and manage storage version upgrades. The schema config is **not** used by the Cortex [blocks storage](#blocks-storage).
    80  
    81  For more information, please refer to the [Schema config reference](../chunks-storage/schema-config.md).
    82  
    83  ### Series
    84  
    85  In the Prometheus ecosystem, a series (or time series) is a single stream of timestamped values belonging to the same metric, with the same set of label key-value pairs.
    86  
    87  For example, given a single metric `node_cpu_seconds_total` you may have multiple series, each one uniquely identified by the combination of metric name and unique label key-value pairs:
    88  
    89  ```
    90  node_cpu_seconds_total{instance="10.0.0.1",mode="system"}
    91  node_cpu_seconds_total{instance="10.0.0.1",mode="user"}
    92  node_cpu_seconds_total{instance="10.0.0.2",mode="system"}
    93  node_cpu_seconds_total{instance="10.0.0.2",mode="user"}
    94  ```
    95  
    96  ### Tenant
    97  
    98  A tenant (also called "user" or "org") is the owner of a set of series written to and queried from Cortex. Cortex multi-tenancy support allows you to isolate series belonging to different tenants. For example, if you have two tenants `team-A` and `team-B`, `team-A` series will be isolated from `team-B`, and each team will be able to query only their own series.
    99  
   100  For more information, please refer to:
   101  
   102  - [HTTP API authentication](../api/_index.md#authentication)
   103  - [Tenant ID limitations](./limitations.md#tenant-id-naming)
   104  
   105  ### Time series
   106  
   107  _See [Series](#series)._
   108  
   109  ### User
   110  
   111  _See [Tenant](#tenant)._
   112  
   113  ### WAL
   114  
   115  The Write-Ahead Log (WAL) is an append only log stored on disk used by ingesters to recover their in-memory state after the process gets restarted, either after a clear shutdown or an abruptly termination. Despite the implementation is different, the WAL is supported both by Cortex chunks and blocks storage engines.
   116  
   117  For more information, please refer to:
   118  
   119  - [Ingesters with WAL](../chunks-storage/ingesters-with-wal.md) when running **chunks storage**.
   120  - [Ingesters with WAL](../blocks-storage/_index.md#the-write-path) when running **blocks storage**.