Where the in demand of tech skills and leadership: What Matters

package main

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

    "github.com/prometheus/client_golang/prometheus"
    "github.com/prometheus/client_golang/prometheus/promhttp"
)

// EngineeringKPI represents a single leadership/team health metric
type EngineeringKPI struct {
    CodeReviewTurnaroundSeconds float64 `json:"code_review_turnaround_seconds"`
    IncidentLeadTimeSeconds     float64 `json:"incident_lead_time_seconds"`
    MentorSessionCount          int     `json:"mentor_session_count"`
    LastUpdated                 string  `json:"last_updated"`
}

// Define Prometheus metrics
var (
    codeReviewTurnaround = prometheus.NewHistogram(prometheus.HistogramOpts{
        Name:    "engineering_code_review_turnaround_seconds",
        Help:    "Histogram of time taken to complete code reviews, bucketed by priority",
        Buckets: prometheus.DefBuckets,
    })
    incidentLeadTime = prometheus.NewHistogram(prometheus.HistogramOpts{
        Name:    "engineering_incident_lead_time_seconds",
        Help:    "Time from incident detection to first mitigation step",
        Buckets: []float64{60, 300, 600, 1800, 3600, 7200},
    })
    mentorSessionCount = prometheus.NewCounter(prometheus.CounterOpts{
        Name: "engineering_mentor_session_total",
        Help: "Total number of mentorship sessions conducted by team leads",
    })
)

// loadKPIs reads KPI data from a local JSON file with error handling
func loadKPIs(ctx context.Context, filePath string) (*EngineeringKPI, error) {
    // Check if context is cancelled before proceeding
    if ctx.Err() != nil {
        return nil, fmt.Errorf("context cancelled: %w", ctx.Err())
    }

    file, err := os.Open(filePath)
    if err != nil {
        return nil, fmt.Errorf("failed to open KPI file %s: %w", filePath, err)
    }
    defer file.Close()

    var kpi EngineeringKPI
    if err := json.NewDecoder(file).Decode(&kpi); err != nil {
        return nil, fmt.Errorf("failed to decode KPI JSON: %w", err)
    }

    // Validate KPI data
    if kpi.CodeReviewTurnaroundSeconds < 0 {
        return nil, fmt.Errorf("invalid code review turnaround: negative value %f", kpi.CodeReviewTurnaroundSeconds)
    }
    if kpi.LastUpdated == "" {
        return nil, fmt.Errorf("missing last_updated timestamp in KPI data")
    }

    return &kpi, nil
}

// updateMetrics pushes latest KPI values to Prometheus metrics
func updateMetrics(kpi *EngineeringKPI) {
    codeReviewTurnaround.Observe(kpi.CodeReviewTurnaroundSeconds)
    incidentLeadTime.Observe(kpi.IncidentLeadTimeSeconds)
    mentorSessionCount.Add(float64(kpi.MentorSessionCount))
}

func main() {
    // Register Prometheus metrics
    prometheus.MustRegister(codeReviewTurnaround)
    prometheus.MustRegister(incidentLeadTime)
    prometheus.MustRegister(mentorSessionCount)

    // Start metrics update loop
    go func() {
        ticker := time.NewTicker(30 * time.Second)
        defer ticker.Stop()

        for {
            select {
            case <-ticker.C:
                ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
                kpi, err := loadKPIs(ctx, "engineering_kpis.json")
                cancel()
                if err != nil {
                    log.Printf("Failed to load KPIs: %v", err)
                    continue
                }
                updateMetrics(kpi)
                log.Printf("Updated metrics from KPI data last updated: %s", kpi.LastUpdated)
            }
        }
    }()

    // Expose /metrics endpoint
    http.Handle("/metrics", promhttp.Handler())
    log.Println("Starting Prometheus exporter on :9090")
    if err := http.ListenAndServe(":9090", nil); err != nil {
        log.Fatalf("Failed to start HTTP server: %v", err)
    }
}

# Terraform module to provision autoscaling GitLab CI runners on AWS
# Requires Terraform >= 1.7.0, AWS provider ~> 5.0
terraform {
  required_version = ">= 1.7.0"
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
  }
}

# Configure AWS provider with explicit region validation
provider "aws" {
  region = var.aws_region

  # Validate region is supported for GitLab runner AMIs
  assume_role {
    role_arn = var.assume_role_arn != "" ? var.assume_role_arn : null
  }
}

# Variables with validation rules for error handling
variable "aws_region" {
  type        = string
  description = "AWS region to deploy GitLab runners"
  default     = "us-east-1"

  validation {
    condition     = contains(["us-east-1", "us-west-2", "eu-west-1"], var.aws_region)
    error_message = "Unsupported region. GitLab runner AMIs are only available in us-east-1, us-west-2, eu-west-1."
  }
}

