trace_tail_sampling_rules.gen.go

// Code generated by chronogen; DO NOT EDIT
package configunstable

import (
	"context"
	"fmt"

	"github.com/chronosphereio/chronoctl-core/src/cmd/pkg/client"
	"github.com/chronosphereio/chronoctl-core/src/cmd/pkg/clienterror"
	"github.com/chronosphereio/chronoctl-core/src/cmd/pkg/dry"
	"github.com/chronosphereio/chronoctl-core/src/cmd/pkg/file"
	"github.com/chronosphereio/chronoctl-core/src/cmd/pkg/groups"
	"github.com/chronosphereio/chronoctl-core/src/cmd/pkg/output"
	config_unstable "github.com/chronosphereio/chronoctl-core/src/generated/swagger/configunstable/client/operations"
	"github.com/chronosphereio/chronoctl-core/src/generated/swagger/configunstable/models"
	"github.com/chronosphereio/chronoctl-core/src/types"
	"github.com/spf13/cobra"
)

func init() { types.MustRegisterObject(TraceTailSamplingRulesTypeMeta, &TraceTailSamplingRules{}) }

var _ types.Object = &TraceTailSamplingRules{}

var TraceTailSamplingRulesTypeMeta = types.TypeMeta{
	APIVersion: "unstable/config",
	Kind:       "TraceTailSamplingRules",
}

type TraceTailSamplingRules struct {
	types.TypeMeta `json:",inline"`
	Spec           *models.ConfigunstableTraceTailSamplingRules `json:"spec"`
}

func NewTraceTailSamplingRules(spec *models.ConfigunstableTraceTailSamplingRules) *TraceTailSamplingRules {
	return &TraceTailSamplingRules{
		TypeMeta: TraceTailSamplingRulesTypeMeta,
		Spec:     spec,
	}
}

func (e *TraceTailSamplingRules) Description() string {
	return types.TypeDescription(e)
}

func (e *TraceTailSamplingRules) Identifier() string {
	return "TraceTailSamplingRules"
}

func CreateTraceTailSamplingRules(
	ctx context.Context,
	client config_unstable.ClientService,
	entity *TraceTailSamplingRules,
	dryRun bool,
) (*TraceTailSamplingRules, error) {
	res, err := client.CreateTraceTailSamplingRules(&config_unstable.CreateTraceTailSamplingRulesParams{
		Context: ctx,
		Body: &models.ConfigunstableCreateTraceTailSamplingRulesRequest{
			DryRun:                 dryRun,
			TraceTailSamplingRules: entity.Spec,
		},
	})
	if err != nil {
		return nil, clienterror.Wrap(err)
	}
	return NewTraceTailSamplingRules(res.Payload.TraceTailSamplingRules), nil
}

func newTraceTailSamplingRulesCreateCmd() *cobra.Command {
	var (
		permissiveParsing bool
		dryRunFlags       = dry.NewFlags()
		clientFlags       = client.NewClientFlags()
		outputFlags       = output.NewFlags(output.WithoutOutputDirectory(), output.WithoutCreateFilePerObject())
		fileFlags         = file.NewFlags(true /* required */)
	)

	var (
		use   string
		short string
	)
	use = "create -f <file>"
	short = "Creates a single TraceTailSamplingRules."

	cmd := &cobra.Command{
		Use:     use,
		GroupID: groups.Commands.ID,
		Short:   short,
		RunE: func(cmd *cobra.Command, args []string) error {
			ctx, cancel := context.WithTimeout(cmd.Context(), clientFlags.Timeout())
			defer cancel()
			if err := outputFlags.Validate(); err != nil {
				return err
			}
			defer outputFlags.Close(cmd.OutOrStdout())
			stderr := output.NewStderrPrinter(cmd)

			client, err := clientFlags.ConfigUnstableClient()
			if err != nil {
				return err
			}

			var traceTailSamplingRules *TraceTailSamplingRules
			file, err := fileFlags.File()
			if err != nil {
				return err
			}
			defer file.Close() //nolint:errcheck
			traceTailSamplingRules, err = types.MustDecodeSingleObject[*TraceTailSamplingRules](file, permissiveParsing)
			if err != nil {
				return err
			}

			if dryRunFlags.DryRun {
				stderr.Println("--dry-run is set")
			}
			fullTraceTailSamplingRules, err := CreateTraceTailSamplingRules(ctx, client, traceTailSamplingRules, dryRunFlags.DryRun)
			if err != nil {
				return err
			}

			if dryRunFlags.DryRun {
				stderr.Println("TraceTailSamplingRules is valid and can be created")
				return nil
			}
			stderr.Printf("TraceTailSamplingRules created successfully\n")

			if err := outputFlags.WriteObject(fullTraceTailSamplingRules, cmd.OutOrStdout()); err != nil {
				return err
			}
			return nil
		},
	}
	dryRunFlags.AddFlags(cmd)
	clientFlags.AddFlags(cmd)
	outputFlags.AddFlags(cmd)
	fileFlags.AddFlags(cmd)
	cmd.Flags().BoolVar(&permissiveParsing, "no-strict", false, "If set, manifests with unknown fields are not rejected. Defaults to false.")

	return cmd
}

