naming

package
v1.31.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jun 2, 2023 License: Apache-2.0 Imports: 2 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var Inputs = struct {
	ElementIdentifier Input
	InputType         Input
	MetaData          Input
	PageTitle         Input
	PageURL           Input
	SourceURL         Input
	TopXHRURL         Input
	XHRURL            Input
}{
	"ELEMENT_IDENTIFIER",
	"INPUT_TYPE",
	"METADATA",
	"PAGE_TITLE",
	"PAGE_URL",
	"SOURCE_URL",
	"TOP_XHR_URL",
	"XHR_URL",
}
View Source 
var Operators = struct {
	Contains                    Operator
	EndsWith                    Operator
	Equals                      Operator
	IsEmpty                     Operator
	IsNotEmpty                  Operator
	MatchesRegularExpression    Operator
	NotContains                 Operator
	NotEndsWith                 Operator
	NotEquals                   Operator
	NotMatchesRegularExpression Operator
	NotStartsWith               Operator
	StartsWith                  Operator
}{
	"CONTAINS",
	"ENDS_WITH",
	"EQUALS",
	"IS_EMPTY",
	"IS_NOT_EMPTY",
	"MATCHES_REGULAR_EXPRESSION",
	"NOT_CONTAINS",
	"NOT_ENDS_WITH",
	"NOT_EQUALS",
	"NOT_MATCHES_REGULAR_EXPRESSION",
	"NOT_STARTS_WITH",
	"STARTS_WITH",
}
View Source 
var PatternSearchTypes = struct {
	First PatternSearchType
	Last  PatternSearchType
}{
	"FIRST",
	"LAST",
}
View Source 
var ProcessingParts = struct {
	All    ProcessingPart
	Anchor ProcessingPart
	Path   ProcessingPart
}{
	"ALL",
	"ANCHOR",
	"PATH",
}
View Source 
var ProcessingStepTypes = struct {
	ExtractByRegularExpression   ProcessingStepType
	Replacement                  ProcessingStepType
	ReplaceIDs                   ProcessingStepType
	ReplaceWithPattern           ProcessingStepType
	ReplaceWithRegularExpression ProcessingStepType
	SubString                    ProcessingStepType
}{
	"EXTRACT_BY_REGULAR_EXPRESSION",
	"REPLACEMENT",
	"REPLACE_IDS",
	"REPLACE_WITH_PATTERN",
	"REPLACE_WITH_REGULAR_EXPRESSION",
	"SUBSTRING",
}

Functions

This section is empty.

Types

type Input 

type Input string

type Operator 

type Operator string

type PatternSearchType 

type PatternSearchType string

type Placeholder 

type Placeholder struct {
	Name                        string          `json:"name"`                        // Placeholder name. Valid length needs to be between 1 and 50 characters.
	Input                       Input           `json:"input"`                       // The input for the place holder. Possible values are `ELEMENT_IDENTIFIER`, `INPUT_TYPE`, `METADATA`, `PAGE_TITLE`, `PAGE_URL`, `SOURCE_URL`, `TOP_XHR_URL` and `XHR_URL`.
	ProcessingPart              ProcessingPart  `json:"processingPart"`              // The part to process. Possible values are `ALL`, `ANCHOR` and `PATH`.
	ProcessingSteps             ProcessingSteps `json:"processingSteps,omitempty"`   // The processing step settings
	MetaDataID                  *int32          `json:"metadataId,omitempty"`        // The ID of the metadata
	UseGuessedElementIdentifier bool            `json:"useGuessedElementIdentifier"` // Use the element identifier that was selected by Dynatrace
}

Placeholder The placeholder settings

func (*Placeholder) MarshalHCL 

func (me *Placeholder) MarshalHCL(properties hcl.Properties) error

func (*Placeholder) Schema 

func (me *Placeholder) Schema() map[string]*schema.Schema

func (*Placeholder) UnmarshalHCL 

func (me *Placeholder) UnmarshalHCL(decoder hcl.Decoder) error

type Placeholders 

type Placeholders []*Placeholder

func (Placeholders) MarshalHCL 

