How We Grew HubSpot vs Trello: A Head-to-Head

import os
import requests
import json
from datetime import datetime
from typing import Dict, List, Optional

# Configuration: Load from environment variables to avoid hardcoding secrets
HUBSPOT_API_KEY = os.getenv("HUBSPOT_API_KEY")
HUBSPOT_PROJECT_ID = os.getenv("HUBSPOT_PROJECT_ID", "proj_123456789")
CI_RUN_ID = os.getenv("GITHUB_RUN_ID", "local-dev")
CI_COMMIT_SHA = os.getenv("GITHUB_SHA", "abc123def456")

# Base URL for HubSpot Projects API v3
HUBSPOT_BASE_URL = "https://api.hubapi.com/crm/v3/projects"

class HubSpotTaskError(Exception):
    """Custom exception for HubSpot task creation failures"""
    pass

def create_ci_linked_task(
    task_name: str,
    description: str,
    assignee_email: str,
    labels: List[str],
    due_date: Optional[datetime] = None
) -> Dict:
    """
    Creates a task in HubSpot Projects linked to a CI/CD run.

    Args:
        task_name: Display name of the task
        description: Markdown-supported task description
        assignee_email: Email of the user to assign the task to
        labels: List of label strings to apply to the task
        due_date: Optional due date for the task

    Returns:
        Dict containing created task details from HubSpot API

    Raises:
        HubSpotTaskError: If API request fails or returns non-2xx status
    """
    if not HUBSPOT_API_KEY:
        raise HubSpotTaskError("HUBSPOT_API_KEY environment variable is not set")

    # Construct request headers
    headers = {
        "Authorization": f"Bearer {HUBSPOT_API_KEY}",
        "Content-Type": "application/json"
    }

    # Build task payload with CI/CD metadata
    payload = {
        "name": task_name,
        "description": f"{description}\n\n**CI/CD Context:**\n- Run ID: {CI_RUN_ID}\n- Commit SHA: {CI_COMMIT_SHA}",
        "projectId": HUBSPOT_PROJECT_ID,
        "assigneeEmail": assignee_email,
        "labels": labels,
        "customProperties": {
            "ci_run_id": CI_RUN_ID,
            "commit_sha": CI_COMMIT_SHA,
            "created_by": "ci-pipeline"
        }
    }

    if due_date:
        payload["dueDate"] = due_date.isoformat()

    try:
        # Send POST request to HubSpot Tasks endpoint
        response = requests.post(
            f"{HUBSPOT_BASE_URL}/{HUBSPOT_PROJECT_ID}/tasks",
            headers=headers,
            json=payload,
            timeout=10  # 10 second timeout to avoid hanging
        )
        response.raise_for_status()  # Raise exception for 4xx/5xx responses
    except requests.exceptions.Timeout:
        raise HubSpotTaskError("Request to HubSpot API timed out after 10 seconds")
    except requests.exceptions.HTTPError as e:
        raise HubSpotTaskError(f"HubSpot API returned error: {e.response.status_code} - {e.response.text}")
    except requests.exceptions.RequestException as e:
        raise HubSpotTaskError(f"Failed to connect to HubSpot API: {str(e)}")

    # Parse and return response JSON
    return response.json()

if __name__ == "__main__":
    # Example usage: Create a task for a failed CI build
    try:
        task = create_ci_linked_task(
            task_name="Fix failing unit tests in auth service",
            description="3 unit tests are failing in the auth service after commit abc123. See logs for details.",
            assignee_email="dev@company.com",
            labels=["bug", "ci-failure", "auth-service"],
            due_date=datetime.now().replace(hour=23, minute=59, second=0)
        )
        print(f"Successfully created HubSpot task: {task.get('id')}")
        print(f"Task URL: https://app.hubspot.com/projects/task/{task.get('id')}")
    except HubSpotTaskError as e:
        print(f"Failed to create task: {str(e)}")
        exit(1)

import os
import requests
import json
from datetime import datetime
from typing import Dict, List, Optional