variable "gitlab_runner_token" {
  type        = string
  description = "Registration token for GitLab CI runner"
  sensitive   = true

  validation {
    condition     = length(var.gitlab_runner_token) == 20
    error_message = "GitLab runner token must be exactly 20 characters long."
  }
}

variable "runner_instance_type" {
  type        = string
  description = "EC2 instance type for runners"
  default     = "t4g.medium"

  validation {
    condition     = contains(["t4g.small", "t4g.medium", "t4g.large"], var.runner_instance_type)
    error_message = "Unsupported instance type. Use t4g.small, t4g.medium, or t4g.large for cost efficiency."
  }
}

# Fetch latest GitLab runner AMI for ARM64 (Graviton2)
data "aws_ami" "gitlab_runner" {
  most_recent = true
  owners      = ["self"] # Replace with GitLab's official AMI owner ID in production

  filter {
    name   = "name"
    values = ["gitlab-runner-ubuntu-22.04-arm64-*"]
  }

  filter {
    name   = "virtualization-type"
    values = ["hvm"]
  }
}

# Autoscaling group for GitLab runners
resource "aws_autoscaling_group" "gitlab_runner" {
  name_prefix          = "gitlab-runner-asg-"
  vpc_zone_identifier  = var.subnet_ids
  desired_capacity     = var.desired_capacity
  max_size             = var.max_capacity
  min_size             = var.min_capacity
  health_check_type    = "EC2"
  force_delete         = true

  launch_template {
    id      = aws_launch_template.gitlab_runner.id
    version = aws_launch_template.gitlab_runner.latest_version
  }

  tag {
    key                 = "Name"
    value               = "gitlab-ci-runner"
    propagate_at_launch = true
  }

  tag {
    key                 = "Environment"
    value               = var.environment
    propagate_at_launch = true
  }
}

# Launch template with runner configuration
resource "aws_launch_template" "gitlab_runner" {
  name_prefix   = "gitlab-runner-lt-"
  image_id      = data.aws_ami.gitlab_runner.id
  instance_type = var.runner_instance_type
  key_name      = var.ssh_key_name

  user_data = base64encode(templatefile("${path.module}/runner-init.sh", {
    gitlab_url       = var.gitlab_url
    runner_token     = var.gitlab_runner_token
    runner_tags      = join(",", var.runner_tags)
    concurrent_jobs  = var.concurrent_jobs
  }))

  network_interfaces {
    associate_public_ip_address = false
    security_groups             = [aws_security_group.gitlab_runner.id]
  }

  lifecycle {
    create_before_destroy = true
  }
}

# Security group for runners
resource "aws_security_group" "gitlab_runner" {
  name_prefix = "gitlab-runner-sg-"
  vpc_id      = var.vpc_id

  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }
}

# Output the ASG name for downstream tooling
output "autoscaling_group_name" {
  value       = aws_autoscaling_group.gitlab_runner.name
  description = "Name of the GitLab runner autoscaling group"
}

"""
GitHub Contribution Leadership Analyzer
Analyzes repository contribution patterns to identify engineers demonstrating leadership behaviors
Requires: PyGithub >= 2.1.0, python-dotenv >= 1.0.0
"""

import os
import sys
import time
from datetime import datetime, timedelta
from typing import Dict, List, Tuple

from dotenv import load_dotenv
from github import Github, GithubException, RateLimitExceededException

# Load environment variables from .env file
load_dotenv()
GITHUB_TOKEN = os.getenv("GITHUB_TOKEN")
if not GITHUB_TOKEN:
    print("Error: GITHUB_TOKEN environment variable not set. Create a .env file with your GitHub personal access token.")
    sys.exit(1)

# Initialize GitHub client with error handling for invalid tokens
try:
    gh = Github(GITHUB_TOKEN)
    # Test authentication to catch invalid tokens early
    _ = gh.get_user().login
except GithubException as e:
    print(f"Authentication failed: {e.data.get('message', str(e))}")
    sys.exit(1)

# Configuration
REPO_OWNER = "octocat"
REPO_NAME = "Hello-World"
ANALYSIS_WINDOW_DAYS = 90
LEADERSHIP_THRESHOLDS = {
    "min_commits": 15,
    "min_pr_reviews": 10,
    "min_mention_count": 5,
    "min_closed_issues": 3
}


def get_repo(owner: str, name: str):
    """Fetch repository object with error handling for non-existent repos"""
    try:
        return gh.get_repo(f"{owner}/{name}")
    except GithubException as e:
        if e.status == 404:
            raise ValueError(f"Repository {owner}/{name} not found or access denied") from e
        raise