func (me Placeholders) MarshalHCL(properties hcl.Properties) error

func (*Placeholders) Schema 

func (me *Placeholders) Schema() map[string]*schema.Schema

func (*Placeholders) UnmarshalHCL 

func (me *Placeholders) UnmarshalHCL(decoder hcl.Decoder) error

type ProcessingPart 

type ProcessingPart string

type ProcessingStep 

type ProcessingStep struct {
	Type                    ProcessingStepType `json:"type"`                              // An action to be taken by the processing: \n\n* `SUBSTRING`: Extracts the string between **patternBefore** and **patternAfter**. \n* `REPLACEMENT`: Replaces the string between **patternBefore** and **patternAfter** with the specified **replacement**.\n* `REPLACE_WITH_PATTERN`: Replaces the **patternToReplace** with the specified **replacement**. \n* `EXTRACT_BY_REGULAR_EXPRESSION`: Extracts the part of the string that matches the **regularExpression**. \n* `REPLACE_WITH_REGULAR_EXPRESSION`: Replaces all occurrences that match **regularExpression** with the specified **replacement**. \n* `REPLACE_IDS`: Replaces all IDs and UUIDs with the specified **replacement**. Possible values are `EXTRACT_BY_REGULAR_EXPRESSION`, `REPLACEMENT`, `REPLACE_IDS`, `REPLACE_WITH_PATTERN`, `REPLACE_WITH_REGULAR_EXPRESSION` and `SUBSTRING`.
	PatternBefore           *string            `json:"patternBefore,omitempty"`           // The pattern before the required value. It will be removed
	PatternBeforeSearchType *PatternSearchType `json:"patternBeforeSearchType,omitempty"` // The required occurrence of **patternBefore**. Possible values are `FIRST` and `LAST`.
	PatternAfter            *string            `json:"patternAfter,omitempty"`            // The pattern after the required value. It will be removed.
	PatternAfterSearchType  *PatternSearchType `json:"patternAfterSearchType,omitempty"`  // The required occurrence of **patternAfter**. Possible values are `FIRST` and `LAST`.
	Replacement             *string            `json:"replacement,omitempty"`             // Replacement for the original value
	PatternToReplace        *string            `json:"patternToReplace,omitempty"`        // The pattern to be replaced. \n\n Only applicable if the `type` is `REPLACE_WITH_PATTERN`.
	RegularExpression       *string            `json:"regularExpression,omitempty"`       // A regular expression for the string to be extracted or replaced. Only applicable if the `type` is `EXTRACT_BY_REGULAR_EXPRESSION` or `REPLACE_WITH_REGULAR_EXPRESSION`.
	FallbackToInput         bool               `json:"fallbackToInput,omitempty"`         // If set to `true`: Returns the input if `patternBefore` or `patternAfter` cannot be found and the `type` is `SUBSTRING`. Returns the input if `regularExpression` doesn't match and `type` is `EXTRACT_BY_REGULAR_EXPRESSION`. \n\n Otherwise `null` is returned.
}

func (*ProcessingStep) MarshalHCL 

func (me *ProcessingStep) MarshalHCL(properties hcl.Properties) error

func (*ProcessingStep) Schema 

func (me *ProcessingStep) Schema() map[string]*schema.Schema

func (*ProcessingStep) UnmarshalHCL 

func (me *ProcessingStep) UnmarshalHCL(decoder hcl.Decoder) error

type ProcessingStepType 

type ProcessingStepType string

type ProcessingSteps 

type ProcessingSteps []*ProcessingStep

func (ProcessingSteps) MarshalHCL 

func (me ProcessingSteps) MarshalHCL(properties hcl.Properties) error

func (*ProcessingSteps) Schema 

func (me *ProcessingSteps) Schema() map[string]*schema.Schema

func (*ProcessingSteps) UnmarshalHCL 

func (me *ProcessingSteps) UnmarshalHCL(decoder hcl.Decoder) error

type Rule 

