Finishing touches

fix lint issue

Signed-off-by: Cyril Tovena <[email protected]>

removes useless loop

Signed-off-by: Cyril Tovena <[email protected]>

This should be on v11 not v10.

Signed-off-by: Cyril Tovena <[email protected]>

s/metricConstRangeKeyV1/labelNamesRangeKeyV1/

The code was first written to store the entire series, but now changed
to do just labelNames.

Signed-off-by: Goutham Veeramachaneni <[email protected]>

Add note about v11 being experimental.

Signed-off-by: Goutham Veeramachaneni <[email protected]>

Author: cyriltovena

docs/architecture.md

@@ -145,4 +145,4 @@ The interface works somewhat differently across the supported databases:
 
 A set of schemas are used to map the matchers and label sets used on reads and writes to the chunk store into appropriate operations on the index. Schemas have been added as Cortex has evolved, mainly in an attempt to better load balance writes and improve query performance.
 
-> The current schema recommendation is the **v10 schema**.
+> The current schema recommendation is the **v10 schema**. v11 schema is an experimental schema.

docs/single-process-config.yaml

@@ -54,7 +54,7 @@ schema:
   - from: 2019-07-29
     store: boltdb
     object_store: filesystem
-    schema: v11
+    schema: v10
     index:
       prefix: index_
       period: 168h

pkg/chunk/inmemory_storage_client.go

