Benchmark: Asana 5.0 vs. Monday.com 8.0 vs. ClickUp 4.0 for Engineering Project Management

import requests
import time
import json
import os
import logging
from typing import Dict, List, Tuple
from dataclasses import dataclass

# Configure logging for benchmark runs
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s - %(message)s"
)
logger = logging.getLogger(__name__)

@dataclass
class BenchmarkConfig:
    """Configuration for PM tool API benchmark runs"""
    tool_name: str
    api_base_url: str
    api_token: str
    test_workspace_id: str
    task_count: int = 1000
    concurrency: int = 10
    rate_limit_retries: int = 3

class PMToolBenchmarker:
    """Base class for benchmarking PM tool API throughput"""
    def __init__(self, config: BenchmarkConfig):
        self.config = config
        self.headers = {
            "Authorization": f"Bearer {config.api_token}",
            "Content-Type": "application/json"
        }
        self.success_count = 0
        self.error_count = 0
        self.latencies: List[float] = []

    def create_task(self, task_title: str, task_description: str) -> bool:
        """Create a single task via tool API, with error handling and latency tracking"""
        payload = self._build_task_payload(task_title, task_description)
        start_time = time.perf_counter()
        try:
            response = requests.post(
                f"{self.config.api_base_url}/tasks",
                headers=self.headers,
                json=payload,
                timeout=10
            )
            latency = time.perf_counter() - start_time
            self.latencies.append(latency)

            if response.status_code == 429:  # Rate limited
                logger.warning(f"Rate limited by {self.config.tool_name}, retrying after 1s")
                time.sleep(1)
                return self.create_task(task_title, task_description)  # Recursive retry
            elif response.status_code >= 400:
                logger.error(f"Failed to create task: {response.status_code} {response.text}")
                self.error_count += 1
                return False
            self.success_count += 1
            return True
        except requests.exceptions.Timeout:
            logger.error(f"Timeout creating task for {self.config.tool_name}")
            self.error_count += 1
            return False
        except Exception as e:
            logger.error(f"Unexpected error for {self.config.tool_name}: {str(e)}")
            self.error_count += 1
            return False

    def _build_task_payload(self, title: str, description: str) -> Dict:
        """Override in child classes for tool-specific payloads"""
        raise NotImplementedError

    def run_benchmark(self) -> Dict:
        """Execute full benchmark run and return metrics"""
        logger.info(f"Starting benchmark for {self.config.tool_name} with {self.config.task_count} tasks")
        start_time = time.perf_counter()

        for i in range(self.config.task_count):
            task_title = f"Benchmark Task {i}"
            task_description = f"Load test task {i} for {self.config.tool_name}"
            self.create_task(task_title, task_description)

        total_time = time.perf_counter() - start_time
        avg_latency = sum(self.latencies) / len(self.latencies) if self.latencies else 0
        throughput = self.success_count / total_time if total_time > 0 else 0

        return {
            "tool": self.config.tool_name,
            "success_count": self.success_count,
            "error_count": self.error_count,
            "total_time_sec": round(total_time, 2),
            "avg_latency_ms": round(avg_latency * 1000, 2),
            "throughput_tasks_per_sec": round(throughput, 2)
        }

class AsanaBenchmarker(PMToolBenchmarker):
    def _build_task_payload(self, title: str, description: str) -> Dict:
        return {
            "data": {
                "name": title,
                "notes": description,
                "workspace": self.config.test_workspace_id,
                "projects": [os.getenv("ASANA_TEST_PROJECT_ID")]
            }
        }

class MondayBenchmarker(PMToolBenchmarker):
    def _build_task_payload(self, title: str, description: str) -> Dict:
        return {
            "query": """
                mutation CreateTask($title: String!, $desc: String!) {
                    create_item(
                        board_id: %s,
                        item_name: $title,
                        column_values: "{\"description\": \"$desc\"}"
                    ) { id }
                }
            """ % self.config.test_workspace_id,
            "variables": {"title": title, "desc": description}
        }

