Add multinode to master (timescale#168)

* Update Travis config to work for private repo

We need to rename the checked out repo to be named the same as the
public repo (tsbs) so that the imports match up correctly. This
also adds testing for 1.12 and removes the codecov part since we
don't have support for private repos there.

* Add support for benchmarking clustered version of TimescaleDB

* Add support for benchmarking clustered version of TimescaleDB
Add replication factor for distributed hypertable
Pass in replication_factor from bash script

* Allow tsbs_load_timescaledb to use existing table

This change correctly handles the createMeticsTable flag to skip the
table creation commands in PostCreateDB, but still set up the internal
structures needed by the rest of the test.  If the flag is set, the
PostCreateDB will also verify that the necessary table exists on the
database, and will wait for up to a minute for the table to be created.

This change also stops passing 0 values for numberPartions or
replicationFactor when creating the table.  For number_partitions, this
enables the default behavior of 1 partition per data node.  For
replicationFactor, values greater than 1 aren't supported by the
current code, so we simply call create_distributed_hypertable for all
non-zero values.

Also included in this change is a bit of clean-up for the multinode
branch rebase.

* Allow tsbs_load_timescaledb to partition on hostname

This change adds a new option (partition-on-hostname) to the
tsbs_load_timescaledb, and exposes it through the load_timescaledb.sh
script.  This is needed for efficiently running query tests with
USE_TAGS=false, as the test will then access rows by hostname.

This change also fixes the double-groupby class of queries to work
properly with the USE_TAGS=false option.

* Add port argument. Fix max_queries script

* Fix flag var after rebasing
Fix travis for Go 1.10.x

* Add new query type that scans more data

Add cpu-max-all-32-24 query type that
scans metrics for 32 hosts during 24 hour interval.
This query type is more sutable for multinode testing.

* Reworking how distributed hypertables are created

* Reworking parameters and creation code for TimescaleDB. It turns out that `create_hypertable` will
create a distributed hypertable with a replication factor >= 1.

Tried to leave options for testing various configurations of both regular and distributed hypertables.

Still trying to figure out default values with Viper.

* Can now set multiple kinds of tests with a few parameters.

 * Single-node, no partitions
 * single-node, partitions on tag table "name" column
 * multi-node, partition on tag table "name" column

Co-authored-by: Jônatas Davi Paganini <[email protected]>

* Adding YAML configuration samples for TimescaleDB

* Fixing the OR logic in hostname where clauses

* Fixed tests for query generation

* Update TimescaleDB documentation for multi-node related configuration

* Adding options for TimescaleDB input

* Simply committing to kick off another build for checks.

* Forcing build

Co-authored-by: Rob Kiefer <[email protected]>
Co-authored-by: niksa <[email protected]>
Co-authored-by: Brian Rowe <[email protected]>
Co-authored-by: Jônatas Davi Paganini <[email protected]>

Author: 5 people

.travis.yml

@@ -16,5 +16,3 @@ jobs:
       install: skip
       script:
         - GO111MODULE=on go test -v -race -coverprofile=coverage.txt -covermode=atomic ./...
-      after_success:
-        - bash <(curl -s https://codecov.io/bash)

cmd/tsbs_generate_queries/databases/cassandra/devops.go

@@ -111,8 +111,8 @@ func (d *Devops) GroupByTimeAndPrimaryTag(qi query.Query, numMetrics int) {
 // FROM cpu WHERE (hostname = '$HOSTNAME_1' OR ... OR hostname = '$HOSTNAME_N')
 // AND time >= '$HOUR_START' AND time < '$HOUR_END'
 // GROUP BY hour ORDER BY hour
-func (d *Devops) MaxAllCPU(qi query.Query, nHosts int) {
-	interval := d.Interval.MustRandWindow(devops.MaxAllDuration)
+func (d *Devops) MaxAllCPU(qi query.Query, nHosts int, duration time.Duration) {
+	interval := d.Interval.MustRandWindow(duration)
 
 	tagSet := d.getHostWhere(nHosts)
 

cmd/tsbs_generate_queries/databases/clickhouse/devops.go

@@ -85,8 +85,8 @@ const clickhouseTimeStringFormat = "2006-01-02 15:04:05"
 // Resultsets:
 // cpu-max-all-1
 // cpu-max-all-8
-func (d *Devops) MaxAllCPU(qi query.Query, nHosts int) {
-	interval := d.Interval.MustRandWindow(devops.MaxAllDuration)
+func (d *Devops) MaxAllCPU(qi query.Query, nHosts int, duration time.Duration) {
+	interval := d.Interval.MustRandWindow(duration)
 	metrics := devops.GetAllCPUMetrics()
 	selectClauses := d.getSelectClausesAggMetrics("max", metrics)
 

cmd/tsbs_generate_queries/databases/clickhouse/devops_test.go

@@ -154,7 +154,7 @@ func TestMaxAllCPU(t *testing.T) {
 
 	testFunc := func(d *Devops, c testCase) query.Query {
 		q := d.GenerateEmptyQuery()
-		d.MaxAllCPU(q, c.input)
+		d.MaxAllCPU(q, c.input, devops.MaxAllDuration)
 		return q
 	}
 

cmd/tsbs_generate_queries/databases/influx/devops.go

@@ -104,8 +104,8 @@ func (d *Devops) GroupByTimeAndPrimaryTag(qi query.Query, numMetrics int) {
 // FROM cpu WHERE (hostname = '$HOSTNAME_1' OR ... OR hostname = '$HOSTNAME_N')
 // AND time >= '$HOUR_START' AND time < '$HOUR_END'
 // GROUP BY hour ORDER BY hour
-func (d *Devops) MaxAllCPU(qi query.Query, nHosts int) {
-	interval := d.Interval.MustRandWindow(devops.MaxAllDuration)
+func (d *Devops) MaxAllCPU(qi query.Query, nHosts int, duration time.Duration) {
+	interval := d.Interval.MustRandWindow(duration)
 	whereHosts := d.getHostWhereString(nHosts)
 	selectClauses := d.getSelectClausesAggMetrics("max", devops.GetAllCPUMetrics())
 

cmd/tsbs_generate_queries/databases/influx/devops_test.go

@@ -269,7 +269,7 @@ func TestMaxAllCPU(t *testing.T) {
 
 	testFunc := func(d *Devops, c testCase) query.Query {
 		q := d.GenerateEmptyQuery()
-		d.MaxAllCPU(q, c.input)
+		d.MaxAllCPU(q, c.input, devops.MaxAllDuration)
 		return q
 	}
 

cmd/tsbs_generate_queries/databases/mongo/devops.go

@@ -168,8 +168,8 @@ func (d *Devops) GroupByTime(qi query.Query, nHosts, numMetrics int, timeRange t
 // FROM cpu WHERE (hostname = '$HOSTNAME_1' OR ... OR hostname = '$HOSTNAME_N')
 // AND time >= '$HOUR_START' AND time < '$HOUR_END'
 // GROUP BY hour ORDER BY hour
-func (d *Devops) MaxAllCPU(qi query.Query, nHosts int) {
-	interval := d.Interval.MustRandWindow(devops.MaxAllDuration)
+func (d *Devops) MaxAllCPU(qi query.Query, nHosts int, duration time.Duration) {
+	interval := d.Interval.MustRandWindow(duration)
 	hostnames, err := d.GetRandomHosts(nHosts)
 	panicIfErr(err)
 	docs := getTimeFilterDocs(interval)

cmd/tsbs_generate_queries/databases/siridb/devops.go

@@ -120,8 +120,8 @@ func (d *Devops) GroupByTimeAndPrimaryTag(qi query.Query, numMetrics int) {
 // hosts and all `cpu` metrics are returned):
 //
 // select max(1h) from (`groupHost1` | ...) & `cpu` between 'time1' and 'time2'
-func (d *Devops) MaxAllCPU(qi query.Query, nHosts int) {
-	interval := d.Interval.MustRandWindow(devops.MaxAllDuration)
+func (d *Devops) MaxAllCPU(qi query.Query, nHosts int, duration time.Duration) {
+	interval := d.Interval.MustRandWindow(duration)
 
 	whereMetrics := "`cpu`"
 	whereHosts := d.getHostWhereString(nHosts)

cmd/tsbs_generate_queries/databases/siridb/devops_test.go

@@ -236,7 +236,7 @@ func TestMaxAllCPU(t *testing.T) {
 
 	testFunc := func(d *Devops, c testCase) query.Query {
 		q := d.GenerateEmptyQuery()
-		d.MaxAllCPU(q, c.input)
+		d.MaxAllCPU(q, c.input, devops.MaxAllDuration)
 		return q
 	}
 

cmd/tsbs_generate_queries/databases/timescaledb/devops.go

@@ -46,11 +46,11 @@ func (d *Devops) getHostWhereWithHostnames(hostnames []string) string {
 		return fmt.Sprintf("tags_id IN (SELECT id FROM tags WHERE hostname IN (%s))", strings.Join(hostnameClauses, ","))
 	} else {
 		for _, s := range hostnames {
-			hostnameClauses = append(hostnameClauses, fmt.Sprintf("hostname = '%s'", s))
+			hostnameClauses = append(hostnameClauses, fmt.Sprintf("'%s'", s))
 		}
-		combinedHostnameClause := strings.Join(hostnameClauses, " OR ")
-
-		return "(" + combinedHostnameClause + ")"
+		// using the OR logic here is an anti-pattern for the query planner. Doing
+		// the IN will get translated to an ANY query and do better
+		return fmt.Sprintf("hostname IN (%s)", strings.Join(hostnameClauses, ","))
 	}
 }
 
@@ -83,7 +83,7 @@ func (d *Devops) getSelectClausesAggMetrics(agg string, metrics []string) []stri
 //
 // SELECT minute, max(metric1), ..., max(metricN)
 // FROM cpu
-// WHERE (hostname = '$HOSTNAME_1' OR ... OR hostname = '$HOSTNAME_N')
+// WHERE hostname IN ('$HOSTNAME_1',...,'$HOSTNAME_N')
 // AND time >= '$HOUR_START' AND time < '$HOUR_END'
 // GROUP BY minute ORDER BY minute ASC
 func (d *Devops) GroupByTime(qi query.Query, nHosts, numMetrics int, timeRange time.Duration) {
@@ -153,28 +153,31 @@ func (d *Devops) GroupByTimeAndPrimaryTag(qi query.Query, numMetrics int) {
 
 	hostnameField := "hostname"
 	joinStr := ""
+	partitionGrouping := hostnameField
 	if d.UseJSON || d.UseTags {
 		if d.UseJSON {
 			hostnameField = "tags->>'hostname'"
 		} else if d.UseTags {
 			hostnameField = "tags.hostname"
 		}
 		joinStr = "JOIN tags ON cpu_avg.tags_id = tags.id"
+		partitionGrouping = "tags_id"
 	}
 
 	sql := fmt.Sprintf(`
         WITH cpu_avg AS (
-          SELECT %s as hour, tags_id,
+          SELECT %s as hour, %s,
           %s
           FROM cpu
           WHERE time >= '%s' AND time < '%s'
-          GROUP BY hour, tags_id
+          GROUP BY 1, 2
         )
         SELECT hour, %s, %s
         FROM cpu_avg
         %s
         ORDER BY hour, %s`,
 		d.getTimeBucket(oneHour),
+		partitionGrouping,
 		strings.Join(selectClauses, ", "),
 		interval.Start().Format(goTimeFmt),
 		interval.End().Format(goTimeFmt),
@@ -189,11 +192,11 @@ func (d *Devops) GroupByTimeAndPrimaryTag(qi query.Query, numMetrics int) {
 // e.g. in pseudo-SQL:
 //
 // SELECT MAX(metric1), ..., MAX(metricN)
-// FROM cpu WHERE (hostname = '$HOSTNAME_1' OR ... OR hostname = '$HOSTNAME_N')
+// FROM cpu WHERE hostname IN ('$HOSTNAME_1',...,'$HOSTNAME_N')
 // AND time >= '$HOUR_START' AND time < '$HOUR_END'
 // GROUP BY hour ORDER BY hour
-func (d *Devops) MaxAllCPU(qi query.Query, nHosts int) {
-	interval := d.Interval.MustRandWindow(devops.MaxAllDuration)
+func (d *Devops) MaxAllCPU(qi query.Query, nHosts int, duration time.Duration) {
+	interval := d.Interval.MustRandWindow(duration)
 
 	metrics := devops.GetAllCPUMetrics()
 	selectClauses := d.getSelectClausesAggMetrics("max", metrics)

cmd/tsbs_generate_queries/databases/timescaledb/devops_test.go

@@ -25,14 +25,14 @@ func TestDevopsGetHostWhereWithHostnames(t *testing.T) {
 			hostnames: []string{"foo1"},
 			useJSON:   false,
 			useTags:   false,
-			want:      "(hostname = 'foo1')",
+			want:      "hostname IN ('foo1')",
 		},
 		{
 			desc:      "multi host - no json or tags",
 			hostnames: []string{"foo1", "foo2"},
 			useJSON:   false,
 			useTags:   false,
-			want:      "(hostname = 'foo1' OR hostname = 'foo2')",
+			want:      "hostname IN ('foo1','foo2')",
 		},
 		{
 			desc:      "single host - w/ json",
@@ -88,15 +88,15 @@ func TestDevopsGetHostWhereString(t *testing.T) {
 	}{
 		{
 			nHosts: 1,
-			want:   "(hostname = 'host_5')",
+			want:   "hostname IN ('host_5')",
 		},
 		{
 			nHosts: 2,
-			want:   "(hostname = 'host_5' OR hostname = 'host_9')",
+			want:   "hostname IN ('host_5','host_9')",
 		},
 		{
 			nHosts: 5,
-			want:   "(hostname = 'host_5' OR hostname = 'host_9' OR hostname = 'host_3' OR hostname = 'host_1' OR hostname = 'host_7')",
+			want:   "hostname IN ('host_5','host_9','host_3','host_1','host_7')",
 		},
 	}
 
@@ -184,7 +184,7 @@ func TestDevopsGroupByTime(t *testing.T) {
 	expectedSQLQuery := `SELECT time_bucket('60 seconds', time) AS minute,
         max(usage_user) as max_usage_user
         FROM cpu
-        WHERE (hostname = 'host_9') AND time >= '1970-01-01 00:05:58.646325 +0000' AND time < '1970-01-01 00:05:59.646325 +0000'
+        WHERE hostname IN ('host_9') AND time >= '1970-01-01 00:05:58.646325 +0000' AND time < '1970-01-01 00:05:59.646325 +0000'
         GROUP BY minute ORDER BY minute ASC`
 
 	rand.Seed(123) // Setting seed for testing purposes.
@@ -255,11 +255,11 @@ func TestGroupByTimeAndPrimaryTag(t *testing.T) {
 			expectedHypertable: "cpu",
 			expectedSQLQuery: `
         WITH cpu_avg AS (
-          SELECT time_bucket('3600 seconds', time) as hour, tags_id,
+          SELECT time_bucket('3600 seconds', time) as hour, hostname,
           avg(usage_user) as mean_usage_user
           FROM cpu
           WHERE time >= '1970-01-01 00:16:22.646325 +0000' AND time < '1970-01-01 12:16:22.646325 +0000'
-          GROUP BY hour, tags_id
+          GROUP BY 1, 2
         )
         SELECT hour, hostname, mean_usage_user
         FROM cpu_avg
@@ -278,7 +278,7 @@ func TestGroupByTimeAndPrimaryTag(t *testing.T) {
           avg(usage_user) as mean_usage_user
           FROM cpu
           WHERE time >= '1970-01-01 00:54:10.138978 +0000' AND time < '1970-01-01 12:54:10.138978 +0000'
-          GROUP BY hour, tags_id
+          GROUP BY 1, 2
         )
         SELECT hour, tags->>'hostname', mean_usage_user
         FROM cpu_avg
@@ -297,7 +297,7 @@ func TestGroupByTimeAndPrimaryTag(t *testing.T) {
           avg(usage_user) as mean_usage_user
           FROM cpu
           WHERE time >= '1970-01-01 00:47:30.894865 +0000' AND time < '1970-01-01 12:47:30.894865 +0000'
-          GROUP BY hour, tags_id
+          GROUP BY 1, 2
         )
         SELECT hour, tags.hostname, mean_usage_user
         FROM cpu_avg
@@ -317,7 +317,7 @@ func TestGroupByTimeAndPrimaryTag(t *testing.T) {
           avg(usage_user) as mean_usage_user
           FROM cpu
           WHERE time >= '1970-01-01 00:37:12.342805 +0000' AND time < '1970-01-01 12:37:12.342805 +0000'
-          GROUP BY hour, tags_id
+          GROUP BY 1, 2
         )
         SELECT hour, tags->>'hostname', mean_usage_user
         FROM cpu_avg
@@ -363,7 +363,7 @@ func TestMaxAllCPU(t *testing.T) {
 		"max(usage_softirq) as max_usage_softirq, max(usage_steal) as max_usage_steal, max(usage_guest) as max_usage_guest, " +
 		`max(usage_guest_nice) as max_usage_guest_nice
         FROM cpu
-        WHERE (hostname = 'host_9') AND time >= '1970-01-01 00:16:22.646325 +0000' AND time < '1970-01-01 08:16:22.646325 +0000'
+        WHERE hostname IN ('host_9') AND time >= '1970-01-01 00:16:22.646325 +0000' AND time < '1970-01-01 08:16:22.646325 +0000'
         GROUP BY hour ORDER BY hour`
 	rand.Seed(123) // Setting seed for testing purposes.
 	s := time.Unix(0, 0)
@@ -379,7 +379,7 @@ func TestMaxAllCPU(t *testing.T) {
 	d := dq.(*Devops)
 
 	q := d.GenerateEmptyQuery()
-	d.MaxAllCPU(q, 1)
+	d.MaxAllCPU(q, 1, devops.MaxAllDuration)
 	verifyQuery(t, q, expectedHumanLabel, expectedHumanDesc, expectedHypertable, expectedSQLQuery)
 }
 
@@ -476,7 +476,7 @@ func TestHighCPUForHosts(t *testing.T) {
 			expectedHumanDesc:  "TimescaleDB CPU over threshold, 1 host(s): 1970-01-01T00:47:30Z",
 			expectedHypertable: "cpu",
 			expectedSQLQuery: "SELECT * FROM cpu WHERE usage_user > 90.0 and time >= '1970-01-01 00:47:30.894865 +0000'" +
-				" AND time < '1970-01-01 12:47:30.894865 +0000' AND (hostname = 'host_9')",
+				" AND time < '1970-01-01 12:47:30.894865 +0000' AND hostname IN ('host_9')",
 		},
 		{
 			desc:               "five hosts",
@@ -485,8 +485,7 @@ func TestHighCPUForHosts(t *testing.T) {
 			expectedHumanDesc:  "TimescaleDB CPU over threshold, 5 host(s): 1970-01-01T00:08:59Z",
 			expectedHypertable: "cpu",
 			expectedSQLQuery: "SELECT * FROM cpu WHERE usage_user > 90.0 and time >= '1970-01-01 00:08:59.080812 +0000'" +
-				" AND time < '1970-01-01 12:08:59.080812 +0000' AND (hostname = 'host_5' OR hostname = 'host_9' " +
-				"OR hostname = 'host_1' OR hostname = 'host_7' OR hostname = 'host_2')",
+				" AND time < '1970-01-01 12:08:59.080812 +0000' AND hostname IN ('host_5','host_9','host_1','host_7','host_2')",
 		},
 	}
 

cmd/tsbs_generate_queries/main.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"github.com/timescale/tsbs/pkg/query/config"
 	"os"
+	"time"
 
 	"github.com/blagojts/viper"
 	"github.com/spf13/pflag"
@@ -24,8 +25,9 @@ var useCaseMatrix = map[string]map[string]utils.QueryFillerMaker{
 		devops.LabelSingleGroupby + "-5-1-1":  devops.NewSingleGroupby(5, 1, 1),
 		devops.LabelSingleGroupby + "-5-1-12": devops.NewSingleGroupby(5, 1, 12),
 		devops.LabelSingleGroupby + "-5-8-1":  devops.NewSingleGroupby(5, 8, 1),
-		devops.LabelMaxAll + "-1":             devops.NewMaxAllCPU(1),
-		devops.LabelMaxAll + "-8":             devops.NewMaxAllCPU(8),
+		devops.LabelMaxAll + "-1":             devops.NewMaxAllCPU(1, devops.MaxAllDuration),
+		devops.LabelMaxAll + "-8":             devops.NewMaxAllCPU(8, devops.MaxAllDuration),
+		devops.LabelMaxAll + "-32-24":         devops.NewMaxAllCPU(32, 24*time.Hour),
 		devops.LabelDoubleGroupby + "-1":      devops.NewGroupBy(1),
 		devops.LabelDoubleGroupby + "-5":      devops.NewGroupBy(5),
 		devops.LabelDoubleGroupby + "-all":    devops.NewGroupBy(devops.GetCPUMetricsLen()),

cmd/tsbs_generate_queries/uses/devops/common.go

@@ -107,7 +107,7 @@ type LastPointFiller interface {
 
 // MaxAllFiller is a type that can fill in a max all CPU metrics query
 type MaxAllFiller interface {
-	MaxAllCPU(query.Query, int)
+	MaxAllCPU(query.Query, int, time.Duration)
 }
 
 // GroupbyOrderbyLimitFiller is a type that can fill in a groupby-orderby-limit query

cmd/tsbs_generate_queries/uses/devops/max_all_cpu.go

@@ -1,23 +1,27 @@
 package devops
 
 import (
+	"time"
+
 	"github.com/timescale/tsbs/cmd/tsbs_generate_queries/uses/common"
 	"github.com/timescale/tsbs/cmd/tsbs_generate_queries/utils"
 	"github.com/timescale/tsbs/pkg/query"
 )
 
 // MaxAllCPU contains info for filling in a query.Query for "max all" queries
 type MaxAllCPU struct {
-	core  utils.QueryGenerator
-	hosts int
+	core     utils.QueryGenerator
+	hosts    int
+	duration time.Duration
 }
 
 // NewMaxAllCPU produces a new function that produces a new AllMaxCPU
-func NewMaxAllCPU(hosts int) utils.QueryFillerMaker {
+func NewMaxAllCPU(hosts int, duration time.Duration) utils.QueryFillerMaker {
 	return func(core utils.QueryGenerator) utils.QueryFiller {
 		return &MaxAllCPU{
-			core:  core,
-			hosts: hosts,
+			core:     core,
+			hosts:    hosts,
+			duration: duration,
 		}
 	}
 }
@@ -28,6 +32,6 @@ func (d *MaxAllCPU) Fill(q query.Query) query.Query {
 	if !ok {
 		common.PanicUnimplementedQuery(d.core)
 	}
-	fc.MaxAllCPU(q, d.hosts)
+	fc.MaxAllCPU(q, d.hosts, d.duration)
 	return q
 }

cmd/tsbs_load_timescaledb/main.go

@@ -33,6 +33,7 @@ func initProgramOptions() (*timescaledb.LoadingOptions, load.BenchmarkRunner, *l
 		panic(fmt.Errorf("unable to decode config: %s", err))
 	}
 	opts := timescaledb.LoadingOptions{}
+	viper.SetTypeByDefaultValue(true)
 	opts.PostgresConnect = viper.GetString("postgres")
 	opts.Host = viper.GetString("host")
 	opts.Port = viper.GetString("port")
@@ -42,11 +43,22 @@ func initProgramOptions() (*timescaledb.LoadingOptions, load.BenchmarkRunner, *l
 	opts.LogBatches = viper.GetBool("log-batches")
 
 	opts.UseHypertable = viper.GetBool("use-hypertable")
+	opts.ChunkTime = viper.GetDuration("chunk-time")
+
 	opts.UseJSON = viper.GetBool("use-jsonb-tags")
+
+	// This must be set to 'true' if you are going to test
+	// distributed hypertable queries and insert. Replication
+	// factor must also be set to true for distributed hypertables
 	opts.InTableTag = viper.GetBool("in-table-partition-tag")
 
+	// 	We currently use `create_hypertable` for all variations. When
+	//   `replication-factor`>=1, we automatically create a distributed
+	//   hypertable.
+	opts.ReplicationFactor = viper.GetInt("replication-factor")
+	// Currently ignored for distributed hypertables. We assume all
+	// data nodes will be used based on the partition-column above
 	opts.NumberPartitions = viper.GetInt("partitions")
-	opts.ChunkTime = viper.GetDuration("chunk-time")
 
 	opts.TimeIndex = viper.GetBool("time-index")
 	opts.TimePartitionIndex = viper.GetBool("time-partition-index")
@@ -59,6 +71,7 @@ func initProgramOptions() (*timescaledb.LoadingOptions, load.BenchmarkRunner, *l
 	opts.CreateMetricsTable = viper.GetBool("create-metrics-table")
 
 	opts.ForceTextFormat = viper.GetBool("force-text-format")
+	opts.UseInsert = viper.GetBool("use-insert")
 
 	loader := load.GetBenchmarkRunner(loaderConf)
 	return &opts, loader, &loaderConf