@odigos/ui-kit 0.0.9 → 0.0.11-1.patch-dev.361

package/lib/types/config/index.d.ts

@@ -0,0 +1,80 @@
+import { ProgrammingLanguages } from '..';
+export declare enum Profile {
+    CodeAttributes = "code-attributes",
+    FullPayloadCollection = "full-payload-collection",
+    DbPayloadCollection = "db-payload-collection",
+    QueryOperationDetector = "query-operation-detector",
+    AllowConcurrentAgents = "allow_concurrent_agents",
+    JavaEbpfInstrumentations = "java-ebpf-instrumentations",
+    JavaNativeInstrumentations = "java-native-instrumentations",
+    SizeS = "size_s",
+    SizeM = "size_m",
+    SizeL = "size_l"
+}
+export declare enum MountMethod {
+    VirtualDevice = "VirtualDevice",
+    HostPath = "HostPath",
+    InitContainer = "InitContainer"
+}
+export declare enum AgentEnvVarsInjectionMethod {
+    Loader = "loader",
+    PodManifest = "pod-manifest",
+    LoaderFallbackToPodManifest = "loader-fallback-to-pod-manifest"
+}
+export interface CollectorNode {
+    collectorOwnMetricsPort: number;
+    requestMemoryMiB: number;
+    limitMemoryMiB: number;
+    requestCPUm: number;
+    limitCPUm: number;
+    memoryLimiterLimitMiB: number;
+    memoryLimiterSpikeLimitMiB: number;
+    goMemLimitMiB: number;
+    k8sNodeLogsDirectory: string;
+}
+export interface CollectorGateway extends Omit<CollectorNode, 'collectorOwnMetricsPort' | 'k8sNodeLogsDirectory'> {
+    minReplicas: number;
+    maxReplicas: number;
+}
+export interface UserInstrumentationEnvsLanguage {
+    enabled: boolean;
+    env: {
+        [key: string]: string;
+    };
+}
+export interface UserInstrumentationEnvs {
+    languages: {
+        [key in ProgrammingLanguages]?: UserInstrumentationEnvsLanguage;
+    };
+}
+export interface RolloutConfiguration {
+    automaticRolloutDisabled: boolean;
+}
+export interface OidcConfiguration {
+    tenantUrl: string;
+    clientId: string;
+    clientSecret: string;
+}
+export interface OdigosConfig {
+    karpenterEnabled: boolean | null;
+    allowConcurrentAgents: boolean | null;
+    uiPaginationLimit: number | null;
+    centralBackendURL: string | null;
+    oidc: OidcConfiguration | null;
+    clusterName: string | null;
+    imagePrefix: string | null;
+    ignoredNamespaces: string[] | null;
+    ignoredContainers: string[] | null;
+    profiles: Profile[] | null;
+    mountMethod: MountMethod | null;
+    agentEnvVarsInjectionMethod: AgentEnvVarsInjectionMethod | null;
+    customContainerRuntimeSocketPath: string | null;
+    odigletHealthProbeBindPort: number | null;
+    rollbackDisabled: boolean | null;
+    rollbackGraceTime: string | null;
+    rollbackStabilityWindow: string | null;
+    nodeSelector: Record<string, string> | null;
+    rollout: RolloutConfiguration | null;
+    collectorNode: CollectorNode | null;
+    collectorGateway: CollectorGateway | null;
+}

package/lib/types/data-flow/index.d.ts

