@loadstrike/loadstrike-sdk 1.0.27101 → 1.0.27301

package/dist/types/sinks.d.ts

@@ -642,6 +642,142 @@ export declare class OtelCollectorReportingSink implements LoadStrikeReportingSi
     private getSession;
     private persistEvents;
 }
+export interface ExpandedSinkOptionsInput {
+    BaseUrl?: string;
+    baseUrl?: string;
+    EndpointPath?: string;
+    endpointPath?: string;
+    Headers?: Record<string, string>;
+    headers?: Record<string, string>;
+    StaticTags?: Record<string, string>;
+    staticTags?: Record<string, string>;
+    TimeoutSeconds?: number;
+    timeoutSeconds?: number;
+    TimeoutMs?: number;
+    timeoutMs?: number;
+    FetchImpl?: SinkFetch;
+    fetchImpl?: SinkFetch;
+}
+declare abstract class ExpandedEventReportingSink implements LoadStrikeReportingSink {
+    readonly SinkName: string;
+    readonly sinkName: string;
+    readonly LicenseFeature: string;
+    readonly licenseFeature: string;
+    protected baseContext: LoadStrikeBaseContext | null;
+    protected session: SinkSessionMetadata | null;
+    protected constructor(sinkName: string, licenseFeature: string);
+    init(context: LoadStrikeBaseContext, _infraConfig: Record<string, unknown>): void;
+    Init(context: LoadStrikeBaseContext, infraConfig: Record<string, unknown>): void;
+    start(session: LoadStrikeSessionStartInfo): void;
+    Start(session: LoadStrikeSessionStartInfo): void;
+    saveRealtimeStats(scenarioStats: LoadStrikeScenarioStats[]): Promise<void>;
+    SaveRealtimeStats(scenarioStats: LoadStrikeScenarioStats[]): Promise<void>;
+    saveRealtimeMetrics(metrics: LoadStrikeMetricStats): Promise<void>;
+    SaveRealtimeMetrics(metrics: LoadStrikeMetricStats): Promise<void>;
+    saveRunResult(result: LoadStrikeRunResult): Promise<void>;
+    SaveRunResult(result: LoadStrikeRunResult): Promise<void>;
+    stop(): void;
+    Stop(): void;
+    Dispose(): void;
+    protected getBaseContext(): LoadStrikeBaseContext;
+    protected getSession(): SinkSessionMetadata;
+    protected buildPayload(events: ReportingSinkEvent[], staticTags?: Record<string, string>): Record<string, unknown>;
+    protected abstract persistEvents(events: ReportingSinkEvent[]): Promise<void>;
+}
+declare class ExpandedHttpJsonReportingSink extends ExpandedEventReportingSink {
+    private readonly fetchImpl;
+    private readonly baseUrl;
+    private readonly endpointPath;
+    private readonly headers;
+    private readonly staticTags;
+    private readonly timeoutMs;
+    constructor(sinkName: string, licenseFeature: string, defaultEndpointPath: string, options?: ExpandedSinkOptionsInput);
+    init(context: LoadStrikeBaseContext, infraConfig: Record<string, unknown>): void;
+    protected persistEvents(events: ReportingSinkEvent[]): Promise<void>;
+}
+export declare class PrometheusRemoteWriteReportingSink extends ExpandedHttpJsonReportingSink {
+    constructor(options?: ExpandedSinkOptionsInput);
+}
+export declare class CloudWatchReportingSink extends ExpandedHttpJsonReportingSink {
+    constructor(options?: ExpandedSinkOptionsInput);
+}
+export declare class DynatraceReportingSink extends ExpandedHttpJsonReportingSink {
+    constructor(options?: ExpandedSinkOptionsInput);
+}
+export declare class ElasticsearchReportingSink extends ExpandedHttpJsonReportingSink {
+    constructor(options?: ExpandedSinkOptionsInput);
+}
+export declare class OpenSearchReportingSink extends ExpandedHttpJsonReportingSink {
+    constructor(options?: ExpandedSinkOptionsInput);
+}
+export declare class NewRelicReportingSink extends ExpandedHttpJsonReportingSink {
+    constructor(options?: ExpandedSinkOptionsInput);
+}
+export declare class GenericWebhookReportingSink extends ExpandedHttpJsonReportingSink {
+    constructor(options?: ExpandedSinkOptionsInput);
+}
+export interface KafkaReportingSinkOptionsInput {
+    Topic?: string;
+    topic?: string;
+    BootstrapServers?: string;
+    bootstrapServers?: string;
+    StaticTags?: Record<string, string>;
+    staticTags?: Record<string, string>;
+    PublishAsync?: (topic: string, payload: string) => Promise<void> | void;
+    publishAsync?: (topic: string, payload: string) => Promise<void> | void;
+}
+export declare class KafkaReportingSink extends ExpandedEventReportingSink {
+    private readonly topic;
+    private readonly staticTags;
+    private readonly publishAsync?;
+    constructor(options?: KafkaReportingSinkOptionsInput);
+    protected persistEvents(events: ReportingSinkEvent[]): Promise<void>;
+}
+export interface StatsDReportingSinkOptionsInput {
+    Prefix?: string;
+    prefix?: string;
+    Host?: string;
+    host?: string;
+    Port?: number;
+    port?: number;
+    Tags?: Record<string, string>;
+    tags?: Record<string, string>;
+    SendLineAsync?: (line: string) => Promise<void> | void;
+    sendLineAsync?: (line: string) => Promise<void> | void;
+}
+declare class StatsDReportingSinkBase extends ExpandedEventReportingSink {
+    private readonly prefix;
+    private readonly host;
+    private readonly port;
+    private readonly tags;
+    private readonly sendLineAsync?;
+    private readonly dogStatsD;
+    constructor(sinkName: string, licenseFeature: string, options?: StatsDReportingSinkOptionsInput, dogStatsD?: boolean);
+    protected persistEvents(events: ReportingSinkEvent[]): Promise<void>;
+    private formatPoint;
+    private sendLine;
+}
+export declare class StatsDReportingSink extends StatsDReportingSinkBase {
+    constructor(options?: StatsDReportingSinkOptionsInput);
+}
+export declare class DogStatsDReportingSink extends StatsDReportingSinkBase {
+    constructor(options?: StatsDReportingSinkOptionsInput);
+}
+export declare class NetdataStatsDReportingSink extends StatsDReportingSinkBase {
+    constructor(options?: StatsDReportingSinkOptionsInput);
+}
+export interface JsonlFileReportingSinkOptionsInput {
+    FilePath?: string;
+    filePath?: string;
+    StaticTags?: Record<string, string>;
+    staticTags?: Record<string, string>;
+}
+export declare class JsonlFileReportingSink extends ExpandedEventReportingSink {
+    private readonly filePath;
+    private readonly staticTags;
+    constructor(options?: JsonlFileReportingSinkOptionsInput);
+    protected persistEvents(events: ReportingSinkEvent[]): Promise<void>;
+}
 declare function createRealtimeStatsEvents(session: SinkSessionMetadata, scenarios: LoadStrikeScenarioStats[]): ReportingSinkEvent[];
 declare function createFinalStatsEvents(session: SinkSessionMetadata, stats: LoadStrikeNodeStats): ReportingSinkEvent[];
 declare function createRunResultEvents(session: SinkSessionMetadata, result: LoadStrikeRunResult): ReportingSinkEvent[];

