Case Study Salesforce vs Asana: A Head-to-Head

import os
import sys
import json
import logging
from typing import Dict, List, Optional
from asana import ApiClient, Configuration, TaskApi
from asana.exceptions import ApiException, NotFoundException, RateLimitException

# Configure logging for audit trails
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s',
    handlers=[logging.StreamHandler(sys.stdout)]
)
logger = logging.getLogger(__name__)

class AsanaTaskCreator:
    """Handle bulk task creation in Asana with retry logic and error handling."""

    def __init__(self, access_token: str, project_gid: str):
        """Initialize Asana client with auth token and target project.

        Args:
            access_token: Personal Access Token from Asana Developer Console
            project_gid: GID of the target Asana project (e.g., 123456789012345)
        """
        self.project_gid = project_gid
        config = Configuration()
        config.access_token = access_token
        self.client = ApiClient(config)
        self.task_api = TaskApi(self.client)
        self.max_retries = 3
        self.retry_delay = 2  # seconds

    def create_task(self, task_data: Dict) -> Optional[str]:
        """Create a single task with exponential backoff for rate limits.

        Args:
            task_data: Dict containing task fields (name, notes, assignee, due_on)

        Returns:
            Task GID if successful, None otherwise
        """
        for attempt in range(self.max_retries):
            try:
                response = self.task_api.create_task(
                    task_data,
                    opts={'project': self.project_gid}
                )
                logger.info(f'Created task: {response["gid"]} - {response["name"]}')
                return response['gid']
            except RateLimitException as e:
                wait_time = self.retry_delay * (2 ** attempt)
                logger.warning(f'Rate limited. Retrying in {wait_time}s (attempt {attempt+1}/{self.max_retries})')
                time.sleep(wait_time)
            except NotFoundException as e:
                logger.error(f'Project or assignee not found: {e}')
                return None
            except ApiException as e:
                logger.error(f'Asana API error: {e.status} - {e.body}')
                if attempt == self.max_retries - 1:
                    return None
                time.sleep(self.retry_delay)
        return None

    def bulk_create_tasks(self, tasks: List[Dict]) -> Dict[str, int]:
        """Bulk create tasks from a list of task dicts.

        Returns:
            Dict with success/failure counts
        """
        results = {'success': 0, 'failed': 0}
        for task in tasks:
            if self.create_task(task):
                results['success'] += 1
            else:
                results['failed'] += 1
        logger.info(f'Bulk creation complete: {results}')
        return results

if __name__ == '__main__':
    # Load config from environment variables (never hardcode tokens!)
    access_token = os.getenv('ASANA_PAT')
    project_gid = os.getenv('ASANA_PROJECT_GID')

    if not access_token or not project_gid:
        logger.error('Missing ASANA_PAT or ASANA_PROJECT_GID environment variables')
        sys.exit(1)

    # Sample task list for a backend release sprint
    release_tasks = [
        {'name': 'Implement user auth middleware', 'notes': 'Add JWT validation for API endpoints', 'assignee': '987654321', 'due_on': '2024-10-15'},
        {'name': 'Write integration tests for auth', 'notes': 'Cover 90% of auth edge cases', 'assignee': '987654321', 'due_on': '2024-10-17'},
        {'name': 'Deploy to staging environment', 'notes': 'Use GitHub Actions workflow 4.2', 'assignee': '123456789', 'due_on': '2024-10-18'},
    ]

    creator = AsanaTaskCreator(access_token, project_gid)
    results = creator.bulk_create_tasks(release_tasks)
    print(f'Results: {results}')

public class SalesforceProjectTaskCreator {
    // Custom exception for task creation failures
    public class TaskCreationException extends Exception {}

    // Configuration constants
    private static final Integer MAX_RETRIES = 3;
    private static final Integer RATE_LIMIT_DELAY_MS = 2000;
    private static final String PROJECT_RECORD_TYPE = 'Engineering_Project';

