kube

type APIClientsetProvider func(config k8sconfig.APIConfig) (kubernetes.Interface, error)

type Association struct {
	Name    string
	Sources []AssociationSource
}

type AssociationSource struct {
	From string
	Name string
}

type Associations struct {
	Associations []Association
}

type Client interface {
	GetPod(PodIdentifier) (*Pod, bool)
	GetNamespace(string) (*Namespace, bool)
	Start()
	Stop()
}

type ClientProvider func(*zap.Logger, k8sconfig.APIConfig, ExtractionRules, Filters, []Association, Excludes, APIClientsetProvider, InformerProvider, InformerProviderNamespace) (Client, error)

type Container struct {
	Name      string
	ImageName string
	ImageTag  string

	// Statuses is a map of container k8s.container.restart_count attribute to ContainerStatus struct.
	Statuses map[int]ContainerStatus
}

type ContainerStatus struct {
	ContainerID string
}

type ExcludePods struct {
	Name *regexp.Regexp
}

type Excludes struct {
	Pods []ExcludePods
}

type ExtractionRules struct {
	CronJobName        bool
	Deployment         bool
	DaemonSetUID       bool
	DaemonSetName      bool
	JobUID             bool
	JobName            bool
	Namespace          bool
	PodName            bool
	PodUID             bool
	PodHostName        bool
	ReplicaSetID       bool
	ReplicaSetName     bool
	StatefulSetUID     bool
	StatefulSetName    bool
	Node               bool
	StartTime          bool
	ContainerName      bool
	ContainerID        bool
	ContainerImageName bool
	ContainerImageTag  bool

	Annotations []FieldExtractionRule
	Labels      []FieldExtractionRule
}

type FakeController struct {
	sync.Mutex
	// contains filtered or unexported fields
}

type FakeInformer struct {
	*FakeController
	// contains filtered or unexported fields
}

type FakeNamespaceInformer struct {
	*FakeController
}

type FieldExtractionRule struct {
	// Name is used to as the Span tag name.
	Name string
	// Key is used to lookup k8s pod fields.
	Key string
	// KeyRegex is a regular expression(full length match) used to extract a Key that matches the regex.
	KeyRegex             *regexp.Regexp
	HasKeyRegexReference bool
	// Regex is a regular expression used to extract a sub-part of a field value.
	// Full value is extracted when no regexp is provided.
	Regex *regexp.Regexp
	// From determines the kubernetes object the field should be retrieved from.
	// Currently only two values are supported,
	//  - pod
	//  - namespace
	From string
}

type FieldFilter struct {
	// Key matches the field name.
	Key string
	// Value matches the field value.
	Value string
	// Op determines the matching operation.
	// Currently only two operations are supported,
	//  - Equals
	//  - NotEquals
	Op selection.Operator
}

type Filters struct {
	Node      string
	Namespace string
	Fields    []FieldFilter
	Labels    []FieldFilter
}

type InformerProvider func(
	client kubernetes.Interface,
	namespace string,
	labelSelector labels.Selector,
	fieldSelector fields.Selector,
) cache.SharedInformer

type InformerProviderNamespace func(
	client kubernetes.Interface,
) cache.SharedInformer

type Namespace struct {
	Name         string
	NamespaceUID string
	Attributes   map[string]string
	StartTime    metav1.Time
	DeletedAt    time.Time
}

type NoOpController struct {
	// contains filtered or unexported fields
}

type NoOpInformer struct {
	*NoOpController
}

type Pod struct {
	Name        string
	Address     string
	PodUID      string
	Attributes  map[string]string
	StartTime   *metav1.Time
	Ignore      bool
	Namespace   string
	HostNetwork bool

	// Containers specifies all containers in this pod.
	Containers PodContainers

	DeletedAt time.Time
}

type PodContainers struct {
	// ByID specifies all containers in a pod by container ID.
	ByID map[string]*Container
	// ByName specifies all containers in a pod by container name (k8s.container.name).
	ByName map[string]*Container
}

type PodIdentifier [PodIdentifierMaxLength]PodIdentifierAttribute

type PodIdentifierAttribute struct {
	Source AssociationSource
	Value  string
}

type WatchClient struct {

	// A map containing Pod related data, used to associate them with resources.
	// Key can be either an IP address or Pod UID
	Pods         map[PodIdentifier]*Pod
	Rules        ExtractionRules
	Filters      Filters
	Associations []Association
	Exclude      Excludes

	// A map containing Namespace related data, used to associate them with resources.
	// Key is namespace name
	Namespaces map[string]*Namespace
	// contains filtered or unexported fields
}