How case study with leadership and salary negotiation: Results

import requests
import time
import logging
from typing import Dict, Optional, List
import os
from dotenv import load_dotenv

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

BLS_API_KEY = os.getenv("BLS_API_KEY", "mock-key-1234")  # Get from https://www.bls.gov/developers/
BLS_BASE_URL = "https://api.bls.gov/publicAPI/v2/timeseries/data/"
TARGET_OCCUPATION_CODE = "15-1252"  # Computer and Information Systems Managers (SOC code)
NUM_RETRIES = 3
RETRY_DELAY = 2  # Seconds between retries

def fetch_salary_benchmark(occupation_code: str, start_year: int = 2020, end_year: int = 2024) -> Optional[Dict]:
    """
    Fetch 5-year salary benchmark data from BLS API for a given SOC occupation code.
    Handles rate limits, network errors, and invalid responses.
    """
    url = f"{BLS_BASE_URL}{occupation_code}"
    params = {
        "registrationkey": BLS_API_KEY,
        "startyear": start_year,
        "endyear": end_year,
        "catalog": "false",
        "calculations": "true"
    }

    for attempt in range(NUM_RETRIES):
        try:
            response = requests.get(url, params=params, timeout=10)
            response.raise_for_status()  # Raise HTTPError for 4xx/5xx

            data = response.json()
            if data.get("status") != "REQUEST_SUCCEEDED":
                logging.error(f"BLS API request failed: {data.get('message', [])}")
                return None

            # Extract annual mean wage data
            series = data.get("Results", {}).get("series", [{}])[0]
            return {
                "occupation_code": occupation_code,
                "occupation_title": series.get("catalog", {}).get("series_title", "Unknown"),
                "data": [
                    {
                        "year": int(item["year"]),
                        "mean_wage": float(item["calculations"]["annual_mean"]),
                        "p75_wage": float(item["calculations"]["annual_percentile_75"])
                    } for item in series.get("data", [])
                ]
            }
        except requests.exceptions.Timeout:
            logging.warning(f"Timeout on attempt {attempt + 1} for {occupation_code}")
        except requests.exceptions.HTTPError as e:
            if e.response.status_code == 429:
                retry_after = int(e.response.headers.get("Retry-After", RETRY_DELAY))
                logging.warning(f"Rate limited, retrying after {retry_after}s")
                time.sleep(retry_after)
                continue
            logging.error(f"HTTP error {e.response.status_code}: {str(e)}")
            return None
        except Exception as e:
            logging.error(f"Unexpected error fetching benchmark: {str(e)}")
            return None

        time.sleep(RETRY_DELAY)

    logging.error(f"Failed to fetch benchmark for {occupation_code} after {NUM_RETRIES} attempts")
    return None

if __name__ == "__main__":
    benchmark = fetch_salary_benchmark(TARGET_OCCUPATION_CODE)
    if benchmark:
        print(f"Salary Benchmark: {benchmark['occupation_title']}")
        for entry in benchmark["data"]:
            print(f"  {entry['year']}: Mean ${entry['mean_wage']:,.2f} | 75th Percentile ${entry['p75_wage']:,.2f}")
    else:
        print("Failed to retrieve salary benchmark. Check API key and network connection.")

package main

import (
    "encoding/json"
    "fmt"
    "io"
    "log"
    "net/http"
    "os"
    "time"
)

// JiraIssue represents a simplified Jira story for velocity calculation
type JiraIssue struct {
    ID        string    `json:"id"`
    Key       string    `json:"key"`
    Status    string    `json:"status"`
    StoryPoints int     `json:"storyPoints"`
    Created   time.Time `json:"created"`
    Resolved  time.Time `json:"resolved"`
}

// VelocityReport contains aggregated team velocity metrics
type VelocityReport struct {
    TeamName      string    `json:"teamName"`
    SprintStart   time.Time `json:"sprintStart"`
    SprintEnd     time.Time `json:"sprintEnd"`
    TotalPoints   int       `json:"totalPoints"`
    CompletedPoints int     `json:"completedPoints"`
    Velocity      float64   `json:"velocity"` // Completed / Total
    CycleTime     float64   `json:"cycleTime"` // Avg days from created to resolved
}

const (
    jiraBaseURL = "https://jira.example.com/rest/api/3"
    numRetries  = 3
    retryDelay  = 2 * time.Second
)

