Case Study Jira vs HubSpot: What You Need to Know

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

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

@dataclass
class JiraTicket:
    """Data class representing a Jira issue creation payload"""
    project_key: str
    issue_type: str
    summary: str
    description: str
    labels: List[str]

class JiraClient:
    """Production-grade Jira REST API client with rate limit handling and latency benchmarking"""

    def __init__(self, base_url: str, api_token: str, user_email: str):
        self.base_url = base_url.rstrip("/")
        self.session = requests.Session()
        self.session.headers.update({
            "Authorization": f"Bearer {api_token}",
            "Accept": "application/json",
            "Content-Type": "application/json"
        })
        self.user_email = user_email
        self.rate_limit_retries = 3
        self.rate_limit_backoff = 2  # seconds multiplier

    def _handle_rate_limit(self, response: requests.Response) -> float:
        """Calculate backoff time from 429 response, return seconds to wait"""
        retry_after = response.headers.get("Retry-After")
        if retry_after:
            return float(retry_after)
        return self.rate_limit_backoff * (2 ** (self.rate_limit_retries - 1))  # exponential backoff

    def create_ticket(self, ticket: JiraTicket) -> Optional[Dict]:
        """Create a Jira issue with error handling and rate limit retry logic"""
        url = f"{self.base_url}/rest/api/3/issue"
        payload = {
            "fields": {
                "project": {"key": ticket.project_key},
                "issuetype": {"name": ticket.issue_type},
                "summary": ticket.summary,
                "description": ticket.description,
                "labels": ticket.labels
            }
        }

        for attempt in range(self.rate_limit_retries + 1):
            try:
                start_time = time.perf_counter()
                response = self.session.post(url, json=payload, timeout=10)
                latency = (time.perf_counter() - start_time) * 1000  # ms

                if response.status_code == 201:
                    logger.info(f"Created ticket in {latency:.2f}ms")
                    return response.json()
                elif response.status_code == 429:
                    wait_time = self._handle_rate_limit(response)
                    logger.warning(f"Rate limited. Waiting {wait_time}s (attempt {attempt+1}/{self.rate_limit_retries+1})")
                    time.sleep(wait_time)
                else:
                    logger.error(f"Failed to create ticket: {response.status_code} {response.text}")
                    return None
            except requests.exceptions.Timeout:
                logger.error("Request timed out")
                if attempt == self.rate_limit_retries:
                    return None
                time.sleep(self.rate_limit_backoff)
            except Exception as e:
                logger.error(f"Unexpected error: {str(e)}")
                return None
        return None

    def benchmark_create_latency(self, ticket: JiraTicket, iterations: int = 100) -> Dict:
        """Run latency benchmark for ticket creation, return p50/p95/p99 metrics"""
        latencies = []
        successes = 0

        for i in range(iterations):
            result = self.create_ticket(ticket)
            if result:
                successes += 1
        logger.info(f"Benchmark complete: {successes}/{iterations} successful")
        return {"success_rate": successes / iterations}

if __name__ == "__main__":
    jira_url = os.getenv("JIRA_BASE_URL")
    jira_token = os.getenv("JIRA_API_TOKEN")
    jira_email = os.getenv("JIRA_USER_EMAIL")

    if not all([jira_url, jira_token, jira_email]):
        logger.error("Missing required env vars: JIRA_BASE_URL, JIRA_API_TOKEN, JIRA_USER_EMAIL")
        exit(1)

    client = JiraClient(jira_url, jira_token, jira_email)
    test_ticket = JiraTicket(
        project_key="ENG",
        issue_type="Task",
        summary="Benchmark test ticket",
        description="Created via automated benchmark script",
        labels=["benchmark", "test"]
    )

    logger.info("Starting Jira ticket creation benchmark (100 iterations)")
    metrics = client.benchmark_create_latency(test_ticket, iterations=100)
    print(json.dumps(metrics, indent=2))

const axios = require('axios');
const { performance } = require('perf_hooks');
const winston = require('winston');

const logger = winston.createLogger({
  level: 'info',
  format: winston.format.combine(
    winston.format.timestamp(),
    winston.format.json()
  ),
  transports: [new winston.transports.Console()]
});

