Merge pull request #10 from polarsignals/add-post-step

Rewrite in JS and create deployment link linking to Polar Signals Cloud

Author: brancz

.github/workflows/github-actions-demo.yml

@@ -1,6 +1,10 @@
 name: GitHub Actions Demo of Continuous Profiling
 run-name: ${{ github.actor }} is testing out GitHub Actions Continuous Profiling 🚀
 on: [push]
+permissions:
+  deployments: write
+  contents: read    
+  pull-requests: read
 jobs:
   Profile-Your-CI:
     runs-on: ubuntu-latest
@@ -15,10 +19,12 @@ jobs:
         id: extract_branch
       - uses: ./ # Uses an action in the root directory.
         with:
-          polarsignals_cloud_token: ${{ secrets.PSToken }}
-          labels: 'branch=${{ steps.extract_branch.outputs.branch }};gh_run_id=${{ github.run_id }}'
+          polarsignals_cloud_token: ${{ secrets.PSTOKEN }}
+          labels: branch=${{ steps.extract_branch.outputs.branch }};gh_run_id=${{ github.run_id }}
+          project_uuid: ${{ secrets.POLARSIGNALSPROJECTUUID }}
+          github_token: ${{ secrets.GITHUB_TOKEN }}
       - name: Set up Go
         uses: actions/setup-go@6edd4406fa81c3da01a34fa6f6343087c207a568 # v3.5.0
       - name: Run my little go program that does busy work.
         run: cd example-process && go run main.go
-      - run: echo "🍏 This job's status is ${{ job.status }}." && sleep 300
+      - run: echo "🍏 This job's status is ${{ job.status }}." && sleep 10

README.md

