workloadmeta

type AgentType uint8

type Capabilities struct {
	Add  []string
	Drop []string
}

type Collector interface {
	// Start starts a collector. The collector should run until the context
	// is done. It also gets a reference to the store that started it so it
	// can use Notify, or get access to other entities in the store.
	Start(context.Context, Component) error

	// Pull triggers an entity collection. To be used by collectors that
	// don't have streaming functionality, and called periodically by the
	// store.
	Pull(context.Context) error

	// GetID returns the identifier for the respective component.
	GetID() string

	// GetTargetCatalog gets the expected catalog.
	GetTargetCatalog() AgentType
}

type CollectorEvent struct {
	Type   EventType
	Source Source
	Entity Entity
}

type CollectorList []Collector

type CollectorProvider struct {
	fx.Out

	Collector Collector `group:"workloadmeta"`
}

type CollectorStatus uint8

type Component interface {
	// Subscribe subscribes the caller to events representing changes to the
	// store, limited to events matching the filter.  The name is used for
	// telemetry and debugging.
	//
	// The first message on the channel is special: it contains an EventTypeSet
	// event for each entity currently in the store.  If the Subscribe call
	// occurs at agent startup, then the first message approximates entities
	// that were running before the agent started.  This is an inherently racy
	// distinction, but may be useful for decisions such as whether to begin
	// logging at the head or tail of an entity's logs.
	//
	// Multiple EventTypeSet messages may be sent, either as the entity's state
	// evolves or as information about the entity is reported from multiple
	// sources (such as a container runtime and an orchestrator).
	//
	// See the documentation for EventBundle regarding appropriate handling
	// for messages on this channel.
	Subscribe(name string, priority SubscriberPriority, filter *Filter) chan EventBundle

	// Unsubscribe closes the EventBundle channel. Note that it will emit a zero-value event.
	// Thus, it is important to check that the channel is not closed.
	Unsubscribe(ch chan EventBundle)

	// GetContainer returns metadata about a container.  It fetches the entity
	// with kind KindContainer and the given ID.
	GetContainer(id string) (*Container, error)

	// ListContainers returns metadata about all known containers, equivalent
	// to all entities with kind KindContainer.
	ListContainers() []*Container

	// ListContainersWithFilter returns all the containers for which the passed
	// filter evaluates to true.
	ListContainersWithFilter(filter EntityFilterFunc[*Container]) []*Container

	// GetKubernetesPod returns metadata about a Kubernetes pod.  It fetches
	// the entity with kind KindKubernetesPod and the given ID.
	GetKubernetesPod(id string) (*KubernetesPod, error)

	// GetKubernetesPodForContainer retrieves the ownership information for the
	// given container and returns the owner pod. This information might lag because
	// the kubelet check sets the `Owner` field but a container can also be stored by CRI
	// checks, which do not have ownership info. Thus, the function might return an error
	// when the pod actually exists.
	GetKubernetesPodForContainer(containerID string) (*KubernetesPod, error)

	// GetKubernetesPodByName returns the first pod whose name and namespace matches those passed in
	// to this function.
	GetKubernetesPodByName(podName, podNamespace string) (*KubernetesPod, error)

	// ListKubernetesPods returns metadata about all known Kubernetes pods, equivalent
	// to all entities with kind KindKubernetesPod.
	ListKubernetesPods() []*KubernetesPod

	// GetKubeletMetrics returns metadata about kubelet metrics.
	GetKubeletMetrics() (*KubeletMetrics, error)

	// GetKubernetesDeployment returns metadata about a Kubernetes deployment. It fetches
	// the entity with kind KindKubernetesDeployment and the given ID.
	GetKubernetesDeployment(id string) (*KubernetesDeployment, error)

	// GetKubernetesMetadata returns metadata about a Kubernetes resource. It fetches
	// the entity with kind KubernetesMetadata and the given ID.
	GetKubernetesMetadata(id KubeMetadataEntityID) (*KubernetesMetadata, error)

	// ListKubernetesMetadata returns all the kubernetes metadata objects for
	// which the passed filter evaluates to true.
	ListKubernetesMetadata(filterFunc EntityFilterFunc[*KubernetesMetadata]) []*KubernetesMetadata

	// ListECSTasks returns metadata about all ECS tasks, equivalent to all
	// entities with kind KindECSTask.
	ListECSTasks() []*ECSTask

	// GetECSTask returns metadata about an ECS task.  It fetches the entity with
	// kind KindECSTask and the given ID.
	GetECSTask(id string) (*ECSTask, error)

	// ListImages returns metadata about all known images, equivalent to all
	// entities with kind KindContainerImageMetadata.
	ListImages() []*ContainerImageMetadata

	// GetImage returns metadata about a container image. It fetches the entity
	// with kind KindContainerImageMetadata and the given ID.
	GetImage(id string) (*ContainerImageMetadata, error)

	// GetProcess returns metadata about a process.  It fetches the entity
	// with kind KindProcess and the given ID.
	GetProcess(pid int32) (*Process, error)

	// ListProcesses returns metadata about all known processes, equivalent
	// to all entities with kind KindProcess.
	ListProcesses() []*Process

	// GetContainerForProcess returns the container associated with a process if it exists.
	// It fetches the entity with kind KindProcess and the given pid and then the entity
	// with kind KindContainer with the cid from the process entity.
	GetContainerForProcess(processID string) (*Container, error)

	// GetGPU returns metadata about a GPU device. It fetches the entity
	// with kind KindGPU and the given ID.
	GetGPU(id string) (*GPU, error)

	// GetKubelet returns the kubelet. It fetches the entity with kind KindKubelet.
	// There can only be one kubelet entity so further specification is unnecessary.
	GetKubelet() (*Kubelet, error)

	// ListGPUs returns metadata about all known GPU devices, equivalent
	// to all entities with kind KindGPU.
	ListGPUs() []*GPU

	// ListProcessesWithFilter returns all the processes for which the passed
	// filter evaluates to true.
	ListProcessesWithFilter(filterFunc EntityFilterFunc[*Process]) []*Process

	// Notify notifies the store with a slice of events.  It should only be
	// used by workloadmeta collectors.
	Notify(events []CollectorEvent)

	// Dump lists the content of the store, for debugging purposes.
	Dump(verbose bool) WorkloadDumpResponse

	// ResetProcesses resets the state of the store so that newProcesses are the
	// only entites stored.
	ResetProcesses(newProcesses []Entity, source Source)

	// Reset resets the state of the store so that newEntities are the only
	// entities stored. This function sends events to the subscribers in the
	// following cases:
	// - EventTypeSet: one for each entity in newEntities that doesn't exist in
	// the store. Also, when the entity exists, but with different values.
	// - EventTypeUnset: one for each entity that exists in the store but is not
	// present in newEntities.
	Reset(newEntities []Entity, source Source)

	// Push allows external sources to push events to the metadata store.
	// Only EventTypeSet and EventTypeUnset event types are allowed.
	Push(source Source, events ...Event) error

	// IsInitialized If startCandidates is run at least once, return true.
	IsInitialized() bool
}