# Configuration: Load from environment variables
TRELLO_API_KEY = os.getenv("TRELLO_API_KEY")
TRELLO_API_TOKEN = os.getenv("TRELLO_API_TOKEN")
TRELLO_BOARD_ID = os.getenv("TRELLO_BOARD_ID", "board_987654321")
TRELLO_LIST_ID = os.getenv("TRELLO_LIST_ID", "list_123456789")  # "To Do" list ID
CI_RUN_ID = os.getenv("GITHUB_RUN_ID", "local-dev")
CI_COMMIT_SHA = os.getenv("GITHUB_SHA", "abc123def456")

# Base URL for Trello API v1
TRELLO_BASE_URL = "https://api.trello.com/1"

class TrelloCardError(Exception):
    """Custom exception for Trello card creation failures"""
    pass

def create_ci_linked_card(
    card_name: str,
    description: str,
    assignee_member_id: str,
    labels: List[str],
    due_date: Optional[datetime] = None
) -> Dict:
    """
    Creates a card in Trello linked to a CI/CD run.

    Args:
        card_name: Display name of the Trello card
        description: Markdown-supported card description
        assignee_member_id: Trello member ID to assign the card to
        labels: List of label IDs to apply to the card (Trello uses label IDs, not strings)
        due_date: Optional due date for the card

    Returns:
        Dict containing created card details from Trello API

    Raises:
        TrelloCardError: If API request fails or returns non-2xx status
    """
    if not all([TRELLO_API_KEY, TRELLO_API_TOKEN]):
        raise TrelloCardError("TRELLO_API_KEY and TRELLO_API_TOKEN environment variables must be set")

    # Construct request parameters (Trello uses query params for auth, not headers)
    params = {
        "key": TRELLO_API_KEY,
        "token": TRELLO_API_TOKEN,
        "idList": TRELLO_LIST_ID,
        "name": card_name,
        "desc": f"{description}\n\n**CI/CD Context:**\n- Run ID: {CI_RUN_ID}\n- Commit SHA: {CI_COMMIT_SHA}",
        "idMembers": [assignee_member_id],
        "idLabels": labels,
        "customFieldItems": [
            {
                "idCustomField": "custom_field_ci_run",
                "value": {"text": CI_RUN_ID}
            },
            {
                "idCustomField": "custom_field_commit_sha",
                "value": {"text": CI_COMMIT_SHA}
            }
        ]
    }

    if due_date:
        params["due"] = due_date.isoformat()

    try:
        # Send POST request to Trello Cards endpoint
        response = requests.post(
            f"{TRELLO_BASE_URL}/cards",
            params=params,
            timeout=10
        )
        response.raise_for_status()
    except requests.exceptions.Timeout:
        raise TrelloCardError("Request to Trello API timed out after 10 seconds")
    except requests.exceptions.HTTPError as e:
        raise TrelloCardError(f"Trello API returned error: {e.response.status_code} - {e.response.text}")
    except requests.exceptions.RequestException as e:
        raise TrelloCardError(f"Failed to connect to Trello API: {str(e)}")

    return response.json()

def get_trello_label_ids(label_names: List[str]) -> List[str]:
    """Helper to convert label names to Trello label IDs (required for Trello API)"""
    if not all([TRELLO_API_KEY, TRELLO_API_TOKEN]):
        raise TrelloCardError("TRELLO_API_KEY and TRELLO_API_TOKEN must be set")

    params = {
        "key": TRELLO_API_KEY,
        "token": TRELLO_API_TOKEN
    }

    try:
        response = requests.get(
            f"{TRELLO_BASE_URL}/boards/{TRELLO_BOARD_ID}/labels",
            params=params,
            timeout=5
        )
        response.raise_for_status()
    except requests.exceptions.RequestException as e:
        raise TrelloCardError(f"Failed to fetch Trello labels: {str(e)}")

    labels = response.json()
    label_id_map = {label["name"]: label["id"] for label in labels}

    return [label_id_map[name] for name in label_names if name in label_id_map]