    /** Create a project task linked to a parent opportunity (Salesforce CRM integration)
     * 
     * @param projectId: ID of the Engineering_Project__c record
     * @param taskData: Map of task fields (Name, Description, AssigneeId, DueDate)
     * @return: ID of the created Task record
     * @throws TaskCreationException: If task creation fails after retries
     */
    public static Id createProjectTask(Id projectId, Map taskData) {
        // Validate project exists and is active
        Engineering_Project__c project;
        try {
            project = [SELECT Id, Name, Status__c FROM Engineering_Project__c WHERE Id = :projectId AND Status__c != 'Closed' LIMIT 1];
        } catch (QueryException e) {
            throw new TaskCreationException('Project not found or closed: ' + projectId);
        }

        // Prepare task record
        Task newTask = new Task();
        newTask.Subject = (String) taskData.get('Name');
        newTask.Description = (String) taskData.get('Description');
        newTask.OwnerId = (Id) taskData.get('AssigneeId');
        newTask.ActivityDate = (Date) taskData.get('DueDate');
        newTask.WhatId = projectId;  // Link to custom project record
        newTask.Priority = (String) taskData.getOrDefault('Priority', 'Medium');
        newTask.Status = 'Not Started';

        // Retry logic for DML failures (e.g., rate limits, validation rules)
        for (Integer attempt = 0; attempt < MAX_RETRIES; attempt++) {
            try {
                insert newTask;
                // Log to Salesforce Debug logs for audit
                System.debug(LoggingLevel.INFO, 'Created Task: ' + newTask.Id + ' for Project: ' + project.Name);
                return newTask.Id;
            } catch (DmlException e) {
                // Check if error is rate limit related
                if (e.getMessage().contains('UNABLE_TO_LOCK_ROW') || e.getMessage().contains('REQUEST_LIMIT_EXCEEDED')) {
                    System.debug(LoggingLevel.WARN, 'Rate limit hit, retrying after delay. Attempt: ' + (attempt + 1));
                    Long startTime = System.currentTimeMillis();
                    while (System.currentTimeMillis() - startTime < RATE_LIMIT_DELAY_MS * (2 ^ attempt)) {
                        // Busy wait (not ideal, but Salesforce doesn't support Thread.sleep)
                    }
                } else {
                    throw new TaskCreationException('DML error creating task: ' + e.getMessage());
                }
            }
        }
        throw new TaskCreationException('Failed to create task after ' + MAX_RETRIES + ' retries');
    }

    /** Bulk create tasks for a sprint, linked to a parent opportunity
     * 
     * @param projectId: Parent project ID
     * @param taskList: List of task data maps
     * @return: Map of task names to created IDs (null for failures)
     */
    public static Map bulkCreateTasks(Id projectId, List> taskList) {
        Map results = new Map();
        for (Map taskData : taskList) {
            try {
                Id taskId = createProjectTask(projectId, taskData);
                results.put((String) taskData.get('Name'), taskId);
            } catch (TaskCreationException e) {
                System.debug(LoggingLevel.ERROR, 'Failed to create task: ' + taskData.get('Name') + ' - ' + e.getMessage());
                results.put((String) taskData.get('Name'), null);
            }
        }
        return results;
    }

    // Sample usage for a release sprint
    public static void createReleaseSprintTasks() {
        // Fetch active release project
        Engineering_Project__c releaseProject;
        try {
            releaseProject = [SELECT Id FROM Engineering_Project__c WHERE Name = '2024 Q4 Backend Release' AND Status__c = 'In Progress' LIMIT 1];
        } catch (QueryException e) {
            System.debug(LoggingLevel.ERROR, 'Release project not found');
            return;
        }

        List> sprintTasks = new List>();
        sprintTasks.add(new Map{
            'Name' => 'Implement user auth middleware',
            'Description' => 'Add JWT validation for API endpoints',
            'AssigneeId' => UserInfo.getUserId(),  // Current user
            'DueDate' => Date.newInstance(2024, 10, 15),
            'Priority' => 'High'
        });
        sprintTasks.add(new Map{
            'Name' => 'Write integration tests for auth',
            'Description' => 'Cover 90% of auth edge cases',
            'AssigneeId' => UserInfo.getUserId(),
            'DueDate' => Date.newInstance(2024, 10, 17),
            'Priority' => 'High'
        });
        bulkCreateTasks(releaseProject.Id, sprintTasks);
    }
}