type CompressedSBOM struct {
	Bom                []byte
	GenerationTime     time.Time
	GenerationDuration time.Duration
	Status             SBOMStatus
	Error              string
}

type Container struct {
	EntityID
	EntityMeta
	// ECSContainer contains properties specific to container running in ECS
	*ECSContainer
	// EnvVars are limited to variables included in pkg/util/containers/env_vars_filter.go
	EnvVars       map[string]string
	Hostname      string
	Image         ContainerImage
	NetworkIPs    map[string]string
	PID           int
	Ports         []ContainerPort
	Runtime       ContainerRuntime
	RuntimeFlavor ContainerRuntimeFlavor
	State         ContainerState
	// CollectorTags represent tags coming from the collector itself
	// and that it would be impossible to compute later on
	CollectorTags   []string
	Owner           *EntityID
	SecurityContext *ContainerSecurityContext
	ReadinessProbe  *ContainerProbe
	Resources       ContainerResources
	ResizePolicy    ContainerResizePolicy

	// ResolvedAllocatedResources is the list of resources allocated to this pod. Requires the
	// PodResources API to query that data.
	ResolvedAllocatedResources []ContainerAllocatedResource
	// CgroupPath is a path to the cgroup of the container.
	// It can be relative to the cgroup parent.
	// Linux only.
	CgroupPath   string
	RestartCount int
}