@@ -1,18 +1,20 @@
-export declare enum NODE_TYPES {
-    HEADER = "header",
-    ADD = "add",
-    BASE = "base",
-    EDGED = "edged",
-    FRAME = "frame",
-    SCROLL = "scroll",
-    SKELETON = "skeleton"
+export declare enum NodeTypes {
+    Header = "header",
+    Add = "add",
+    Base = "base",
+    Edged = "edged",
+    Frame = "frame",
+    Scroll = "scroll",
+    Skeleton = "skeleton",
+    MapItem = "map-item",
+    NoData = "no-data"
 }
-export declare enum EDGE_TYPES {
-    LABELED = "labeled"
+export declare enum EdgeTypes {
+    Labeled = "labeled"
 }
-export declare enum ADD_NODE_TYPES {
-    ADD_RULE = "addRule",
-    ADD_SOURCE = "addSource",
-    ADD_ACTION = "addAction",
-    ADD_DESTINATION = "addDestination"
+export declare enum AddNodeTypes {
+    AddRule = "addRule",
+    AddSource = "addSource",
+    AddAction = "addAction",
+    AddDestination = "addDestination"
 }

package/lib/types/data-streams/index.d.ts

@@ -0,0 +1,3 @@
+export interface DataStream {
+    name: string;
+}

package/lib/types/describe/index.d.ts

@@ -1,4 +1,4 @@
-interface EntityProperty {
+export interface EntityProperty {
     name: string;
     value: string;
     status?: string | null;
@@ -68,20 +68,24 @@ interface OtelAgentsAnalyze {
     createTime?: EntityProperty | null;
     containers: ContainerAgentConfigAnalyze[];
 }
-interface InstrumentationInstanceAnalyze {
+export interface InstrumentationInstanceAnalyze {
     healthy: EntityProperty;
     message?: EntityProperty | null;
     identifyingAttributes?: EntityProperty[];
 }
-interface PodContainerAnalyze {
+export interface PodContainerAnalyze {
     containerName: EntityProperty;
     actualDevices: EntityProperty;
+    started?: EntityProperty | null;
+    ready?: EntityProperty | null;
     instrumentationInstances: InstrumentationInstanceAnalyze[];
 }
 interface PodAnalyze {
     podName: EntityProperty;
     nodeName: EntityProperty;
     phase: EntityProperty;
+    agentInjected: EntityProperty;
+    runningLatestWorkloadRevision?: EntityProperty | null;
     containers: PodContainerAnalyze[];
 }
 export interface DescribeSource {

package/lib/types/destinations/index.d.ts

@@ -1,9 +1,78 @@
-import type { Comparison } from '@/functions';
 import type { DropdownProps } from '@/components';
-import { type Condition, FIELD_TYPES } from '../common';
+import { type Condition, FieldTypes, SVG } from '../common';
+export declare enum DestinationTypes {
+    Alauda = "alauda",
+    AlibabaCloud = "alibabacloud",
+    AppDynamics = "appdynamics",
+    Axiom = "axiom",
+    AzureBlob = "azureblob",
+    BetterStack = "betterstack",
+    Bonree = "bonree",
+    Causely = "causely",
+    Checkly = "checkly",
+    Chronosphere = "chronosphere",
+    ClickHouse = "clickhouse",
+    CloudWatch = "cloudwatch",
+    Coralogix = "coralogix",
+    Dash0 = "dash0",
+    Datadog = "datadog",
+    Dynamic = "dynamic",
+    Dynatrace = "dynatrace",
+    ElasticApm = "elasticapm",
+    ElasticSearch = "elasticsearch",
+    GoogleCloud = "googlecloud",
+    GoogleCloudOTLP = "googlecloudotlp",
+    GrafanaCloudLoki = "grafanacloudloki",
+    GrafanaCloudPrometheus = "grafanacloudprometheus",
+    GrafanaCloudTempo = "grafanacloudtempo",
+    Greptime = "greptime",
+    Groundcover = "groundcover",
+    Honeycomb = "honeycomb",
+    HyperDX = "hyperdx",
+    Instana = "instana",
+    Jaeger = "jaeger",
+    Kafka = "kafka",
+    Kloudmate = "kloudmate",
+    Last9 = "last9",
+    Lightstep = "lightstep",
+    LogzIo = "logzio",
+    Loki = "loki",
+    Lumigo = "lumigo",
+    Middleware = "middleware",
+    NewRelic = "newrelic",
+    Observe = "observe",
+    Odigos = "odigos",
+    OneUptime = "oneuptime",
+    OpenObserve = "openobserve",
+    Opsverse = "opsverse",
+    Oracle = "oracle",
+    OTLP = "otlp",
+    OTLPHttp = "otlphttp",
+    Prometheus = "prometheus",
+    Qryn = "qryn",
+    QrynOss = "qryn-oss",
+    Quickwit = "quickwit",
+    S3 = "s3",
+    Seq = "seq",
+    Signoz = "signoz",
+    Splunk = "splunk",
+    SplunkSapm = "splunksapm",
+    SplunkOtlp = "splunkotlp",
+    SumoLogic = "sumologic",
+    TelemetryHub = "telemetryhub",
+    Tempo = "tempo",
+    Tingyun = "tingyun",
+    Traceloop = "traceloop",
+    Uptrace = "uptrace",
+    VictoriaMetrics = "victoriametrics",
+    VictoriaMetricsCloud = "victoriametricscloud",
+    XRay = "xray"
+}
 export interface Destination {
     id: string;
     name: string;
+    disabled: boolean;
+    dataStreamNames: string[];
     exportedSignals: {
         traces: boolean;
         metrics: boolean;
@@ -12,9 +81,8 @@ export interface Destination {
     fields: string;
     conditions: Condition[] | null;
     destinationType: {
-        type: string;
+        type: DestinationTypes;
         displayName: string;
-        imageUrl: string;
         supportedSignals: {
             logs: {
                 supported: boolean;
@@ -28,10 +96,12 @@ export interface Destination {
         };
     };
 }
-type YamlCompareArr = [string, Comparison, string] | ['true' | 'false'];
+export type ComparisonStrings = '===' | '==' | '!==' | '!=' | '>' | '<' | '>=' | '<=';
+export type ComparisonArrays = 'INCLUDES' | 'EXCLUDES';
+export type YamlCompareArr = [string | 'SIGNALS', ComparisonStrings | ComparisonArrays, string] | ['true' | 'false'];
 export interface DestinationYamlProperties {
     name: string;
-    componentType: FIELD_TYPES;
+    componentType: FieldTypes;
     componentProperties?: string;
     displayName?: string;
     secret?: boolean;
@@ -45,26 +115,30 @@ export interface DestinationYamlProperties {
     }[];
 }
 export interface DestinationOption {
+    id?: string;
+    selected?: boolean;
     type: Destination['destinationType']['type'];
     displayName: Destination['destinationType']['displayName'];
-    imageUrl: Destination['destinationType']['imageUrl'];
     supportedSignals: Destination['destinationType']['supportedSignals'];
     testConnectionSupported: boolean;
     fields: DestinationYamlProperties[];
 }
 export type DestinationCategories = {
-    name: 'managed' | 'self hosted';
+    icon?: SVG;
+    name: string;
     description: string;
     items: DestinationOption[];
 }[];
 export interface DestinationFormData {
     type: Destination['destinationType']['type'];
     name: Destination['destinationType']['displayName'];
+    currentStreamName: string;
     exportedSignals: Destination['exportedSignals'];
     fields: {
         key: string;
         value: string;
     }[];
+    disabled: Destination['disabled'];
 }
 export interface DestinationDynamicField {
     name: DestinationYamlProperties['name'];
@@ -77,4 +151,10 @@ export interface DestinationDynamicField {
     placeholder?: string;
     options?: DropdownProps['options'];
 }
-export {};
+export interface TestConnectionResponse {
+    succeeded: boolean;
+    message: string;
+    reason: string;
+    destinationType?: DestinationTypes;
+}
+export type TestConnectionFunc = (payload: DestinationFormData) => Promise<TestConnectionResponse | undefined>;

package/lib/types/index.d.ts

@@ -1,12 +1,16 @@
 export * from './actions';
 export * from './common';
-export * from './connection';
+export * from './config';
 export * from './data-flow';
+export * from './data-streams';
 export * from './describe';
 export * from './destinations';
+export * from './instrumentation-instances';
 export * from './instrumentation-rules';
 export * from './metrics';
 export * from './namespaces';
+export * from './service-map';
 export * from './signals';
 export * from './sources';
 export * from './tokens';
+export * from './traces';

package/lib/types/instrumentation-instances/index.d.ts

@@ -0,0 +1,7 @@
+export interface InstrumentationInstanceComponent {
+    name: string;
+    nonIdentifyingAttributes: {
+        key: string;
+        value: string;
+    }[];
+}

package/lib/types/instrumentation-rules/index.d.ts

@@ -1,14 +1,16 @@
-import type { SVG } from '../common';
 import type { WorkloadId } from '../sources';
-export declare enum INSTRUMENTATION_RULE_TYPE {
-    PAYLOAD_COLLECTION = "PayloadCollection",
-    CODE_ATTRIBUTES = "CodeAttributes",
-    UNKNOWN_TYPE = "UnknownType"
+import type { ProgrammingLanguages, SVG } from '../common';
+export declare enum InstrumentationRuleType {
+    CodeAttributes = "CodeAttributes",
+    HeadersCollection = "HeadersCollection",
+    PayloadCollection = "PayloadCollection",
+    CustomInstrumentation = "CustomInstrumentation",
+    UnknownType = "UnknownType"
 }
 export interface InstrumentationRule {
     ruleId: string;
     ruleName: string;
-    type: INSTRUMENTATION_RULE_TYPE;
+    type: InstrumentationRuleType;
     notes: string;
     disabled: boolean;
     mutable: boolean;
@@ -18,8 +20,50 @@ export interface InstrumentationRule {
         language: string;
         library: string;
     }[] | null;
-    payloadCollection?: PayloadCollection | null;
     codeAttributes?: CodeAttributes | null;
+    headersCollection?: HeadersCollection | null;
+    payloadCollection?: PayloadCollection | null;
+    customInstrumentations?: CustomInstrumentations | null;
+}
+export declare enum CodeAttributesKeyTypes {
+    Column = "column",
+    FilePath = "filePath",
+    Function = "function",
+    LineNumber = "lineNumber",
+    Namespace = "namespace",
+    StackTrace = "stacktrace"
+}
+export interface CodeAttributes {
+    [CodeAttributesKeyTypes.Column]?: boolean | null;
+    [CodeAttributesKeyTypes.FilePath]?: boolean | null;
+    [CodeAttributesKeyTypes.Function]?: boolean | null;
+    [CodeAttributesKeyTypes.LineNumber]?: boolean | null;
+    [CodeAttributesKeyTypes.Namespace]?: boolean | null;
+    [CodeAttributesKeyTypes.StackTrace]?: boolean | null;
+}
+export declare enum HeadersCollectionKeyTypes {
+    HeaderKeys = "headerKeys"
+}
+export interface HeadersCollection {
+    [HeadersCollectionKeyTypes.HeaderKeys]?: string[] | null;
+}
+export declare enum CustomInstrumentationsKeyTypes {
+    Java = "java",
+    Golang = "golang"
+}
+export interface JavaCustomProbe {
+    className: string;
+    methodName: string;
+}
+export interface GolangCustomProbe {
+    packageName: string;
+    functionName: string | null;
+    receiverName?: string | null;
+    receiverMethodName?: string | null;
+}
+export interface CustomInstrumentations {
+    [CustomInstrumentationsKeyTypes.Java]?: JavaCustomProbe[] | null;
+    [CustomInstrumentationsKeyTypes.Golang]?: GolangCustomProbe[] | null;
 }
 interface HttpPayloadCollection {
     mimeTypes?: string[] | null;
@@ -34,41 +78,26 @@ interface MessagingPayloadCollection {
     maxPayloadLength?: number | null;
     dropPartialPayloads?: boolean | null;
 }
-export declare enum PAYLOAD_COLLECTION_KEY_TYPES {
-    HTTP_REQUEST = "httpRequest",
-    HTTP_RESPONSE = "httpResponse",
-    DB_QUERY = "dbQuery",
-    MESSAGING = "messaging"
+export declare enum PayloadCollectionKeyTypes {
+    HttpRequest = "httpRequest",
+    HttpResponse = "httpResponse",
+    DbQuery = "dbQuery",
+    Messaging = "messaging"
 }
 export interface PayloadCollection {
-    [PAYLOAD_COLLECTION_KEY_TYPES.HTTP_REQUEST]?: HttpPayloadCollection | null;
-    [PAYLOAD_COLLECTION_KEY_TYPES.HTTP_RESPONSE]?: HttpPayloadCollection | null;
-    [PAYLOAD_COLLECTION_KEY_TYPES.DB_QUERY]?: DbQueryPayloadCollection | null;
-    [PAYLOAD_COLLECTION_KEY_TYPES.MESSAGING]?: MessagingPayloadCollection | null;
-}
-export declare enum CODE_ATTRIBUTES_KEY_TYPES {
-    COLUMN = "column",
-    FILE_PATH = "filePath",
-    FUNCTION = "function",
-    LINE_NUMBER = "lineNumber",
-    NAMESPACE = "namespace",
-    STACKTRACE = "stacktrace"
-}
-export interface CodeAttributes {
-    [CODE_ATTRIBUTES_KEY_TYPES.COLUMN]?: boolean | null;
-    [CODE_ATTRIBUTES_KEY_TYPES.FILE_PATH]?: boolean | null;
-    [CODE_ATTRIBUTES_KEY_TYPES.FUNCTION]?: boolean | null;
-    [CODE_ATTRIBUTES_KEY_TYPES.LINE_NUMBER]?: boolean | null;
-    [CODE_ATTRIBUTES_KEY_TYPES.NAMESPACE]?: boolean | null;
-    [CODE_ATTRIBUTES_KEY_TYPES.STACKTRACE]?: boolean | null;
+    [PayloadCollectionKeyTypes.HttpRequest]?: HttpPayloadCollection | null;
+    [PayloadCollectionKeyTypes.HttpResponse]?: HttpPayloadCollection | null;
+    [PayloadCollectionKeyTypes.DbQuery]?: DbQueryPayloadCollection | null;
+    [PayloadCollectionKeyTypes.Messaging]?: MessagingPayloadCollection | null;
 }
 export interface InstrumentationRuleOption {
-    type: INSTRUMENTATION_RULE_TYPE;
+    type: InstrumentationRuleType;
     icon: SVG;
     label: string;
-    description?: string;
-    docsEndpoint?: string;
-    docsDescription?: string;
+    description: string;
+    docsEndpoint: string;
+    docsDescription: string;
+    supportedLanguages: ProgrammingLanguages[];
 }
 export type InstrumentationRuleFormData = Omit<InstrumentationRule, 'ruleId' | 'type' | 'mutable' | 'profileName'>;
 export {};

package/lib/types/namespaces/index.d.ts

@@ -2,5 +2,19 @@ import type { Source } from '../sources';
 export interface Namespace {
     name: string;
     selected: boolean;
+    dataStreamNames: string[];
     sources?: Source[];
 }
+export type FetchSingleNamespace = (payload: {
+    variables: {
+        namespaceName: string;
+    };
+}) => Promise<{
+    loading: boolean;
+    error?: string;
+    data?: {
+        computePlatform?: {
+            k8sActualNamespace?: Namespace;
+        };
+    };
+}>;

package/lib/types/service-map/index.d.ts

@@ -0,0 +1,10 @@
+export interface ServiceMapFromSource {
+    serviceName: string;
+    services: ServiceMapToSource[];
+}
+export interface ServiceMapToSource {
+    serviceName: string;
+    requests: number;
+    dateTime: string;
+}
+export type ServiceMapSources = ServiceMapFromSource[];

package/lib/types/signals/index.d.ts

@@ -1,9 +1,9 @@
-export declare enum SIGNAL_TYPE {
-    LOGS = "logs",
-    METRICS = "metrics",
-    TRACES = "traces"
+export declare enum SignalType {
+    Logs = "logs",
+    Metrics = "metrics",
+    Traces = "traces"
 }
 export interface MonitorsOption {
-    id: SIGNAL_TYPE;
+    id: SignalType;
     value: string;
 }

package/lib/types/sources/index.d.ts

@@ -1,33 +1,55 @@
-import { type Condition, PROGRAMMING_LANGUAGES } from '../common';
-export declare enum K8S_RESOURCE_KIND {
-    DEPLOYMENT = "Deployment",
-    DAEMON_SET = "DaemonSet",
-    STATEFUL_SET = "StatefulSet"
+import { type Condition, ProgrammingLanguages } from '../common';
+import type { NamespaceSelectionFormData, SourceSelectionFormData } from '@/store';
+export declare enum K8sResourceKind {
+    Deployment = "Deployment",
+    DaemonSet = "DaemonSet",
+    StatefulSet = "StatefulSet",
+    CronJob = "CronJob"
+}
+export declare enum OdigosHealthStatus {
+    Error = "Error",
+    Failure = "Failure",
+    Notice = "Notice",
+    Pending = "Pending",
+    Waiting = "Waiting",
+    Unsupported = "Unsupported",
+    Disabled = "Disabled",
+    Success = "Success",
+    Irrelevant = "Irrelevant",
+    Unknown = "Unknown"
 }
 export interface WorkloadId {
     namespace: string;
     name: string;
-    kind: K8S_RESOURCE_KIND | '';
+    kind: K8sResourceKind | '';
+}
+export interface SourceContainer {
+    containerName: string;
+    language: ProgrammingLanguages;
+    runtimeVersion: string;
+    overriden?: boolean;
+    instrumented: boolean;
+    instrumentationMessage: string;
+    otelDistroName: string | null;
 }
 export interface Source extends WorkloadId {
     selected: boolean;
     otelServiceName: string;
     numberOfInstances?: number;
-    containers: {
-        containerName: string;
-        language: PROGRAMMING_LANGUAGES;
-        runtimeVersion: string;
-        instrumented: boolean;
-        instrumentationMessage: string;
-        otelDistroName: string | null;
-    }[] | null;
+    dataStreamNames: string[];
+    containers: SourceContainer[] | null;
     conditions: Condition[] | null;
+    workloadOdigosHealthStatus?: {
+        status: OdigosHealthStatus;
+        reasonEnum: string;
+        message: string;
+    } | null;
 }
 export interface SourceFormData {
-    otelServiceName: string;
+    otelServiceName?: string;
+    currentStreamName?: string;
+    containerName?: string;
+    language?: ProgrammingLanguages | null;
+    version?: string;
 }
-export type PersistSources = (selectAppsList: {
-    [namespace: string]: Pick<Source, 'name' | 'kind' | 'selected'>[];
-}, futureSelectAppsList: {
-    [namespace: string]: boolean;
-}) => void;
+export type PersistSources = (selectAppsList: SourceSelectionFormData, futureSelectAppsList: NamespaceSelectionFormData) => void;

package/lib/types/traces/index.d.ts

@@ -0,0 +1,38 @@
+interface TraceTag {
+    key: string;
+    type: string;
+    value: string;
+}
+interface TraceReference {
+    refType: string;
+    traceID: string;
+    spanID: string;
+}
+export interface TraceLog {
+    timestamp: number;
+    fields: TraceTag[];
+}
+export interface TraceSpan {
+    traceID: string;
+    spanID: string;
+    operationName: string;
+    references: TraceReference[];
+    startTime: number;
+    duration: number;
+    tags: TraceTag[];
+    logs: TraceLog[];
+    processID: string;
+    warnings: string;
+    spans?: TraceSpan[];
+}
+export interface TraceProcess {
+    serviceName: string;
+    tags: TraceTag[];
+}
+export interface Trace {
+    traceID: string;
+    spans: TraceSpan[];
+    processes: TraceProcess[];
+    warnings: string;
+}
+export {};