if __name__ == "__main__":
    # Example usage: Create a Trello card for a failed CI build
    try:
        # First get label IDs for "bug" and "ci-failure"
        label_ids = get_trello_label_ids(["bug", "ci-failure"])

        card = create_ci_linked_card(
            card_name="Fix failing unit tests in auth service",
            description="3 unit tests are failing in the auth service after commit abc123. See logs for details.",
            assignee_member_id="member_123456789",  # Trello member ID for dev@company.com
            labels=label_ids,
            due_date=datetime.now().replace(hour=23, minute=59, second=0)
        )
        print(f"Successfully created Trello card: {card.get('id')}")
        print(f"Card URL: {card.get('shortUrl')}")
    except TrelloCardError as e:
        print(f"Failed to create card: {str(e)}")
        exit(1)

import os
import requests
import time
import statistics
from typing import List, Dict
from dataclasses import dataclass

# Configuration
HUBSPOT_API_KEY = os.getenv("HUBSPOT_API_KEY")
TRELLO_API_KEY = os.getenv("TRELLO_API_KEY")
TRELLO_API_TOKEN = os.getenv("TRELLO_API_TOKEN")
HUBSPOT_PROJECT_ID = os.getenv("HUBSPOT_PROJECT_ID", "proj_123456789")
TRELLO_BOARD_ID = os.getenv("TRELLO_BOARD_ID", "board_987654321")

@dataclass
class BenchmarkResult:
    tool: str
    version: str
    endpoint: str
    sample_count: int
    mean_ms: float
    median_ms: float
    p95_ms: float
    p99_ms: float
    error_rate: float

def benchmark_hubspot_task_fetch(sample_size: int = 100) -> BenchmarkResult:
    """Benchmark GET /tasks endpoint for HubSpot Projects API"""
    if not HUBSPOT_API_KEY:
        raise ValueError("HUBSPOT_API_KEY not set")

    headers = {
        "Authorization": f"Bearer {HUBSPOT_API_KEY}",
        "Content-Type": "application/json"
    }

    url = f"https://api.hubapi.com/crm/v3/projects/{HUBSPOT_PROJECT_ID}/tasks"
    response_times: List[float] = []
    errors = 0

    for _ in range(sample_size):
        start = time.perf_counter()
        try:
            response = requests.get(url, headers=headers, timeout=5)
            response.raise_for_status()
            elapsed = (time.perf_counter() - start) * 1000  # Convert to ms
            response_times.append(elapsed)
        except Exception:
            errors += 1
        time.sleep(0.1)  # Avoid rate limiting

    if not response_times:
        raise RuntimeError("All HubSpot benchmark requests failed")

    return BenchmarkResult(
        tool="HubSpot",
        version="v2024.9",
        endpoint="/projects/{id}/tasks",
        sample_count=sample_size,
        mean_ms=statistics.mean(response_times),
        median_ms=statistics.median(response_times),
        p95_ms=statistics.quantiles(response_times, n=20)[18],  # 95th percentile
        p99_ms=statistics.quantiles(response_times, n=100)[98],  # 99th percentile
        error_rate=errors / sample_size
    )

def benchmark_trello_card_fetch(sample_size: int = 100) -> BenchmarkResult:
    """Benchmark GET /cards endpoint for Trello API"""
    if not all([TRELLO_API_KEY, TRELLO_API_TOKEN]):
        raise ValueError("TRELLO_API_KEY and TRELLO_API_TOKEN not set")

    params = {
        "key": TRELLO_API_KEY,
        "token": TRELLO_API_TOKEN,
        "limit": 10  # Fetch 10 cards per request to match HubSpot's default
    }

    url = f"https://api.trello.com/1/boards/{TRELLO_BOARD_ID}/cards"
    response_times: List[float] = []
    errors = 0

    for _ in range(sample_size):
        start = time.perf_counter()
        try:
            response = requests.get(url, params=params, timeout=5)
            response.raise_for_status()
            elapsed = (time.perf_counter() - start) * 1000  # Convert to ms
            response_times.append(elapsed)
        except Exception:
            errors += 1
        time.sleep(0.1)  # Avoid rate limiting

    if not response_times:
        raise RuntimeError("All Trello benchmark requests failed")

    return BenchmarkResult(
        tool="Trello",
        version="v2024.8",
        endpoint="/boards/{id}/cards",
        sample_count=sample_size,
        mean_ms=statistics.mean(response_times),
        median_ms=statistics.median(response_times),
        p95_ms=statistics.quantiles(response_times, n=20)[18],
        p99_ms=statistics.quantiles(response_times, n=100)[98],
        error_rate=errors / sample_size
    )

