11 posts tagged with "github"

module.exports = {
    metadata: {
        name: 'aws-lambda-browse-github-code',
        description: 'Browse the deployed code for AWS Lambda functions by linking to the GitHub repository at the specific version',
        match: {
            contextType: 'aws',
            context: {
                'service.name': { equals: 'lambda' },
                'service.arn': { exists: true },
                'scope.region': { exists: true },
                'service.resourceName': { exists: true }
            }
        },
        requiredSecrets: ['AWS_ACCESS_KEY_ID', 'AWS_SECRET_ACCESS_KEY'],
        cache: 900
    },
    run: async function (context, secrets = {}) {
        // Get AWS region from context
        const awsRegion = context.scope.region;
        const functionName = context.service.resourceName;

        try {
            // Query AWS Lambda to get function tags
            const { LambdaClient, ListTagsCommand } = require('@aws-sdk/client-lambda');
            
            const lambdaClient = new LambdaClient({
                credentials: {
                    accessKeyId: secrets.AWS_ACCESS_KEY_ID,
                    secretAccessKey: secrets.AWS_SECRET_ACCESS_KEY,
                },
                region: awsRegion
            });

            const command = new ListTagsCommand({ Resource: context.service.arn });
            const tagsResponse = await lambdaClient.send(command);
            
            // Look for repository and version tags
            const repository = tagsResponse.Tags?.repository;
            const version = tagsResponse.Tags?.version;
            
            if (!repository) {
                logger.warn({
                    operation: 'aws-lambda-browse-github-code',
                    step: 'no-repository-tag',
                    functionName: functionName
                }, 'No repository tag found on Lambda function');
                return [];
            }

            if (!version) {
                logger.warn({
                    operation: 'aws-lambda-browse-github-code',
                    step: 'no-version-tag',
                    functionName: functionName,
                    repository: repository
                }, 'No version tag found on Lambda function');
                return [];
            }

            // Construct GitHub URL
            const githubUrl = `https://github.com/${repository}/tree/${version}`;

            const results = [
                {
                    type: 'link',
                    content: `Browse code @ ${version.substring(0, 7)}`,
                    href: githubUrl,
                    icon: 'github'
                }
            ];

            logger.info({
                operation: 'aws-lambda-browse-github-code',
                step: 'success',
                functionName: functionName,
                repository: repository,
                version: version,
                githubUrl: githubUrl
            }, 'Successfully generated GitHub code browse link');

            return results;

        } catch (error) {
            logger.error({
                operation: 'aws-lambda-browse-github-code',
                step: 'aws-lambda-error',
                functionName: functionName,
                error: error.message
            }, 'Error querying AWS Lambda tags');
            return [];
        }
    }
};

module.exports = {
    metadata: {
        name: 'github-aws-infrastructure',
        description: 'Show Lambda functions in us-east-1 tagged with this repository as a dropdown',
        match: {
            contextType: 'github',
            context: {
                'page.repository': { startsWith: 'my-org/' }
            }
        },
        requiredSecrets: ['AWS_ACCESS_KEY_ID', 'AWS_SECRET_ACCESS_KEY'],
        cache: 1800
    },
    run: async function (context, secrets = {}) {
        const { ResourceGroupsTaggingAPIClient, GetResourcesCommand } = require('@aws-sdk/client-resource-groups-tagging-api');

        const region = 'us-east-1';
        const tagKey = 'repository';
        const tagValue = context.page.repository; // e.g., "company/webshop"

        const tagging = new ResourceGroupsTaggingAPIClient({
            region,
            credentials: {
                accessKeyId: secrets.AWS_ACCESS_KEY_ID,
                secretAccessKey: secrets.AWS_SECRET_ACCESS_KEY,
            },
        });

        const matched = [];
        let token;
        do {
            const out = await tagging.send(new GetResourcesCommand({
                ResourceTypeFilters: ['lambda:function'],
                TagFilters: [{ Key: tagKey, Values: [tagValue] }],
                PaginationToken: token,
            }));

            const list = out.ResourceTagMappingList || [];
            for (const m of list) {
                if (matched.length > 10) break; // collect up to 11 to know if there are more
                const arn = m.ResourceARN || '';
                const name = arn.split(':').pop();
                if (name) {
                    matched.push({ name, arn });
                }
            }

            token = out.PaginationToken;
            if (matched.length > 10) break;
        } while (token);

        if (matched.length === 0) {
            return [];
        }

        // First 10 items
        const items = matched.slice(0, 10).map(m => ({
            content: m.name,
            href: `https://${region}.console.aws.amazon.com/lambda/home?region=${region}#/functions/${encodeURIComponent(m.name)}?tab=configuration`
        }));

        // If more than 10, add a More… item linking to Lambda list filtered by tag
        if (matched.length > 10) {
            const moreUrl = `https://${region}.console.aws.amazon.com/lambda/home?region=${region}#/functions?search=${encodeURIComponent('tag:repository=' + tagValue)}`;
            items.push({ content: 'More…', href: moreUrl, status: 'relevant' });
        }

        return [{
            type: 'dropdown',
            content: `AWS Infra (${matched.length} Lambdas)`,
            items
        }];
    }
};