#!/bin/bash
set -euo pipefail  # Exit on error, undefined vars, pipe failures

# Configuration (load from GitHub Actions env vars)
ASANA_PAT="${ASANA_PAT:-}"
ASANA_PROJECT_GID="${ASANA_PROJECT_GID:-}"
SF_ACCESS_TOKEN="${SF_ACCESS_TOKEN:-}"
SF_PROJECT_ID="${SF_PROJECT_ID:-}"
TOOL_CHOICE="${TOOL_CHOICE:-asana}"  # Default to Asana
WORKFLOW_NAME="${GITHUB_WORKFLOW:-Unknown Workflow}"
RUN_ID="${GITHUB_RUN_ID:-0}"
REPO="${GITHUB_REPOSITORY:-unknown/repo}"
FAILURE_MESSAGE="${1:-Workflow failed}"

# Validate required environment variables
validate_env() {
    case "${TOOL_CHOICE}" in
        asana)
            if [[ -z "${ASANA_PAT}" || -z "${ASANA_PROJECT_GID}" ]]; then
                echo "ERROR: Missing ASANA_PAT or ASANA_PROJECT_GID for Asana integration"
                exit 1
            fi
            ;;
        salesforce)
            if [[ -z "${SF_ACCESS_TOKEN}" || -z "${SF_PROJECT_ID}" ]]; then
                echo "ERROR: Missing SF_ACCESS_TOKEN or SF_PROJECT_ID for Salesforce integration"
                exit 1
            fi
            ;;
        *)
            echo "ERROR: Invalid TOOL_CHOICE. Use 'asana' or 'salesforce'"
            exit 1
            ;;
    esac
}

# Create task in Asana via REST API
create_asana_task() {
    local task_name="CI Failure: ${WORKFLOW_NAME} (Run ${RUN_ID})"
    local task_notes="Workflow failed in repo ${REPO}\\n\\nMessage: ${FAILURE_MESSAGE}\\n\\nRun URL: https://github.com/${REPO}/actions/runs/${RUN_ID}"

    response=$(curl -s -w "%{http_code}" -X POST 'https://app.asana.com/api/1.0/tasks' \
        -H 'Authorization: Bearer ${ASANA_PAT}' \
        -H 'Content-Type: application/json' \
        -d '{
            "data": {
                "name": "'"${task_name}"'',
                "notes": "'"${task_notes}"'',
                "projects": ["'"${ASANA_PROJECT_GID}"'']
                "tags": ["CI-Failure"]
            }
        }')

    http_code="${response: -3}"
    response_body="${response%???}"

    if [[ "${http_code}" == "201" ]]; then
        task_gid=$(echo "${response_body}" | jq -r '.data.gid')
        echo "Successfully created Asana task: ${task_gid}"
        echo "Task URL: https://app.asana.com/0/${ASANA_PROJECT_GID}/${task_gid}"
        return 0
    else
        echo "ERROR: Failed to create Asana task. HTTP ${http_code}: ${response_body}"
        return 1
    fi
}

# Create task in Salesforce via REST API
create_salesforce_task() {
    local task_name="CI Failure: ${WORKFLOW_NAME} (Run ${RUN_ID})"
    local task_description="Workflow failed in repo ${REPO}\\n\\nMessage: ${FAILURE_MESSAGE}\\n\\nRun URL: https://github.com/${REPO}/actions/runs/${RUN_ID}"

    # First get instance URL from Salesforce
    instance_url=$(curl -s 'https://login.salesforce.com/services/oauth2/userinfo' \
        -H 'Authorization: Bearer ${SF_ACCESS_TOKEN}' | jq -r '.custom_attributes.instance_url')

    response=$(curl -s -w "%{http_code}" -X POST "${instance_url}/services/data/v58.0/sobjects/Task" \
        -H 'Authorization: Bearer ${SF_ACCESS_TOKEN}' \
        -H 'Content-Type: application/json' \
        -d '{
            "Subject": "'"${task_name}"'',
            "Description": "'"${task_description}"'',
            "WhatId": "'"${SF_PROJECT_ID}"'',
            "Priority": "High",
            "Status": "Not Started"
        }')

    http_code="${response: -3}"
    response_body="${response%???}"

    if [[ "${http_code}" == "201" ]]; then
        task_id=$(echo "${response_body}" | jq -r '.id')
        echo "Successfully created Salesforce task: ${task_id}"
        echo "Task URL: ${instance_url}/${task_id}"
        return 0
    else
        echo "ERROR: Failed to create Salesforce task. HTTP ${http_code}: ${response_body}"
        return 1
    fi
}

# Main execution
main() {
    echo "Starting CI failure task creation for ${WORKFLOW_NAME}..."
    validate_env

    case "${TOOL_CHOICE}" in
        asana)
            create_asana_task
            ;;
        salesforce)
            create_salesforce_task
            ;;
    esac

    if [[ $? -eq 0 ]]; then
        echo "Task creation completed successfully"
    else
        echo "Task creation failed"
        exit 1
    fi
}