type ContainerAllocatedResource struct {
	// Name is the name of the resource as defined in the pod spec (e.g. "nvidia.com/gpu").
	Name string

	// ID is the unique ID of the resource, the format depends on the provider
	ID string
}

type ContainerHealth string

type ContainerHealthStatus struct {
	Status   string
	Since    *time.Time
	ExitCode *int64
	Output   string
}

type ContainerImage struct {
	ID         string
	RawName    string
	Name       string
	Registry   string
	ShortName  string
	Tag        string
	RepoDigest string
}

type ContainerImageLayer struct {
	MediaType string
	Digest    string
	SizeBytes int64
	URLs      []string
	History   *v1.History
}

type ContainerImageMetadata struct {
	EntityID
	EntityMeta
	RepoTags     []string
	RepoDigests  []string
	MediaType    string
	SizeBytes    int64
	OS           string
	OSVersion    string
	Architecture string
	Variant      string
	Layers       []ContainerImageLayer
	SBOM         *CompressedSBOM
}

type ContainerNetwork struct {
	NetworkMode   string
	IPv4Addresses []string
	IPv6Addresses []string
}

type ContainerPort struct {
	Name     string
	Port     int
	Protocol string
	HostPort uint16
}

type ContainerProbe struct {
	// This is only used by KSM, so it only includes the fields used by KSM. We
	// can add the rest later as needed.
	InitialDelaySeconds int32
}

type ContainerResizePolicy struct {
	CPURestartPolicy    string
	MemoryRestartPolicy string
}

type ContainerResources struct {
	GPURequest    *uint64 // Number of GPUs
	GPULimit      *uint64
	GPUVendorList []string // The type of GPU requested (eg. nvidia, amd, intel)
	CPURequest    *float64 // Percentage 0-100*numCPU (aligned with CPU Limit from metrics provider)
	CPULimit      *float64
	MemoryRequest *uint64 // Bytes
	MemoryLimit   *uint64

	// The container is requesting to use entire core(s)
	// e.g. 1000m or 1 -- NOT 1500m or 1.5
	RequestedWholeCores *bool

	// Raw resources. This duplicates some of the information in other fields,
	// but it is needed by kubelet check because it needs to emit metrics for
	// all resources. This includes the typical ones defined above (cpu, memory,
	// gpu) but also custom resources.
	RawRequests map[string]string
	RawLimits   map[string]string
}

type ContainerRuntime string

type ContainerRuntimeFlavor string

type ContainerSecurityContext struct {
	*Capabilities
	Privileged     bool
	SeccompProfile *SeccompProfile
}

type ContainerState struct {
	Running    bool
	Status     ContainerStatus
	Health     ContainerHealth
	CreatedAt  time.Time
	StartedAt  time.Time
	FinishedAt time.Time
	ExitCode   *int64
}

type ContainerStatus string

type ContainerVolume struct {
	Name        string
	Source      string
	Destination string
}

type ECSContainer struct {
	DisplayName   string
	Networks      []ContainerNetwork
	Volumes       []ContainerVolume
	Health        *ContainerHealthStatus
	DesiredStatus string
	KnownStatus   string
	Type          string
	LogDriver     string
	LogOptions    map[string]string
	ContainerARN  string
	Snapshotter   string
}

type ECSLaunchType string