class ClickUpBenchmarker(PMToolBenchmarker):
    def _build_task_payload(self, title: str, description: str) -> Dict:
        return {
            "name": title,
            "description": description,
            "list_id": self.config.test_workspace_id,
            "priority": 3,
            "status": "Open"
        }

if __name__ == "__main__":
    tools_config = [
        BenchmarkConfig(
            tool_name="Asana 5.0",
            api_base_url="https://app.asana.com/api/1.0",
            api_token=os.getenv("ASANA_API_TOKEN"),
            test_workspace_id=os.getenv("ASANA_WORKSPACE_ID")
        ),
        BenchmarkConfig(
            tool_name="Monday.com 8.0",
            api_base_url="https://api.monday.com/v4",
            api_token=os.getenv("MONDAY_API_TOKEN"),
            test_workspace_id=os.getenv("MONDAY_BOARD_ID")
        ),
        BenchmarkConfig(
            tool_name="ClickUp 4.0",
            api_base_url="https://api.clickup.com/api/v3",
            api_token=os.getenv("CLICKUP_API_TOKEN"),
            test_workspace_id=os.getenv("CLICKUP_LIST_ID")
        )
    ]
    results = []
    for config in tools_config:
        if not all([config.api_token, config.test_workspace_id]):
            logger.error(f"Missing config for {config.tool_name}, skipping")
            continue
        if "Asana" in config.tool_name:
            benchmarker = AsanaBenchmarker(config)
        elif "Monday" in config.tool_name:
            benchmarker = MondayBenchmarker(config)
        else:
            benchmarker = ClickUpBenchmarker(config)
        results.append(benchmarker.run_benchmark())
    logger.info("Benchmark results: %s", json.dumps(results, indent=2))

const axios = require('axios');
const dotenv = require('dotenv');
const { WebClient } = require('@slack/web-api');

dotenv.config();

const config = {
  gitlab: {
    baseUrl: process.env.GITLAB_BASE_URL || 'https://gitlab.com/api/v4',
    token: process.env.GITLAB_TOKEN,
    projectId: process.env.GITLAB_PROJECT_ID
  },
  asana: {
    baseUrl: 'https://app.asana.com/api/1.0',
    token: process.env.ASANA_API_TOKEN,
    workspaceId: process.env.ASANA_WORKSPACE_ID,
    projectId: process.env.ASANA_PROJECT_ID
  },
  monday: {
    baseUrl: 'https://api.monday.com/v4',
    token: process.env.MONDAY_API_TOKEN,
    boardId: process.env.MONDAY_BOARD_ID
  },
  clickup: {
    baseUrl: 'https://api.clickup.com/api/v3',
    token: process.env.CLICKUP_API_TOKEN,
    listId: process.env.CLICKUP_LIST_ID
  },
  slack: {
    token: process.env.SLACK_TOKEN,
    channel: process.env.SLACK_ALERT_CHANNEL || '#eng-pm-sync'
  }
};

const slackClient = new WebClient(config.slack.token);

async function fetchGitLabPipelines() {
  try {
    const response = await axios.get(
      `${config.gitlab.baseUrl}/projects/${config.gitlab.projectId}/pipelines`,
      {
        headers: { 'PRIVATE-TOKEN': config.gitlab.token },
        params: { status: 'success,failed', per_page: 10 }
      }
    );
    return response.data;
  } catch (error) {
    console.error('Failed to fetch GitLab pipelines:', error.message);
    await sendSlackAlert('GitLab pipeline fetch failed', error.message);
    throw error;
  }
}