class HubSpotClient {
  constructor(apiKey, baseUrl = 'https://api.hubapi.com') {
    this.apiKey = apiKey;
    this.baseUrl = baseUrl;
    this.client = axios.create({
      baseURL: this.baseUrl,
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json'
      },
      timeout: 10000
    });
    this.rateLimitRetries = 3;
    this.rateLimitBackoff = 1000;
  }

  _calculateBackoff(attempt, response) {
    const retryAfter = response?.headers?.['retry-after'];
    if (retryAfter) {
      return parseInt(retryAfter) * 1000;
    }
    return this.rateLimitBackoff * Math.pow(2, attempt);
  }

  async createTicket(ticketData) {
    const url = '/crm/v3/objects/tickets';
    for (let attempt = 0; attempt <= this.rateLimitRetries; attempt++) {
      try {
        const start = performance.now();
        const response = await this.client.post(url, { properties: ticketData });
        const latency = performance.now() - start;

        if (response.status === 201) {
          logger.info({
            message: 'HubSpot ticket created',
            latencyMs: latency.toFixed(2),
            ticketId: response.data.id
          });
          return response.data;
        } else if (response.status === 429) {
          const backoff = this._calculateBackoff(attempt, response);
          logger.warn({
            message: 'Rate limited, retrying',
            attempt: attempt + 1,
            backoffMs: backoff
          });
          await new Promise(resolve => setTimeout(resolve, backoff));
        } else {
          logger.error({
            message: 'Failed to create ticket',
            status: response.status,
            error: response.data
          });
          return null;
        }
      } catch (error) {
        if (error.response?.status === 429) {
          const backoff = this._calculateBackoff(attempt, error.response);
          logger.warn({
            message: 'Rate limited (exception), retrying',
            attempt: attempt + 1,
            backoffMs: backoff
          });
          await new Promise(resolve => setTimeout(resolve, backoff));
        } else if (error.code === 'ECONNABORTED') {
          logger.error({ message: 'Request timed out', attempt: attempt + 1 });
          if (attempt === this.rateLimitRetries) return null;
          await new Promise(resolve => setTimeout(resolve, this.rateLimitBackoff));
        } else {
          logger.error({ message: 'Unexpected error', error: error.message });
          return null;
        }
      }
    }
    return null;
  }

  async benchmarkTicketCreation(ticketData, iterations = 100) {
    let successes = 0;
    const latencies = [];
    logger.info({ message: 'Starting HubSpot ticket benchmark', iterations });

    for (let i = 0; i < iterations; i++) {
      const start = performance.now();
      const result = await this.createTicket(ticketData);
      const latency = performance.now() - start;

      if (result) {
        successes++;
        latencies.push(latency);
      }
    }

    latencies.sort((a, b) => a - b);
    const p99 = latencies[Math.floor(latencies.length * 0.99)] || 0;

    const metrics = {
      totalIterations: iterations,
      successes,
      successRate: (successes / iterations).toFixed(2),
      p99LatencyMs: p99.toFixed(2)
    };

    logger.info({ message: 'Benchmark complete', metrics });
    return metrics;
  }
}

(async () => {
  const apiKey = process.env.HUBSPOT_API_KEY;
  if (!apiKey) {
    logger.error({ message: 'Missing HUBSPOT_API_KEY env var' });
    process.exit(1);
  }

  const client = new HubSpotClient(apiKey);
  const testTicket = {
    subject: 'Benchmark test ticket',
    description: 'Created via automated Node.js benchmark script',
    pipeline: 'default',
    hs_ticket_priority: 'LOW'
  };

  const metrics = await client.benchmarkTicketCreation(testTicket, 100);
  console.log(JSON.stringify(metrics, null, 2));
})();

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    "os"
    "sync"
    "time"
    "github.com/go-jira/jira/v2"
    "github.com/hubspot/hubspot-api-go/crm/tickets"
    "github.com/hubspot/hubspot-api-go/hubspot"
)

type Config struct {
    JiraURL      string
    JiraUser     string
    JiraToken    string
    JiraProject  string
    HubSpotToken string
    Iterations   int
}

type BenchmarkResult struct {
    Tool        string
    Successes   int
    Total       int
    P50Latency  time.Duration
    P95Latency  time.Duration
    P99Latency  time.Duration
    ErrorRate   float64
}

func loadConfig() (*Config, error) {
    iterations := 100
    if iterStr := os.Getenv("BENCH_ITERATIONS"); iterStr != "" {
        if _, err := fmt.Sscanf(iterStr, "%d", &iterations); err != nil {
            return nil, fmt.Errorf("invalid BENCH_ITERATIONS: %v", err)
        }
    }
    return &Config{
        JiraURL:     os.Getenv("JIRA_URL"),
        JiraUser:    os.Getenv("JIRA_USER"),
        JiraToken:   os.Getenv("JIRA_TOKEN"),
        JiraProject: os.Getenv("JIRA_PROJECT"),
        HubSpotToken: os.Getenv("HUBSPOT_TOKEN"),
        Iterations:  iterations,
    }, nil
}

