@grow-codes/grafana-loki 0.0.0-stage → 0.1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,471 @@
1
+ /** Canonical error codes shared by every Grow Codes SDK (SPEC §2.1). Values are the wire form. */
2
+ declare const ErrorCode: {
3
+ readonly Config: "CONFIG";
4
+ readonly Authentication: "AUTHENTICATION";
5
+ readonly PermissionDenied: "PERMISSION_DENIED";
6
+ readonly NotFound: "NOT_FOUND";
7
+ readonly Conflict: "CONFLICT";
8
+ readonly RateLimited: "RATE_LIMITED";
9
+ readonly Validation: "VALIDATION";
10
+ readonly Unavailable: "UNAVAILABLE";
11
+ readonly Timeout: "TIMEOUT";
12
+ readonly Unsupported: "UNSUPPORTED";
13
+ readonly Cancelled: "CANCELLED";
14
+ };
15
+ /** One of the {@link ErrorCode} wire values, e.g. `"NOT_FOUND"`. */
16
+ type ErrorCode = (typeof ErrorCode)[keyof typeof ErrorCode];
17
+ /** Optional details attached to an SDK error. */
18
+ interface ErrorDetails {
19
+ /** HTTP status when the error came from a response. */
20
+ httpStatus?: number;
21
+ /** Vendor request id header when present. */
22
+ requestId?: string;
23
+ /** Overrides the default retryability of the code. */
24
+ retryable?: boolean;
25
+ /** Server-requested wait (from `Retry-After`) in milliseconds. */
26
+ retryAfterMs?: number;
27
+ /** Underlying error (already redacted). */
28
+ cause?: unknown;
29
+ }
30
+ /**
31
+ * Base class of every error thrown by the Grafana Loki SDK.
32
+ *
33
+ * The message never contains credentials, request bodies or unfiltered response bodies.
34
+ */
35
+ declare class LokiError extends Error {
36
+ /** Canonical error code. */
37
+ readonly code: ErrorCode;
38
+ /** HTTP status when the error came from a response. */
39
+ readonly httpStatus?: number;
40
+ /** Vendor request id when the response carried one. */
41
+ readonly requestId?: string;
42
+ /** Whether retrying the same call may succeed. */
43
+ readonly retryable: boolean;
44
+ /** Server-requested wait in milliseconds (rate limits, `Retry-After`). */
45
+ readonly retryAfterMs?: number;
46
+ constructor(code: ErrorCode, message: string, details?: ErrorDetails);
47
+ /** JSON form (no stack, no cause). */
48
+ toJSON(): Record<string, unknown>;
49
+ }
50
+ /** Invalid or missing configuration. */
51
+ declare class ConfigError extends LokiError {
52
+ constructor(message: string, details?: ErrorDetails);
53
+ }
54
+ /** HTTP 401: missing or invalid credentials. */
55
+ declare class AuthenticationError extends LokiError {
56
+ constructor(message: string, details?: ErrorDetails);
57
+ }
58
+ /** HTTP 403: the credentials do not allow the operation. */
59
+ declare class PermissionDeniedError extends LokiError {
60
+ constructor(message: string, details?: ErrorDetails);
61
+ }
62
+ /** HTTP 404 or a missing record. */
63
+ declare class NotFoundError extends LokiError {
64
+ constructor(message: string, details?: ErrorDetails);
65
+ }
66
+ /** HTTP 409/412 or a compare-and-set mismatch. */
67
+ declare class ConflictError extends LokiError {
68
+ constructor(message: string, details?: ErrorDetails);
69
+ }
70
+ /** HTTP 429. `retryAfterMs` is set when the server sent `Retry-After`. */
71
+ declare class RateLimitError extends LokiError {
72
+ constructor(message: string, details?: ErrorDetails);
73
+ }
74
+ /** HTTP 400/413/422/other 4xx, or bad input caught client side. */
75
+ declare class ValidationError extends LokiError {
76
+ constructor(message: string, details?: ErrorDetails);
77
+ }
78
+ /** Network error or HTTP 500/502/503. */
79
+ declare class UnavailableError extends LokiError {
80
+ constructor(message: string, details?: ErrorDetails);
81
+ }
82
+ /** A connect, request or total deadline was exceeded, or HTTP 408/504. */
83
+ declare class TimeoutError extends LokiError {
84
+ constructor(message: string, details?: ErrorDetails);
85
+ }
86
+ /** The service or deployment does not offer the capability (HTTP 501, missing API). */
87
+ declare class UnsupportedError extends LokiError {
88
+ constructor(message: string, details?: ErrorDetails);
89
+ }
90
+ /** The caller cancelled the operation (AbortSignal). */
91
+ declare class CancelledError extends LokiError {
92
+ constructor(message: string, details?: ErrorDetails);
93
+ }
94
+ /** Creates the subclass that matches `code`. */
95
+ declare function errorForCode(code: ErrorCode, message: string, details?: ErrorDetails): LokiError;
96
+ /** Default short reason for a code, used in messages such as `"op: not found (HTTP 404)"`. */
97
+ declare function reasonForCode(code: ErrorCode): string;
98
+ /** Maps an HTTP status (>= 400) to its canonical {@link ErrorCode} (SPEC §2.1). */
99
+ declare function codeForStatus(status: number): ErrorCode;
100
+ /** Builds the error for an HTTP error response: `"<operation>: <reason> (HTTP <status>)"`. */
101
+ declare function errorForStatus(operation: string, status: number, details?: Omit<ErrorDetails, "httpStatus"> & {
102
+ reason?: string;
103
+ }): LokiError;
104
+ /** True when `err` is an SDK error (optionally with the given code). */
105
+ declare function isLokiError(err: unknown, code?: ErrorCode): err is LokiError;
106
+
107
+ /** Result of `client.health()` (SPEC §2.4). */
108
+ interface HealthStatus {
109
+ /** Whether the service answered and reports itself usable. */
110
+ healthy: boolean;
111
+ /** `"ok" | "degraded" | "unhealthy" | "unreachable"` or the vendor's word. */
112
+ status: string;
113
+ /** Extra vendor details (string values). */
114
+ details: Record<string, string>;
115
+ }
116
+ /** True when a vendor status word means healthy. */
117
+ declare function isHealthyWord(status: string): boolean;
118
+ /** Builds a {@link HealthStatus}; `healthy` defaults to {@link isHealthyWord}(status). */
119
+ declare function healthStatus(status: string, details?: Record<string, unknown>, healthy?: boolean): HealthStatus;
120
+ /**
121
+ * Runs a health probe and converts failures into a {@link HealthStatus} (SPEC §2.4): network
122
+ * errors and timeouts → `unreachable`; HTTP errors → `unhealthy` (with the status code in
123
+ * `details.httpStatus`). Only `CANCELLED` and `CONFIG` errors are rethrown.
124
+ */
125
+ declare function probeHealth(probe: () => Promise<HealthStatus>): Promise<HealthStatus>;
126
+
127
+ /** OpenTelemetry severity numbers (SPEC §4). */
128
+ declare enum Severity {
129
+ Trace = 1,
130
+ Debug = 5,
131
+ Info = 9,
132
+ Warn = 13,
133
+ Error = 17,
134
+ Fatal = 21
135
+ }
136
+ /** Attribute value: JSON-like data without `null`. */
137
+ type AttrValue = string | number | boolean | AttrValue[] | {
138
+ [key: string]: AttrValue;
139
+ };
140
+ /** Attribute map used by log records, spans and resources. */
141
+ type Attributes = Record<string, AttrValue>;
142
+ /** One log record (SPEC §4). */
143
+ interface LogRecord {
144
+ timestamp: Date;
145
+ observedTimestamp?: Date;
146
+ severity: Severity;
147
+ /** `"TRACE"`…`"FATAL"` or vendor text. */
148
+ severityText: string;
149
+ /** Message; structured bodies are JSON-encoded strings. */
150
+ body: string;
151
+ attributes: Attributes;
152
+ /** `service.name`, `service.version`, `deployment.environment`, `host.name`, … */
153
+ resource: Attributes;
154
+ /** 32 lower-case hex characters. */
155
+ traceId?: string;
156
+ /** 16 lower-case hex characters. */
157
+ spanId?: string;
158
+ traceFlags?: number;
159
+ }
160
+ /** Convenience input accepted by {@link LogClient.send}. */
161
+ interface LogInput {
162
+ message: string;
163
+ severity?: Severity;
164
+ attributes?: Attributes;
165
+ timestamp?: Date;
166
+ traceId?: string;
167
+ spanId?: string;
168
+ traceFlags?: number;
169
+ }
170
+ /** Result of one {@link LogExporter.export} call. */
171
+ interface ExportResult {
172
+ accepted: number;
173
+ rejected: number;
174
+ error?: LokiError;
175
+ }
176
+ /** Options passed to {@link LogExporter.export}. */
177
+ interface ExportOptions {
178
+ signal?: AbortSignal;
179
+ gzip: boolean;
180
+ }
181
+ /** Sends records to the service; implemented by each service package. */
182
+ interface LogExporter {
183
+ export(records: LogRecord[], opts: ExportOptions): Promise<ExportResult>;
184
+ shutdown(): Promise<void>;
185
+ }
186
+ /** Why records were dropped. */
187
+ type DropReason = "queue_full" | "shutdown" | "export_failed";
188
+ /** Counters of a {@link BatchProcessor}. */
189
+ interface BatchStats {
190
+ /** Records waiting in the queue or in flight right now. */
191
+ queued: number;
192
+ /** Records the exporter accepted. */
193
+ sent: number;
194
+ /** Records dropped before export (`queue_full`, `shutdown`). */
195
+ dropped: number;
196
+ /** Records lost because the export failed or the service rejected them. */
197
+ failed: number;
198
+ /** Export attempts repeated after a retryable failure. */
199
+ retries: number;
200
+ }
201
+ /**
202
+ * Canonical text for a severity number. Numbers between the canonical values (OTel `INFO2` etc.)
203
+ * map to the text of the range they fall into.
204
+ */
205
+ declare function severityText(severity: number): string;
206
+ /** The named {@link Severity} whose range (`TRACE` 1–4, `DEBUG` 5–8, …) contains `severity`. */
207
+ declare function canonicalSeverity(severity: number): Severity;
208
+ /**
209
+ * Parses a severity name (`"info"`, `"WARNING"`, …) or number. Returns `null` for unknown input.
210
+ */
211
+ declare function parseSeverity(value: string | number): Severity | null;
212
+
213
+ /** Attribute name fragments redacted by default (SPEC §4). */
214
+ declare const DEFAULT_REDACT_KEYS: readonly string[];
215
+ /** Options of {@link RedactionProcessor}. */
216
+ interface RedactionOptions {
217
+ /** Attribute name fragments (case-insensitive substring match). Default {@link DEFAULT_REDACT_KEYS}. */
218
+ keys?: readonly string[];
219
+ /** Patterns replaced in the body and in every string attribute value. */
220
+ patterns?: readonly RegExp[];
221
+ /** Replacement text. Default `"[REDACTED]"`. */
222
+ replacement?: string;
223
+ }
224
+ /** Removes secrets from log records before they leave the process. */
225
+ declare class RedactionProcessor {
226
+ #private;
227
+ constructor(options?: RedactionOptions);
228
+ /** Returns a redacted copy of `record`; the input is not modified. */
229
+ process(record: LogRecord): LogRecord;
230
+ /** Whether an attribute name is sensitive. */
231
+ isSensitiveKey(key: string): boolean;
232
+ /** Applies the patterns to `text`. */
233
+ redactText(text: string): string;
234
+ /** Redacts an attribute map recursively. */
235
+ redactAttributes(attributes: Attributes): Attributes;
236
+ }
237
+
238
+ /** What {@link BatchProcessor.add} does when the queue is full. */
239
+ type DropPolicy = "drop_newest" | "drop_oldest" | "block";
240
+ /** Options of {@link BatchProcessor} (SPEC §4). */
241
+ interface BatchOptions {
242
+ /** Records kept in memory before the drop policy applies. Default 2048. */
243
+ maxQueueSize?: number;
244
+ /** Records per export call. Default 512. */
245
+ maxBatchSize?: number;
246
+ /** UTF-8 JSON bytes per export call (a batch always holds at least one record). Default 1 MiB. */
247
+ maxBatchBytes?: number;
248
+ /** Interval of the background export. Default 1000 ms. */
249
+ flushIntervalMs?: number;
250
+ /** Deadline of one export call; also the default timeout of flush/shutdown. Default 30000 ms. */
251
+ exportTimeoutMs?: number;
252
+ /**
253
+ * `drop_newest` (default) rejects new records while the queue is full, `drop_oldest` evicts the
254
+ * oldest queued record, `block` never drops for a full queue: the queue may grow past
255
+ * `maxQueueSize`, an export starts at once, and {@link BatchProcessor.addAsync} waits for capacity
256
+ * (JavaScript cannot block a synchronous call).
257
+ */
258
+ dropPolicy?: DropPolicy;
259
+ /** Ask the exporter to gzip the payload. Default true. */
260
+ gzip?: boolean;
261
+ /** Export attempts repeated after a retryable failure (`error.retryable`). Default 2. */
262
+ maxExportRetries?: number;
263
+ /** Base delay before a repeated export, doubled per attempt. Default 200 ms. */
264
+ retryBackoffMs?: number;
265
+ /** Called with records that will never be exported. Exceptions are ignored. */
266
+ onDrop?: (records: LogRecord[], reason: DropReason) => void;
267
+ /** Called when an export fails or the service rejects records. Exceptions are ignored. */
268
+ onError?: (error: unknown, records: LogRecord[]) => void;
269
+ }
270
+ /** {@link BatchOptions} with every default applied. */
271
+ type ResolvedBatchOptions = Required<Omit<BatchOptions, "onDrop" | "onError">> & Pick<BatchOptions, "onDrop" | "onError">;
272
+ /** Defaults of {@link BatchOptions}. */
273
+ declare const DEFAULT_BATCH_OPTIONS: Readonly<Required<Omit<BatchOptions, "onDrop" | "onError">>>;
274
+ /** Applies defaults and validates; throws `ConfigError` for invalid values. */
275
+ declare function resolveBatchOptions(options?: BatchOptions): ResolvedBatchOptions;
276
+ /**
277
+ * Queues log records and exports them in batches from a background timer (SPEC §4). One export runs
278
+ * at a time; a full batch (count or bytes) starts an export at once.
279
+ */
280
+ declare class BatchProcessor {
281
+ #private;
282
+ constructor(exporter: LogExporter, options?: BatchOptions);
283
+ /** The resolved options. */
284
+ get options(): Readonly<ResolvedBatchOptions>;
285
+ /** Enqueues a record. Returns false when it was dropped. Never blocks (see `dropPolicy`). */
286
+ add(record: LogRecord): boolean;
287
+ /**
288
+ * Like {@link add}, but with `dropPolicy: "block"` waits until the queue has room first.
289
+ * Resolves false when the record was dropped (for example because the processor shut down).
290
+ */
291
+ addAsync(record: LogRecord): Promise<boolean>;
292
+ /** Exports everything queued at the time of the call. Rejects with `TimeoutError` after `timeoutMs`. */
293
+ flush(timeoutMs?: number): Promise<void>;
294
+ /**
295
+ * Drains the queue (bounded by `timeoutMs`), drops what is left with reason `shutdown`, then shuts
296
+ * the exporter down. Idempotent; later {@link add} calls drop with reason `shutdown`.
297
+ */
298
+ shutdown(timeoutMs?: number): Promise<void>;
299
+ /** Current counters. */
300
+ stats(): BatchStats;
301
+ }
302
+
303
+ /** Anything that accepts log input (a {@link LogClient}). */
304
+ interface LogSink {
305
+ send(record: LogInput): void;
306
+ }
307
+ /** Options of {@link Logger}. */
308
+ interface LoggerOptions {
309
+ /** Logger name, sent as attribute `logger.name`. */
310
+ name?: string;
311
+ /** Attributes added to every record (record attributes win). */
312
+ attributes?: Attributes;
313
+ /** Records below this severity are discarded. Default `Severity.Info`. */
314
+ minSeverity?: Severity;
315
+ }
316
+ /**
317
+ * Logging facade on top of a {@link LogClient}. When an OpenTelemetry span is active, its
318
+ * trace id, span id and flags are attached to every record.
319
+ */
320
+ declare class Logger {
321
+ #private;
322
+ constructor(sink: LogSink, options?: LoggerOptions);
323
+ /** The logger name, when set. */
324
+ get name(): string | undefined;
325
+ /** The minimum severity this logger sends. */
326
+ get minSeverity(): Severity;
327
+ /** Whether a record of `severity` would be sent. */
328
+ isEnabled(severity: Severity): boolean;
329
+ trace(message: string, attributes?: Attributes): void;
330
+ debug(message: string, attributes?: Attributes): void;
331
+ info(message: string, attributes?: Attributes): void;
332
+ warn(message: string, attributes?: Attributes): void;
333
+ error(message: string, attributes?: Attributes): void;
334
+ fatal(message: string, attributes?: Attributes): void;
335
+ /** Sends one record at `severity` (if enabled). */
336
+ log(severity: Severity, message: string, attributes?: Attributes): void;
337
+ /** A logger with extra attributes (same sink, name and minimum severity). */
338
+ child(attributes: Attributes): Logger;
339
+ }
340
+
341
+ /** Sends log records to the service (SPEC §4). */
342
+ interface LogClient {
343
+ /** Enqueues one record (applies redaction and defaults). Never throws and never blocks. */
344
+ send(record: LogRecord | LogInput): void;
345
+ /** Enqueues several records. */
346
+ sendBatch(records: readonly (LogRecord | LogInput)[]): void;
347
+ /** Exports everything queued now. */
348
+ flush(timeoutMs?: number): Promise<void>;
349
+ /** Flushes and shuts down; idempotent. */
350
+ close(): Promise<void>;
351
+ /** Batch counters. */
352
+ stats(): BatchStats;
353
+ /** A {@link Logger} facade writing to this client. */
354
+ logger(name?: string, attributes?: Attributes): Logger;
355
+ }
356
+ /** Options of {@link BatchingLogClient}. */
357
+ interface BatchingLogClientOptions {
358
+ /** Batching behaviour. */
359
+ batch?: BatchOptions;
360
+ /** Resource attributes added to every record (`service.name`, `deployment.environment`, …). */
361
+ resource?: Attributes;
362
+ /** Redaction applied before records are queued; `false` disables it (not recommended). */
363
+ redaction?: RedactionProcessor | RedactionOptions | false;
364
+ /** Default minimum severity of loggers created by {@link BatchingLogClient.logger}. */
365
+ minSeverity?: Severity;
366
+ /** Clock used for missing timestamps (tests). */
367
+ now?: () => Date;
368
+ }
369
+ /** {@link LogClient} built from a service {@link LogExporter} and a {@link BatchProcessor}. */
370
+ declare class BatchingLogClient implements LogClient {
371
+ #private;
372
+ constructor(exporter: LogExporter, options?: BatchingLogClientOptions);
373
+ /** The underlying processor. */
374
+ get processor(): BatchProcessor;
375
+ /** The resource attributes added to every record. */
376
+ get resource(): Readonly<Attributes>;
377
+ send(record: LogRecord | LogInput): void;
378
+ sendBatch(records: readonly (LogRecord | LogInput)[]): void;
379
+ flush(timeoutMs?: number): Promise<void>;
380
+ close(): Promise<void>;
381
+ stats(): BatchStats;
382
+ logger(name?: string, attributes?: Attributes): Logger;
383
+ }
384
+
385
+ /** Options of {@link LogQueryClient.search}. */
386
+ interface LogSearchOptions {
387
+ start?: Date;
388
+ end?: Date;
389
+ /** Maximum records per page. Default 100. */
390
+ limit?: number;
391
+ /** Default `"desc"` (newest first). */
392
+ order?: "desc" | "asc";
393
+ /** Opaque cursor from {@link LogSearchResult.nextCursor}. */
394
+ cursor?: string;
395
+ signal?: AbortSignal;
396
+ }
397
+ /** One page of search results. */
398
+ interface LogSearchResult {
399
+ records: LogRecord[];
400
+ nextCursor?: string;
401
+ total?: number;
402
+ }
403
+ /** Options of {@link LogQueryClient.tail}. */
404
+ interface TailOptions {
405
+ /** Only records at or after this time. Default: now. */
406
+ start?: Date;
407
+ /** Poll interval for polling implementations. Default 1000 ms. */
408
+ intervalMs?: number;
409
+ /** Called on query errors; tailing continues. */
410
+ onError?: (error: unknown) => void;
411
+ }
412
+ /** Handle returned by {@link LogQueryClient.tail}. */
413
+ interface TailHandle {
414
+ /** Stops tailing; idempotent. */
415
+ stop(): void;
416
+ }
417
+ /** Options of {@link LogQueryClient.waitForLog}. */
418
+ interface WaitForLogOptions {
419
+ /** Default 30000 ms. */
420
+ timeoutMs?: number;
421
+ /** Default 1000 ms. */
422
+ intervalMs?: number;
423
+ /** Extra condition a record must satisfy. */
424
+ predicate?: (record: LogRecord) => boolean;
425
+ /** Search window start. */
426
+ start?: Date;
427
+ signal?: AbortSignal;
428
+ }
429
+ /**
430
+ * Reads logs back from the service (SPEC §4). Services without a query API throw
431
+ * `UnsupportedError` from every method.
432
+ */
433
+ interface LogQueryClient {
434
+ search(query: string, opts?: LogSearchOptions): Promise<LogSearchResult>;
435
+ tail(query: string, onRecord: (record: LogRecord) => void, opts?: TailOptions): TailHandle;
436
+ listStreams(): Promise<string[]>;
437
+ listLabels(): Promise<string[]>;
438
+ waitForLog(query: string, opts?: WaitForLogOptions): Promise<LogRecord>;
439
+ }
440
+ /**
441
+ * Polls `client.search(query)` until a record matches `predicate` (or any record when no predicate
442
+ * is given). Throws `TimeoutError` when nothing matches within `timeoutMs`.
443
+ */
444
+ declare function waitForLog(client: Pick<LogQueryClient, "search">, query: string, opts?: WaitForLogOptions): Promise<LogRecord>;
445
+ /**
446
+ * Starts a polling tail on top of `search`: every `intervalMs` it asks for records newer than the
447
+ * last one seen (ascending) and calls `onRecord` once per new record.
448
+ */
449
+ declare function pollTail(client: Pick<LogQueryClient, "search">, query: string, onRecord: (record: LogRecord) => void, opts?: TailOptions): TailHandle;
450
+ /**
451
+ * Base class for service query clients: implements {@link waitForLog} and a polling {@link tail}
452
+ * on top of {@link search}; `listStreams`/`listLabels` throw `UnsupportedError` unless overridden.
453
+ */
454
+ declare abstract class BaseLogQueryClient implements LogQueryClient {
455
+ abstract search(query: string, opts?: LogSearchOptions): Promise<LogSearchResult>;
456
+ tail(query: string, onRecord: (record: LogRecord) => void, opts?: TailOptions): TailHandle;
457
+ listStreams(): Promise<string[]>;
458
+ listLabels(): Promise<string[]>;
459
+ waitForLog(query: string, opts?: WaitForLogOptions): Promise<LogRecord>;
460
+ }
461
+ /** A {@link LogQueryClient} for services without a query API: every method throws `UnsupportedError`. */
462
+ declare class UnsupportedLogQueryClient implements LogQueryClient {
463
+ search(): Promise<LogSearchResult>;
464
+ tail(): TailHandle;
465
+ listStreams(): Promise<string[]>;
466
+ listLabels(): Promise<string[]>;
467
+ waitForLog(): Promise<LogRecord>;
468
+ }
469
+
470
+ export { isLokiError as $, BaseLogQueryClient as B, CancelledError as C, DEFAULT_BATCH_OPTIONS as D, RedactionProcessor as G, TimeoutError as J, UnsupportedError as K, LokiError as L, UnsupportedLogQueryClient as M, NotFoundError as N, canonicalSeverity as O, PermissionDeniedError as P, codeForStatus as Q, RateLimitError as R, Severity as S, UnavailableError as U, ValidationError as V, errorForCode as X, errorForStatus as Y, healthStatus as Z, isHealthyWord as _, parseSeverity as a0, pollTail as a1, probeHealth as a2, reasonForCode as a3, resolveBatchOptions as a4, severityText as a5, waitForLog as a6, BatchingLogClient as j, AuthenticationError as k, BatchProcessor as m, ConfigError as o, ConflictError as p, DEFAULT_REDACT_KEYS as q, ErrorCode as t, Logger as y };
471
+ export type { Attributes as A, ExportOptions as E, RedactionOptions as F, HealthStatus as H, ResolvedBatchOptions as I, TailOptions as T, WaitForLogOptions as W, LogRecord as a, AttrValue as b, LogClient as c, LogExporter as d, ExportResult as e, LogSearchOptions as f, LogSearchResult as g, TailHandle as h, BatchingLogClientOptions as i, BatchOptions as l, BatchStats as n, DropPolicy as r, DropReason as s, ErrorDetails as u, LogInput as v, LogQueryClient as w, LogSink as x, LoggerOptions as z };