@@ -12,3 +12,45 @@ If you are using Polar Signals cloud, the only thing required to configure is th
 
 Profiling data from one CI run looks [like this](https://pprof.me/475d1cc/).
 
+## Deployment Links
+
+This action can automatically create GitHub deployments with links to your profiling data, making it easy to access the results directly from your GitHub repository. For this feature to work, the following parameters must be configured:
+
+- `project_uuid`: Your Polar Signals Cloud project UUID
+
+If any of the required parameters are missing, the deployment creation will be skipped without failing the workflow, and log messages will indicate the reason.
+
+### Required Permissions
+
+For the deployment creation to work, your workflow needs the following permissions:
+
+```yaml
+permissions:
+  deployments: write
+  contents: read
+```
+
+### Example Configuration
+
+```yaml
+name: Profiling Workflow
+on: [push]
+
+permissions:
+  deployments: write
+  contents: read
+
+jobs:
+  profile:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      
+      - name: Run Continuous Profiling
+        uses: polarsignals/gh-actions-ps-profiling@main
+        with:
+          polarsignals_cloud_token: ${{ secrets.POLARSIGNALS_CLOUD_TOKEN }}
+          project_uuid: 'your-project-uuid-here'
+          labels: 'branch=${{ github.ref_name }};workflow=${{ github.workflow }}'
+```
+

action.yaml renamed to action.yml

@@ -1,4 +1,3 @@
-# action.yaml
 name: 'Polar Signals Continuous Profiling'
 description: 'Installs Parca to continuously profile your CI/CD pipeline.'
 inputs:
@@ -27,14 +26,21 @@ inputs:
   extra_args:
     description: 'Add any further arguments to the execution of the agent.'
     required: false
+  project_uuid:
+    description: 'Polar Signals Cloud project UUID for query URL generation.'
+    required: false
+  cloud_hostname:
+    description: 'Polar Signals Cloud hostname for query URL generation.'
+    required: false
+    default: 'cloud.polarsignals.com'
+  github_token:
+    description: 'GitHub token to use for creating deployments.'
+    required: false
+    default: '${{ github.token }}'
+outputs:
+  profiling_url:
+    description: 'The URL to the profiling data in Polar Signals Cloud.'
 runs:
-  using: 'composite'
-  steps:
-    - name: Install Parca Agent
-      shell: bash
-      run: |
-        curl --connect-timeout 5 --max-time 60 --retry 5 --retry-delay 0 --retry-max-time 600 -sL https://github.com/parca-dev/parca-agent/releases/download/v${{ inputs.parca_agent_version }}/parca-agent_${{ inputs.parca_agent_version }}_`uname -s`_`uname -m` > parca-agent
-        chmod +x ./parca-agent
-    - name: Run parca agent in background
-      shell: bash
-      run: sudo ./parca-agent --metadata-external-labels='${{ inputs.labels }}' --profiling-duration=${{ inputs.profiling_duration }} --profiling-cpu-sampling-frequency=${{ inputs.profiling_frequency }} --node=github --remote-store-address=${{ inputs.store_address }} --remote-store-bearer-token=${{ inputs.polarsignals_cloud_token }} ${{ inputs.extra_args }} > ${{ runner.temp }}/parca-agent.log 2>&1 &
+  using: 'node16'
+  main: 'index.js'
+  post: 'index.js'

example-process/main.go

@@ -11,7 +11,7 @@ func main() {
 }
 
 func printTenTimes() {
-	for i := 0; i < 10; i++ {
+	for i := 0; i < 5; i++ {
 		fmt.Println("Looping...")
 		doNothingButLoop()
 		time.Sleep(5 * time.Second)

index.js

@@ -0,0 +1,265 @@
+const core = require('@actions/core');
+const exec = require('@actions/exec');
+const tc = require('@actions/tool-cache');
+const os = require('os');
+const path = require('path');
+const fs = require('fs');
+
+// Store timestamps file path
+const timestampFile = path.join(process.env.RUNNER_TEMP || '/tmp', 'parca-agent-timestamps.json');
+
+// Parse labels string into an object
+function parseLabels(labelsString) {
+  if (!labelsString) return {};
+  
+  const result = {};
+  labelsString.split(';').forEach(label => {
+    const [key, value] = label.trim().split('=');
+    if (key && value !== undefined) {
+      result[key.trim()] = value.trim();
+    }
+  });
+  
+  return result;
+}
+
+async function run() {
+  try {
+    // Save start timestamp
+    const startTimestamp = Date.now();
+    
+    // Get inputs
+    const polarsignalsCloudToken = core.getInput('polarsignals_cloud_token', { required: true });
+    const storeAddress = core.getInput('store_address') || 'grpc.polarsignals.com:443';
+    const parcaAgentVersion = core.getInput('parca_agent_version') || '0.38.0';
+    const profilingFrequency = core.getInput('profiling_frequency') || '99';
+    const profilingDuration = core.getInput('profiling_duration') || '3s';
+    const labelsString = core.getInput('labels') || '';
+    const extraArgs = core.getInput('extra_args') || '';
+    const projectUuid = core.getInput('project_uuid') || '';
+    const cloudHostname = core.getInput('cloud_hostname') || 'cloud.polarsignals.com';
+    
+    // Parse labels
+    const labels = parseLabels(labelsString);
+    
+    // Save start timestamp and configuration to file
+    fs.writeFileSync(timestampFile, JSON.stringify({ 
+      startTimestamp,
+      projectUuid,
+      cloudHostname,
+      labels,
+      labelsString
+    }));
+    
+    core.info(`Saved start timestamp: ${startTimestamp}`);
+
+    // Determine platform specifics
+    const platform = os.platform();
+    const arch = os.arch();
+    
+    // Map NodeJS arch to Parca arch format
+    let parcaArch = arch;
+    if (arch === 'x64') parcaArch = 'x86_64';
+    if (arch === 'arm64') parcaArch = 'aarch64';
+    
+    // Map NodeJS platform to Parca platform format
+    let parcaPlatform = platform;
+    if (platform === 'win32') parcaPlatform = 'Windows';
+    if (platform === 'darwin') parcaPlatform = 'Darwin';
+    if (platform === 'linux') parcaPlatform = 'Linux';
+
+    // Download URL
+    const downloadUrl = `https://github.com/parca-dev/parca-agent/releases/download/v${parcaAgentVersion}/parca-agent_${parcaAgentVersion}_${parcaPlatform}_${parcaArch}`;
+    
+    core.info(`Downloading Parca Agent from ${downloadUrl}...`);
+    
+    // Download the Parca Agent
+    const agentPath = await tc.downloadTool(downloadUrl);
+    
+    // Make it executable
+    await exec.exec('chmod', ['+x', agentPath]);
+    
+    // Run the Parca agent in the background
+    const tempLogFile = path.join(process.env.RUNNER_TEMP || '/tmp', 'parca-agent.log');
+    
+    const args = [
+      `--metadata-external-labels=${labelsString}`,
+      `--profiling-duration=${profilingDuration}`,
+      `--profiling-cpu-sampling-frequency=${profilingFrequency}`,
+      '--node=github',
+      `--remote-store-address=${storeAddress}`,
+      `--remote-store-bearer-token=${polarsignalsCloudToken}`
+    ];
+    
+    if (extraArgs) {
+      args.push(extraArgs);
+    }
+    
+    core.info('Starting Parca Agent in the background...');
+    
+    // Use spawn to run in background
+    const { spawn } = require('child_process');
+    const sudoPrefix = platform === 'linux' ? ['sudo'] : [];
+    const command = sudoPrefix.concat([agentPath, ...args]);
+    
+    const parcaProcess = spawn(command[0], command.slice(1), {
+      detached: true,
+      stdio: ['ignore', 
+        fs.openSync(tempLogFile, 'a'),
+        fs.openSync(tempLogFile, 'a')
+      ]
+    });
+    
+    // Detach the process
+    parcaProcess.unref();
+    
+    core.info(`Parca Agent started with PID ${parcaProcess.pid}`);
+    core.info(`Logs available at: ${tempLogFile}`);
+    
+  } catch (error) {
+    core.setFailed(`Action failed with error: ${error.message}`);
+  }
+}
+
+async function post() {
+  try {
+    // Get ending timestamp
+    const endTimestamp = Date.now();
+    
+    // Read start timestamp from file
+    if (!fs.existsSync(timestampFile)) {
+      core.warning('Start timestamp file not found. Cannot create Polar Signals Cloud query.');
+      return;
+    }
+    
+    const data = JSON.parse(fs.readFileSync(timestampFile, 'utf8'));
+    const { startTimestamp, projectUuid, cloudHostname, labels, labelsString } = data;
+    
+    // Build the URL with the proper format
+    let queryUrl = `https://${cloudHostname}/`;
+    
+    // Append project UUID if provided
+    if (projectUuid) {
+      queryUrl += `projects/${projectUuid}?`;
+    }
+    
+    // Build label selector string
+    let labelSelector = '';
+    if (labelsString && Object.keys(labels).length > 0) {
+      const labelSelectors = [];
+      
+      for (const [key, value] of Object.entries(labels)) {
+        labelSelectors.push(`${key}="${value}"`);
+      }
+      
+      if (labelSelectors.length > 0) {
+        labelSelector = '{' + labelSelectors.join(',') + '}';
+      }
+    }
+    
+    // Define parameters for the URL
+    const baseMetric = 'parca_agent:samples:count:cpu:nanoseconds:delta';
+    const expression = labelSelector ? `${baseMetric}${labelSelector}` : baseMetric;
+    const encodedExpression = encodeURIComponent(expression);
+    
+    // Calculate a reasonable step count
+    const durationSeconds = Math.floor((endTimestamp - startTimestamp) / 1000);
+    const stepCount = Math.min(Math.max(Math.floor(durationSeconds / 10), 50), 500); // Between 50 and 500 steps
+    
+    // Add the query parameters with the complex format
+    queryUrl += `query_browser_mode=simple`;
+    queryUrl += `&step_count=${stepCount}`;
+    queryUrl += `&expression_a=${encodedExpression}`;
+    queryUrl += `&from_a=${startTimestamp}`;
+    queryUrl += `&to_a=${endTimestamp}`;
+    queryUrl += `&time_selection_a=custom`;
+    queryUrl += `&sum_by_a=comm`;
+    queryUrl += `&merge_from_a=${startTimestamp}`;
+    queryUrl += `&merge_to_a=${endTimestamp}`;
+    queryUrl += `&selection_a=${encodedExpression}`;
+    
+    core.info('Polar Signals Cloud Query Information:');
+    core.info(`- Start time: ${new Date(startTimestamp).toISOString()} (${startTimestamp}ms)`);
+    core.info(`- End time: ${new Date(endTimestamp).toISOString()} (${endTimestamp}ms)`);
+    core.info(`- Duration: ${Math.round((endTimestamp - startTimestamp) / 1000)} seconds`);
+    core.info(`- Query URL: ${queryUrl}`);
+    
+    // Set output for the action
+    core.setOutput('profiling_url', queryUrl);
+
+    // Create a GitHub deployment if running in GitHub Actions and all required parameters are available
+    if (process.env.GITHUB_ACTIONS) {
+      try {
+        const github_token = core.getInput('github_token');
+        const repository = process.env.GITHUB_REPOSITORY;
+        const [owner, repo] = (repository || '').split('/');
+        const ref = process.env.GITHUB_REF || process.env.GITHUB_SHA;
+        
+        // Check if all required parameters are available for deployment
+        if (github_token && owner && repo && ref && projectUuid && queryUrl) {
+          core.info(`Creating deployment for ${owner}/${repo} at ${ref}`);
+          
+          const octokit = require('@octokit/rest');
+          const { Octokit } = octokit;
+          const client = new Octokit({
+            auth: github_token
+          });
+          
+          const deployment = await client.repos.createDeployment({
+            owner,
+            repo,
+            ref,
+            environment: 'polar-signals-cloud',
+            required_contexts: [],
+            auto_merge: false,
+            description: 'Polar Signals Profiling Results',
+            transient_environment: true,
+            production_environment: false
+          });
+          
+          // Create a deployment status
+          if (deployment.data.id) {
+            const deploymentId = deployment.data.id;
+            await client.repos.createDeploymentStatus({
+              owner,
+              repo,
+              deployment_id: deploymentId,
+              state: 'success',
+              description: 'Profiling data is available',
+              environment_url: queryUrl,
+              log_url: queryUrl,
+              auto_inactive: true
+            });
+            
+            core.info(`Created deployment with ID: ${deploymentId}`);
+          }
+        } else {
+          core.info('Skipping GitHub deployment creation due to missing required parameters:');
+          if (!github_token) core.info('- Missing github_token');
+          if (!owner || !repo) core.info(`- Missing repository information: ${repository}`);
+          if (!ref) core.info('- Missing ref information');
+          if (!projectUuid) core.info('- Missing project_uuid');
+          if (!queryUrl) core.info('- Missing queryUrl');
+        }
+      } catch (deployError) {
+        core.warning(`Failed to create GitHub deployment: ${deployError.message}`);
+      }
+    }
+    
+    // Clean up timestamp file
+    fs.unlinkSync(timestampFile);
+    
+  } catch (error) {
+    core.warning(`Post action failed with error: ${error.message}`);
+  }
+}
+
+// Determine whether to run the main action or post action
+const isPost = !!process.env.STATE_isPost;
+if (isPost) {
+  post();
+} else {
+  run();
+  // Save state to indicate post action should run
+  core.saveState('isPost', 'true');
+}