def print_benchmark_comparison(hubspot_result: BenchmarkResult, trello_result: BenchmarkResult):
    """Print formatted comparison of benchmark results"""
    print(f"{'Metric':<20} {'HubSpot (v2024.9)':<25} {'Trello (v2024.8)':<25} {'Difference':<15}")
    print("-" * 85)

    metrics = [
        ("Mean Response (ms)", hubspot_result.mean_ms, trello_result.mean_ms),
        ("Median Response (ms)", hubspot_result.median_ms, trello_result.median_ms),
        ("P95 Response (ms)", hubspot_result.p95_ms, trello_result.p95_ms),
        ("P99 Response (ms)", hubspot_result.p99_ms, trello_result.p99_ms),
        ("Error Rate (%)", hubspot_result.error_rate * 100, trello_result.error_rate * 100)
    ]

    for metric_name, hubspot_val, trello_val in metrics:
        diff = hubspot_val - trello_val
        print(f"{metric_name:<20} {hubspot_val:<25.2f} {trello_val:<25.2f} {diff:<15.2f}")

    print(f"\nBenchmark Methodology: {hubspot_result.sample_count} samples per tool, AWS c6g.4xlarge client, 1Gbps network, 5s timeout per request")

if __name__ == "__main__":
    print("Running API Response Time Benchmark: HubSpot vs Trello")
    print("=" * 60)

    try:
        hubspot_res = benchmark_hubspot_task_fetch(sample_size=100)
        trello_res = benchmark_trello_card_fetch(sample_size=100)
        print_benchmark_comparison(hubspot_res, trello_res)
    except Exception as e:
        print(f"Benchmark failed: {str(e)}")
        exit(1)

// Handle GitHub Actions webhook payload to update HubSpot tasks
exports.main = (event, callback) => {
  const payload = JSON.parse(event.body);
  const { action, workflow_run } = payload;

  if (action === "completed" && workflow_run.conclusion === "failure") {
    const commitAuthor = workflow_run.head_commit.author.email;
    // Call HubSpot API to create task (reuse logic from first code example)
    createCIErrorTask(workflow_run.name, workflow_run.html_url, commitAuthor);
  }
  callback();
};

import Trello from "trello-js-sdk";

const trello = new Trello({
  apiKey: process.env.TRELLO_API_KEY,
  apiToken: process.env.TRELLO_API_TOKEN
});

// Update test coverage custom field for a card
async function updateCoverage(cardId, coveragePercent) {
  const customFields = await trello.cards.getCustomFields(cardId);
  const coverageField = customFields.find(f => f.name === "test-coverage");

  if (!coverageField) {
    throw new Error("test-coverage custom field not found on card");
  }

  await trello.cards.updateCustomField(cardId, coverageField.id, {
    value: { number: coveragePercent }
  });
}

import csv
from typing import Dict
from dataclasses import dataclass

# Reuse BenchmarkResult from third code example
@dataclass
class BenchmarkResult:
    tool: str
    version: str
    endpoint: str
    sample_count: int
    mean_ms: float
    median_ms: float
    p95_ms: float
    p99_ms: float
    error_rate: float

def export_benchmark_to_csv(result: BenchmarkResult, filename: str = "benchmark_results.csv"):
    with open(filename, "a", newline="") as f:
        writer = csv.writer(f)
        writer.writerow([
            datetime.now().isoformat(),
            result.tool,
            result.version,
            result.mean_ms,
            result.p95_ms,
            result.error_rate
        ])