db: make sure blocks don't overlap

Reduce `block.MaxTime` by 1 millisecond so that `blocks[1].MinTime ==
blocks[0].MaxTime + 1`.

This prevents chunks that start exactly at the block end (i.e.
`chunk.MinTime == block.MaxTime`) from being included in that block.

See prometheus-junkyard#347 for a detailed explanation.

Signed-off-by: Benoît Knecht <benoit.knecht@fsfe.org>

db.go

@@ -550,7 +550,7 @@ func (db *DB) reload(deleteable ...string) (err error) {
 	if len(blocks) == 0 {
 		return nil
 	}
-	maxt := blocks[len(blocks)-1].Meta().MaxTime
+	maxt := blocks[len(blocks)-1].Meta().MaxTime + 1
 
 	return errors.Wrap(db.head.Truncate(maxt), "head truncate failed")
 }
@@ -805,9 +805,12 @@ func (db *DB) Querier(mint, maxt int64) (Querier, error) {
 	return sq, nil
 }
 
+// Returns a closed time interval that contains t, with its lower boundary
+// aligned on a multiple of width. The upper boundary is such that the next
+// interval is contiguous without overlapping.
 func rangeForTimestamp(t int64, width int64) (mint, maxt int64) {
 	mint = (t / width) * width
-	return mint, mint + width
+	return mint, mint + width - 1
 }
 
 // Delete implements deletion of metrics. It only has atomicity guarantees on a per-block basis.

head.go

@@ -1133,7 +1133,10 @@ func (s *memSeries) cut(mint int64) *memChunk {
 
 	// Set upper bound on when the next chunk must be started. An earlier timestamp
 	// may be chosen dynamically at a later point.
-	_, s.nextAt = rangeForTimestamp(mint, s.chunkRange)
+	_, maxt := rangeForTimestamp(mint, s.chunkRange)
+	// rangeForTimestamp() returns the maximum timestamp for the previous
+	// chunk; we want to cut right after that, so we add 1 millisecond
+	s.nextAt = maxt + 1
 
 	app, err := c.chunk.Appender()
 	if err != nil {