@dx-do/client 6.0.4 → 6.1.0

package/dist/index.cjs.js

@@ -28283,6 +28283,37 @@ const TasGraphSchema = v4.z.looseObject({
     totalEdges: v4.z.number().optional(),
 });
 
+const TasStoreGraphInputSchema = v4.z.looseObject({
+    includeSuccessResult: v4.z.boolean().optional(),
+    ttl: v4.z.number().optional(),
+    endTimeAllowedThreshold: v4.z.number().optional(),
+    storeType: TasAttributeTypeSchema.optional(),
+    graph: TasGraphSchema,
+});
+const TasStoreChangeSchema = v4.z.looseObject({
+    changeType: v4.z.string().optional(),
+    id: v4.z.unknown().optional(),
+});
+const TasStoreGraphResponseSchema = v4.z.looseObject({
+    graph: TasGraphSchema.optional(),
+    failedVertices: v4.z
+        .array(v4.z.looseObject({
+        object: TasVertexSchema,
+        code: v4.z.string().optional(),
+        message: v4.z.string().optional(),
+    }))
+        .optional(),
+    failedEdges: v4.z
+        .array(v4.z.looseObject({
+        object: TasEdgeSchema,
+        code: v4.z.string().optional(),
+        message: v4.z.string().optional(),
+    }))
+        .optional(),
+    edgeChanges: v4.z.array(TasStoreChangeSchema).optional(),
+    vertexChanges: v4.z.array(TasStoreChangeSchema).optional(),
+});
+
 /**
  * Comparison operators used in the `PART` specifier for comparing
  * dot-separated source-name segments numerically or lexically.
@@ -28912,6 +28943,29 @@ const MetadataMetricQuerySchema = v4.z.looseObject({
         .describe('Optional server hints; currently supports `ForceRange`'),
 });
 
+const MetricRegisterSchema = v4.z.looseObject({
+    id: v4.z.string().optional(),
+    sourceName: v4.z.string(),
+    attributeName: v4.z.string(),
+    type: v4.z.number().optional(),
+    typeEnum: v4.z.array(v4.z.string()).optional(),
+    attributes: v4.z.record(v4.z.string(), v4.z.unknown()).optional(),
+    firstSeen: v4.z.number().optional(),
+    lastSeen: v4.z.number().optional(),
+});
+const MetricRegisterRequestSchema = v4.z.looseObject({
+    sync: v4.z.boolean().optional(),
+    metrics: v4.z.array(MetricRegisterSchema),
+});
+const MetricRegisterSourceSchema = v4.z.looseObject({
+    sourceId: v4.z.string().optional(),
+    name: v4.z.string().optional(),
+});
+const MetricRegisterResponseSchema = v4.z.looseObject({
+    metrics: v4.z.array(MetricRegisterSchema).optional(),
+    sources: v4.z.array(MetricRegisterSourceSchema).optional(),
+});
+
 const MetricAttributeSchema = v4.z.looseObject({
     id: v4.z.string().optional(),
     sourceName: v4.z.string().optional(),
@@ -45512,36 +45566,35 @@ exports.LogQuery = void 0;
         };
     }
     LogQuery.createOr = createOr;
-    function createLogQueryRequestBody(range, ors, severities = ['Error'], includes = [
+    function createLogQueryRequestBody(range, ors, severities = [], includes = [
         '_id',
         'host',
         'logseverity',
-        'logotype',
+        'logtype',
         'timestamp',
         'file',
         'message',
     ], size = 1000, sort = [{ sortKey: 'timestamp', sortOrder: 'Asc' }]) {
+        const nonEmptySeverities = severities.filter((s) => s.length > 0);
+        const severityClause = nonEmptySeverities.length > 0
+            ? [
+                {
+                    or: {
+                        expressions: nonEmptySeverities.map((severity) => ({
+                            fieldDescription: 'Log Severity',
+                            field: 'logseverity',
+                            value: severity,
+                            condition: 'equals',
+                        })),
+                    },
+                },
+            ]
+            : [];
         return {
             size,
             query: {
                 and: {
-                    expressions: [
-                        {
-                            or: {
-                                expressions: [
-                                    ...severities.map((severity) => {
-                                        return {
-                                            fieldDescription: 'Log Severity',
-                                            field: 'logseverity',
-                                            value: severity,
-                                            condition: 'equals',
-                                        };
-                                    }),
-                                ],
-                            },
-                        },
-                        ...ors,
-                    ],
+                    expressions: [...severityClause, ...ors],
                 },
             },
             includes,
@@ -61105,6 +61158,15 @@ class AgentService {
         };
         return this.dxSaaSService.tenantPost('/apm/atc/api/private/trace/summary', traceSummaryRequestBody);
     }
+    /** Posts a synthetic transaction trace to the tracestore ingestion endpoint. */
+    injectTrace(trace) {
+        return this.injectTraces([trace]);
+    }
+    /** Posts one or more synthetic transaction traces to the tracestore ingestion endpoint. */
+    injectTraces(traces) {
+        const body = { values: traces };
+        return this.dxSaaSService.tenantPost('/tracestore/process', body);
+    }
     /** Starts a trace session on one or more agents with optional filters. */
     startAgentTrace(agents, minTXDuration, sessionDuration, parameterName, operationType, parameterNotSign, parameterValue, errorFilterValue) {
         let body = {
@@ -69530,6 +69592,30 @@ class DxSaasService {
             }
         });
     }