type Rule struct {
	Template        string         `json:"template"`             // Naming pattern. Use Curly brackets `{}` to select placeholders
	Conditions      RuleConditions `json:"conditions,omitempty"` // Defines the conditions when the naming rule should apply
	UseOrConditions bool           `json:"useOrConditions"`      // If set to `true` the conditions will be connected by logical OR instead of logical AND
}

Rule The settings of naming rule

func (*Rule) MarshalHCL 

func (me *Rule) MarshalHCL(properties hcl.Properties) error

func (*Rule) Schema 

func (me *Rule) Schema() map[string]*schema.Schema

func (*Rule) UnmarshalHCL 

func (me *Rule) UnmarshalHCL(decoder hcl.Decoder) error

type RuleCondition 

type RuleCondition struct {
	Operand1 string   `json:"operand1"`           // Must be a defined placeholder wrapped in curly braces
	Operand2 *string  `json:"operand2,omitempty"` // Must be null if operator is `IS_EMPTY`, a regex if operator is `MATCHES_REGULAR_ERPRESSION`. In all other cases the value can be a freetext or a placeholder wrapped in curly braces
	Operator Operator `json:"operator"`           // The operator of the condition. Possible values are `CONTAINS`, `ENDS_WITH`, `EQUALS`, `IS_EMPTY`, `IS_NOT_EMPTY`, `MATCHES_REGULAR_EXPRESSION`, `NOT_CONTAINS`, `NOT_ENDS_WITH`, `NOT_EQUALS`, `NOT_MATCHES_REGULAR_EXPRESSION`, `NOT_STARTS_WITH` and `STARTS_WITH`.
}

RuleCondition The settings of conditions for user action naming

func (*RuleCondition) MarshalHCL 

func (me *RuleCondition) MarshalHCL(properties hcl.Properties) error

func (*RuleCondition) Schema 

func (me *RuleCondition) Schema() map[string]*schema.Schema

func (*RuleCondition) UnmarshalHCL 

func (me *RuleCondition) UnmarshalHCL(decoder hcl.Decoder) error

type RuleConditions 

type RuleConditions []*RuleCondition

func (RuleConditions) MarshalHCL 

func (me RuleConditions) MarshalHCL(properties hcl.Properties) error

func (*RuleConditions) Schema 

func (me *RuleConditions) Schema() map[string]*schema.Schema

func (*RuleConditions) UnmarshalHCL 

func (me *RuleConditions) UnmarshalHCL(decoder hcl.Decoder) error

type Rules 

type Rules []*Rule

func (Rules) MarshalHCL 

func (me Rules) MarshalHCL(properties hcl.Properties) error

func (*Rules) Schema 

func (me *Rules) Schema() map[string]*schema.Schema

func (*Rules) UnmarshalHCL 

func (me *Rules) UnmarshalHCL(decoder hcl.Decoder) error

type Settings 

type Settings struct {
	Placeholders               Placeholders `json:"placeholders"`                     // User action placeholders
	LoadActionNamingRules      Rules        `json:"loadActionNamingRules"`            // User action naming rules for loading actions
	XHRActionNamingRules       Rules        `json:"xhrActionNamingRules"`             // User action naming rules for XHR actions
	CustomActionNamingRules    Rules        `json:"customActionNamingRules"`          // User action naming rules for custom actions
	IgnoreCase                 bool         `json:"ignoreCase"`                       // Case insensitive naming
	UseFirstDetectedLoadAction bool         `json:"useFirstDetectedLoadAction"`       // First load action found under an XHR action should be used when true. Else the deepest one under the xhr action is used
	SplitUserActionsByDomain   bool         `json:"splitUserActionsByDomain"`         // Deactivate this setting if different domains should not result in separate user actions
	QueryParameterCleanups     []string     `json:"queryParameterCleanups,omitempty"` // List of parameters that should be removed from the query before using the query in the user action name
}

Settings The settings of user action naming

func (*Settings) MarshalHCL 

func (me *Settings) MarshalHCL(properties hcl.Properties) error

func (*Settings) Schema 

func (me *Settings) Schema() map[string]*schema.Schema

func (*Settings) UnmarshalHCL 

func (me *Settings) UnmarshalHCL(decoder hcl.Decoder) error

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.