@liquidmetal-ai/raindrop 0.5.1 → 0.5.2

package/dist/commands/log/query.js

@@ -0,0 +1,231 @@
+import { valueOf } from '@liquidmetal-ai/drizzle/appify/build';
+import { create } from '@bufbuild/protobuf';
+import { QueryLogsRequestSchema, TimeQuerySchema } from '@liquidmetal-ai/drizzle/liquidmetal/v1alpha1/riverjack_pb';
+import { Flags } from '@oclif/core';
+import { BaseCommand } from '../../base-command.js';
+export default class Query extends BaseCommand {
+    static args = {};
+    static description = 'query logs of applications with time range filtering';
+    static examples = [
+        `<%= config.bin %> <%= command.id %>`,
+        `<%= config.bin %> <%= command.id %> --application my-app`,
+        `<%= config.bin %> <%= command.id %> --application my-app --version v1.2.3`,
+        `<%= config.bin %> <%= command.id %> --application my-app --start-time 1638360000000 --end-time 1638363600000`,
+    ];
+    static flags = {
+        ...BaseCommand.HIDDEN_FLAGS,
+        output: Flags.string({
+            char: 'o',
+            description: 'output format',
+            default: 'text',
+            options: ['text', 'json'],
+        }),
+        impersonate: Flags.string({
+            char: 'i',
+            description: 'impersonate organization',
+            required: false,
+            hidden: true,
+        }),
+        manifest: Flags.string({
+            char: 'm',
+            description: 'project manifest',
+            required: false,
+            default: 'raindrop.manifest',
+            hidden: true,
+        }),
+        application: Flags.string({
+            char: 'a',
+            description: 'application',
+            required: false,
+        }),
+        version: Flags.string({
+            char: 'v',
+            description: 'application version',
+            required: false,
+        }),
+        startTime: Flags.string({
+            char: 's',
+            description: 'start time for query (Unix timestamp in milliseconds or ISO string)',
+            required: false,
+        }),
+        endTime: Flags.string({
+            char: 'e',
+            description: 'end time for query (Unix timestamp in milliseconds or ISO string)',
+            required: false,
+        }),
+        last: Flags.string({
+            char: 'l',
+            description: 'query logs from last duration (e.g., "1h", "30m", "2d")',
+            required: false,
+        }),
+        rainbowAuthService: Flags.string({
+            default: 'https://liquidmetal.run/api/connect',
+            hidden: true,
+            env: 'LIQUIDMETAL_RAINBOW_AUTH_SERVICE',
+        }),
+        raindropCatalogService: Flags.string({
+            env: 'RAINDROP_CATALOG_SERVICE',
+            description: 'URL of the catalog service',
+            hidden: true,
+        }),
+    };
+    parseTimeToMillis(timeStr) {
+        // Try parsing as Unix timestamp first
+        const timestamp = Number(timeStr);
+        if (!isNaN(timestamp)) {
+            // If it's a reasonable number, assume it's already in milliseconds
+            if (timestamp > 1000000000000) {
+                return BigInt(timestamp);
+            }
+            // If it's smaller, assume it's in seconds and convert to milliseconds
+            return BigInt(timestamp * 1000);
+        }
+        // Try parsing as ISO string
+        const date = new Date(timeStr);
+        if (!isNaN(date.getTime())) {
+            return BigInt(date.getTime());
+        }
+        throw new Error(`Invalid time format: ${timeStr}. Use Unix timestamp (ms) or ISO string.`);
+    }
+    parseDurationToMillis(duration) {
+        const match = duration.match(/^(\d+)([smhd])$/);
+        console.log('Match Given');
+        console.log(match);
+        if (!match) {
+            throw new Error(`Invalid duration format: ${duration}. Use format like "1h", "30m", "2d".`);
+        }
+        const value = parseInt(match[1], 10);
+        const unit = match[2];
+        switch (unit) {
+            case 's':
+                return value * 1000;
+            case 'm':
+                return value * 60 * 1000;
+            case 'h':
+                return value * 60 * 60 * 1000;
+            case 'd':
+                return value * 24 * 60 * 60 * 1000;
+            default:
+                throw new Error(`Unsupported duration unit: ${unit}`);
+        }
+    }
+    async run() {
+        // Load version from config if not provided
+        const apps = await this.loadManifest();
+        const config = await this.loadConfig();
+        if (!this.flags.version) {
+            if (!config.versionId) {
+                this.error('No version provided or found in config', { exit: 1 });
+            }
+            this.flags.version = config.versionId;
+        }
+        // Load application from manifest if not provided
+        if (!this.flags.application) {
+            const app = apps[0];
+            if (app === undefined) {
+                this.error('No application provided or found in manifest', { exit: 1 });
+            }
+            this.flags.application = valueOf(app.name);
+        }
+        const { userId, client: riverjackService, organizationId: defaultOrganizationId, } = await this.tenantRiverjackService();
+        const organizationId = this.flags.impersonate ?? defaultOrganizationId;
+        // Calculate time range
+        let startTime;
+        let endTime;
+        const now = Date.now();
+        if (this.flags.last) {
+            // Use "last" duration
+            try {
+                const durationMs = this.parseDurationToMillis(this.flags.last);
+                startTime = BigInt(now - durationMs);
+                endTime = BigInt(now);
+            }
+            catch (error) {
+                this.error(`Invalid duration: ${error instanceof Error ? error.message : String(error)}`, { exit: 1 });
+                return;
+            }
+        }
+        else if (this.flags.startTime || this.flags.endTime) {
+            // Use explicit start/end times
+            try {
+                startTime = this.flags.startTime ? this.parseTimeToMillis(this.flags.startTime) : BigInt(now - 60 * 60 * 1000); // Default to 1 hour ago
+                endTime = this.flags.endTime ? this.parseTimeToMillis(this.flags.endTime) : BigInt(now);
+            }
+            catch (error) {
+                this.error(`Invalid time format: ${error instanceof Error ? error.message : String(error)}`, { exit: 1 });
+                return;
+            }
+        }
+        else {
+            // Default to last hour
+            startTime = BigInt(now - 60 * 60 * 1000);
+            endTime = BigInt(now);
+        }
+        this.log(`Using organization: ${organizationId}`);
+        this.log(`Using user: ${userId}`);
+        this.log(`Querying logs for ${this.flags.application}@${this.flags.version}`);
+        this.log(`Time range: ${new Date(Number(startTime)).toLocaleString()} - ${new Date(Number(endTime)).toLocaleString()}`);
+        this.log('');
+        try {
+            const timeQuery = create(TimeQuerySchema, {
+                startTime,
+                endTime,
+            });
+            const request = create(QueryLogsRequestSchema, {
+                organizationId,
+                userId,
+                applicationName: this.flags.application,
+                applicationVersionId: this.flags.version,
+                timeQuery,
+            });
+            const response = await riverjackService.queryLogs(request);
+            if (this.flags.output === 'json') {
+                this.log(JSON.stringify(response, null, 2));
+            }
+            else {
+                if (response.messages.length === 0) {
+                    this.log('No log messages found for the specified criteria.');
+                }
+                else {
+                    this.log(`Found ${response.messages.length} log messages:\n`);
+                    response.messages.forEach((message, index) => {
+                        try {
+                            const parsed = JSON.parse(message);
+                            // Format structured log messages
+                            if (parsed.timestamp) {
+                                const timestamp = new Date(parsed.timestamp).toLocaleTimeString();
+                                const level = parsed.level || 'INFO';
+                                const msg = parsed.message || parsed.msg || message;
+                                this.log(`[${timestamp}] ${level}: ${msg}`);
+                                // Show additional fields if present
+                                Object.entries(parsed).forEach(([key, value]) => {
+                                    if (!['timestamp', 'level', 'message', 'msg'].includes(key) && value !== undefined) {
+                                        this.log(`  ${key}: ${JSON.stringify(value)}`);
+                                    }
+                                });
+                            }
+                            else {
+                                // If not structured, just display the message with index
+                                this.log(`Message ${index + 1}: ${message}`);
+                            }
+                            this.log('');
+                        }
+                        catch {
+                            // If message isn't JSON, display it as-is with index
+                            this.log(`Message ${index + 1}: ${message}`);
+                            this.log('');
+                        }
+                    });
+                }
+            }
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                this.error(`Failed to query logs: ${error.message}`, { exit: 1 });
+            }
+            else {
+                this.error('Failed to query logs: Unknown error', { exit: 1 });
+            }
+        }
+    }
+}