module.exports = {
    metadata: {
        name: 'github-datadog-logs-alerts',
        description: 'Show any active alerts from Datadog in Github, and jump from Github to Logs and Alerts for this repository',
        match: {
            contextType: 'github',
            context: {
                'page.repository': { startsWith: 'my-org/' }
            }
        },
        requiredSecrets: ['DATADOG_API_KEY', 'DATADOG_APP_KEY'],
        cache: 300
    },
    run: async function (context, secrets = {}) {

        // adjust this to your Datadog instance
        const DATADOG_HOST = 'https://api.datadoghq.com';
        
        // assume the alerts for services belonging to this repository are tagged using the repository tag
        const repoTag = `repository:${context.page.repository}`;

        // if using Datadog EU instance, please change the url accordingly
        const url = `${DATADOG_HOST}/api/v1/monitor?group_states=alert&monitor_tags=${encodeURIComponent(repoTag)}`;
        const response = await fetch(url, {
            method: 'GET',
            headers: {
                'DD-API-KEY': secrets.DATADOG_API_KEY,
                'DD-APPLICATION-KEY': secrets.DATADOG_APP_KEY,
                'Content-Type': 'application/json'
            }
        });

        if (!response.ok) {
            throw new Error(`Datadog API error: ${response.status} ${response.statusText}`);
        }

        monitorList = await response.json();
        // Filter monitorList to only include monitors with overall_state === "Alert"
        monitorList = Array.isArray(monitorList)
            ? monitorList.filter(monitor => monitor.overall_state === "Alert")
            : [];
        const activeAlertsCount = monitorList.length || 0;
  
        // Build Datadog logs and alerts URLs for this repository
        const logsUrl = `${DATADOG_HOST}/logs?query=${encodeURIComponent(repoTag)}`;
        const alertsUrl = `${DATADOG_HOST}/monitors/manage?q=tag%3A"${encodeURIComponent(repoTag)}`;

        const results = [
            {
                type: 'link',
                content: `${activeAlertsCount} alert${activeAlertsCount === 1 ? '' : 's'}`,
                href: alertsUrl,
                status: activeAlertsCount > 0 ? 'important' : 'success',
                icon: 'datadog'
            },
            { type: 'link', content: 'Logs', href: logsUrl, icon: 'datadog' }
        ];

        return results;
    }
};

module.exports = {
    metadata: {
        name: 'github-show-deployed-service-urls',
        description: 'Show staging and production URLs for this repository as a dropdown, using a data file mapping',
        match: {
            contextType: 'github',
            context: {
                'page.repository': { startsWith: 'my-org/' }
            }
        },
        requiredSecrets: [],
        cache: 300
    },
    run: async function (context, secrets = {}, dataFiles = []) {
        const repo = context.page.repository; // e.g., "company/webshop"

        // Expect a data file like deployed-urls.data.json with shape:
        // { "mappings": { "org/repo": { "production": "https://...", "staging": "https://..." } } }
        const df = dataFiles.find(f => f.id === 'deployed-urls');
        if (!df || !df.data) {
            return [];
        }

        const mappings = df.data.mappings || {};
        const envs = mappings[repo];
        if (!envs || (typeof envs !== 'object')) {
            return [];
        }

        const items = [];
        if (envs.production) {
            items.push({ content: 'Production', href: envs.production, status: 'important', icon: 'link' });
        }
        if (envs.staging) {
            items.push({ content: 'Staging', href: envs.staging, icon: 'link' });
        }

        if (items.length === 0) {
            return [];
        }

        return [
            {
                type: 'dropdown',
                content: 'Deployed URLs',
                items
            }
        ];
    }
};