async function syncToAsana(pipeline) {
  const taskPayload = {
    data: {
      name: `CI Pipeline ${pipeline.id} - ${pipeline.status}`,
      notes: `GitLab Pipeline: ${pipeline.web_url}\nStatus: ${pipeline.status}\nDuration: ${pipeline.duration}s`,
      workspace: config.asana.workspaceId,
      projects: [config.asana.projectId],
      custom_fields: {
        [process.env.ASANA_PIPELINE_ID_FIELD]: pipeline.id.toString(),
        [process.env.ASANA_PIPELINE_STATUS_FIELD]: pipeline.status
      }
    }
  };
  try {
    await axios.post(
      `${config.asana.baseUrl}/tasks`,
      taskPayload,
      { headers: { 'Authorization': `Bearer ${config.asana.token}` } }
    );
    console.log(`Synced pipeline ${pipeline.id} to Asana`);
  } catch (error) {
    console.error(`Asana sync failed for pipeline ${pipeline.id}:`, error.response?.data || error.message);
    await sendSlackAlert('Asana CI sync failed', `Pipeline ${pipeline.id}: ${error.message}`);
  }
}

async function syncToMonday(pipeline) {
  const query = `
    mutation CreatePipelineTask($boardId: ID!, $name: String!, $desc: String!) {
      create_item(
        board_id: $boardId,
        item_name: $name,
        column_values: "{\"pipeline_id\": \"${pipeline.id}\", \"status\": \"${pipeline.status}\"}"
      ) { id }
    }
  `;
  try {
    await axios.post(
      config.monday.baseUrl,
      { query, variables: { boardId: config.monday.boardId, name: `CI Pipeline ${pipeline.id}`, desc: `GitLab: ${pipeline.web_url}` } },
      { headers: { 'Authorization': `Bearer ${config.monday.token}` } }
    );
    console.log(`Synced pipeline ${pipeline.id} to Monday.com`);
  } catch (error) {
    console.error(`Monday sync failed for pipeline ${pipeline.id}:`, error.response?.data || error.message);
    await sendSlackAlert('Monday.com CI sync failed', `Pipeline ${pipeline.id}: ${error.message}`);
  }
}

async function syncToClickUp(pipeline) {
  const taskPayload = {
    name: `CI Pipeline ${pipeline.id} - ${pipeline.status}`,
    description: `GitLab Pipeline: ${pipeline.web_url}\nStatus: ${pipeline.status}\nDuration: ${pipeline.duration}s`,
    list_id: config.clickup.listId,
    custom_fields: [
      { id: process.env.CLICKUP_PIPELINE_ID_FIELD, value: pipeline.id.toString() },
      { id: process.env.CLICKUP_STATUS_FIELD, value: pipeline.status }
    ]
  };
  try {
    await axios.post(
      `${config.clickup.baseUrl}/task`,
      taskPayload,
      { headers: { 'Authorization': config.clickup.token } }
    );
    console.log(`Synced pipeline ${pipeline.id} to ClickUp`);
  } catch (error) {
    console.error(`ClickUp sync failed for pipeline ${pipeline.id}:`, error.response?.data || error.message);
    await sendSlackAlert('ClickUp CI sync failed', `Pipeline ${pipeline.id}: ${error.message}`);
  }
}

async function sendSlackAlert(title, message) {
  try {
    await slackClient.chat.postMessage({
      channel: config.slack.channel,
      text: `*${title}*\n${message}`,
      mrkdwn: true
    });
  } catch (error) {
    console.error('Failed to send Slack alert:', error.message);
  }
}

async function main() {
  try {
    console.log('Fetching latest GitLab pipelines...');
    const pipelines = await fetchGitLabPipelines();
    console.log(`Found ${pipelines.length} pipelines to sync`);
    for (const pipeline of pipelines) {
      await Promise.all([
        syncToAsana(pipeline),
        syncToMonday(pipeline),
        syncToClickUp(pipeline)
      ]);
      await new Promise(resolve => setTimeout(resolve, 500));
    }
    console.log('All pipeline syncs completed successfully');
  } catch (error) {
    console.error('Main sync process failed:', error.message);
    await sendSlackAlert('CI Sync Process Failed', error.message);
    process.exit(1);
  }
}

setInterval(main, 5 * 60 * 1000);
main();