@@ -165,7 +165,7 @@ func (m *MockStorage) BatchWrite(ctx context.Context, batch WriteBatch) error {
 			itemComponents := decodeRangeKey(items[i].rangeValue)
 			if !bytes.Equal(itemComponents[3], metricNameRangeKeyV1) &&
 				!bytes.Equal(itemComponents[3], seriesRangeKeyV1) &&
-				!bytes.Equal(itemComponents[3], metricConstRangeKeyV1) &&
+				!bytes.Equal(itemComponents[3], labelNamesRangeKeyV1) &&
 				!bytes.Equal(itemComponents[3], labelSeriesRangeKeyV1) {
 				return fmt.Errorf("Dupe write")
 			}

pkg/chunk/schema.go

@@ -24,7 +24,7 @@ var (
 	seriesRangeKeyV1      = []byte{'7'}
 	labelSeriesRangeKeyV1 = []byte{'8'}
 	// For v11 schema
-	metricConstRangeKeyV1 = []byte{'9'}
+	labelNamesRangeKeyV1 = []byte{'9'}
 
 	// ErrNotSupported when a schema doesn't support that particular lookup.
 	ErrNotSupported = errors.New("not supported")
@@ -48,7 +48,7 @@ type Schema interface {
 
 	// If the query resulted in series IDs, use this method to find chunks.
 	GetChunksForSeries(from, through model.Time, userID string, seriesID []byte) ([]IndexQuery, error)
-	// Returns queries to retrieve all labels of multiple series by id.
+	// Returns queries to retrieve all label names of multiple series by id.
 	GetLabelNamesForSeries(from, through model.Time, userID string, seriesID []byte) ([]IndexQuery, error)
 }
 
@@ -687,31 +687,13 @@ func (s v10Entries) GetLabelWriteEntries(bucket Bucket, metricName string, label
 	// read first 32 bits of the hash and use this to calculate the shard
 	shard := binary.BigEndian.Uint32(seriesID) % s.rowShards
 
-	labelNames := make([]string, 0, len(labels))
-	for _, l := range labels {
-		if l.Name == model.MetricNameLabel {
-			continue
-		}
-		labelNames = append(labelNames, l.Name)
-	}
-	data, err := jsoniter.ConfigFastest.Marshal(labelNames)
-	if err != nil {
-		return nil, err
-	}
 	entries := []IndexEntry{
 		// Entry for metricName -> seriesID
 		{
 			TableName:  bucket.tableName,
 			HashValue:  fmt.Sprintf("%02d:%s:%s", shard, bucket.hashKey, metricName),
 			RangeValue: encodeRangeKey(seriesID, nil, nil, seriesRangeKeyV1),
 		},
-		// Entry for seriesID -> labels
-		{
-			TableName:  bucket.tableName,
-			HashValue:  string(seriesID),
-			RangeValue: encodeRangeKey(nil, nil, nil, metricConstRangeKeyV1),
-			Value:      data,
-		},
 	}
 
 	// Entries for metricName:labelName -> hash(value):seriesID
@@ -804,6 +786,57 @@ type v11Entries struct {
 	v10Entries
 }
 
+func (s v11Entries) GetLabelWriteEntries(bucket Bucket, metricName string, labels labels.Labels, chunkID string) ([]IndexEntry, error) {
+	seriesID := labelsSeriesID(labels)
+
+	// read first 32 bits of the hash and use this to calculate the shard
+	shard := binary.BigEndian.Uint32(seriesID) % s.rowShards
+
+	labelNames := make([]string, 0, len(labels))
+	for _, l := range labels {
+		if l.Name == model.MetricNameLabel {
+			continue
+		}
+		labelNames = append(labelNames, l.Name)
+	}
+	data, err := jsoniter.ConfigFastest.Marshal(labelNames)
+	if err != nil {
+		return nil, err
+	}
+	entries := []IndexEntry{
+		// Entry for metricName -> seriesID
+		{
+			TableName:  bucket.tableName,
+			HashValue:  fmt.Sprintf("%02d:%s:%s", shard, bucket.hashKey, metricName),
+			RangeValue: encodeRangeKey(seriesID, nil, nil, seriesRangeKeyV1),
+		},
+		// Entry for seriesID -> label names
+		{
+			TableName:  bucket.tableName,
+			HashValue:  string(seriesID),
+			RangeValue: encodeRangeKey(nil, nil, nil, labelNamesRangeKeyV1),
+			Value:      data,
+		},
+	}
+
+	// Entries for metricName:labelName -> hash(value):seriesID
+	// We use a hash of the value to limit its length.
+	for _, v := range labels {
+		if v.Name == model.MetricNameLabel {
+			continue
+		}
+		valueHash := sha256bytes(v.Value)
+		entries = append(entries, IndexEntry{
+			TableName:  bucket.tableName,
+			HashValue:  fmt.Sprintf("%02d:%s:%s:%s", shard, bucket.hashKey, metricName, v.Name),
+			RangeValue: encodeRangeKey(valueHash, seriesID, nil, labelSeriesRangeKeyV1),
+			Value:      []byte(v.Value),
+		})
+	}
+
+	return entries, nil
+}
+
 func (v11Entries) GetLabelNamesForSeries(bucket Bucket, seriesID []byte) ([]IndexQuery, error) {
 	return []IndexQuery{
 		{

pkg/chunk/series_store.go

@@ -406,7 +406,8 @@ func (c *seriesStore) lookupLabelNamesBySeries(ctx context.Context, from, throug
 		return nil, err
 	}
 	level.Debug(log).Log("entries", len(entries))
-	uniqueLabelNames := map[string]struct{}{model.MetricNameLabel: struct{}{}}
+	result := []string{model.MetricNameLabel}
+	uniqueLabelNames := map[string]struct{}{model.MetricNameLabel: {}}
 	for _, entry := range entries {
 		lbs := []string{}
 		err := jsoniter.ConfigFastest.Unmarshal(entry.Value, &lbs)
@@ -416,13 +417,10 @@ func (c *seriesStore) lookupLabelNamesBySeries(ctx context.Context, from, throug
 		for _, l := range lbs {
 			if _, ok := uniqueLabelNames[l]; !ok {
 				uniqueLabelNames[l] = struct{}{}
+				result = append(result, l)
 			}
 		}
 	}
-	result := make([]string, 0, len(uniqueLabelNames))
-	for name := range uniqueLabelNames {
-		result = append(result, name)
-	}
 	sort.Strings(result)
 	return result, nil
 }