type ECSTask struct {
	EntityID
	EntityMeta
	Tags                    MapTags
	ContainerInstanceTags   MapTags
	ClusterName             string
	ContainerInstanceARN    string
	ClusterARN              string
	ServiceARN              string
	TaskDefinitionARN       string
	AWSAccountID            string
	Region                  string
	AvailabilityZone        string
	Family                  string
	Version                 string
	DesiredStatus           string
	KnownStatus             string
	PullStartedAt           *time.Time
	PullStoppedAt           *time.Time
	ExecutionStoppedAt      *time.Time
	VPCID                   string
	ServiceName             string
	EphemeralStorageMetrics map[string]int64
	Limits                  map[string]float64
	LaunchType              ECSLaunchType
	Containers              []OrchestratorContainer
}

type Entity interface {
	// GetID gets the EntityID for this entity.
	GetID() EntityID

	// Merge merges this entity with another of the same kind.  This is used
	// to generate a composite entity representing data from several sources.
	Merge(Entity) error

	// DeepCopy copies an entity such that modifications of the copy will not
	// affect the original.
	DeepCopy() Entity

	// String provides a summary of the entity.  The string may span several lines,
	// especially if verbose.
	String(verbose bool) string
}

type EntityFilterFunc[T Entity] func(T) bool

type EntityID struct {
	// Kind identifies the kind of entity.  This typically corresponds to the concrete
	// type of the Entity, but this is not always the case; see Entity for details.
	Kind Kind

	// ID is the ID for this entity, in a format specific to the entity Kind.
	ID string
}

type EntityMeta struct {
	Name        string
	Namespace   string
	Annotations map[string]string
	Labels      map[string]string
	UID         string
}

type Event struct {
	// Type gives the type of this event.
	//
	// When Type is EventTypeSet, this represents an added or updated entity.
	// Multiple set events may be sent for a single entity.
	//
	// When Type is EventTypeUnset, this represents a removed entity.
	Type EventType

	// Entity is the entity involved in this event.  For an EventTypeSet event,
	// this may contain information "merged" from multiple sources.  For an
	// unset event it contains only an EntityID.
	//
	// For Type == EventTypeSet, this field can be cast unconditionally to the
	// concrete type corresponding to its kind (Entity.GetID().Kind).  For Type
	// == EventTypeUnset, only the Entity ID is available and such a cast will
	// fail.
	Entity Entity
}

type EventBundle struct {
	// Events gives the events in this bundle.
	Events []Event

	// Ch should be closed once the subscriber has handled the event.
	Ch chan struct{}
}

type EventType int

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

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

type GPU struct {
	EntityID
	EntityMeta
	// Vendor is the name of the manufacturer of the device (e.g., NVIDIA)
	Vendor string

	// Device is the commercial name of the device (e.g., Tesla V100) as returned
	// by the device driver (NVML for NVIDIA GPUs). Note that some models might
	// have some additional information like the memory size (e.g., Tesla
	// A100-SXM2-80GB), the exact format of this field is vendor and device
	// specific.
	Device string

	// DriverVersion is the version of the driver used for the gpu device
	DriverVersion string

	// ActivePIDs is the list of process IDs that are using the GPU.
	ActivePIDs []int

	// Index is the index of the GPU in the host system. This is useful as sometimes
	// GPUs will be identified by their index instead of their UUID. Note that the index
	// is not guaranteed to be stable across reboots, nor is necessarily the same inside
	// of containers.
	Index int

	// Architecture contains the architecture of the GPU (e.g., Pascal, Volta, etc.). Optional, can be empty.
	Architecture string

	// ComputeCapability contains the compute capability version of the GPU. Optional, can be 0/0
	ComputeCapability GPUComputeCapability

	// Total number of cores available for the device,
	// this is a number that represents number of SMs * number of cores per SM (depends on the model)
	TotalCores int

	// TotalMemory is the total available memory for the device in bytes
	TotalMemory uint64

	// MaxClockRates contains the maximum clock rates for SM and Memory
	MaxClockRates [GPUCOUNT]uint32

	// MemoryBusWidth is the width of the memory bus in bits.
	MemoryBusWidth uint32

	// DeviceType identifies if this is a physical or virtual device (e.g. MIG)
	DeviceType GPUDeviceType

	// VirtualizationMode contains the virtualization mode of the device
	VirtualizationMode string
}