def get_contributors(repo, since: datetime) -> List[Dict]:
    """Retrieve contributors with commits in the analysis window"""
    contributors = []
    try:
        for contributor in repo.get_contributors():
            # Fetch commit activity for the contributor
            commits = list(repo.get_commits(author=contributor, since=since))
            if not commits:
                continue
            contributors.append({
                "login": contributor.login,
                "commit_count": len(commits),
                "last_commit": commits[0].commit.author.date
            })
    except RateLimitExceededException:
        print("GitHub rate limit exceeded. Waiting 60 seconds...")
        time.sleep(60)
        return get_contributors(repo, since)
    return contributors


def get_pr_review_count(repo, user_login: str, since: datetime) -> int:
    """Count PR reviews performed by a user in the analysis window"""
    review_count = 0
    try:
        for pr in repo.get_pulls(state="all", sort="updated", direction="desc"):
            if pr.updated_at < since:
                break
            # Check if user reviewed this PR
            for review in pr.get_reviews():
                if review.user.login == user_login and review.submitted_at >= since:
                    review_count += 1
                    break
    except RateLimitExceededException:
        print("GitHub rate limit exceeded. Waiting 60 seconds...")
        time.sleep(60)
        return get_pr_review_count(repo, user_login, since)
    return review_count


def get_leadership_score(contributor: Dict, repo, since: datetime) -> Tuple[int, Dict]:
    """Calculate leadership score based on predefined thresholds"""
    score = 0
    details = {
        "commits": contributor["commit_count"],
        "pr_reviews": 0,
        "mentions": 0,
        "closed_issues": 0
    }

    # PR review count
    details["pr_reviews"] = get_pr_review_count(repo, contributor["login"], since)
    if details["pr_reviews"] >= LEADERSHIP_THRESHOLDS["min_pr_reviews"]:
        score += 30

    # Mention count in issues/PRs
    mention_count = 0
    for issue in repo.get_issues(state="all", since=since):
        if f"@{contributor['login']}" in issue.body or f"@{contributor['login']}" in (issue.title or ""):
            mention_count += 1
    details["mentions"] = mention_count
    if mention_count >= LEADERSHIP_THRESHOLDS["min_mention_count"]:
        score += 25

    # Closed issues
    closed_issues = list(repo.get_issues(assignee=contributor["login"], state="closed", since=since))
    details["closed_issues"] = len(closed_issues)
    if len(closed_issues) >= LEADERSHIP_THRESHOLDS["min_closed_issues"]:
        score += 25

    # Commit count
    if contributor["commit_count"] >= LEADERSHIP_THRESHOLDS["min_commits"]:
        score += 20

    return score, details


def main():
    since_date = datetime.now() - timedelta(days=ANALYSIS_WINDOW_DAYS)
    print(f"Analyzing {REPO_OWNER}/{REPO_NAME} for leadership potential since {since_date.strftime('%Y-%m-%d')}")

    try:
        repo = get_repo(REPO_OWNER, REPO_NAME)
    except ValueError as e:
        print(f"Error: {e}")
        sys.exit(1)

    contributors = get_contributors(repo, since_date)
    print(f"Found {len(contributors)} active contributors in analysis window")

    for contributor in contributors:
        score, details = get_leadership_score(contributor, repo, since_date)
        print(f"\nContributor: {contributor['login']}")
        print(f"Leadership Score: {score}/100")
        print(f"Details: {details}")
        if score >= 70:
            print("✅ High leadership potential: Demonstrates mentorship, code review, and issue ownership behaviors")
        elif score >= 40:
            print("⚠️ Moderate leadership potential: Needs to increase PR reviews or mentorship activity")
        else:
            print("❌ Low leadership potential: Focus on code contribution and team collaboration")


if __name__ == "__main__":
    main()

// Rust function to validate Kubernetes pod annotations for leadership tracking
fn validate_pod_annotations(annotations: &std::collections::HashMap) -> Result<(), String> {
    let required_keys = ["code-review-owner", "incident-lead", "mentor-assigned"];
    for key in required_keys {
        if !annotations.contains_key(*key) {
            return Err(format!("Missing required annotation: {}", key));
        }
    }
    Ok(())
}

-- SQL query to count PR reviews per engineer in the last 30 days (PostgreSQL)
SELECT u.username, COUNT(prr.id) AS review_count
FROM pull_request_reviews prr
JOIN users u ON prr.reviewer_id = u.id
WHERE prr.created_at >= NOW() - INTERVAL '30 days'
GROUP BY u.username
ORDER BY review_count DESC;

# Terraform variable addition for tracking junior engineer runner access
variable "junior_engineer_arns" {
  type        = list(string)
  description = "List of ARNs for junior engineers allowed to trigger CI runs"
  default     = []

  validation {
    condition     = alltrue([for arn in var.junior_engineer_arns : can(regex("^arn:aws:iam::[0-9]{12}:user/.+", arn))])
    error_message = "All junior engineer ARNs must be valid IAM user ARNs."
  }
}