Prometheus时序数据库-数据的插入

运维 数据库运维
笔者详细的阐述了Prometheus时序数据库在内存和磁盘中的存储结构。有了前面的铺垫,笔者就可以在本篇文章阐述下数据的插入过程。

[[385979]]

前言

在之前的文章里,笔者详细的阐述了Prometheus时序数据库在内存和磁盘中的存储结构。有了前面的铺垫,笔者就可以在本篇文章阐述下数据的插入过程。

监控数据的插入

在这里,笔者并不会去讨论Promtheus向各个Endpoint抓取数据的过程。而是仅仅围绕着数据是如何插入Prometheus的过程做下阐述。对应方法:

  1. func (a *headAppender) Add(lset labels.Labels, t int64, v float64) (uint64, error) { 
  2.     ...... 
  3.     // 如果lset对应的series没有,则建一个。同时把新建的series放入倒排Posting映射里面 
  4.     s, created := a.head.getOrCreate(lset.Hash(), lset)  
  5.     if created { // 如果新创建了一个,则将新建的也放到a.series里面 
  6.         a.series = append(a.series, record.RefSeries{ 
  7.             Ref:    s.ref, 
  8.             Labels: lset, 
  9.         }) 
  10.     } 
  11.     return s.ref, a.AddFast(s.ref, t, v) 

我们就以下面的add函数调用为例:

  1. app.Add(labels.FromStrings("foo""bar"), 0, 0) 

首先是getOrCreate,顾名思义,不存在则创建一个。创建的过程包含了seriesHashMap/Postings(倒排索引)/LabelIndex的维护。如下图所示:

然后是AddFast方法

  1. func (a *headAppender) AddFast(ref uint64, t int64, v float64) error{ 
  2.         // 拿出对应的memSeries 
  3.         s := a.head.series.getByID(ref) 
  4.         ...... 
  5.         // 设置为等待提交状态 
  6.         s.pendingCommit=true 
  7.         ...... 
  8.         // 为了事务概念,放入temp存储,等待真正commit时候再写入memSeries 
  9.         a.samples = append(a.samples, record.RefSample{Ref: ref,T:   t,V:   v,}) 
  10.         //  

Prometheus在add数据点的时候并没有直接add到memSeries(也就是query所用到的结构体里),而是加入到一个临时的samples切片里面。同时还将这个数据点对应的memSeries同步增加到另一个sampleSeries里面。

事务可见性

为什么要这么做呢?就是为了实现commit语义,只有commit过后数据才可见(能被查询到)。否则,无法见到这些数据。而commit的动作主要就是WAL(Write Ahead Log)以及将headerAppender.samples数据写到其对应的memSeries中。这样,查询就可见这些数据了,如下图所示:

WAL

由于Prometheus最近的数据是保存在内存里面的,未防止服务器宕机丢失数据。其在commit之前先写了日志WAL。等服务重启的时候,再从WAL日志里面获取信息并重放。

为了性能,Prometheus了另一个goroutine去做文件的sync操作,所以并不能保证WAL不丢。进而也不能保证监控数据完全不丢。这点也是监控业务的特性决定的。

写入代码为:

  1. commit() 
  2. |=> 
  3. func (a *headAppender) log() error { 
  4.     ...... 
  5.     // 往WAL写入对应的series信息 
  6.     if len(a.series) > 0 { 
  7.         rec = enc.Series(a.series, buf) 
  8.         buf = rec[:0] 
  9.  
  10.         if err := a.head.wal.Log(rec); err != nil { 
  11.             return errors.Wrap(err, "log series"
  12.         } 
  13.     } 
  14.     ...... 
  15.     // 往WAL写入真正的samples 
  16.     if len(a.samples) > 0 { 
  17.         rec = enc.Samples(a.samples, buf) 
  18.         buf = rec[:0] 
  19.  
  20.         if err := a.head.wal.Log(rec); err != nil { 
  21.             return errors.Wrap(err, "log samples"
  22.         } 
  23.     } 

对应的WAL日志格式为:

Series records

  1. ┌────────────────────────────────────────────┐ 
  2. │ type = 1 <1b>                              │ 
  3. ├────────────────────────────────────────────┤ 
  4. │ ┌─────────┬──────────────────────────────┐ │ 
  5. │ │ id <8b> │ n = len(labels) <uvarint>    │ │ 
  6. │ ├─────────┴────────────┬─────────────────┤ │ 
  7. │ │ len(str_1) <uvarint> │ str_1 <bytes>   │ │ 
  8. │ ├──────────────────────┴─────────────────┤ │ 
  9. │ │  ...                                   │ │ 
  10. │ ├───────────────────────┬────────────────┤ │ 
  11. │ │ len(str_2n) <uvarint> │ str_2n <bytes> │ │ 
  12. │ └───────────────────────┴────────────────┘ │ 
  13. │                  . . .                     │ 
  14. └────────────────────────────────────────────┘ 

 

Sample records

  1. ┌──────────────────────────────────────────────────────────────────┐ 
  2. │ type = 2 <1b>                                                    │ 
  3. ├──────────────────────────────────────────────────────────────────┤ 
  4. │ ┌────────────────────┬───────────────────────────┐               │ 
  5. │ │ id <8b>            │ timestamp <8b>            │               │ 
  6. │ └────────────────────┴───────────────────────────┘               │ 
  7. │ ┌────────────────────┬───────────────────────────┬─────────────┐ │ 
  8. │ │ id_delta <uvarint> │ timestamp_delta <uvarint> │ value <8b>  │ │ 
  9. │ └────────────────────┴───────────────────────────┴─────────────┘ │ 
  10. │                              . . .                               │ 
  11. └──────────────────────────────────────────────────────────────────┘ 

见Prometheus WAL.md

落盘存储

之前描述的所有数据都是写到内存里面。最终落地是通过compator routine将每两个小时的数据打包到一个Blocks里面。

具体可见笔者之前的博客《Prometheus时序数据库-磁盘中的存储结构》

总结

在这篇文章里,笔者详细描述了Prometheus数据的插入过程。在下一篇文章里面,笔者会继续

阐述Prometheus数据的查询过程。

本文转载自微信公众号「解Bug之路」,可以通过以下二维码关注。转载本文请联系解Bug之路公众号。

 

责任编辑:武晓燕 来源: 解Bug之路
相关推荐

2021-03-15 10:10:29

数据库数据查询

2021-02-22 10:37:47

存储Prometheus

2021-03-01 10:20:52

存储

2022-07-06 15:41:55

数据库

2022-09-23 07:44:48

时序数据库物联网

2017-11-20 11:37:19

时序数据数据存储HBase

2021-09-26 10:08:33

TSDB时序数据库压缩解压

2022-07-11 10:45:12

数据库分析

2020-03-11 09:50:21

时序数据库快速检索

2022-07-11 11:12:32

数据分析

2022-12-18 19:38:31

时序数据库数据库

2021-08-31 14:01:59

时序数据库数据库数据

2022-07-07 12:23:29

数据库

2022-06-10 17:37:37

数据库

2022-07-07 12:37:27

数据

2017-09-05 14:45:14

时序数据数据库大数据

2018-06-26 09:37:07

时序数据库FacebookNoSQL

2021-08-04 05:49:40

数据库数时序数据库技术

2019-05-30 08:31:39

数据库QTSDB分布式

2018-04-16 08:44:51

InfluxDB TS时序数据库存储
点赞
收藏

51CTO技术栈公众号