module.exports = {
    metadata: {
        name: 'github-launchdarkly',
        description: 'Show LaunchDarkly feature flags tagged with this repository as a dropdown',
        match: {
            contextType: 'github',
            context: {
                'page.repository': { startsWith: 'my-org/' }
            }
        },
        requiredSecrets: ['LAUNCHDARKLY_ACCESS_TOKEN'],
        cache: 1800
    },
    run: async function (context, secrets = {}) {
        // Extract repository name (last part after /)
        const repository = context.page.repository; // e.g., "company/webshop"
        const repoName = repository.split('/').pop(); // e.g., "webshop"
        
        const projectKey = 'your-project-key'; // Replace with your LaunchDarkly project key
        const tagKey = 'repository';
        const tagValue = repoName;

        const apiUrl = `https://app.launchdarkly.com/api/v2/flags/${projectKey}?filter=tags:${tagKey}:${tagValue}`;

        const response = await fetch(apiUrl, {
            method: 'GET',
            headers: {
                'Authorization': `Bearer ${secrets.LAUNCHDARKLY_ACCESS_TOKEN}`,
                'Content-Type': 'application/json'
            }
        });

        if (!response.ok) {
            throw new Error(`LaunchDarkly API request failed: ${response.status} ${response.statusText}`);
        }

        const data = await response.json();
        const flags = data.items || [];

        if (flags.length === 0) {
            return [];
        }

        // First 10 items
        const items = flags.slice(0, 10).map(flag => ({
            content: flag.key,
            href: `https://app.launchdarkly.com/${projectKey}/flags/${flag.key}`,
            icon: 'launchdarkly'
        }));

        // If more than 10, add a More… item linking to LaunchDarkly flags list filtered by tag
        if (flags.length > 10) {
            const moreUrl = `https://app.launchdarkly.com/${projectKey}/flags?filter=tags:${tagKey}:${tagValue}`;
            items.push({ 
                content: 'More…', 
                href: moreUrl, 
                status: 'relevant',
                icon: 'launchdarkly'
            });
        }

        return [{
            type: 'dropdown',
            content: `Feature Flags (${flags.length} flags)`,
            icon: 'launchdarkly',
            items
        }];
    }
};

module.exports = {
    metadata: {
        name: 'github-next-deploy',
        description: 'Show when the repository will be deployed next based on a hardcoded schedule',
        match: {
            contextType: 'github',
            context: {
                'page.repository': { startsWith: 'my-org/' }
            }
        },
        requiredSecrets: [],
        cache: 60
    },
    run: async function (context, secrets = {}, dataFiles = []) {
        // Hardcoded deployment schedule:
        // Days: Tuesday, Wednesday, Thursday
        // Times (local time): 09:00, 15:00, 20:00
        const allowedDays = new Set([2, 3, 4]); // 0=Sun ... 6=Sat
        const allowedHours = [9, 15, 20];

        const now = new Date();

        function nextScheduled(nowDate) {
            const candidates = [];
            for (let d = 0; d <= 7; d++) { // look up to one week ahead
                const probe = new Date(nowDate);
                probe.setDate(nowDate.getDate() + d);
                const day = probe.getDay();
                if (!allowedDays.has(day)) continue;
                for (const h of allowedHours) {
                    const slot = new Date(probe);
                    slot.setHours(h, 0, 0, 0);
                    if (slot > nowDate) {
                        candidates.push(slot.getTime());
                    }
                }
            }
            if (candidates.length === 0) return null;
            const ts = Math.min(...candidates);
            return new Date(ts);
        }

        function formatDiff(from, to) {
            const ms = Math.max(0, to.getTime() - from.getTime());
            const HOUR = 60 * 60 * 1000;
            const DAY = 24 * HOUR;
            const days = Math.floor(ms / DAY);
            const hours = Math.floor((ms - days * DAY) / HOUR);
            if (days > 0) return `Next deploy: ${days}d ${hours}h`;
            return `Next deploy: ${hours}h`;
        }

        const next = nextScheduled(now);
        if (!next) return [];

        return [
            { type: 'text', status: 'relevant', content: formatDiff(now, next) }
        ];
    }
};