type GPUClockType int

type GPUComputeCapability struct {
	// Major represents the major version of the compute capability.
	Major int

	// Minor represents the minor version of the compute capability.
	Minor int
}

type GPUDeviceType int

type GenericEntityFilterFunc EntityFilterFunc[Entity]

type HostTags struct {
	EntityID

	HostTags []string
}

type InitHelper func(context.Context, Component, config.Component) error

type InjectionState int

type Kind string

type KubeMetadataEntityID string

type Kubelet struct {
	EntityID
	EntityMeta
	ConfigDocument KubeletConfigDocument
}

type KubeletConfigDocument struct {
	KubeletConfig KubeletConfigSpec `json:"kubeletconfig"`
}

type KubeletConfigSpec struct {
	CPUManagerPolicy string `json:"cpuManagerPolicy"`
}

type KubeletMetrics struct {
	EntityID
	ExpiredPodCount int
}

type KubernetesContainerState struct {
	Waiting    *KubernetesContainerStateWaiting
	Running    *KubernetesContainerStateRunning
	Terminated *KubernetesContainerStateTerminated
}

type KubernetesContainerStateRunning struct {
	StartedAt time.Time
}

type KubernetesContainerStateTerminated struct {
	ExitCode   int32
	StartedAt  time.Time
	FinishedAt time.Time
	Reason     string
}

type KubernetesContainerStateWaiting struct {
	Reason string
}

type KubernetesContainerStatus struct {
	ContainerID          string
	Name                 string
	Image                string
	ImageID              string
	Ready                bool
	RestartCount         int32
	State                KubernetesContainerState
	LastTerminationState KubernetesContainerState
}

type KubernetesDeployment struct {
	EntityID
	EntityMeta
	Env     string
	Service string
	Version string

	// InjectableLanguages indicate containers languages that can be injected by the admission controller
	// These languages are determined by parsing the deployment annotations
	InjectableLanguages languagemodels.ContainersLanguages

	// DetectedLanguages languages indicate containers languages detected and reported by the language
	// detection server.
	DetectedLanguages languagemodels.ContainersLanguages
}

type KubernetesEphemeralVolume struct {
	Name        string
	UID         string
	Annotations map[string]string
	Labels      map[string]string
}

type KubernetesMetadata struct {
	EntityID
	EntityMeta
	GVR *schema.GroupVersionResource
}

type KubernetesPersistentVolumeClaim struct {
	ClaimName string
	ReadOnly  bool
}

type KubernetesPod struct {
	EntityID
	EntityMeta
	Owners                     []KubernetesPodOwner
	PersistentVolumeClaimNames []string
	InitContainers             []OrchestratorContainer
	Containers                 []OrchestratorContainer
	EphemeralContainers        []OrchestratorContainer
	Ready                      bool
	Phase                      string
	IP                         string
	PriorityClass              string
	QOSClass                   string
	GPUVendorList              []string
	RuntimeClass               string
	KubeServices               []string
	NamespaceLabels            map[string]string
	NamespaceAnnotations       map[string]string
	FinishedAt                 time.Time
	SecurityContext            *PodSecurityContext

	// The following fields are only needed for the kubelet check or KSM check
	// when configured to emit pod metrics from the node agent. That means only
	// the node agent needs them, so for now they're not added to the protobufs.
	CreationTimestamp          time.Time
	DeletionTimestamp          *time.Time
	StartTime                  *time.Time
	NodeName                   string
	HostIP                     string
	HostNetwork                bool
	InitContainerStatuses      []KubernetesContainerStatus
	ContainerStatuses          []KubernetesContainerStatus
	EphemeralContainerStatuses []KubernetesContainerStatus
	Conditions                 []KubernetesPodCondition
	Volumes                    []KubernetesPodVolume
	Tolerations                []KubernetesPodToleration
	Reason                     string
}