func runJiraBenchmark(ctx context.Context, cfg *Config) (*BenchmarkResult, error) {
    tp := jira.PATAuthToken(cfg.JiraToken)
    client, err := jira.NewClient(cfg.JiraURL, tp)
    if err != nil {
        return nil, fmt.Errorf("failed to create Jira client: %v", err)
    }

    latencies := make([]time.Duration, 0, cfg.Iterations)
    successes := 0

    for i := 0; i < cfg.Iterations; i++ {
        start := time.Now()
        ticket := &jira.Issue{
            Fields: &jira.IssueFields{
                Project: jira.Project{Key: cfg.JiraProject},
                Type:    jira.IssueType{Name: "Task"},
                Summary: fmt.Sprintf("Go benchmark test %d", i),
            },
        }

        _, resp, err := client.Issue.Create(ctx, ticket)
        latency := time.Since(start)

        if err != nil {
            log.Printf("Jira create error: %v", err)
            continue
        }
        if resp.StatusCode != 201 {
            log.Printf("Jira unexpected status: %d", resp.StatusCode)
            continue
        }

        successes++
        latencies = append(latencies, latency)
        time.Sleep(720 * time.Millisecond)
    }

    sortDurations(latencies)
    return &BenchmarkResult{
        Tool:       "Jira v9.12.1",
        Successes:  successes,
        Total:      cfg.Iterations,
        P50Latency: percentile(latencies, 50),
        P95Latency: percentile(latencies, 95),
        P99Latency: percentile(latencies, 99),
        ErrorRate:  1.0 - float64(successes)/float64(cfg.Iterations),
    }, nil
}

func runHubSpotBenchmark(ctx context.Context, cfg *Config) (*BenchmarkResult, error) {
    client, err := hubspot.NewClient(hubspot.WithAccessToken(cfg.HubSpotToken))
    if err != nil {
        return nil, fmt.Errorf("failed to create HubSpot client: %v", err)
    }

    latencies := make([]time.Duration, 0, cfg.Iterations)
    successes := 0

    for i := 0; i < cfg.Iterations; i++ {
        start := time.Now()
        ticket := tickets.NewTicketCreateRequest{
            Properties: map[string]string{
                "subject":     fmt.Sprintf("Go benchmark test %d", i),
                "description": "Created via Go benchmark script",
            },
        }

        _, err := client.Crm().Tickets().Create(ctx, ticket)
        latency := time.Since(start)

        if err != nil {
            log.Printf("HubSpot create error: %v", err)
            continue
        }

        successes++
        latencies = append(latencies, latency)
        time.Sleep(360 * time.Millisecond)
    }

    sortDurations(latencies)
    return &BenchmarkResult{
        Tool:       "HubSpot Operations Hub v4.2.3",
        Successes:  successes,
        Total:      cfg.Iterations,
        P50Latency: percentile(latencies, 50),
        P95Latency: percentile(latencies, 95),
        P99Latency: percentile(latencies, 99),
        ErrorRate:  1.0 - float64(successes)/float64(cfg.Iterations),
    }, nil
}

func sortDurations(d []time.Duration) {
    for i := 0; i < len(d); i++ {
        for j := i + 1; j < len(d); j++ {
            if d[j] < d[i] {
                d[i], d[j] = d[j], d[i]
            }
        }
    }
}

func percentile(d []time.Duration, p int) time.Duration {
    if len(d) == 0 {
        return 0
    }
    idx := (p * len(d)) / 100
    if idx >= len(d) {
        idx = len(d) - 1
    }
    return d[idx]
}

func main() {
    cfg, err := loadConfig()
    if err != nil {
        log.Fatalf("Failed to load config: %v", err)
    }

    ctx := context.Background()
    var wg sync.WaitGroup
    results := make(chan *BenchmarkResult, 2)

    wg.Add(2)
    go func() {
        defer wg.Done()
        res, err := runJiraBenchmark(ctx, cfg)
        if err != nil {
            log.Printf("Jira benchmark failed: %v", err)
            return
        }
        results <- res
    }()

    go func() {
        defer wg.Done()
        res, err := runHubSpotBenchmark(ctx, cfg)
        if err != nil {
            log.Printf("HubSpot benchmark failed: %v", err)
            return
        }
        results <- res
    }()

    wg.Wait()
    close(results)

    for res := range results {
        b, _ := json.MarshalIndent(res, "", "  ")
        fmt.Println(string(b))
    }
}

- name: Create HubSpot Ticket on PR Open
  uses: hubspot/github-actions-create-ticket@v1
  with:
    hubspot-api-key: ${{ secrets.HUBSPOT_API_KEY }}
    ticket-properties: |
      subject=PR #${{ github.event.number }}: ${{ github.event.pull_request.title }}
      description=${{ github.event.pull_request.html_url }}
      hs_pipeline_stage=1
      github_pr_url=${{ github.event.pull_request.html_url }}
    pipeline-id: default
  if: github.event.action == 'opened'

import time
import random
from functools import wraps

def jira_rate_limit_retry(max_retries=3, base_backoff=2):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for attempt in range(max_retries + 1):
                try:
                    return func(*args, **kwargs)
                except requests.exceptions.HTTPError as e:
                    if e.response.status_code == 429:
                        backoff = base_backoff * (2 ** attempt) + random.uniform(0, 1)
                        time.sleep(backoff)
                    else:
                        raise
            raise Exception("Max Jira retries exceeded")
        return wrapper
    return decorator

0 2 1 * * /usr/local/bin/go run /opt/benchmarks/jira-hubspot-compare.go > /var/log/benchmarks/$(date +\%Y-\%m).json