@todoist/doistbot-cli 0.0.0-stage → 1.0.16

package/sandbox/dist/tasks/persist-logs/persist-logs.js

@@ -0,0 +1,491 @@
+import fs from 'fs';
+import { performance } from 'node:perf_hooks';
+import path from 'path';
+import { GetObjectCommand, PutObjectCommand, S3Client } from '@aws-sdk/client-s3';
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
+import { buildDatadogLink } from 'doistbot-shared-contracts';
+import { App } from 'octokit';
+import { recordTaskMetrics, } from '../../core/datadog-metrics.js';
+import { REPOS_SUBDIR, WORKSPACE_DIR } from '../../core/environment.js';
+import { logger } from '../../core/logging.js';
+import { scrubPii } from '../../core/pii-scrubber.js';
+import { removeIssueCommentReactionIfPresent } from '../../core/reactions.js';
+import { resolveIssueRepositories } from '../../core/repository-resolver.js';
+import { cloneDefaultBranchToPath } from '../../core/shared.js';
+import { LOG_SNAPSHOT_MARKER, PRESIGN_EXPIRY_SECONDS } from '../../core/snapshot-helpers.js';
+import { shutdownTracing } from '../../core/tracing-setup.js';
+import { parsePersistLogsContext } from './context.js';
+import { PERSIST_LOGS_PROVIDER, runInvestigation } from './llm-query-planner.js';
+async function createInstallationOctokit(ctx) {
+    const app = new App({
+        appId: ctx.appId,
+        privateKey: ctx.privateKey,
+    });
+    const octokit = await app.getInstallationOctokit(ctx.installationId);
+    return { app, octokit };
+}
+async function fetchIssue(octokit, ctx) {
+    const response = await octokit.rest.issues.get({
+        owner: ctx.owner,
+        repo: ctx.repo,
+        issue_number: ctx.issueNumber,
+    });
+    return response.data;
+}
+async function fetchIssueComments(octokit, ctx) {
+    return (await octokit.paginate(octokit.rest.issues.listComments, {
+        owner: ctx.owner,
+        repo: ctx.repo,
+        issue_number: ctx.issueNumber,
+        per_page: 100,
+    }));
+}
+async function uploadToS3({ bucket, issueNumber, analysisContent, csvContent, rawJsonContent, worklogContent, }) {
+    const s3 = new S3Client({});
+    const now = new Date().toISOString().replace(/[:.]/g, '-');
+    const prefix = `issues/${issueNumber}/${now}`;
+    const files = [
+        {
+            name: 'analysis',
+            key: `${prefix}/analysis.md`,
+            body: analysisContent,
+            contentType: 'text/markdown',
+        },
+        {
+            name: 'csv',
+            key: `${prefix}/logs.csv`,
+            body: csvContent,
+            contentType: 'text/csv',
+        },
+        {
+            name: 'rawLogs',
+            key: `${prefix}/raw-logs.json`,
+            body: rawJsonContent,
+            contentType: 'application/json',
+        },
+        {
+            name: 'worklog',
+            key: `${prefix}/worklog.md`,
+            body: worklogContent,
+            contentType: 'text/markdown',
+        },
+    ];
+    const presignedUrls = { analysis: '', csv: '', rawLogs: '', worklog: '' };
+    const s3Keys = { analysis: '', csv: '', rawLogs: '', worklog: '' };
+    for (const file of files) {
+        if (!file.body)
+            continue;
+        await s3.send(new PutObjectCommand({
+            Bucket: bucket,
+            Key: file.key,
+            Body: file.body,
+            ContentType: file.contentType,
+        }));
+        s3Keys[file.name] = file.key;
+        presignedUrls[file.name] = await getSignedUrl(s3, new GetObjectCommand({ Bucket: bucket, Key: file.key }), { expiresIn: PRESIGN_EXPIRY_SECONDS });
+    }
+    return {
+        s3Path: `s3://${bucket}/${prefix}/`,
+        s3Keys,
+        presignedUrls,
+    };
+}
+/**
+ * Strip presigned S3 URLs from comment text to avoid leaking them into the LLM prompt.
+ * Replaces any URL containing `X-Amz-` query params with a placeholder.
+ */
+function stripPresignedUrls(text) {
+    return text.replace(/https:\/\/[^\s)]+X-Amz-[^\s)]+/g, '[presigned-url-redacted]');
+}
+async function deleteComment(octokit, ctx, commentId) {
+    try {
+        await octokit.rest.issues.deleteComment({
+            owner: ctx.owner,
+            repo: ctx.repo,
+            comment_id: commentId,
+        });
+    }
+    catch {
+        // Best effort — don't fail the task over a cleanup issue
+    }
+}
+async function postComment({ octokit, ctx, body, }) {
+    await octokit.rest.issues.createComment({
+        owner: ctx.owner,
+        repo: ctx.repo,
+        issue_number: ctx.issueNumber,
+        body,
+    });
+}
+export async function main() {
+    const startedAt = performance.now();
+    const ctx = parsePersistLogsContext();
+    let exitCode = 0;
+    let metricOutcome = 'failure';
+    let metricReason;
+    logger.setBaseContext({
+        deliveryId: ctx.deliveryId,
+        repository: `${ctx.owner}/${ctx.repo}`,
+        issueNumber: ctx.issueNumber,
+    });
+    logger.info('Persist-logs task started', {
+        task: 'persist-logs',
+        issueNumber: ctx.issueNumber,
+        dryRun: ctx.dryRun,
+    });
+    let octokit;
+    let cleanedUp = false;
+    async function cleanup() {
+        if (cleanedUp)
+            return;
+        cleanedUp = true;
+        if (octokit) {
+            await removeIssueCommentReactionIfPresent({
+                octokit,
+                owner: ctx.owner,
+                repo: ctx.repo,
+                commentId: ctx.commentId,
+                reactionId: ctx.reactionId,
+                warnMessage: 'Failed to remove persist-logs reaction',
+                successMessage: 'Persist-logs reaction removed',
+                logMeta: {
+                    task: 'persist-logs',
+                    reactionId: ctx.reactionId,
+                },
+            });
+        }
+        logger.info('Persist-logs task finalized', {
+            task: 'persist-logs',
+            issueNumber: ctx.issueNumber,
+            durationMs: performance.now() - startedAt,
+        });
+    }
+    try {
+        const clients = await createInstallationOctokit(ctx);
+        const app = clients.app;
+        octokit = clients.octokit;
+        const [issue, comments] = await Promise.all([
+            fetchIssue(octokit, ctx),
+            fetchIssueComments(octokit, ctx),
+        ]);
+        const issueTitle = issue.title ?? 'Untitled issue';
+        const issueBody = issue.body ?? '';
+        logger.info('Issue context loaded', {
+            task: 'persist-logs',
+            issueNumber: ctx.issueNumber,
+            commentsCount: comments.length,
+        });
+        // Post initial progress comment with DD link (skip in dry-run)
+        let progressCommentId;
+        if (!ctx.dryRun) {
+            const datadogLink = buildDatadogLink(ctx.deliveryId);
+            const progressBody = datadogLink
+                ? `Investigating Datadog logs for this issue. Follow along [in Datadog](${datadogLink}).`
+                : 'Investigating Datadog logs for this issue.';
+            const progressComment = await octokit.rest.issues.createComment({
+                owner: ctx.owner,
+                repo: ctx.repo,
+                issue_number: ctx.issueNumber,
+                body: progressBody,
+            });
+            progressCommentId = progressComment.data.id;
+        }
+        // Resolve which repos to clone based on issue labels
+        const issueLabels = (issue.labels ?? [])
+            .map((l) => (typeof l === 'string' ? l : (l.name ?? '')))
+            .filter(Boolean);
+        const resolution = resolveIssueRepositories(issueLabels);
+        if (resolution.status === 'unresolved') {
+            logger.warn('Repository resolution failed', {
+                task: 'persist-logs',
+                reason: resolution.reason,
+                labels: issueLabels,
+            });
+            const msg = `Unable to determine which repository to investigate: ${resolution.reason}\n\nPlease add the appropriate labels (e.g. \`Product:Todoist\`, \`App:Backend\`) and try again.`;
+            if (ctx.dryRun) {
+                process.stdout.write(`${msg}\n`);
+            }
+            else {
+                if (progressCommentId)
+                    await deleteComment(octokit, ctx, progressCommentId);
+                await postComment({ octokit, ctx, body: msg });
+            }
+            metricReason = 'no_repo';
+            return;
+        }
+        const repos = resolution.repositories;
+        logger.info('Repository resolution', {
+            task: 'persist-logs',
+            status: resolution.status,
+            reason: resolution.reason,
+            repos: repos.map((r) => r.fullName),
+        });
+        // Clone resolved repos — backend repos are most useful for log investigation
+        logger.info('Cloning repositories for code context', {
+            task: 'persist-logs',
+            repos: repos.map((r) => r.fullName),
+        });
+        const reposDir = path.join(WORKSPACE_DIR, REPOS_SUBDIR);
+        const clonedRepoDirs = [];
+        for (const repo of repos) {
+            const repoPath = path.join(reposDir, repo.repo);
+            try {
+                await cloneDefaultBranchToPath({
+                    app,
+                    owner: repo.owner,
+                    repo: repo.repo,
+                    installationId: ctx.installationId,
+                    targetPath: repoPath,
+                    depth: 1,
+                });
+                logger.info('Repository cloned', {
+                    task: 'persist-logs',
+                    repo: repo.fullName,
+                });
+                clonedRepoDirs.push(repoPath);
+            }
+            catch (cloneError) {
+                logger.warn('Failed to clone repo, continuing without it', {
+                    task: 'persist-logs',
+                    repo: repo.fullName,
+                    error: cloneError instanceof Error ? cloneError.message : String(cloneError),
+                });
+            }
+        }
+        // Run LLM-driven investigation — pass the first cloned repo as primary context
+        logger.info('Starting LLM investigation against Datadog', {
+            task: 'persist-logs',
+            repoCount: clonedRepoDirs.length,
+        });
+        const primaryRepoDir = clonedRepoDirs[0] ?? WORKSPACE_DIR;
+        const outputDir = path.join(WORKSPACE_DIR, 'persist-logs-output');
+        const result = await runInvestigation({
+            openaiApiKey: ctx.openaiApiKey,
+            datadogApiKey: ctx.datadogApiKey,
+            datadogAppKey: ctx.datadogAppKey,
+            issueNumber: ctx.issueNumber,
+            issueTitle,
+            issueBody,
+            comments: comments.map((c) => ({
+                author: c.user?.login ?? 'unknown',
+                body: stripPresignedUrls(c.body ?? ''),
+            })),
+            repoDir: primaryRepoDir,
+            outputDir,
+        });
+        logger.info('LLM investigation finished', {
+            task: 'persist-logs',
+            success: result.success,
+            totalLogs: result.totalLogs,
+        });
+        if (!result.success) {
+            const msg = `Sorry, the log investigation failed: ${result.error ?? 'unknown error'}. Please try again or contact the team maintaining the bot.`;
+            logger.error('LLM investigation failed', {
+                task: 'persist-logs',
+                error: result.error,
+            });
+            if (ctx.dryRun) {
+                process.stdout.write(`${msg}\n`);
+            }
+            else {
+                if (progressCommentId)
+                    await deleteComment(octokit, ctx, progressCommentId);
+                await postComment({ octokit, ctx, body: msg });
+            }
+            metricReason = 'llm_failed';
+            return;
+        }
+        if (result.totalLogs === 0) {
+            const msg = 'No Datadog logs found matching the issue context. The investigation ran but found no relevant logs in the 14-day retention window.';
+            if (ctx.dryRun) {
+                process.stdout.write(`${msg}\n`);
+            }
+            else {
+                if (progressCommentId)
+                    await deleteComment(octokit, ctx, progressCommentId);
+                await postComment({ octokit, ctx, body: msg });
+            }
+            metricOutcome = 'success';
+            return;
+        }
+        // Read output files and scrub any residual PII
+        const analysisContent = scrubPii(result.analysisPath ? fs.readFileSync(result.analysisPath, 'utf-8') : '');
+        const csvContent = scrubPii(result.csvPath ? fs.readFileSync(result.csvPath, 'utf-8') : '');
+        const rawJsonContent = result.rawLogsPath
+            ? fs.readFileSync(result.rawLogsPath, 'utf-8')
+            : '{}';
+        const worklogContent = scrubPii(result.worklogPath ? fs.readFileSync(result.worklogPath, 'utf-8') : '');
+        if (ctx.dryRun) {
+            // Print outputs locally instead of uploading/posting
+            process.stdout.write('\n========== ANALYSIS ==========\n');
+            process.stdout.write(analysisContent || '(empty)\n');
+            process.stdout.write('\n========== WORKLOG ==========\n');
+            process.stdout.write(worklogContent || '(empty)\n');
+            const csvLines = csvContent.split('\n');
+            process.stdout.write(`\n========== CSV (${csvLines.length} lines, first 20) ==========\n`);
+            process.stdout.write(csvLines.slice(0, 20).join('\n') + '\n');
+            process.stdout.write(`\n========== RAW LOGS (${rawJsonContent.length} bytes) ==========\n`);
+            process.stdout.write(`(saved to ${result.rawLogsPath ?? 'N/A'})\n`);
+            logger.info('Persist-logs dry run completed', {
+                task: 'persist-logs',
+                issueNumber: ctx.issueNumber,
+                totalLogs: result.totalLogs,
+                durationMs: performance.now() - startedAt,
+            });
+            metricOutcome = 'success';
+        }
+        else {
+            // Upload to S3 and post snapshot comment
+            logger.info('Uploading results to S3', { task: 'persist-logs' });
+            const { s3Path, s3Keys, presignedUrls } = await uploadToS3({
+                bucket: ctx.logSnapshotBucket,
+                issueNumber: ctx.issueNumber,
+                analysisContent,
+                csvContent,
+                rawJsonContent,
+                worklogContent,
+            });
+            logger.info('Logs uploaded to S3', {
+                task: 'persist-logs',
+                issueNumber: ctx.issueNumber,
+                s3Path,
+            });
+            const snapshotComment = buildSnapshotComment({
+                analysisContent,
+                csvContent,
+                worklogContent,
+                totalLogs: result.totalLogs,
+                bucket: ctx.logSnapshotBucket,
+                s3Keys,
+                presignedUrls,
+                deliveryId: ctx.deliveryId,
+            });
+            await postComment({ octokit, ctx, body: snapshotComment });
+            // Clean up the progress comment now that the snapshot is posted
+            if (progressCommentId)
+                await deleteComment(octokit, ctx, progressCommentId);
+            logger.info('Persist-logs task completed', {
+                task: 'persist-logs',
+                issueNumber: ctx.issueNumber,
+                totalLogs: result.totalLogs,
+                s3Path,
+                durationMs: performance.now() - startedAt,
+            });
+            metricOutcome = 'success';
+        }
+    }
+    catch (error) {
+        metricReason = 'exception';
+        logger.error('Persist-logs task failed', {
+            task: 'persist-logs',
+            issueNumber: ctx.issueNumber,
+            error: error instanceof Error ? error.message : String(error),
+            durationMs: performance.now() - startedAt,
+        });
+        if (!ctx.dryRun && octokit) {
+            try {
+                await postComment({
+                    octokit,
+                    ctx,
+                    body: 'Sorry, I encountered an error while capturing logs. Please try again or contact the team maintaining the bot.',
+                });
+            }
+            catch (commentError) {
+                logger.warn('Failed to post persist-logs failure response', {
+                    task: 'persist-logs',
+                    issueNumber: ctx.issueNumber,
+                    error: commentError instanceof Error ? commentError.message : String(commentError),
+                });
+            }
+        }
+        exitCode = 1;
+    }
+    finally {
+        // Independent network targets (GitHub vs Datadog) — safe to run concurrently.
+        await Promise.all([
+            cleanup(),
+            recordTaskMetrics({
+                type: 'logs',
+                repository: `${ctx.owner}/${ctx.repo}`,
+                model: PERSIST_LOGS_PROVIDER,
+                outcome: metricOutcome,
+                durationMs: performance.now() - startedAt,
+                reason: metricReason,
+            }),
+        ]);
+    }
+    if (exitCode !== 0) {
+        await shutdownTracing();
+        process.exit(exitCode);
+    }
+}
+const MAX_CSV_PREVIEW_ROWS = 50;
+export function buildSnapshotComment({ analysisContent, csvContent, worklogContent, totalLogs, bucket, s3Keys, presignedUrls, deliveryId, }) {
+    // Hidden metadata for /refresh-s3-urls to parse — flat list of all S3 keys
+    const allKeys = Object.values(s3Keys).filter(Boolean).join(',');
+    const s3Metadata = `<!-- s3-keys:${bucket}:${allKeys} -->`;
+    const linkItems = [];
+    if (presignedUrls.analysis) {
+        linkItems.push(`- [Full Analysis Report](${presignedUrls.analysis})`);
+    }
+    if (presignedUrls.csv) {
+        linkItems.push(`- [Full Logs CSV](${presignedUrls.csv}) (${totalLogs} entries)`);
+    }
+    if (presignedUrls.rawLogs) {
+        linkItems.push(`- [Raw Logs JSON](${presignedUrls.rawLogs})`);
+    }
+    if (presignedUrls.worklog) {
+        linkItems.push(`- [Investigation Worklog](${presignedUrls.worklog})`);
+    }
+    const linksSection = [
+        '### Archived Logs',
+        '',
+        ...linkItems,
+        '',
+        '_Links expire in 7 days. Use `@doistbot /refresh-s3-urls` to generate new links._',
+    ].join('\n');
+    const csvPreview = buildCsvPreview(csvContent);
+    // Always prepend the marker; model output won't contain it.
+    const analysis = analysisContent
+        ? `${LOG_SNAPSHOT_MARKER}\n${analysisContent}`
+        : `${LOG_SNAPSHOT_MARKER}\n## Datadog Log Snapshot\n\n**${totalLogs} log entries** captured from Datadog.`;
+    const sections = [s3Metadata, analysis];
+    if (worklogContent) {
+        sections.push('');
+        sections.push('<details>');
+        sections.push('<summary>Investigation worklog (queries and reasoning)</summary>');
+        sections.push('');
+        sections.push(worklogContent);
+        sections.push('');
+        sections.push('</details>');
+    }
+    if (csvPreview) {
+        sections.push('');
+        sections.push('<details>');
+        sections.push(`<summary>Top log entries (${Math.min(MAX_CSV_PREVIEW_ROWS, totalLogs)} of ${totalLogs})</summary>`);
+        sections.push('');
+        sections.push('```csv');
+        sections.push(csvPreview);
+        sections.push('```');
+        sections.push('</details>');
+    }
+    sections.push('');
+    sections.push(linksSection);
+    // Footer with DD logs link
+    const ddLink = buildDatadogLink(deliveryId);
+    if (ddLink) {
+        sections.push('');
+        sections.push(`<sub>[Investigation Logs](${ddLink})</sub>`);
+    }
+    return sections.join('\n');
+}
+function buildCsvPreview(csvContent) {
+    if (!csvContent)
+        return null;
+    const lines = csvContent.split('\n').filter((l) => l.trim());
+    if (lines.length <= 1)
+        return null; // header only or empty
+    // Keep header + up to MAX_CSV_PREVIEW_ROWS data rows
+    const preview = lines.slice(0, MAX_CSV_PREVIEW_ROWS + 1);
+    return preview.join('\n');
+}