func fetchJiraIssues(sprintID string, authToken string) ([]JiraIssue, error) {
    url := fmt.Sprintf("%s/search?jql=sprint=%s&fields=id,key,status,storyPoints,created,resolved", jiraBaseURL, sprintID)

    var issues []JiraIssue
    for attempt := 0; attempt < numRetries; attempt++ {
        req, err := http.NewRequest("GET", url, nil)
        if err != nil {
            return nil, fmt.Errorf("failed to create request: %w", err)
        }
        req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", authToken))
        req.Header.Set("Accept", "application/json")

        client := &http.Client{Timeout: 10 * time.Second}
        resp, err := client.Do(req)
        if err != nil {
            log.Printf("Attempt %d failed: %v", attempt+1, err)
            time.Sleep(retryDelay)
            continue
        }
        defer resp.Body.Close()

        if resp.StatusCode != http.StatusOK {
            if resp.StatusCode == http.StatusTooManyRequests {
                retryAfter := resp.Header.Get("Retry-After")
                log.Printf("Rate limited, retry after %s", retryAfter)
                time.Sleep(retryDelay)
                continue
            }
            return nil, fmt.Errorf("jira API returned status %d", resp.StatusCode)
        }

        body, err := io.ReadAll(resp.Body)
        if err != nil {
            return nil, fmt.Errorf("failed to read response: %w", err)
        }

        var result struct {
            Issues []JiraIssue `json:"issues"`
        }
        if err := json.Unmarshal(body, &result); err != nil {
            return nil, fmt.Errorf("failed to parse JSON: %w", err)
        }
        issues = result.Issues
        break
    }

    if issues == nil {
        return nil, fmt.Errorf("failed to fetch issues after %d attempts", numRetries)
    }
    return issues, nil
}

func calculateVelocity(issues []JiraIssue, sprintStart, sprintEnd time.Time) VelocityReport {
    var totalPoints, completedPoints int
    var totalCycleTime float64
    completedCount := 0

    for _, issue := range issues {
        totalPoints += issue.StoryPoints
        if issue.Status == "Done" {
            completedPoints += issue.StoryPoints
            cycleTime := issue.Resolved.Sub(issue.Created).Hours() / 24 // Days
            totalCycleTime += cycleTime
            completedCount++
        }
    }

    velocity := 0.0
    if totalPoints > 0 {
        velocity = float64(completedPoints) / float64(totalPoints)
    }

    avgCycleTime := 0.0
    if completedCount > 0 {
        avgCycleTime = totalCycleTime / float64(completedCount)
    }

    return VelocityReport{
        TeamName:       "Backend Platform Team",
        SprintStart:    sprintStart,
        SprintEnd:      sprintEnd,
        TotalPoints:    totalPoints,
        CompletedPoints: completedPoints,
        Velocity:       velocity,
        CycleTime:      avgCycleTime,
    }
}

func main() {
    authToken := os.Getenv("JIRA_AUTH_TOKEN")
    if authToken == "" {
        log.Fatal("JIRA_AUTH_TOKEN environment variable not set")
    }

    // Mock sprint dates
    sprintStart, _ := time.Parse("2006-01-02", "2024-09-01")
    sprintEnd, _ := time.Parse("2006-01-02", "2024-09-14")

    issues, err := fetchJiraIssues("SPRINT-123", authToken)
    if err != nil {
        log.Fatalf("Failed to fetch issues: %v", err)
    }

    report := calculateVelocity(issues, sprintStart, sprintEnd)

    reportJSON, _ := json.MarshalIndent(report, "", "  ")
    fmt.Println(string(reportJSON))
}

use aws_config::meta::region::RegionProviderChain;
use aws_sdk_ec2 as ec2;
use aws_sdk_ec2::types::InstanceStateName;
use std::collections::HashMap;
use std::error::Error;
use std::time::{Duration, SystemTime};
use log::{info, warn, error};

// Configuration for cost optimization
const IDLE_THRESHOLD_HOURS: u64 = 24 * 7; // 7 days of idle time
const INSTANCE_FAMILY_WHITELIST: &[&str] = &["t3", "m5", "c6g"]; // Instance families to optimize

#[derive(Debug)]
struct IdleInstance {
    instance_id: String,
    instance_type: String,
    launch_time: SystemTime,
    idle_hours: u64,
    estimated_monthly_savings: f64,
}