+    /**
+     * POST to the log ingestion gateway (`dxLogIngestionURL`) without a cohort path segment.
+     * Auth uses the same `Bearer {userToken}` as other tenant methods.
+     * Throws if `dxLogIngestionURL` is not set in config.
+     */
+    async logPost(path, body) {
+        const logBase = this.dxdoConfiguration.dxConfiguration.dxLogIngestionURL;
+        if (!logBase) {
+            throw new Error('dxLogIngestionURL is not set in config — add it to your .dxo2.config.json (e.g. "https://logs-gateway.dxi-na1.saas.broadcom.com")');
+        }
+        const url = `${logBase}/${path}`;
+        this.log.debug(`log posting to: ${url}`);
+        return this._httpClient
+            .post(url, body ?? {}, this.createSimpleUserAuthorizedRequestConfig(undefined))
+            .then((response) => response.data)
+            .catch((reason) => {
+            if (reason.response || reason.request) {
+                throw DxSaasService.handleAxiosError(reason);
+            }
+            else {
+                throw new Error(reason);
+            }
+        });
+    }
     /**
      * GET from an ACC path, returning the response as a Node.js readable stream.
      * @param path - Path segment appended after `.../acc/`.
@@ -73334,12 +73420,25 @@ class JsExtensionService {
     }
 }
 
+function detectIPv4() {
+    const nets = require$$0$4.networkInterfaces();
+    for (const iface of Object.values(nets)) {
+        if (!iface)
+            continue;
+        for (const net of iface) {
+            if (net.family === 'IPv4' && !net.internal) {
+                return net.address;
+            }
+        }
+    }
+    return '127.0.0.1';
+}
 /**
- * Service for querying log analytics via the OI log filter API.
+ * Service for querying and ingesting log analytics data.
  */
 class LogsService {
     dxSaasService;
-    /** @param dxSaasService - DX SaaS HTTP client for OI POST requests */
+    /** @param dxSaasService - DX SaaS HTTP client */
     constructor(dxSaasService) {
         this.dxSaasService = dxSaasService;
     }
@@ -73347,6 +73446,56 @@ class LogsService {
     queryLogs(logQueryBody) {
         return this.dxSaasService.oiPost('oi/loganalytics/v1/api/logs/filter', logQueryBody);
     }
+    /** Ingests a single log entry into the log gateway. */
+    ingestLog(entry) {
+        return this.ingestLogs([entry]);
+    }
+    /**
+     * Builds the enriched payload array that will be sent to the uim_logs endpoint.
+     * Exposed so callers can inspect the payload without sending (e.g. dry-run).
+     */
+    buildLogPayload(entries) {
+        const cohortId = this.dxSaasService.dxdoConfiguration.dxConfiguration.cohortId;
+        const tenantIdUpper = cohortId.toUpperCase();
+        const now = new Date().toISOString();
+        return entries.map((e) => {
+            const host = e.host ?? require$$0$4.hostname();
+            const logtype = e.logtype;
+            const ip = e.ip ?? detectIPv4();
+            const agentInstance = e.agentInstance ?? 'dx-do';
+            const agentName = e.agentName ?? 'Logs Collector';
+            const containerId = e.containerId ?? host;
+            const containerName = e.containerName ?? agentInstance;
+            const file = e.file ?? 'dx-do.cli';
+            const tag = `${logtype} logs`;
+            // temp_fields must have exactly 9 space-separated components before the message
+            // is appended by the SaaS filter (agentbase_msg = temp_fields + " " + message).
+            // The Kafka consumer parses positionally: [0]=tenant [1]=logtype [2]=host
+            // [3]=container_id [4]=container_name [5]=ip [6-7]=tags [8]=source_file [9+]=message.
+            const temp_fields = `${tenantIdUpper} ${logtype} ${host} ${containerId} ${containerName} ${ip} ${tag} ${file}`;
+            return {
+                '@timestamp': now,
+                // logtype must be top-level: the SaaS filter does `update => ["type", "%{logtype}"]`
+                // which drives Kafka consumer index routing — without it type stays as "ingestionapi"
+                logtype,
+                message: e.message ?? '',
+                host: { name: host, hostname: host },
+                tenant_id: tenantIdUpper,
+                temp_fields,
+                tags: [tag],
+                __agent_name: agentName,
+                __agent_instance: agentInstance,
+                container_id: containerId,
+                container_name: containerName,
+                ...Object.fromEntries(Object.entries(e).filter(([k]) => !['logtype', 'message', 'host', 'timestamp', 'ip',
+                    'agentInstance', 'agentName', 'containerId', 'containerName', 'file'].includes(k))),
+            };
+        });
+    }
+    /** Ingests a batch of log entries into the log gateway. */
+    ingestLogs(entries) {
+        return this.dxSaasService.logPost('mdo/v2/aoanalytics/ingestion/uim_logs', this.buildLogPayload(entries));
+    }
 }
 
 /**
@@ -73806,7 +73955,11 @@ class NASSService {
         this.dxSaaSService = dxSaaSService;
         this.log = log;
     }
-    /** Registers one or more metrics in the NASS metadata store. */
+    /**
+     * @deprecated Use {@link DataStoreMetricsMetadataService.registerMetrics} instead —
+     * it accepts the full `MetricRegister[]` shape including `typeEnum`, `id`,
+     * `firstSeen`, and `lastSeen`.
+     */
     async registerMetrics(metricRegistrations) {
         const metricRegistrationBody = {
             metrics: metricRegistrations,
@@ -73866,7 +74019,9 @@ class NASSService {
         };
         return this.dxSaaSService.tenantPost('/metadata/queryMetric', metadataQuery);
     }
-    /** Registers a single metric with the given source/attribute name, type, and custom attributes. */
+    /**
+     * @deprecated Use {@link DataStoreMetricsMetadataService.registerMetric} instead.
+     */
     async registerMetric(sourceName, attributeName, metricType, attributes) {
         const metricRegistrationBody = {
             metrics: [
@@ -73880,7 +74035,11 @@ class NASSService {
         };
         return this.dxSaaSService.tenantPost('/metadata/registerMetric', metricRegistrationBody);
     }
-    /** Stores one or more metric values in the NASS metric value store. */
+    /**
+     * @deprecated Use {@link DataStoreNASSService.storeMetricValues} instead — it
+     * accepts typed {@link NassDatapoint} tuples covering regular, string, and
+     * extension metric variants, and returns a typed {@link NassStoreResponse}.
+     */
     async storeMetricValue(metricValues) {
         const metricStoreBody = { values: new Array() };
         metricValues.forEach((metricValue) => metricStoreBody.values.push([
@@ -74880,7 +75039,11 @@ class TASService {
         this.dxSaaSService = dxSaaSService;
         this.log = log;
     }
-    /** Stores a graph (vertices and edges) in the TAS topology store. */
+    /**
+     * @deprecated Use {@link DataStoreTASService.storeGraph} instead — it accepts
+     * the full `TasStoreGraphInput` model with all optional fields and returns a
+     * typed `TasStoreGraphResponse` with `failedVertices`/`failedEdges`.
+     */
     async storeGraph(graphBody) {
         this.log.debug('storing');
         return this.dxSaaSService.tenantPost('/tas/graph/store', graphBody);
@@ -76138,6 +76301,32 @@ class DataStoreMetricsMetadataService {
         this.dxSaasService = dxSaasService;
         this.log = log;
     }
+    /**
+     * Registers one or more metrics via `POST /metadata/registerMetric`.
+     *
+     * @remarks The request is validated against {@link MetricRegisterRequestSchema}.
+     *   If the response fails schema validation, a warning is logged but the raw
+     *   API response is still returned.
+     *
+     * @throws ZodError if the request fails schema validation.
+     */
+    async registerMetrics(metrics, sync) {
+        const body = {
+            metrics,
+            ...(sync !== undefined ? { sync } : {}),
+        };
+        MetricRegisterRequestSchema.parse(body);
+        const raw = await this.dxSaasService.tenantPost('metadata/registerMetric', body);
+        const result = MetricRegisterResponseSchema.safeParse(raw);
+        if (!result.success) {
+            this.log.warn('MetricRegisterResponse validation warning:', result.error.message);
+        }
+        return raw;
+    }
+    /** Registers a single metric. Convenience wrapper around {@link registerMetrics}. */
+    async registerMetric(metric, sync) {
+        return this.registerMetrics([metric], sync);
+    }
     /**
      * POSTs a metadata query to `/metadata/queryMetric` and returns the matching
      * metric / folder records.
@@ -76483,6 +76672,25 @@ class DataStoreTASService {
         this.dxSaasService = dxSaasService;
         this.log = log;
     }
+    /**
+     * POSTs a graph to `/tas/graph/store` and returns the store result including
+     * any failed vertices or edges.
+     *
+     * @remarks The request is validated against {@link TasStoreGraphInputSchema}.
+     *   If the response fails schema validation, a warning is logged but the raw
+     *   API response is still returned.
+     *
+     * @throws ZodError if the request fails schema validation.
+     */
+    async storeGraph(input) {
+        TasStoreGraphInputSchema.parse(input);
+        const raw = await this.dxSaasService.tenantPost('tas/graph/store', input);
+        const result = TasStoreGraphResponseSchema.safeParse(raw);
+        if (!result.success) {
+            this.log.warn('TasStoreGraphResponse validation warning:', result.error.message);
+        }
+        return raw;
+    }
     /**
      * POSTs a TAS graph query to `/tas/graph/query` and returns the resulting
      * graph (vertices, edges, states).
@@ -76966,6 +77174,50 @@ class DataStoreTokensService {
     }
 }
 
+/**
+ * Service for storing metric data points in the DX SaaS DataStore NASS API
+ * (`POST /nass/metricValue/store`).
+ *
+ * Metrics must be registered first via
+ * {@link DataStoreMetricsMetadataService.registerMetric} before values can be
+ * stored. Use the metric's `id` from the registration response as the first
+ * element of each {@link NassDatapoint} tuple.
+ *
+ * Three datapoint variants are supported — see {@link NassDatapoint}:
+ * - **Regular** numeric: `[id, time, min, max, value, count, interval?]`
+ * - **String** metric: same shape but `min` and `max` must be `null`
+ * - **Extension**: `[id, extensionId, time, interval, ...values]`
+ *
+ * @example
+ * ```ts
+ * const service = new DataStoreNASSService(dxSaasService, log);
+ * const response = await service.storeMetricValues([
+ *   ['metricId', Date.now() / 1000, 0, 100, 42, 1, 15],
+ *   ['strMetricId', Date.now() / 1000, null, null, 'running', 1, 15],
+ * ]);
+ * // response.metricForwardFailures — count of failed forwarding (only present if > 0)
+ * ```
+ */
+class DataStoreNASSService {
+    dxSaasService;
+    log;
+    constructor(dxSaasService, log) {
+        this.dxSaasService = dxSaasService;
+        this.log = log;
+    }
+    /**
+     * POSTs one or more metric datapoints to `/nass/metricValue/store`.
+     *
+     * @param values - Array of {@link NassDatapoint} tuples. Each tuple must
+     *   begin with a registered metric ID obtained from
+     *   {@link DataStoreMetricsMetadataService.registerMetric}.
+     */
+    async storeMetricValues(values) {
+        const body = { values };
+        return this.dxSaasService.tenantPost('nass/metricValue/store', body);
+    }
+}
+
 var NullSimpleLog = Logging.NullSimpleLog;
 /**
  * Creates and returns a container of all DX client services (ACC, alerts, alarms,
@@ -76997,6 +77249,7 @@ function createServiceMonolith(dxDoConfiguration, log = new NullSimpleLog()) {
         dxChannelService: new ChannelService(dxSaaSService),
         dxDashboardService: new DashboardService(dxSaaSService),
         dxDataStoreMetricsMetadataService: new DataStoreMetricsMetadataService(dxSaaSService, log),
+        dxDataStoreNASSService: new DataStoreNASSService(dxSaaSService, log),
         dxDataStoreNASSQLService: new DataStoreNASSQLService(dxSaaSService, log),
         dxDataStoreTASService: new DataStoreTASService(dxSaaSService, log),
         dxEventService: new EventService(dxSaaSService, log),
@@ -77069,6 +77322,7 @@ exports.DataStoreBlobStorageService = DataStoreBlobStorageService;
 exports.DataStoreFeaturesService = DataStoreFeaturesService;
 exports.DataStoreMetricsMetadataService = DataStoreMetricsMetadataService;
 exports.DataStoreNASSQLService = DataStoreNASSQLService;
+exports.DataStoreNASSService = DataStoreNASSService;
 exports.DataStoreStatesService = DataStoreStatesService;
 exports.DataStoreTASService = DataStoreTASService;
 exports.DataStoreTokensService = DataStoreTokensService;
@@ -77103,6 +77357,10 @@ exports.MetricAttributeSchema = MetricAttributeSchema;
 exports.MetricBatchService = MetricBatchService;
 exports.MetricFolderSchema = MetricFolderSchema;
 exports.MetricGroupingService = MetricGroupingService;
+exports.MetricRegisterRequestSchema = MetricRegisterRequestSchema;
+exports.MetricRegisterResponseSchema = MetricRegisterResponseSchema;
+exports.MetricRegisterSchema = MetricRegisterSchema;
+exports.MetricRegisterSourceSchema = MetricRegisterSourceSchema;
 exports.MetricTypeEnumNameSchema = MetricTypeEnumNameSchema;
 exports.NASSService = NASSService;
 exports.NassValueTypeSchema = NassValueTypeSchema;
@@ -77203,6 +77461,9 @@ exports.TasProjectionFilterSchema = TasProjectionFilterSchema;
 exports.TasQuerySchema = TasQuerySchema;
 exports.TasServiceFilterSchema = TasServiceFilterSchema;
 exports.TasStatusFilterSchema = TasStatusFilterSchema;
+exports.TasStoreChangeSchema = TasStoreChangeSchema;
+exports.TasStoreGraphInputSchema = TasStoreGraphInputSchema;
+exports.TasStoreGraphResponseSchema = TasStoreGraphResponseSchema;
 exports.TasTakeEdgesFilterSchema = TasTakeEdgesFilterSchema;
 exports.TasTakeFlowsFilterSchema = TasTakeFlowsFilterSchema;
 exports.TasTakeVerticesFilterSchema = TasTakeVerticesFilterSchema;