package/dist/commands/log/tail.d.ts

@@ -0,0 +1,22 @@
+import { BaseCommand } from '../../base-command.js';
+export default class Tail extends BaseCommand<typeof Tail> {
+    static args: {};
+    static description: string;
+    static examples: string[];
+    static flags: {
+        output: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        impersonate: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        manifest: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        application: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        version: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        rainbowAuthService: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        raindropCatalogService: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        config: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        rainbowAuthToken: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        rainbowOrganizationId: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        rainbowUserId: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        sendVersionMetadata: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}
+//# sourceMappingURL=tail.d.ts.map

package/dist/commands/log/tail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tail.d.ts","sourceRoot":"","sources":["../../../src/commands/log/tail.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEpD,MAAM,CAAC,OAAO,OAAO,IAAK,SAAQ,WAAW,CAAC,OAAO,IAAI,CAAC;IACxD,MAAM,CAAC,IAAI,KAAM;IAEjB,MAAM,CAAC,WAAW,SAAwC;IAE1D,MAAM,CAAC,QAAQ,WAIb;IAEF,MAAM,CAAC,KAAK;;;;;;;;;;;;;MAyCV;IAEI,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CA0J3B"}

package/dist/commands/log/tail.js

@@ -0,0 +1,214 @@
+import { valueOf } from '@liquidmetal-ai/drizzle/appify/build';
+import { create } from '@bufbuild/protobuf';
+import { StreamLogsRequestSchema } from '@liquidmetal-ai/drizzle/liquidmetal/v1alpha1/riverjack_pb';
+import { Flags } from '@oclif/core';
+import { BaseCommand } from '../../base-command.js';
+export default class Tail extends BaseCommand {
+    static args = {};
+    static description = 'tail logs of applications deployed';
+    static examples = [
+        `<%= config.bin %> <%= command.id %>`,
+        `<%= config.bin %> <%= command.id %> --application my-app`,
+        `<%= config.bin %> <%= command.id %> --application my-app --version v1.2.3`,
+    ];
+    static flags = {
+        ...BaseCommand.HIDDEN_FLAGS,
+        output: Flags.string({
+            char: 'o',
+            description: 'output format',
+            default: 'text',
+            options: ['text', 'json'],
+        }),
+        impersonate: Flags.string({
+            char: 'i',
+            description: 'impersonate organization',
+            required: false,
+            hidden: true,
+        }),
+        manifest: Flags.string({
+            char: 'm',
+            description: 'project manifest',
+            required: false,
+            default: 'raindrop.manifest',
+            hidden: true,
+        }),
+        application: Flags.string({
+            char: 'a',
+            description: 'application',
+            required: false,
+        }),
+        version: Flags.string({
+            char: 'v',
+            description: 'application version',
+            required: false,
+        }),
+        rainbowAuthService: Flags.string({
+            default: 'https://liquidmetal.run/api/connect',
+            hidden: true,
+            env: 'LIQUIDMETAL_RAINBOW_AUTH_SERVICE',
+        }),
+        raindropCatalogService: Flags.string({
+            env: 'RAINDROP_CATALOG_SERVICE',
+            description: 'URL of the catalog service',
+            hidden: true,
+        }),
+    };
+    async run() {
+        // Load version from config if not provided
+        const apps = await this.loadManifest();
+        const config = await this.loadConfig();
+        if (!this.flags.version) {
+            if (!config.versionId) {
+                this.error('No version provided or found in config', { exit: 1 });
+            }
+            this.flags.version = config.versionId;
+        }
+        // Load application from manifest if not provided
+        if (!this.flags.application) {
+            const app = apps[0];
+            if (app === undefined) {
+                this.error('No application provided or found in manifest', { exit: 1 });
+            }
+            this.flags.application = valueOf(app.name);
+        }
+        const { userId, client: riverjackService, organizationId: defaultOrganizationId, } = await this.tenantRiverjackService();
+        const organizationId = this.flags.impersonate ?? defaultOrganizationId;
+        this.log(`Using organization: ${organizationId}`);
+        this.log(`Using user: ${userId}`);
+        this.log(`Tailing logs for ${this.flags.application}@${this.flags.version} using Riverjack service...`);
+        this.log('Press Ctrl+C to stop\n');
+        try {
+            const request = create(StreamLogsRequestSchema, {
+                organizationId,
+                userId,
+                applicationName: this.flags.application,
+                applicationVersionId: this.flags.version,
+            });
+            for await (const resp of riverjackService.streamLogs(request)) {
+                if (resp.message) {
+                    try {
+                        const parsed = JSON.parse(resp.message);
+                        // Filter out heartbeat messages unless in JSON mode
+                        if (parsed.type === 'heartbeat' && this.flags.output !== 'json') {
+                            continue;
+                        }
+                        if (this.flags.output === 'json') {
+                            this.log(JSON.stringify(resp, null, 2));
+                        }
+                        else {
+                            // Format different message types appropriately
+                            switch (parsed.type) {
+                                case 'stream_started':
+                                    this.log(`🔄 Started streaming logs for ${parsed.applicationName}@${parsed.applicationVersionId}`);
+                                    this.log(`   Organization: ${parsed.organizationId}`);
+                                    this.log(`   User: ${parsed.userId}`);
+                                    this.log(`   Time: ${new Date(parsed.timestamp).toLocaleString()}`);
+                                    break;
+                                case 'new_events':
+                                    // Just show the events without the counter header
+                                    if (parsed.metrics) {
+                                        this.log(`   Total events in system: ${parsed.metrics.totalEvents}`);
+                                        this.log(`   Last processed: ${parsed.metrics.lastProcessed ? new Date(parsed.metrics.lastProcessed).toLocaleString() : 'N/A'}`);
+                                    }
+                                    if (parsed.events && parsed.events.length > 0) {
+                                        parsed.events.forEach((event) => {
+                                            const timestamp = event.storedAt ? new Date(event.storedAt).toLocaleTimeString() : 'Unknown time';
+                                            const eventName = event.name || 'Event';
+                                            const traceId = event.trace && typeof event.trace === 'object' ? event.trace.event_id : 'N/A';
+                                            const status = event.status || 'unknown';
+                                            const duration = event.trace && typeof event.trace === 'object' ?
+                                                event.trace.end_ms - event.trace.start_ms : null;
+                                            this.log(`  [${timestamp}] ${eventName} (${status}) - Trace: ${traceId}${duration ? ` - Duration: ${duration}ms` : ''}`);
+                                            // Show attributes with better formatting
+                                            if (event.attributes && typeof event.attributes === 'object') {
+                                                const attrs = event.attributes;
+                                                Object.entries(attrs).forEach(([key, value]) => {
+                                                    if (value !== undefined && value !== null) {
+                                                        // Format common attributes nicely
+                                                        if (key === 'http.status') {
+                                                            const statusCode = value;
+                                                            const statusEmoji = statusCode >= 200 && statusCode < 300 ? '✅' : statusCode >= 400 ? '❌' : '⚠️';
+                                                            this.log(`    ${key}: ${statusEmoji} ${value}`);
+                                                        }
+                                                        else if (key === 'http.method') {
+                                                            this.log(`    ${key}: ${value}`);
+                                                        }
+                                                        else if (key === 'http.url') {
+                                                            this.log(`    ${key}: ${value}`);
+                                                        }
+                                                        else if (key === 'query') {
+                                                            // SQL query formatting
+                                                            this.log(`    🗄️  SQL Query: ${value}`);
+                                                        }
+                                                        else if (key === 'rows_read') {
+                                                            this.log(`    📊 Rows Read: ${value}`);
+                                                        }
+                                                        else if (key === 'rows_written') {
+                                                            this.log(`    ✍️  Rows Written: ${value}`);
+                                                        }
+                                                        else if (key === 'db') {
+                                                            this.log(`    🏦 Database: ${value}`);
+                                                        }
+                                                        else if (key === 'error' && typeof eventName === 'string' && eventName.includes('sql')) {
+                                                            this.log(`    ❌ SQL Error: ${value}`);
+                                                        }
+                                                        else if (key === 'meta' && typeof value === 'object') {
+                                                            // SQL metadata
+                                                            const meta = value;
+                                                            if (meta.rows_read)
+                                                                this.log(`    📊 Rows Read: ${meta.rows_read}`);
+                                                            if (meta.rows_written)
+                                                                this.log(`    ✍️  Rows Written: ${meta.rows_written}`);
+                                                            if (meta.duration)
+                                                                this.log(`    ⏱️  Query Duration: ${meta.duration}ms`);
+                                                        }
+                                                        else {
+                                                            this.log(`    ${key}: ${JSON.stringify(value)}`);
+                                                        }
+                                                    }
+                                                });
+                                            }
+                                            // Show organization/application context
+                                            if (event.organization || event.application) {
+                                                const org = event.organization && typeof event.organization === 'object' ? event.organization.id : 'N/A';
+                                                const app = event.application && typeof event.application === 'object' ? event.application.name : 'N/A';
+                                                const version = event.application && typeof event.application === 'object' && typeof event.application.version === 'object' ?
+                                                    event.application.version.id : 'N/A';
+                                                this.log(`    Context: org=${org}, app=${app}, version=${version}`);
+                                            }
+                                            this.log(''); // Empty line for readability
+                                        });
+                                    }
+                                    break;
+                                case 'stream_ended':
+                                    this.log(`✅ Stream ended after ${Math.round(parsed.duration / 1000)}s (${parsed.totalPolls} polls)`);
+                                    this.log(`   Subscriber ID: ${parsed.subscriberId}`);
+                                    this.log(`   End time: ${new Date(parsed.timestamp).toLocaleString()}`);
+                                    break;
+                                case 'service_error':
+                                    this.log(`❌ Service error: ${parsed.error}`);
+                                    this.log(`   Time: ${new Date(parsed.timestamp).toLocaleString()}`);
+                                    break;
+                                default:
+                                    // For any other message types, just display the raw message
+                                    this.log(resp.message);
+                            }
+                        }
+                    }
+                    catch {
+                        // If message isn't JSON, just display it as-is
+                        this.log(resp.message);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                this.error(`Failed to tail logs: ${error.message}`, { exit: 1 });
+            }
+            else {
+                this.error('Failed to tail logs: Unknown error', { exit: 1 });
+            }
+        }
+    }
+}