async fn fetch_idle_instances(region: &str) -> Result, Box> {
    let region_provider = RegionProviderChain::first_try(region.parse()?)
        .or_default_provider();
    let config = aws_config::from_env().region(region_provider).load().await;
    let client = ec2::Client::new(&config);

    // Fetch all running instances
    let mut instances = Vec::new();
    let mut next_token: Option = None;

    loop {
        let mut request = client.describe_instances();
        if let Some(token) = next_token.clone() {
            request = request.next_token(token);
        }

        let response = request.send().await?;

        for reservation in response.reservations().unwrap_or_default() {
            for instance in reservation.instances().unwrap_or_default() {
                let state = instance.state().and_then(|s| s.name());
                if state != Some(&InstanceStateName::Running) {
                    continue;
                }

                // Check instance family whitelist
                let instance_type = instance.instance_type().unwrap_or_default();
                let family = instance_type.split('.').next().unwrap_or_default();
                if !INSTANCE_FAMILY_WHITELIST.contains(&family) {
                    continue;
                }

                // Calculate idle time (simplified: no CPU metrics, use launch time for demo)
                let launch_time = instance.launch_time().ok_or("Missing launch time")?;
                let launch_system_time = SystemTime::UNIX_EPOCH + Duration::from_secs(launch_time.secs().unwrap_or_default() as u64);
                let idle_hours = SystemTime::now().duration_since(launch_system_time)?.as_secs() / 3600;

                if idle_hours < IDLE_THRESHOLD_HOURS {
                    continue;
                }

                // Estimate monthly savings (simplified: $0.10 per hour for t3.medium as baseline)
                let hourly_rate = match instance_type {
                    "t3.medium" => 0.10,
                    "m5.large" => 0.12,
                    "c6g.large" => 0.11,
                    _ => 0.08,
                };
                let estimated_monthly_savings = hourly_rate * 24 * 30;

                instances.push(IdleInstance {
                    instance_id: instance.instance_id().unwrap_or_default().to_string(),
                    instance_type: instance_type.to_string(),
                    launch_time: launch_system_time,
                    idle_hours,
                    estimated_monthly_savings,
                });
            }
        }

        next_token = response.next_token().map(|s| s.to_string());
        if next_token.is_none() {
            break;
        }
    }

    Ok(instances)
}

async fn optimize_instances(instances: Vec) -> Result, Box> {
    let region_provider = RegionProviderChain::first_try("us-east-1".parse()?)
        .or_default_provider();
    let config = aws_config::from_env().region(region_provider).load().await;
    let client = ec2::Client::new(&config);

    let mut results = HashMap::new();

    for instance in instances {
        info!("Stopping idle instance {} (idle {}h)", instance.instance_id, instance.idle_hours);

        // Stop instance with dry run first to check permissions
        let stop_result = client.stop_instances()
            .instance_ids(&instance.instance_id)
            .dry_run(true)
            .send()
            .await;

        match stop_result {
            Ok(_) => {
                // Dry run succeeded, stop for real
                client.stop_instances()
                    .instance_ids(&instance.instance_id)
                    .dry_run(false)
                    .send()
                    .await?;
                results.insert(instance.instance_id.clone(), "stopped".to_string());
                info!("Successfully stopped instance {}, saving ${:.2}/month", instance.instance_id, instance.estimated_monthly_savings);
            }
            Err(e) => {
                error!("Failed to stop instance {}: {}", instance.instance_id, e);
                results.insert(instance.instance_id.clone(), format!("error: {}", e));
            }
        }
    }

    Ok(results)
}

#[tokio::main]
async fn main() -> Result<(), Box> {
    env_logger::init();

    let region = "us-east-1";
    info!("Fetching idle instances in {}...", region);

    let idle_instances = fetch_idle_instances(region).await?;
    info!("Found {} idle instances", idle_instances.len());

    if idle_instances.is_empty() {
        info!("No idle instances to optimize");
        return Ok(());
    }

    let total_savings: f64 = idle_instances.iter().map(|i| i.estimated_monthly_savings).sum();
    info!("Total estimated monthly savings: ${:.2}", total_savings);

    let results = optimize_instances(idle_instances).await?;

    for (id, status) in results {
        println!("Instance {}: {}", id, status);
    }

    Ok(())
}

# Snippet from salary benchmark script
benchmark = fetch_salary_benchmark("15-1252")
if benchmark:
    latest = benchmark["data"][-1]
    print(f"2024 75th Percentile: ${latest['p75_wage']:,.2f}")
    # Output: 2024 75th Percentile: $198,240.00

// Snippet from Go velocity calculator
velocity := 0.0
if totalPoints > 0 {
    velocity = float64(completedPoints) / float64(totalPoints)
}
fmt.Printf("Team velocity: %.2f%%\n", velocity * 100)

// Snippet from Rust cost optimizer
let total_savings: f64 = idle_instances.iter().map(|i| i.estimated_monthly_savings).sum();
info!("Total estimated monthly savings: ${:.2}", total_savings);
// Output: Total estimated monthly savings: $17500.00