func GetTraceTailSamplingRules(
	ctx context.Context,
	client config_unstable.ClientService,
) (*TraceTailSamplingRules, error) {
	res, err := client.ReadTraceTailSamplingRules(&config_unstable.ReadTraceTailSamplingRulesParams{
		Context: ctx,
	})
	if err != nil {
		return nil, clienterror.Wrap(err)
	}
	return NewTraceTailSamplingRules(res.GetPayload().TraceTailSamplingRules), nil
}

func newTraceTailSamplingRulesReadCmd() *cobra.Command {
	clientFlags := client.NewClientFlags()
	outputFlags := output.NewFlags(output.WithoutOutputDirectory(), output.WithoutCreateFilePerObject())
	var (
		short string
		use   string
		args  cobra.PositionalArgs
	)
	short = "Reads a TraceTailSamplingRules singleton"
	use = "read"

	cmd := &cobra.Command{
		Use:     use,
		GroupID: groups.Commands.ID,
		Short:   short,
		Args:    args,
		RunE: func(cmd *cobra.Command, args []string) error {
			ctx, cancel := context.WithTimeout(cmd.Context(), clientFlags.Timeout())
			defer cancel()
			if err := outputFlags.Validate(); err != nil {
				return err
			}
			defer outputFlags.Close(cmd.OutOrStdout())

			client, err := clientFlags.ConfigUnstableClient()
			if err != nil {
				return err
			}
			entity, err := GetTraceTailSamplingRules(ctx, client)
			if err != nil {
				return err
			}
			if err := outputFlags.WriteObject(entity, cmd.OutOrStdout()); err != nil {
				return err
			}
			return nil
		},
	}

	clientFlags.AddFlags(cmd)
	outputFlags.AddFlags(cmd)

	return cmd
}

func UpdateTraceTailSamplingRules(
	ctx context.Context,
	client config_unstable.ClientService,
	entity *TraceTailSamplingRules,
	opts UpdateOptions,
) (*TraceTailSamplingRules, error) {
	res, err := client.UpdateTraceTailSamplingRules(&config_unstable.UpdateTraceTailSamplingRulesParams{
		Context: ctx,
		Body: &models.ConfigunstableUpdateTraceTailSamplingRulesRequest{
			CreateIfMissing:        opts.CreateIfMissing,
			DryRun:                 opts.DryRun,
			TraceTailSamplingRules: entity.Spec,
		},
	})
	if err != nil {
		return nil, clienterror.Wrap(err)
	}

	return NewTraceTailSamplingRules(res.Payload.TraceTailSamplingRules), nil
}