package/dist/types/transports.d.ts

@@ -631,6 +631,8 @@ export interface GrpcEndpointOptions extends DelegateEndpointOptions {
     deadlineMs?: number;
     Metadata?: Record<string, string>;
     metadata?: Record<string, string>;
+    NativeClient?: GrpcNativeClientOptions;
+    nativeClient?: GrpcNativeClientOptions | Record<string, unknown>;
 }
 export interface GrpcEndpointDefinition extends TrafficEndpointDefinition, GrpcEndpointOptions {
     Kind?: "Grpc";
@@ -649,6 +651,8 @@ export interface WebSocketEndpointOptions extends DelegateEndpointOptions {
     closeTimeoutSeconds?: number;
     CloseTimeoutMs?: number;
     closeTimeoutMs?: number;
+    NativeClient?: WebSocketNativeClientOptions;
+    nativeClient?: WebSocketNativeClientOptions | Record<string, unknown>;
 }
 export interface WebSocketEndpointDefinition extends TrafficEndpointDefinition, WebSocketEndpointOptions {
     Kind?: "WebSocket";
@@ -845,6 +849,64 @@ declare class PushDiffusionEndpointDefinitionModel extends TrafficEndpointDefini
     constructor(initial?: PushDiffusionEndpointDefinitionInit);
     Validate(): void;
 }
+export declare const GrpcMethodTypes: {
+    readonly Unary: "Unary";
+    readonly ServerStreaming: "ServerStreaming";
+    readonly ClientStreaming: "ClientStreaming";
+    readonly BidirectionalStreaming: "BidirectionalStreaming";
+};
+export type GrpcMethodTypes = typeof GrpcMethodTypes[keyof typeof GrpcMethodTypes];
+export declare class GrpcNativeClientOptions {
+    ProtoFilePath?: string;
+    DescriptorSetPath?: string;
+    UseReflection: boolean;
+    UseTls: boolean;
+    AllowUntrustedCertificates: boolean;
+    DeadlineSeconds: number;
+    Metadata: Record<string, string>;
+    RequestPayloadJson?: string;
+    RequestPayloadJsonStream: string[];
+    constructor(initial?: Record<string, unknown>);
+    Validate(): void;
+    validate(): void;
+}
+export interface GrpcStatusMapping {
+    statusCode: number;
+    StatusCode: number;
+    statusName: string;
+    StatusName: string;
+    isSuccess: boolean;
+    IsSuccess: boolean;
+}
+export declare const GrpcStatusMapper: {
+    readonly fromStatusCode: (statusCode: number) => GrpcStatusMapping;
+    readonly FromStatusCode: (statusCode: number) => GrpcStatusMapping;
+};
+export declare class ProtocolMetricSnapshot {
+    protocol: string;
+    Protocol: string;
+    requests: number;
+    Requests: number;
+    messagesSent: number;
+    MessagesSent: number;
+    messagesReceived: number;
+    MessagesReceived: number;
+    latencyMs: number;
+    LatencyMs: number;
+    streamDurationMs: number;
+    StreamDurationMs: number;
+    bytesSent: number;
+    BytesSent: number;
+    bytesReceived: number;
+    BytesReceived: number;
+    reconnects: number;
+    Reconnects: number;
+    errors: number;
+    Errors: number;
+    status: string;
+    Status: string;
+    constructor(initial?: Record<string, unknown>);
+}
 declare class GrpcEndpointDefinitionModel extends TrafficEndpointDefinitionModel {
     readonly Kind: "Grpc";
     Target: string;
@@ -858,9 +920,60 @@ declare class GrpcEndpointDefinitionModel extends TrafficEndpointDefinitionModel
     ConsumeAsync?: DelegateConsumeAsync;
     ConnectionMetadata: Record<string, string>;
     Metadata: Record<string, string>;
+    NativeClient?: GrpcNativeClientOptions;
     constructor(initial?: GrpcEndpointDefinitionInit);
     Validate(): void;
 }
+export declare class WebSocketReconnectPolicy {
+    MaxAttempts: number;
+    maxAttempts: number;
+    DelaySeconds: number;
+    delaySeconds: number;
+    constructor(initial?: Record<string, unknown>);
+    Validate(): void;
+    validate(): void;
+}
+export declare class WebSocketMessageSpec {
+    Kind: string;
+    kind: string;
+    TextPayload?: string;
+    textPayload?: string;
+    BinaryPayload?: Uint8Array;
+    binaryPayload?: Uint8Array;
+    constructor(initial?: Record<string, unknown>);
+    static Text(payload: string): WebSocketMessageSpec;
+    static Binary(payload: Uint8Array | number[]): WebSocketMessageSpec;
+    Validate(): void;
+    validate(): void;
+}
+export declare class WebSocketExpectedMessage {
+    ContainsText?: string;
+    containsText?: string;
+    ContainsBytes?: Uint8Array;
+    containsBytes?: Uint8Array;
+    TimeoutSeconds: number;
+    timeoutSeconds: number;
+    constructor(initial?: Record<string, unknown>);
+    Validate(): void;
+    validate(): void;
+}
+export declare class WebSocketNativeClientOptions {
+    Headers: Record<string, string>;
+    headers: Record<string, string>;
+    Cookies: string[];
+    cookies: string[];
+    PingIntervalSeconds?: number;
+    pingIntervalSeconds?: number;
+    Reconnect: WebSocketReconnectPolicy;
+    reconnect: WebSocketReconnectPolicy;
+    Messages: WebSocketMessageSpec[];
+    messages: WebSocketMessageSpec[];
+    ExpectedMessages: WebSocketExpectedMessage[];
+    expectedMessages: WebSocketExpectedMessage[];
+    constructor(initial?: Record<string, unknown>);
+    Validate(): void;
+    validate(): void;
+}
 declare class WebSocketEndpointDefinitionModel extends TrafficEndpointDefinitionModel {
     readonly Kind: "WebSocket";
     Url: string;
@@ -872,6 +985,7 @@ declare class WebSocketEndpointDefinitionModel extends TrafficEndpointDefinition
     ProduceAsync?: (request: ProducedMessageRequest) => Promise<ProducedMessageResult | TrackingPayload | null> | ProducedMessageResult | TrackingPayload | null;
     ConsumeAsync?: DelegateConsumeAsync;
     ConnectionMetadata: Record<string, string>;
+    NativeClient?: WebSocketNativeClientOptions;
     constructor(initial?: WebSocketEndpointDefinitionInit);
     Validate(): void;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loadstrike/loadstrike-sdk",
-  "version": "1.0.27101",
+  "version": "1.0.27301",
   "description": "TypeScript and JavaScript SDK for in-process load execution, traffic correlation, and reporting.",
   "keywords": [
     "load-testing",