@oneuptime/common 10.0.30 → 10.0.33

package/Server/Services/LogAggregationService.ts

@@ -5,6 +5,7 @@ import { JSONObject } from "../../Types/JSON";
 import ObjectID from "../../Types/ObjectID";
 import BadDataException from "../../Types/Exception/BadDataException";
 import Includes from "../../Types/BaseDatabase/Includes";
+import AnalyticsTableName from "../../Types/AnalyticsDatabase/AnalyticsTableName";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import { DbJSONResponse, Results } from "./AnalyticsDatabaseService";
 
@@ -82,7 +83,7 @@ export interface AnalyticsTableRow {
 
 export class LogAggregationService {
   private static readonly DEFAULT_FACET_LIMIT: number = 500;
-  private static readonly TABLE_NAME: string = "LogItem";
+  private static readonly TABLE_NAME: string = AnalyticsTableName.Log;
   private static readonly TOP_LEVEL_COLUMNS: Set<string> = new Set([
     "severityText",
     "serviceId",
@@ -641,6 +642,242 @@ export class LogAggregationService {
     }
   }
 
+  @CaptureSpan()
+  public static async getExportLogs(request: {
+    projectId: ObjectID;
+    startTime: Date;
+    endTime: Date;
+    limit: number;
+    serviceIds?: Array<ObjectID> | undefined;
+    severityTexts?: Array<string> | undefined;
+    bodySearchText?: string | undefined;
+    traceIds?: Array<string> | undefined;
+    spanIds?: Array<string> | undefined;
+  }): Promise<Array<JSONObject>> {
+    const maxLimit: number = Math.min(request.limit || 10000, 10000);
+
+    const statement: Statement = SQL`
+      SELECT
+        time,
+        serviceId,
+        severityText,
+        severityNumber,
+        body,
+        traceId,
+        spanId,
+        attributes
+      FROM ${LogAggregationService.TABLE_NAME}
+      WHERE projectId = ${{
+        type: TableColumnType.ObjectID,
+        value: request.projectId,
+      }}
+        AND time >= ${{
+          type: TableColumnType.Date,
+          value: request.startTime,
+        }}
+        AND time <= ${{
+          type: TableColumnType.Date,
+          value: request.endTime,
+        }}
+    `;
+
+    LogAggregationService.appendCommonFilters(statement, request);
+
+    statement.append(
+      SQL` ORDER BY time DESC LIMIT ${{
+        type: TableColumnType.Number,
+        value: maxLimit,
+      }}`,
+    );
+
+    const dbResult: Results = await LogDatabaseService.executeQuery(statement);
+    const response: DbJSONResponse = await dbResult.json<{
+      data?: Array<JSONObject>;
+    }>();
+
+    return response.data || [];
+  }
+
+  @CaptureSpan()
+  public static async getLogContext(request: {
+    projectId: ObjectID;
+    serviceId: ObjectID;
+    time: Date;
+    logId: string;
+    count: number;
+  }): Promise<{ before: Array<JSONObject>; after: Array<JSONObject> }> {
+    const count: number = Math.min(request.count || 5, 20);
+
+    const beforeStatement: Statement = SQL`
+      SELECT
+        _id,
+        time,
+        timeUnixNano,
+        serviceId,
+        severityText,
+        severityNumber,
+        body,
+        traceId,
+        spanId,
+        attributes
+      FROM ${LogAggregationService.TABLE_NAME}
+      WHERE projectId = ${{
+        type: TableColumnType.ObjectID,
+        value: request.projectId,
+      }}
+        AND serviceId = ${{
+          type: TableColumnType.ObjectID,
+          value: request.serviceId,
+        }}
+        AND time <= ${{
+          type: TableColumnType.Date,
+          value: request.time,
+        }}
+        AND _id != ${{
+          type: TableColumnType.Text,
+          value: request.logId,
+        }}
+      ORDER BY time DESC, timeUnixNano DESC
+      LIMIT ${{
+        type: TableColumnType.Number,
+        value: count,
+      }}
+    `;
+
+    const afterStatement: Statement = SQL`
+      SELECT
+        _id,
+        time,
+        timeUnixNano,
+        serviceId,
+        severityText,
+        severityNumber,
+        body,
+        traceId,
+        spanId,
+        attributes
+      FROM ${LogAggregationService.TABLE_NAME}
+      WHERE projectId = ${{
+        type: TableColumnType.ObjectID,
+        value: request.projectId,
+      }}
+        AND serviceId = ${{
+          type: TableColumnType.ObjectID,
+          value: request.serviceId,
+        }}
+        AND time >= ${{
+          type: TableColumnType.Date,
+          value: request.time,
+        }}
+        AND _id != ${{
+          type: TableColumnType.Text,
+          value: request.logId,
+        }}
+      ORDER BY time ASC, timeUnixNano ASC
+      LIMIT ${{
+        type: TableColumnType.Number,
+        value: count,
+      }}
+    `;
+
+    const [beforeResult, afterResult] = await Promise.all([
+      LogDatabaseService.executeQuery(beforeStatement),
+      LogDatabaseService.executeQuery(afterStatement),
+    ]);
+
+    const beforeResponse: DbJSONResponse = await beforeResult.json<{
+      data?: Array<JSONObject>;
+    }>();
+    const afterResponse: DbJSONResponse = await afterResult.json<{
+      data?: Array<JSONObject>;
+    }>();
+
+    const beforeRows: Array<JSONObject> = (beforeResponse.data || []).reverse();
+    const afterRows: Array<JSONObject> = afterResponse.data || [];
+
+    return { before: beforeRows, after: afterRows };
+  }
+
+  @CaptureSpan()
+  public static async getDropFilterEstimate(request: {
+    projectId: ObjectID;
+    startTime: Date;
+    endTime: Date;
+    filterQuery: string;
+    serviceIds?: Array<ObjectID> | undefined;
+    severityTexts?: Array<string> | undefined;
+    bodySearchText?: string | undefined;
+  }): Promise<{
+    totalLogs: number;
+    matchingLogs: number;
+    estimatedReductionPercent: number;
+  }> {
+    // Get total count
+    const totalStatement: Statement = SQL`
+      SELECT count() AS cnt
+      FROM ${LogAggregationService.TABLE_NAME}
+      WHERE projectId = ${{
+        type: TableColumnType.ObjectID,
+        value: request.projectId,
+      }}
+        AND time >= ${{
+          type: TableColumnType.Date,
+          value: request.startTime,
+        }}
+        AND time <= ${{
+          type: TableColumnType.Date,
+          value: request.endTime,
+        }}
+    `;
+
+    LogAggregationService.appendCommonFilters(totalStatement, request);
+
+    // Get matching count using the filter query as body search
+    const matchStatement: Statement = SQL`
+      SELECT count() AS cnt
+      FROM ${LogAggregationService.TABLE_NAME}
+      WHERE projectId = ${{
+        type: TableColumnType.ObjectID,
+        value: request.projectId,
+      }}
+        AND time >= ${{
+          type: TableColumnType.Date,
+          value: request.startTime,
+        }}
+        AND time <= ${{
+          type: TableColumnType.Date,
+          value: request.endTime,
+        }}
+    `;
+
+    LogAggregationService.appendCommonFilters(matchStatement, {
+      ...request,
+      bodySearchText: request.filterQuery,
+    });
+
+    const [totalResult, matchResult] = await Promise.all([
+      LogDatabaseService.executeQuery(totalStatement),
+      LogDatabaseService.executeQuery(matchStatement),
+    ]);
+
+    const totalResponse: DbJSONResponse = await totalResult.json<{
+      data?: Array<JSONObject>;
+    }>();
+    const matchResponse: DbJSONResponse = await matchResult.json<{
+      data?: Array<JSONObject>;
+    }>();
+
+    const totalData: Array<JSONObject> = totalResponse.data || [];
+    const matchData: Array<JSONObject> = matchResponse.data || [];
+
+    const totalLogs: number = Number(totalData[0]?.["cnt"] || 0);
+    const matchingLogs: number = Number(matchData[0]?.["cnt"] || 0);
+    const estimatedReductionPercent: number =
+      totalLogs > 0 ? Math.round((matchingLogs / totalLogs) * 100) : 0;
+
+    return { totalLogs, matchingLogs, estimatedReductionPercent };
+  }
+
   private static isTopLevelColumn(key: string): boolean {
     return LogAggregationService.TOP_LEVEL_COLUMNS.has(key);
   }

package/Server/Services/LogDropFilterService.ts

@@ -0,0 +1,10 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/LogDropFilter";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+}
+
+export default new Service();

package/Server/Services/LogPipelineProcessorService.ts

@@ -0,0 +1,10 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/LogPipelineProcessor";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+}
+
+export default new Service();

package/Server/Services/LogPipelineService.ts

@@ -0,0 +1,10 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/LogPipeline";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+}
+
+export default new Service();

package/Server/Services/LogScrubRuleService.ts

@@ -0,0 +1,10 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/LogScrubRule";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+}
+
+export default new Service();

package/Server/Services/TelemetryAttributeService.ts

@@ -227,8 +227,8 @@ export class TelemetryAttributeService {
       WITH filtered AS (
         SELECT arrayJoin(
             if(
-              ${data.attributeKeysColumn} IS NULL OR empty(${data.attributeKeysColumn}),
-              JSONExtractKeys(${data.attributesColumn}),
+              empty(${data.attributeKeysColumn}),
+              mapKeys(${data.attributesColumn}),
               ${data.attributeKeysColumn}
             )
           ) AS attribute
@@ -238,10 +238,8 @@ export class TelemetryAttributeService {
           value: data.projectId,
         }}
           AND (
-            ${data.attributeKeysColumn} IS NOT NULL OR (
-              ${data.attributesColumn} IS NOT NULL AND
-              ${data.attributesColumn} != ''
-            )
+            NOT empty(${data.attributeKeysColumn}) OR
+            NOT empty(${data.attributesColumn})
           )
           AND ${data.timeColumn} >= ${{
             type: TableColumnType.Date,

package/Server/Utils/AnalyticsDatabase/Statement.ts

@@ -120,7 +120,11 @@ export class Statement implements BaseQueryParams {
         finalValue = v.value.values;
       }
     } else if (v.value instanceof Date) {
-      finalValue = OneUptimeDate.toClickhouseDateTime(v.value);
+      if (typeof v !== "string" && v.type === TableColumnType.DateTime64) {
+        finalValue = OneUptimeDate.toClickhouseDateTime64(v.value);
+      } else {
+        finalValue = OneUptimeDate.toClickhouseDateTime(v.value);
+      }
     } else {
       finalValue = v.value;
     }
@@ -136,6 +140,15 @@ export class Statement implements BaseQueryParams {
       finalValue = OneUptimeDate.toClickhouseDateTime(finalValue);
     }
 
+    if (
+      typeof v !== "string" &&
+      v.type === TableColumnType.DateTime64 &&
+      !(v.value instanceof Date)
+    ) {
+      finalValue = OneUptimeDate.fromString(finalValue as string);
+      finalValue = OneUptimeDate.toClickhouseDateTime64(finalValue);
+    }
+
     return finalValue;
   }
 
@@ -176,6 +189,7 @@ export class Statement implements BaseQueryParams {
       [TableColumnType.Number]: "Int32",
       [TableColumnType.Decimal]: "Double",
       [TableColumnType.Date]: "DateTime",
+      [TableColumnType.DateTime64]: "DateTime64(9)",
       [TableColumnType.JSON]: "JSON",
       [TableColumnType.ArrayNumber]: "Array(Int32)",
       [TableColumnType.ArrayText]: "Array(String)",

package/Server/Utils/AnalyticsDatabase/StatementGenerator.ts

@@ -8,7 +8,7 @@ import logger from "../Logger";
 import { SQL, Statement } from "./Statement";
 import AnalyticsBaseModel from "../../../Models/AnalyticsModels/AnalyticsBaseModel/AnalyticsBaseModel";
 import CommonModel, {
-  Record,
+  Record as AnalyticsRecord,
   RecordValue,
 } from "../../../Models/AnalyticsModels/AnalyticsBaseModel/CommonModel";
 import AnalyticsTableColumn, {
@@ -85,7 +85,7 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
     return columnNames;
   }
 
-  public getRecordValuesStatement(record: Record): string {
+  public getRecordValuesStatement(record: AnalyticsRecord): string {
     let valueStatement: string = "";
 
     for (const value of record) {
@@ -106,7 +106,7 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
     return valueStatement;
   }
 
-  public getValuesStatement(records: Array<Record>): string {
+  public getValuesStatement(records: Array<AnalyticsRecord>): string {
     let statement: string = "";
     for (const record of records) {
       statement += `(${this.getRecordValuesStatement(record)}), `;
@@ -126,10 +126,10 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
       this.model.getTableColumns(),
     );
 
-    const records: Array<Record> = [];
+    const records: Array<AnalyticsRecord> = [];
 
     for (const item of data.item) {
-      const record: Record = this.getRecord(item);
+      const record: AnalyticsRecord = this.getRecord(item);
       records.push(record);
     }
 
@@ -154,8 +154,8 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
     return statement;
   }
 
-  private getRecord(item: CommonModel): Record {
-    const record: Record = [];
+  private getRecord(item: CommonModel): AnalyticsRecord {
+    const record: AnalyticsRecord = [];
 
     for (const column of item.getTableColumns()) {
       const value: RecordValue | undefined = this.sanitizeValue(
@@ -251,6 +251,34 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
       value = `CAST(${this.escapeStringLiteral(value.toString())} AS Int128)`;
     }
 
+    if (column.type === TableColumnType.BigNumber) {
+      if (typeof value === "string") {
+        value = parseInt(value);
+      }
+    }
+
+    if (column.type === TableColumnType.ArrayBigNumber) {
+      value = `[${(value as Array<number>)
+        .map((v: number) => {
+          if (v && typeof v !== "number") {
+            v = parseFloat(v);
+            return isNaN(v) ? "NULL" : v;
+          }
+          return v;
+        })
+        .join(", ")}]`;
+    }
+
+    if (column.type === TableColumnType.MapStringString) {
+      const mapObj: Record<string, string> = value as Record<string, string>;
+      const entries: Array<string> = Object.entries(mapObj).map(
+        ([k, v]: [string, string]) => {
+          return `${this.escapeStringLiteral(k)}, ${this.escapeStringLiteral(v)}`;
+        },
+      );
+      value = `map(${entries.join(", ")})`;
+    }
+
     return value;
   }
 
@@ -387,6 +415,28 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
         } else {
           whereStatement.append(SQL`AND ${key} IS NULL`);
         }
+      } else if (
+        tableColumn.type === TableColumnType.MapStringString &&
+        typeof value === "object"
+      ) {
+        const mapValue: Record<string, string> = value as Record<
+          string,
+          string
+        >;
+        for (const mapKey in mapValue) {
+          if (mapValue[mapKey] === undefined) {
+            continue;
+          }
+          whereStatement.append(
+            SQL`AND ${key}[${{
+              value: mapKey,
+              type: TableColumnType.Text,
+            }}] = ${{
+              value: mapValue[mapKey] as string,
+              type: TableColumnType.Text,
+            }}`,
+          );
+        }
       } else if (
         (tableColumn.type === TableColumnType.JSON ||
           tableColumn.type === TableColumnType.JSONArray) &&
@@ -640,6 +690,13 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
       );
     }
 
+    // Append projections after indexes
+    if (this.model.projections && this.model.projections.length > 0) {
+      for (const projection of this.model.projections) {
+        columns.append(`, PROJECTION ${projection.name} (${projection.query})`);
+      }
+    }
+
     return columns;
   }
 
@@ -649,13 +706,16 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
     return {
       String: TableColumnType.Text,
       Int32: TableColumnType.Number,
-      Int64: TableColumnType.LongNumber,
+      Int64: TableColumnType.BigNumber,
       Int128: TableColumnType.LongNumber,
       Float32: TableColumnType.Decimal,
       Float64: TableColumnType.Decimal,
       DateTime: TableColumnType.Date,
+      "DateTime64(9)": TableColumnType.DateTime64,
       "Array(String)": TableColumnType.ArrayText,
       "Array(Int32)": TableColumnType.ArrayNumber,
+      "Array(Int64)": TableColumnType.ArrayBigNumber,
+      "Map(String, String)": TableColumnType.MapStringString,
       JSON: TableColumnType.JSON, //JSONArray is also JSON
       Bool: TableColumnType.Boolean,
     }[clickhouseType];
@@ -671,11 +731,15 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
       [TableColumnType.IP]: SQL`String`,
       [TableColumnType.Port]: SQL`String`,
       [TableColumnType.Date]: SQL`DateTime`,
+      [TableColumnType.DateTime64]: SQL`DateTime64(9)`,
       [TableColumnType.JSON]: SQL`String`, // we use JSON as a string because ClickHouse has really good JSON support for string types
       [TableColumnType.JSONArray]: SQL`String`, // we use JSON as a string because ClickHouse has really good JSON support for string types
       [TableColumnType.ArrayNumber]: SQL`Array(Int32)`,
+      [TableColumnType.ArrayBigNumber]: SQL`Array(Int64)`,
       [TableColumnType.ArrayText]: SQL`Array(String)`,
       [TableColumnType.LongNumber]: SQL`Int128`,
+      [TableColumnType.BigNumber]: SQL`Int64`,
+      [TableColumnType.MapStringString]: SQL`Map(String, String)`,
     }[type];
 
     if (!statement) {
@@ -700,12 +764,32 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
   }
 
   public toAddColumnStatement(column: AnalyticsTableColumn): Statement {
+    // Build column definition without skip index (indexes must be added separately via ADD INDEX)
+    const columnDef: Statement = new Statement();
+
+    columnDef
+      .append(column.key)
+      .append(SQL` `)
+      .append(
+        column.required
+          ? this.toColumnType(column.type)
+          : SQL`Nullable(`
+              .append(this.toColumnType(column.type))
+              .append(SQL`)`),
+      );
+
+    if (column.codec) {
+      const codecStr: string =
+        column.codec.level !== undefined
+          ? `${column.codec.codec}(${column.codec.level})`
+          : column.codec.codec;
+      columnDef.append(` CODEC(${codecStr})`);
+    }
+
     const statement: Statement = SQL`
             ALTER TABLE ${this.database.getDatasourceOptions().database!}.${
               this.model.tableName
-            } ADD COLUMN IF NOT EXISTS `.append(
-      this.toColumnsCreateStatement([column]),
-    );
+            } ADD COLUMN IF NOT EXISTS `.append(columnDef);
 
     logger.debug(`${this.model.tableName} Add Column Statement`);
     logger.debug(statement);
@@ -713,6 +797,37 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
     return statement;
   }
 
+  public toAddSkipIndexStatement(
+    column: AnalyticsTableColumn,
+  ): Statement | null {
+    if (!column.skipIndex) {
+      return null;
+    }
+
+    const idx: AnalyticsTableColumn["skipIndex"] = column.skipIndex;
+    const paramsStr: string =
+      idx.params && idx.params.length > 0 ? `(${idx.params.join(", ")})` : "";
+
+    const needsAssumeNotNull: boolean =
+      !column.required &&
+      (idx.type === SkipIndexType.TokenBF ||
+        idx.type === SkipIndexType.NgramBF);
+    const columnExpr: string = needsAssumeNotNull
+      ? `assumeNotNull(${column.key})`
+      : column.key;
+
+    const databaseName: string = this.database.getDatasourceOptions().database!;
+    const statement: Statement = new Statement();
+    statement.append(
+      `ALTER TABLE ${databaseName}.${this.model.tableName} ADD INDEX IF NOT EXISTS ${idx.name} ${columnExpr} TYPE ${idx.type}${paramsStr} GRANULARITY ${idx.granularity}`,
+    );
+
+    logger.debug(`${this.model.tableName} Add Skip Index Statement`);
+    logger.debug(statement);
+
+    return statement;
+  }
+
   public toDropColumnStatement(columnName: string): string {
     const statement: string = `ALTER TABLE ${this.database.getDatasourceOptions()
       .database!}.${this.model.tableName} DROP COLUMN IF EXISTS ${columnName}`;

package/Tests/Server/Services/LogAggregationService.test.ts

@@ -2,6 +2,7 @@ import LogAggregationService, {
   FacetRequest,
 } from "../../../Server/Services/LogAggregationService";
 import { Statement } from "../../../Server/Utils/AnalyticsDatabase/Statement";
+import AnalyticsTableName from "../../../Types/AnalyticsDatabase/AnalyticsTableName";
 import ObjectID from "../../../Types/ObjectID";
 import OneUptimeDate from "../../../Types/Date";
 import { describe, expect, test } from "@jest/globals";
@@ -35,7 +36,7 @@ describe("LogAggregationService", () => {
 
     expect(statement.query_params).toStrictEqual({
       p0: "severityText",
-      p1: "LogItem",
+      p1: AnalyticsTableName.Log,
       p2: defaultRequest.projectId.toString(),
       p3: OneUptimeDate.toClickhouseDateTime(defaultRequest.startTime),
       p4: OneUptimeDate.toClickhouseDateTime(defaultRequest.endTime),
@@ -55,7 +56,7 @@ describe("LogAggregationService", () => {
 
     expect(statement.query_params).toStrictEqual({
       p0: facetKey,
-      p1: "LogItem",
+      p1: AnalyticsTableName.Log,
       p2: defaultRequest.projectId.toString(),
       p3: OneUptimeDate.toClickhouseDateTime(defaultRequest.startTime),
       p4: OneUptimeDate.toClickhouseDateTime(defaultRequest.endTime),

package/Types/AnalyticsDatabase/AnalyticsTableName.ts

@@ -0,0 +1,9 @@
+enum AnalyticsTableName {
+  Log = "LogItemV2",
+  Metric = "MetricItemV2",
+  ExceptionInstance = "ExceptionItemV2",
+  Span = "SpanItemV2",
+  MonitorLog = "MonitorLogV2",
+}
+
+export default AnalyticsTableName;

package/Types/AnalyticsDatabase/TableColumnType.ts

@@ -10,8 +10,12 @@ enum ColumnType {
   ArrayNumber = "Array of Numbers",
   ArrayText = "Array of Text",
   LongNumber = "Long Number",
+  BigNumber = "Big Number",
+  DateTime64 = "DateTime64",
   IP = "IP",
   Port = "Port",
+  MapStringString = "Map(String, String)",
+  ArrayBigNumber = "Array of Big Numbers",
 }
 
 export default ColumnType;

package/Types/Date.ts

@@ -1524,4 +1524,26 @@ export default class OneUptimeDate {
     const parsedDate: Date = this.fromString(date);
     return moment(parsedDate).utc().format("YYYY-MM-DD HH:mm:ss");
   }
+
+  public static toClickhouseDateTime64(
+    date: Date | string,
+    nanoTimestamp?: number,
+  ): string {
+    const parsedDate: Date = this.fromString(date);
+    const base: string = moment(parsedDate).utc().format("YYYY-MM-DD HH:mm:ss");
+
+    let nanoFraction: string;
+
+    if (nanoTimestamp !== undefined && nanoTimestamp > 0) {
+      // Extract sub-second nanoseconds from the unix nano timestamp
+      const subSecondNanos: number = nanoTimestamp % 1_000_000_000;
+      nanoFraction = subSecondNanos.toString().padStart(9, "0");
+    } else {
+      // Fall back to milliseconds from the Date object
+      const ms: number = parsedDate.getMilliseconds();
+      nanoFraction = (ms * 1_000_000).toString().padStart(9, "0");
+    }
+
+    return `${base}.${nanoFraction}`;
+  }
 }

package/Types/Log/LogDropFilterAction.ts

@@ -0,0 +1,6 @@
+enum LogDropFilterAction {
+  Drop = "drop",
+  Sample = "sample",
+}
+
+export default LogDropFilterAction;