module.exports = {
    metadata: {
        name: 'github-aws-costs',
        description: 'Show last 30 days AWS cost for resources tagged with this GitHub repository and link to Cost Explorer',
        match: {
            contextType: 'github',
            context: {
                'page.repository': { startsWith: 'my-org/' }
            }
        },
        requiredSecrets: ['AWS_ACCESS_KEY_ID', 'AWS_SECRET_ACCESS_KEY'],
        cache: 300
    },
    run: async function (context, secrets = {}) {
        // Import AWS SDK v3 Cost Explorer client only at runtime
        const { CostExplorerClient, GetCostAndUsageCommand } = require('@aws-sdk/client-cost-explorer');

        // Tag key and value derived from GitHub context
        const tagKey = 'repository';
        const tagValue = context.page.repository; // e.g. "company/webshop"

        // Cost Explorer is in us-east-1
        const client = new CostExplorerClient({
            region: 'us-east-1',
            credentials: {
                accessKeyId: secrets.AWS_ACCESS_KEY_ID,
                secretAccessKey: secrets.AWS_SECRET_ACCESS_KEY,
            },
        });

        // Build a 30-day window (End is exclusive per AWS API)
        function toYMD(d) {
            const y = d.getUTCFullYear();
            const m = String(d.getUTCMonth() + 1).padStart(2, '0');
            const day = String(d.getUTCDate()).padStart(2, '0');
            return `${y}-${m}-${day}`;
        }
        const endDate = new Date(); // today (exclusive)
        const startDate = new Date();
        startDate.setUTCDate(endDate.getUTCDate() - 30);

        const params = {
            TimePeriod: { Start: toYMD(startDate), End: toYMD(endDate) },
            Granularity: 'DAILY',
            Metrics: ['UnblendedCost'],
            Filter: {
                Tags: { Key: tagKey, Values: [tagValue] }
            }
        };

        let total = 0;
        let unit = 'USD';
        let nextToken;
        do {
            const resp = await client.send(new GetCostAndUsageCommand({ ...params, NextPageToken: nextToken }));
            if (Array.isArray(resp.ResultsByTime)) {
                for (const p of resp.ResultsByTime) {
                    const metric = p.Total && p.Total.UnblendedCost;
                    if (metric && metric.Amount) {
                        total += parseFloat(metric.Amount);
                        unit = metric.Unit || unit;
                    }
                }
            }
            nextToken = resp.NextPageToken;
        } while (nextToken);

        // Build a deep link to AWS Cost Explorer filtered by the tag and last 30 days
        const ceFilter = { Tags: { Key: tagKey, Values: [tagValue] } };
        const ceUrl = 'https://us-east-1.console.aws.amazon.com/cost-management/home' +
            '?region=us-east-1#/cost-explorer' +
            `?timeRange=LAST_30_DAYS&granularity=DAILY&costMetric=UnblendedCost&filter=${encodeURIComponent(JSON.stringify(ceFilter))}`;

        // Format amount (simple two-decimal string)
        const currencySymbol = unit === 'USD' ? '$' : `${unit} `;
        const pretty = `${currencySymbol}${total.toFixed(2)}`;

        const results = [
            { type: 'link', content: `Costs 30d: ${pretty}`, href: ceUrl }
        ];

        return results;
    }
};