main

// Node.js Asana webhook receiver with signature validation
const express = require('express');
const crypto = require('crypto');
const app = express();
app.use(express.json());

const ASANA_WEBHOOK_SECRET = process.env.ASANA_WEBHOOK_SECRET;

app.post('/asana-webhook', (req, res) => {
    const signature = req.headers['x-asana-content-signature'];
    const hmac = crypto.createHmac('sha256', ASANA_WEBHOOK_SECRET);
    hmac.update(JSON.stringify(req.body));
    const expectedSignature = hmac.digest('hex');

    if (signature !== expectedSignature) {
        return res.status(401).send('Invalid signature');
    }

    // Process task update event
    const event = req.body.events[0];
    console.log(`Task ${event.resource.gid} updated: ${event.action}`);
    res.status(200).send('OK');
});

app.listen(3000, () => console.log('Webhook receiver running on port 3000'));

// Apex trigger to validate task due dates for engineering projects
trigger TaskDueDateValidation on Task (before insert, before update) {
    // Fetch parent project records for all tasks in trigger
    Set projectIds = new Set();
    for (Task t : Trigger.new) {
        if (t.WhatId != null) projectIds.add(t.WhatId);
    }

    Map projects = new Map(
        [SELECT Id, Type__c FROM Engineering_Project__c WHERE Id IN :projectIds]
    );

    for (Task t : Trigger.new) {
        Engineering_Project__c parentProject = projects.get(t.WhatId);
        // Only validate engineering project tasks
        if (parentProject != null && parentProject.Type__c == 'Engineering') {
            Date minDueDate = Date.today().addDays(2);
            if (t.ActivityDate < minDueDate) {
                t.ActivityDate.addError('Engineering tasks require at least 2 days lead time');
            }
        }
    }
}

import time
import concurrent.futures
from asana import ApiClient, Configuration, TaskApi
from asana.exceptions import RateLimitException

def benchmark_asana_rate_limit(access_token, project_gid, duration_sec=60):
    config = Configuration()
    config.access_token = access_token
    client = ApiClient(config)
    task_api = TaskApi(client)

    start_time = time.time()
    request_count = 0
    failure_count = 0

    while time.time() - start_time < duration_sec:
        try:
            task_api.create_task({'name': f'Benchmark Task {request_count}'}, opts={'project': project_gid})
            request_count += 1
        except RateLimitException:
            failure_count += 1
            time.sleep(2)
        except Exception:
            failure_count += 1

    print(f'Asana Benchmark: {request_count} requests in {duration_sec}s ({request_count/duration_sec:.0f} req/min), {failure_count} failures')