func newTraceTailSamplingRulesUpdateCmd() *cobra.Command {
	var (
		permissiveParsing bool
		createIfMissing   bool
		dryRunFlags       = dry.NewFlags()
		clientFlags       = client.NewClientFlags()
		outputFlags       = output.NewFlags(output.WithoutOutputDirectory(), output.WithoutCreateFilePerObject())
		fileFlags         = file.NewFlags(true /* required */)
	)

	cmd := &cobra.Command{
		Use:     "update -f <filename>",
		GroupID: groups.Commands.ID,
		Short:   "Updates an existing TraceTailSamplingRules.",
		RunE: func(cmd *cobra.Command, args []string) error {
			ctx, cancel := context.WithTimeout(cmd.Context(), clientFlags.Timeout())
			defer cancel()
			if err := outputFlags.Validate(); err != nil {
				return err
			}
			defer outputFlags.Close(cmd.OutOrStdout())
			stderr := output.NewStderrPrinter(cmd)

			client, err := clientFlags.ConfigUnstableClient()
			if err != nil {
				return err
			}

			file, err := fileFlags.File()
			if err != nil {
				return err
			}
			defer file.Close() //nolint:errcheck

			traceTailSamplingRules, err := types.MustDecodeSingleObject[*TraceTailSamplingRules](file, permissiveParsing)
			if err != nil {
				return err
			}

			updateOpts := UpdateOptions{
				DryRun:          dryRunFlags.DryRun,
				CreateIfMissing: createIfMissing,
			}

			if dryRunFlags.DryRun {
				stderr.Println("--dry-run is set, update not persisted")
			}

			fullTraceTailSamplingRules, err := UpdateTraceTailSamplingRules(ctx, client, traceTailSamplingRules, updateOpts)
			if err != nil {
				return err
			}

			if dryRunFlags.DryRun {
				stderr.Println("TraceTailSamplingRules is valid and can be updated")
				return nil
			}
			stderr.Printf("TraceTailSamplingRules applied successfully\n")

			if err := outputFlags.WriteObject(fullTraceTailSamplingRules, cmd.OutOrStdout()); err != nil {
				return err
			}
			return nil
		},
	}
	dryRunFlags.AddFlags(cmd)
	clientFlags.AddFlags(cmd)
	outputFlags.AddFlags(cmd)
	fileFlags.AddFlags(cmd)
	cmd.Flags().BoolVar(&permissiveParsing, "no-strict", false, "If set, manifests with unknown fields are allowed. Defaults to false.")
	cmd.Flags().BoolVar(&createIfMissing, "create-if-missing", false, "If set, creates the TraceTailSamplingRules if it does not already exist. Defaults to false.")

	return cmd
}

func DeleteTraceTailSamplingRules(
	ctx context.Context,
	client config_unstable.ClientService,
) error {
	_, err := client.DeleteTraceTailSamplingRules(&config_unstable.DeleteTraceTailSamplingRulesParams{
		Context: ctx,
	})
	if err != nil {
		return clienterror.Wrap(err)
	}
	return nil
}

func newTraceTailSamplingRulesDeleteCmd() *cobra.Command {
	clientFlags := client.NewClientFlags()
	outputFlags := output.NewFlags(output.WithoutOutputDirectory(), output.WithoutCreateFilePerObject())

	cmd := &cobra.Command{
		Use:     "delete <slug>",
		GroupID: groups.Commands.ID,
		Short:   "Deletes a single TraceTailSamplingRules by slug",
		RunE: func(cmd *cobra.Command, args []string) error {
			ctx, cancel := context.WithTimeout(cmd.Context(), clientFlags.Timeout())
			defer cancel()
			if err := outputFlags.Validate(); err != nil {
				return err
			}
			defer outputFlags.Close(cmd.OutOrStdout())

			client, err := clientFlags.ConfigUnstableClient()
			if err != nil {
				return err
			}

			res, err := client.DeleteTraceTailSamplingRules(&config_unstable.DeleteTraceTailSamplingRulesParams{
				Context: ctx,
			})
			if err != nil {
				return clienterror.Wrap(err)
			}
			_ = res
			fmt.Fprintf(cmd.OutOrStdout(), "deleted TraceTailSamplingRules")
			return nil
		},
	}
	clientFlags.AddFlags(cmd)
	outputFlags.AddFlags(cmd)
	return cmd
}