module.exports = {
    metadata: {
        name: 'github-circleci-browse-deployment',
        description: 'Dropdown to browse the deployed revisions (staging, QA) on GitHub using CircleCI workflows',
        match: {
            contextType: 'github',
            context: {
                'page.repository': { startsWith: 'my-org/' }
            }
        },
        requiredSecrets: ['CIRCLECI_API_TOKEN'],
        cache: 300
    },
    run: async function (context, secrets = {}) {
        const CIRCLE_HOST = 'https://circleci.com/api/v2';
        const repo = context.page.repository; // e.g., "org/repo"
        const projectSlug = `gh/${repo}`;
        const branch = 'main';

        // Conventional workflow names used by many teams; customize if needed
        const WORKFLOWS = {
            staging: 'deploy-staging',
            prod: 'deploy-prod'
        };

        const headers = {
            'Circle-Token': secrets.CIRCLECI_API_TOKEN,
            'Accept': 'application/json'
        };

        async function getDeployedShaForWorkflow(workflowName) {
            // Use Insights to find the most recent successful run for the workflow on the target branch
            const insightsUrl = `${CIRCLE_HOST}/insights/${encodeURIComponent(projectSlug)}/workflows/${encodeURIComponent(workflowName)}?branch=${encodeURIComponent(branch)}`;
            const r1 = await fetch(insightsUrl, { headers });
            if (!r1.ok) throw new Error(`CircleCI insights error (${workflowName}): ${r1.status} ${r1.statusText}`);
            const j1 = await r1.json();
            const items = Array.isArray(j1.items) ? j1.items : [];
            const success = items.find(i => i.status === 'success');
            if (!success) return null;

            // Resolve pipeline id from pipeline number so we can get VCS revision (commit SHA)
            const byNumberUrl = `${CIRCLE_HOST}/project/${encodeURIComponent(projectSlug)}/pipeline/${success.pipeline_number}`;
            const r2 = await fetch(byNumberUrl, { headers });
            if (!r2.ok) throw new Error(`CircleCI pipeline lookup error: ${r2.status} ${r2.statusText}`);
            const j2 = await r2.json();
            const pipelineId = j2.id;
            if (!pipelineId) return null;

            const pipelineUrl = `${CIRCLE_HOST}/pipeline/${pipelineId}`;
            const r3 = await fetch(pipelineUrl, { headers });
            if (!r3.ok) throw new Error(`CircleCI pipeline fetch error: ${r3.status} ${r3.statusText}`);
            const j3 = await r3.json();
            const sha = j3.vcs && j3.vcs.revision;
            return sha || null;
        }

        const [stagingSha, prodSha] = await Promise.all([
            getDeployedShaForWorkflow(WORKFLOWS.staging),
            getDeployedShaForWorkflow(WORKFLOWS.prod)
        ]);

        const items = [];
        if (stagingSha) {
            items.push({ content: 'Staging', href: `https://github.com/${repo}/tree/${stagingSha}` });
        }
        if (prodSha) {
            items.push({ content: 'Prod', href: `https://github.com/${repo}/tree/${prodSha}` });
        }

        if (items.length === 0) return [];

        return [{
            type: 'dropdown',
            content: 'Browse deployment',
            icon: 'github',
            items
        }];
    }
};

module.exports = {
    metadata: {
        name: 'github-circleci-last-deploy',
        description: 'Show when main was last deployed to production (deploy-prod workflow) and link to the workflow run',
        match: {
            contextType: 'github',
            context: {
                'url': { exists: true },
                'page.repository': { startsWith: 'my-org/' }
            }
        },
        requiredSecrets: ['CIRCLECI_API_TOKEN'],
        cache: 300
    },
    run: async function (context, secrets = {}) {
        const CIRCLE_HOST = 'https://circleci.com/api/v2';
        const repo = context.page.repository; // e.g., "org/repo"
        const projectSlug = `gh/${repo}`;
        const workflowName = 'deploy-prod';
        const branch = 'main';

        // Helper to format "Deployed 3d ago" / "Deployed 3h ago"
        function formatRelativeDuration(thenIso) {
            const then = new Date(thenIso).getTime();
            const now = Date.now();
            const diffMs = Math.max(0, now - then);
            const diffMin = Math.floor(diffMs / 60000);
            const diffHr = Math.floor(diffMin / 60);
            const diffDay = Math.floor(diffHr / 24);
            if (diffDay >= 1) return `Deployed ${diffDay}d ago`;
            if (diffHr >= 1) return `Deployed ${diffHr}h ago`;
            return `Deployed ${Math.max(1, diffMin)}m ago`;
        }

        const headers = {
            'Circle-Token': secrets.CIRCLECI_API_TOKEN,
            'Accept': 'application/json'
        };

        // Insights API: latest runs for a workflow on a branch
        const url = `${CIRCLE_HOST}/insights/${encodeURIComponent(projectSlug)}/workflows/${encodeURIComponent(workflowName)}?branch=${encodeURIComponent(branch)}`;
        const resp = await fetch(url, { headers });
        if (!resp.ok) {
            throw new Error(`CircleCI API error: ${resp.status} ${resp.statusText}`);
        }

        const json = await resp.json();
        const items = Array.isArray(json.items) ? json.items : [];
        const success = items.find(i => i.status === 'success');
        if (!success) {
            return [];
        }

        const workflowId = success.id; // workflow UUID
        const pipelineNumber = success.pipeline_number; // for deep link
        const stoppedAt = success.stopped_at || success.created_at;

        const relative = formatRelativeDuration(stoppedAt);
        const link = `https://app.circleci.com/pipelines/gh/${repo}/${pipelineNumber}/workflows/${workflowId}`;

        return [
            { type: 'link', content: relative, href: link, icon: 'circleci' }
        ];
    }
};