type KubernetesPodCondition struct {
	Type   string
	Status string
	Reason string
}

type KubernetesPodOwner struct {
	Kind       string
	Name       string
	ID         string
	Controller *bool
}

type KubernetesPodToleration struct {
	Key               string
	Operator          string
	Value             string
	Effect            string
	TolerationSeconds *int64
}

type KubernetesPodVolume struct {
	Name                  string
	PersistentVolumeClaim *KubernetesPersistentVolumeClaim
	Ephemeral             *KubernetesEphemeralVolume
}

type MapTags map[string]string

type OrchestratorContainer struct {
	ID        string
	Name      string
	Image     ContainerImage
	Resources ContainerResources
}

type Params struct {
	AgentType  AgentType
	InitHelper InitHelper
}

type PodSecurityContext struct {
	RunAsUser  int32
	RunAsGroup int32
	FsGroup    int32
}

type Process struct {
	EntityID // EntityID.ID is the PID

	Pid            int32    // Process ID -- /proc/[pid]
	NsPid          int32    // Namespace PID -- /proc/[pid]/status
	Ppid           int32    // Parent Process ID -- /proc/[pid]/stat
	Name           string   // Name -- /proc/[pid]/status
	Cwd            string   // Current Working Directory -- /proc/[pid]/cwd
	Exe            string   // Exceutable Path -- /proc[pid]/exe
	Comm           string   // Short Command Name -- /proc/[pid]/comm
	Cmdline        []string // Command Line -- /proc/[pid]/cmdline
	Uids           []int32  // User IDs -- /proc/[pid]/status
	Gids           []int32  // Group IDs -- /proc/[pid]/status
	ContainerID    string
	CreationTime   time.Time // Process Start Time -- /proc/[pid]/stat
	Language       *languagemodels.Language
	InjectionState InjectionState // APM auto-injector detection status

	// Owner will temporarily duplicate the ContainerID field until the new collector is enabled so we can then remove the ContainerID field
	Owner *EntityID // Owner is a reference to a container in WLM

	// Service contains service discovery information for this process
	Service *Service
}

type SBOM struct {
	CycloneDXBOM       *cyclonedx_v1_4.Bom
	GenerationTime     time.Time
	GenerationDuration time.Duration
	Status             SBOMStatus
	Error              string // needs to be stored as a string otherwise the merge() will favor the nil value
}

type SBOMStatus string

type SeccompProfile struct {
	Type             SeccompProfileType
	LocalhostProfile string
}

type SeccompProfileType string

type Service struct {
	// GeneratedName is the name generated from the process info
	GeneratedName string

	// LogFiles are the log files associated with this service
	LogFiles []string

	// GeneratedNameSource indicates the source of the generated name
	GeneratedNameSource string

	// AdditionalGeneratedNames contains other potential names for the service
	AdditionalGeneratedNames []string

	// TracerMetadata contains APM tracer metadata
	TracerMetadata []tracermetadata.TracerMetadata

	// UST contains Unified Service Tagging environment variables
	UST UST

	// TCPPorts is the list of TCP ports the service is listening on
	TCPPorts []uint16

	// UDPPorts is the list of UDP ports the service is listening on
	UDPPorts []uint16

	// APMInstrumentation indicates if the service is instrumented for APM
	APMInstrumentation bool

	// Type is the service type (e.g., "web_service")
	Type string
}

type Source string

type SubscriberPriority int

type UST struct {
	Service string
	Env     string
	Version string
}

type WorkloadDumpResponse struct {
	Entities map[string]WorkloadEntity `json:"entities"`
}

type WorkloadEntity struct {
	Infos map[string]string `json:"infos"`
}