const TraceTailSamplingRulesScaffoldYAML = `api_version: unstable/config
kind: TraceTailSamplingRules
spec:
    # Optional. A list of rules, evaluated in order until a match is found,
    # and the sample rate applied, or else the default sample rate is applied.
    rules:
        - # A fraction of traces to keep, which should be a number between 0 and 1, inclusive
          sample_rate: <number>
          # A human-readable name of the rule, which summarizes what it's for
          name: <string>
          # Value used as the metric label value for metrics emitted relating to this rule.
          system_name: <string>
          # When the rule was created (novel system_name)
          created_at: <date-time>
          # When the rule was updated (existing system_name)
          updated_at: <date-time>
          filter:
            # Each SpanFilter object represents all conditions that need to be true on
            # the same span for the span to be considered matching the SpanFilter. If
            # 'span_count' is used, the number of spans within the trace that match the
            # SpanFilter needs to be within [min, max]. Multiple SpanFilters can be used,
            # and each can be satisfied by any number of spans within the trace.
            span:
                - # Matches the tags of the candidate.
                  tags:
                    - # The key (or name) of the span tag that is inspected by this filter.
                      key: <string>
                      numeric_value:
                        # The filter value used in comparison against match candidates.
                        value: <number>
                        comparison: <EQUAL|NOT_EQUAL|GREATER_THAN|GREATER_THAN_OR_EQUAL|LESS_THAN|LESS_THAN_OR_EQUAL>
                      value:
                        # The value the filter compares to the target trace or span field.
                        value: <string>
                        # Values the filter tests against when using IN or NOT_IN match type.
                        in_values:
                            - <string>
                        match: <EXACT|REGEX|EXACT_NEGATION|REGEX_NEGATION|IN|NOT_IN>
                  duration:
                    # Minimum duration, in seconds, required for a span or trace to match.
                    min_secs: <number>
                    # Maximum duration, in seconds, required for a span or trace to match.
                    max_secs: <number>
                  error:
                    # The value the filter compares to the target trace or span field.
                    value: <true|false>
                  match_type: <INCLUDE|EXCLUDE>
                  operation:
                    # The value the filter compares to the target trace or span field.
                    value: <string>
                    # Values the filter tests against when using IN or NOT_IN match type.
                    in_values:
                        - <string>
                    match: <EXACT|REGEX|EXACT_NEGATION|REGEX_NEGATION|IN|NOT_IN>
                  parent_operation:
                    # The value the filter compares to the target trace or span field.
                    value: <string>
                    # Values the filter tests against when using IN or NOT_IN match type.
                    in_values:
                        - <string>
                    match: <EXACT|REGEX|EXACT_NEGATION|REGEX_NEGATION|IN|NOT_IN>
                  parent_service:
                    # The value the filter compares to the target trace or span field.
                    value: <string>
                    # Values the filter tests against when using IN or NOT_IN match type.
                    in_values:
                        - <string>
                    match: <EXACT|REGEX|EXACT_NEGATION|REGEX_NEGATION|IN|NOT_IN>
                  service:
                    # The value the filter compares to the target trace or span field.
                    value: <string>
                    # Values the filter tests against when using IN or NOT_IN match type.
                    in_values:
                        - <string>
                    match: <EXACT|REGEX|EXACT_NEGATION|REGEX_NEGATION|IN|NOT_IN>
                  span_count:
                    # Minimum number of spans that must match a SpanFilter (inclusive).
                    min: <integer>
                    # Maximum number of spans that must match a SpanFilter (inclusive).
                    max: <integer>
            trace:
                duration:
                    # Minimum duration, in seconds, required for a span or trace to match.
                    min_secs: <number>
                    # Maximum duration, in seconds, required for a span or trace to match.
                    max_secs: <number>
                error:
                    # The value the filter compares to the target trace or span field.
                    value: <true|false>
    default_sample_rate:
        # Whether to override the default sample rate
        enabled: <true|false>
        # A fraction of traces to keep, which should be a number between 0 and 1, inclusive
        sample_rate: <number>
`

func newTraceTailSamplingRulesScaffoldCmd() *cobra.Command {
	cmd := &cobra.Command{
		Use:     "scaffold",
		GroupID: groups.Commands.ID,
		Short:   "Scaffolds a complete object with placeholder values",
		Run: func(cmd *cobra.Command, args []string) {
			fmt.Fprint(cmd.OutOrStdout(), TraceTailSamplingRulesScaffoldYAML)
		},
	}
	return cmd
}

func NewTraceTailSamplingRulesCmd() *cobra.Command {
	root := &cobra.Command{
		Use:     "trace-tail-sampling-rules",
		GroupID: groups.Config.ID,
		Short:   "All commands for TraceTailSamplingRules",
	}

	root.AddGroup(groups.Commands)
	root.AddCommand(
		newTraceTailSamplingRulesCreateCmd(),
		newTraceTailSamplingRulesReadCmd(),
		newTraceTailSamplingRulesUpdateCmd(),
		newTraceTailSamplingRulesDeleteCmd(),
		newTraceTailSamplingRulesScaffoldCmd(),
	)
	return root
}