module.exports = {
    metadata: {
        name: 'github-pagerduty-oncall',
        description: 'Show current L1 on-call for the first PagerDuty service tagged with this repository, with link to the On-Call view',
        match: {
            contextType: 'github',
            context: {
                'page.repository': { startsWith: 'my-org/' }
            }
        },
        requiredSecrets: ['PAGERDUTY_API_TOKEN'],
        cache: 900
    },
    run: async function (context, secrets = {}) {
        const PD_HOST = 'https://api.pagerduty.com'; // US API

        const repoTag = `repository:${context.page.repository}`;
        const headers = {
            'Authorization': `Token token=${secrets.PAGERDUTY_API_TOKEN}`,
            'Accept': 'application/vnd.pagerduty+json;version=2',
            'Content-Type': 'application/json'
        };

        // 1) Resolve the tag ID by label (exact match)
        const tagsResp = await fetch(`${PD_HOST}/tags?query=${encodeURIComponent(repoTag)}&limit=25`, { headers });
        if (!tagsResp.ok) {
            throw new Error(`PagerDuty API error (tags): ${tagsResp.status} ${tagsResp.statusText}`);
        }
        const tagsJson = await tagsResp.json();
        const tag = (tagsJson.tags || []).find(t => t.label === repoTag);
        if (!tag) {
            return [];
        }

        // 2) Find first service entity with this tag
        const entitiesResp = await fetch(`${PD_HOST}/tags/${encodeURIComponent(tag.id)}/entities?type=service&limit=25`, { headers });
        if (!entitiesResp.ok) {
            throw new Error(`PagerDuty API error (tag entities): ${entitiesResp.status} ${entitiesResp.statusText}`);
        }
        const entitiesJson = await entitiesResp.json();
        const service = (entitiesJson.entities || []).find(e => e.type === 'service');
        if (!service) {
            return [];
        }

        // 3) Fetch service to get escalation policy
        const serviceResp = await fetch(`${PD_HOST}/services/${encodeURIComponent(service.id)}?include[]=escalation_policy`, { headers });
        if (!serviceResp.ok) {
            throw new Error(`PagerDuty API error (service): ${serviceResp.status} ${serviceResp.statusText}`);
        }
        const serviceJson = await serviceResp.json();
        const ep = serviceJson.service && serviceJson.service.escalation_policy;
        if (!ep || !ep.id) {
            return [];
        }

        // 4) Query on-calls for this escalation policy and pick L1
        const oncallsResp = await fetch(`${PD_HOST}/oncalls?limit=25&escalation_policy_ids[]=${encodeURIComponent(ep.id)}`, { headers });
        if (!oncallsResp.ok) {
            throw new Error(`PagerDuty API error (oncalls): ${oncallsResp.status} ${oncallsResp.statusText}`);
        }
        const oncallsJson = await oncallsResp.json();
        const l1 = (oncallsJson.oncalls || []).find(o => o.escalation_level === 1);
        if (!l1 || !l1.user) {
            return [];
        }

        // Extract first name
        const fullName = l1.user.name || l1.user.summary || '';
        const firstName = fullName.split(' ')[0] || fullName;

        // 5) Build deep link to On-Call view filtered by service
        const oncallUrl = `https://app.pagerduty.com/oncalls?service_ids[]=${encodeURIComponent(service.id)}`;

        const results = [
            { type: 'link', content: `On-call: ${firstName}`, icon: 'pagerduty', href: oncallUrl },
        ];

        return results;
    }
};