Disable profile by default

Author: k1LoW

book.go

@@ -37,7 +37,7 @@ type book struct {
 	grpcRunners          map[string]*grpcRunner
 	cdpRunners           map[string]*cdpRunner
 	sshRunners           map[string]*sshRunner
-	disableProfile       bool
+	profile              bool
 	intervalStr          string
 	interval             time.Duration
 	loop                 *Loop

cmd/loadt.go

@@ -47,8 +47,6 @@ var loadtCmd = &cobra.Command{
 		if err != nil {
 			return err
 		}
-		opts = append(opts, runn.DisableProfile(true))
-
 		// setup cache dir
 		if err := runn.SetCacheDir(flgs.CacheDir); err != nil {
 			return err

cmd/run.go

@@ -76,7 +76,7 @@ var runCmd = &cobra.Command{
 			}
 		}
 
-		if !flgs.DisableProfile {
+		if flgs.Profile {
 			p, err := os.Create(filepath.Clean(flgs.ProfileOut))
 			if err != nil {
 				return err
@@ -124,7 +124,7 @@ func init() {
 	runCmd.Flags().IntVarP(&flgs.ShardN, "shard-n", "", 0, flgs.Usage("ShardN"))
 	runCmd.Flags().IntVarP(&flgs.Random, "random", "", 0, flgs.Usage("Random"))
 	runCmd.Flags().StringVarP(&flgs.Format, "format", "", "", flgs.Usage("Format"))
-	runCmd.Flags().BoolVarP(&flgs.DisableProfile, "disable-profile", "", false, flgs.Usage("DisableProfile"))
+	runCmd.Flags().BoolVarP(&flgs.Profile, "profile", "", false, flgs.Usage("Profile"))
 	runCmd.Flags().StringVarP(&flgs.ProfileOut, "profile-out", "", "runn.prof", flgs.Usage("ProfileOut"))
 	runCmd.Flags().StringVarP(&flgs.CacheDir, "cache-dir", "", "", flgs.Usage("CacheDir"))
 	runCmd.Flags().BoolVarP(&flgs.RetainCacheDir, "retain-cache-dir", "", false, flgs.Usage("RetainCacheDir"))

flags/flags.go

@@ -55,7 +55,7 @@ type Flags struct {
 	LoadTWarmUp     string   `usage:"warn-up time for load test"`
 	LoadTThreshold  string   `usage:"if this threshold condition is not met, loadt command returns exit status 1 (EXIT_FAILURE)"`
 	LoadTMaxRPS     int      `usage:"max RunN per second for load test. 0 means unlimited"`
-	DisableProfile  bool     `usage:"disable profile runs of runbooks"`
+	Profile         bool     `usage:"profile runs of runbooks"`
 	ProfileOut      string   `usage:"profile output path"`
 	ProfileDepth    int      `usage:"depth of profile"`
 	ProfileUnit     string   `usage:"-"`
@@ -81,7 +81,7 @@ func (f *Flags) ToOpts() ([]runn.Option, error) {
 		runn.GRPCNoTLS(f.GRPCNoTLS),
 		runn.GRPCProtos(f.GRPCProtos),
 		runn.GRPCImportPaths(f.GRPCImportPaths),
-		runn.DisableProfile(f.DisableProfile),
+		runn.Profile(f.Profile),
 		runn.Scopes(f.Scopes...),
 		runn.RunLabel(f.RunLabels...),
 	}

include.go

@@ -135,7 +135,7 @@ func (o *operator) newNestedOperator(parent *step, opts ...Option) (*operator, e
 	}
 
 	popts = append(popts, Debug(o.debug))
-	popts = append(popts, DisableProfile(o.disableProfile))
+	popts = append(popts, Profile(o.profile))
 	popts = append(popts, SkipTest(o.skipTest))
 	popts = append(popts, Force(o.force))
 	popts = append(popts, Trace(o.trace))

operator.go

@@ -30,21 +30,21 @@ var errStepSkiped = errors.New("step skipped")
 var _ otchkiss.Requester = (*operators)(nil)
 
 type operator struct {
-	id             string
-	httpRunners    map[string]*httpRunner
-	dbRunners      map[string]*dbRunner
-	grpcRunners    map[string]*grpcRunner
-	cdpRunners     map[string]*cdpRunner
-	sshRunners     map[string]*sshRunner
-	steps          []*step
-	store          store
-	desc           string
-	labels         []string
-	useMap         bool // Use map syntax in `steps:`.
-	debug          bool
-	disableProfile bool
-	interval       time.Duration
-	loop           *Loop
+	id          string
+	httpRunners map[string]*httpRunner
+	dbRunners   map[string]*dbRunner
+	grpcRunners map[string]*grpcRunner
+	cdpRunners  map[string]*cdpRunner
+	sshRunners  map[string]*sshRunner
+	steps       []*step
+	store       store
+	desc        string
+	labels      []string
+	useMap      bool // Use map syntax in `steps:`.
+	debug       bool
+	profile     bool
+	interval    time.Duration
+	loop        *Loop
 	// loopIndex - Index of the loop is dynamically recorded at runtime
 	loopIndex   *int
 	concurrency string
@@ -419,31 +419,31 @@ func New(opts ...Option) (*operator, error) {
 			bindVars: map[string]any{},
 			useMap:   bk.useMap,
 		},
-		useMap:         bk.useMap,
-		desc:           bk.desc,
-		labels:         bk.labels,
-		debug:          bk.debug,
-		disableProfile: bk.disableProfile,
-		interval:       bk.interval,
-		loop:           bk.loop,
-		concurrency:    bk.concurrency,
-		t:              bk.t,
-		thisT:          bk.t,
-		force:          bk.force,
-		trace:          bk.trace,
-		failFast:       bk.failFast,
-		included:       bk.included,
-		ifCond:         bk.ifCond,
-		skipTest:       bk.skipTest,
-		stdout:         bk.stdout,
-		stderr:         bk.stderr,
-		newOnly:        bk.loadOnly,
-		bookPath:       bk.path,
-		beforeFuncs:    bk.beforeFuncs,
-		afterFuncs:     bk.afterFuncs,
-		sw:             stopw.New(),
-		capturers:      bk.capturers,
-		runResult:      newRunResult(bk.desc, bk.labels, bk.path),
+		useMap:      bk.useMap,
+		desc:        bk.desc,
+		labels:      bk.labels,
+		debug:       bk.debug,
+		profile:     bk.profile,
+		interval:    bk.interval,
+		loop:        bk.loop,
+		concurrency: bk.concurrency,
+		t:           bk.t,
+		thisT:       bk.t,
+		force:       bk.force,
+		trace:       bk.trace,
+		failFast:    bk.failFast,
+		included:    bk.included,
+		ifCond:      bk.ifCond,
+		skipTest:    bk.skipTest,
+		stdout:      bk.stdout,
+		stderr:      bk.stderr,
+		newOnly:     bk.loadOnly,
+		bookPath:    bk.path,
+		beforeFuncs: bk.beforeFuncs,
+		afterFuncs:  bk.afterFuncs,
+		sw:          stopw.New(),
+		capturers:   bk.capturers,
+		runResult:   newRunResult(bk.desc, bk.labels, bk.path),
 	}
 
 	if o.debug {
@@ -737,7 +737,7 @@ func (o *operator) Run(ctx context.Context) error {
 	if o.t != nil {
 		o.t.Helper()
 	}
-	if o.disableProfile {
+	if !o.profile {
 		o.sw.Disable()
 	}
 	defer o.sw.Start().Stop()
@@ -1133,21 +1133,21 @@ func (o *operator) StepResults() []*StepResult {
 }
 
 type operators struct {
-	ops            []*operator
-	t              *testing.T
-	sw             *stopw.Span
-	disableProfile bool
-	shuffle        bool
-	shuffleSeed    int64
-	shardN         int
-	shardIndex     int
-	sample         int
-	random         int
-	concmax        int
-	opts           []Option
-	results        []*runNResult
-	runCount       int64
-	mu             sync.Mutex
+	ops         []*operator
+	t           *testing.T
+	sw          *stopw.Span
+	profile     bool
+	shuffle     bool
+	shuffleSeed int64
+	shardN      int
+	shardIndex  int
+	sample      int
+	random      int
+	concmax     int
+	opts        []Option
+	results     []*runNResult
+	runCount    int64
+	mu          sync.Mutex
 }
 
 func Load(pathp string, opts ...Option) (*operators, error) {
@@ -1165,17 +1165,17 @@ func Load(pathp string, opts ...Option) (*operators, error) {
 
 	sw := stopw.New()
 	ops := &operators{
-		t:              bk.t,
-		sw:             sw,
-		disableProfile: bk.disableProfile,
-		shuffle:        bk.runShuffle,
-		shuffleSeed:    bk.runShuffleSeed,
-		shardN:         bk.runShardN,
-		shardIndex:     bk.runShardIndex,
-		sample:         bk.runSample,
-		random:         bk.runRandom,
-		concmax:        1,
-		opts:           opts,
+		t:           bk.t,
+		sw:          sw,
+		profile:     bk.profile,
+		shuffle:     bk.runShuffle,
+		shuffleSeed: bk.runShuffleSeed,
+		shardN:      bk.runShardN,
+		shardIndex:  bk.runShardIndex,
+		sample:      bk.runSample,
+		random:      bk.runRandom,
+		concmax:     1,
+		opts:        opts,
 	}
 	if bk.runConcurrent {
 		ops.concmax = bk.runConcurrentMax
@@ -1404,7 +1404,7 @@ func (ops *operators) runN(ctx context.Context) (*runNResult, error) {
 	if ops.t != nil {
 		ops.t.Helper()
 	}
-	if ops.disableProfile {
+	if !ops.profile {
 		ops.sw.Disable()
 	}
 	defer ops.sw.Start().Stop()

option.go

@@ -648,14 +648,14 @@ func Debug(debug bool) Option {
 	}
 }
 
-// DisableProfile - Disable profile.
-func DisableProfile(disable bool) Option {
+// Profile - Enable profile.
+func Profile(enable bool) Option {
 	return func(bk *book) error {
 		if bk == nil {
 			return ErrNilBook
 		}
-		if !bk.disableProfile {
-			bk.disableProfile = disable
+		if !bk.profile {
+			bk.profile = enable
 		}
 		return nil
 	}

profile_test.go

@@ -37,7 +37,7 @@ func TestProfile(t *testing.T) {
 			opts := []Option{
 				T(t),
 				Book(tt.book),
-				DisableProfile(!tt.profile),
+				Profile(tt.profile),
 				Runner("db", fmt.Sprintf("sqlite://%s", db.Name())),
 				Scopes(ScopeAllowRunExec),
 			}

result_test.go

@@ -232,7 +232,7 @@ func TestResultElasped(t *testing.T) {
 	for _, tt := range tests {
 		tt := tt
 		t.Run(tt.book, func(t *testing.T) {
-			o, err := New(Book(tt.book))
+			o, err := New(Book(tt.book), Profile(true))
 			if err != nil {
 				t.Fatal(err)
 			}
@@ -242,5 +242,17 @@ func TestResultElasped(t *testing.T) {
 				t.Error("cannot measure elapsed time")
 			}
 		})
+
+		t.Run(tt.book, func(t *testing.T) {
+			o, err := New(Book(tt.book))
+			if err != nil {
+				t.Fatal(err)
+			}
+			_ = o.Run(ctx)
+			result := o.Result()
+			if result.Elapsed != 0 {
+				t.Error("elapsed time should be zero")
+			}
+		})
 	}
 }