# Terraform configuration to provision PM tool workspaces for new engineering teams
# Requires Terraform 1.7+ and providers from:
# Asana: https://github.com/asana/terraform-provider-asana (v2.1.0)
# Monday: https://github.com/mondaycom/terraform-provider-monday (v1.3.0)
# ClickUp: https://github.com/clickup/terraform-provider-clickup (v1.2.0)
    erraform {
  required_version = ">= 1.7.0"
  required_providers {
    asana = {
      source  = "asana/asana"
      version = "~> 2.1.0"
    }
    monday = {
      source  = "mondaycom/monday"
      version = "~> 1.3.0"
    }
    clickup = {
      source  = "clickup/clickup"
      version = "~> 1.2.0"
    }
  }
}

variable "team_name" {
  type        = string
  description = "Name of the engineering team (e.g., 'backend-core')"
}

variable "team_size" {
  type        = number
  description = "Number of engineers in the team"
  validation {
    condition     = var.team_size > 0 && var.team_size <= 1000
    error_message = "Team size must be between 1 and 1000 engineers."
  }
}

provider "asana" {
  api_token = var.asana_api_token != "" ? var.asana_api_token : null
}

provider "monday" {
  api_token = var.monday_api_token != "" ? var.monday_api_token : null
}

provider "clickup" {
  api_token = var.clickup_api_token != "" ? var.clickup_api_token : null
}

resource "asana_workspace" "team_workspace" {
  name = "${var.team_name}-engineering"
  description = "PM workspace for ${var.team_name} team (${var.team_size} engineers)"
  settings {
    task_comments_enabled = true
    custom_fields_enabled = true
    max_custom_fields     = 50
    api_rate_limit        = 150000
  }
}

resource "monday_board" "team_board" {
  name        = "${var.team_name} Engineering Board"
  board_kind  = "public"
  description = "CI/CD and sprint tracking for ${var.team_name}"
  columns = [
    { title = "Pipeline ID", type = "text" },
    { title = "Status", type = "status", settings = "{\"done_colors\":[\"#00c875\"]}" }
  ]
}

resource "clickup_list" "team_list" {
  name        = "${var.team_name} Task List"
  description = "Task tracking for ${var.team_name} (supports ${var.team_size} users)"
  custom_fields = [
    { name = "Story Points", type = "number", default = 0 },
    { name = "Git Commit", type = "text" }
  ]
}

output "asana_workspace_url" {
  value       = asana_workspace.team_workspace.web_url
  description = "URL for the team's Asana 5.0 workspace"
}

def batch_create_asana_tasks(tasks: List[Dict], api_token: str, workspace_id: str) -> List[Dict]:
    """Create up to 100 tasks in a single Asana API request"""
    import requests
    url = "https://app.asana.com/api/1.0/tasks/batch"
    headers = {"Authorization": f"Bearer {api_token}", "Content-Type": "application/json"}
    payload = {"data": [{"name": t["name"], "notes": t["notes"], "workspace": workspace_id} for t in tasks]}
    try:
        response = requests.post(url, headers=headers, json=payload, timeout=15)
        response.raise_for_status()
        return response.json()["data"]
    except requests.exceptions.RequestException as e:
        print(f"Batch task creation failed: {e}")
        return []

const express = require('express');
const app = express();
app.use(express.json());

app.post('/monday-webhook', (req, res) => {
    const webhookToken = req.headers['monday-webhook-token'];
    if (webhookToken !== process.env.MONDAY_WEBHOOK_SECRET) {
        return res.status(401).send('Invalid webhook token');
    }
    const event = req.body;
    console.log(`Received Monday event: ${event.type} for item ${event.itemId}`);
    // Process event idempotently using event.eventId
    res.status(200).send('OK');
});

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

resource "clickup_custom_field" "deployment_frequency" {
  list_id = clickup_list.team_list.id
  name    = "Deployment Frequency (per day)"
  type    = "number"
  default = 0
}

resource "clickup_custom_field" "change_failure_rate" {
  list_id = clickup_list.team_list.id
  name    = "Change Failure Rate (%)"
  type    = "number"
  default = 0
}