CI/CD & DevOps

# .github/workflows/ci.yml (example)
name: CI
on: [push, pull_request]

jobs:
  lint-and-typecheck:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Install tools
        run: |
          wget -q https://github.com/llvm/llvm-project/releases/download/llvmorg-17.0.6/clang+llvm-17.0.6-x86_64-linux-gnu-ubuntu-22.04.tar.xz
          tar -xf clang+llvm-17.0.6-x86_64-linux-gnu-ubuntu-22.04.tar.xz
          export PATH=$PWD/clang+llvm-17.0.6-x86_64-linux-gnu-ubuntu-22.04/bin:$PATH
      - run: clang-tidy src/**/*.cpp -- -Iinclude -std=c++20
      - run: clang-format --dry-run --Werror src/**/*.cpp include/**/*.hpp

  unit-tests:
    runs-on: ubuntu-latest
    needs: lint-and-typecheck
    steps:
      - uses: actions/checkout@v4
      - name: Install Catch2
        run: |
          git clone https://github.com/catchorg/Catch2.git
          cd Catch2 && cmake -Bbuild -DCMAKE_BUILD_TYPE=Release && cmake --build build --target install
      - run: cmake -Bbuild -DCMAKE_BUILD_TYPE=Debug && cmake --build build
      - run: ./build/tests --reporter=junit > test-results.xml

// .github/workflows/ci.yml (example)
name: CI
on: [push, pull_request]

jobs:
  lint-and-test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-java@v4
        with:
          distribution: 'temurin'
          java-version: '21'
      - name: Cache Maven
        uses: actions/cache@v4
        with:
          path: ~/.m2/repository
          key: maven-${{ hashFiles('**/pom.xml') }}
      - run: mvn checkstyle:check spotbugs:check
      - run: mvn test jacoco:report
      - uses: codecov/codecov-action@v4
        with:
          files: target/site/jacoco/jacoco.xml

# .github/workflows/ci.yml (example)
name: CI
on: [push, pull_request]

jobs:
  build-and-test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-dotnet@v4
        with:
          dotnet-version: '8.0.x'
      - run: dotnet format --verify-no-changes
      - run: dotnet build --no-restore --configuration Release
      - run: dotnet test --collect:"XPlat Code Coverage" --threshold=85
      - uses: codecov/codecov-action@v4

# .github/workflows/cd-staging.yml
name: CD Staging
on:
  workflow_run:
    workflows: ["CI"]
    types: [completed]
    branches: [main]

jobs:
  deploy-staging:
    if: ${{ github.event.workflow_run.conclusion == 'success' }}
    runs-on: ubuntu-latest
    environment: staging
    steps:
      - uses: actions/checkout@v4
      - name: Build & Push Image
        run: |
          docker build -t ghcr.io/${{ github.repository }}:${{ github.sha }} .
          docker push ghcr.io/${{ github.repository }}:${{ github.sha }}
      - name: Deploy to Staging
        run: |
          kubectl set image deployment/myapp \
            myapp=ghcr.io/${{ github.repository }}/${{ github.sha }} \
            -n staging
      - name: Smoke Tests
        run: |
          sleep 30
          curl -f https://staging.myapp.com/health || exit 1

// .github/workflows/cd-staging.yml
name: CD Staging
on:
  workflow_run:
    workflows: ["CI"]
    types: [completed]
    branches: [main]

jobs:
  deploy-staging:
    if: ${{ github.event.workflow_run.conclusion == 'success' }}
    runs-on: ubuntu-latest
    environment: staging
    steps:
      - uses: actions/checkout@v4
      - name: Build & Push Image
        run: |
          docker build -t ghcr.io/${{ github.repository }}:${{ github.sha }} .
          docker push ghcr.io/${{ github.repository }}:${{ github.sha }}
      - name: Deploy to Staging
        run: |
          kubectl set image deployment/myapp \
            myapp=ghcr.io/${{ github.repository }}:${{ github.sha }} \
            -n staging
      - name: Smoke Tests
        run: |
          sleep 30
          curl -f https://staging.myapp.com/health || exit 1

# .github/workflows/cd-staging.yml
name: CD Staging
on:
  workflow_run:
    workflows: ["CI"]
    types: [completed]
    branches: [main]

jobs:
  deploy-staging:
    if: ${{ github.event.workflow_run.conclusion == 'success' }}
    runs-on: ubuntu-latest
    environment: staging
    steps:
      - uses: actions/checkout@v4
      - name: Build & Push Image
        run: |
          docker build -t ghcr.io/${{ github.repository }}:${{ github.sha }} .
          docker push ghcr.io/${{ github.repository }}:${{ github.sha }}
      - name: Deploy to Staging
        run: |
          kubectl set image deployment/myapp \
            myapp=ghcr.io/${{ github.repository }}:${{ github.sha }} \
            -n staging
      - name: Smoke Tests
        run: |
          sleep 30
          curl -f https://staging.myapp.com/health || exit 1

# .github/workflows/cd-canary.yml
deploy-canary:
  needs: deploy-staging
  environment: production
  steps:
    - name: Deploy Canary (10%)
      run: |
        kubectl set image deployment/myapp \
          myapp=ghcr.io/${{ github.repository }}:${{ github.sha }} \
          -n production --replicas=10%
    - name: Monitor Metrics (15 min)
      run: |
        # Check error rate, latency, business metrics
        ./scripts/check-canary-health.sh
    - name: Promote or Rollback
      run: |
        if [ $CANARY_HEALTHY = true ]; then
          kubectl scale deployment/myapp --replicas=100%
        else
          kubectl rollout undo deployment/myapp
        fi

// .github/workflows/cd-canary.yml
deploy-canary:
  needs: deploy-staging
  environment: production
  steps:
    - name: Deploy Canary (10%)
      run: |
        kubectl set image deployment/myapp \
          myapp=ghcr.io/${{ github.repository }}:${{ github.sha }} \
          -n production --replicas=10%
    - name: Monitor Metrics (15 min)
      run: |
        # Check error rate, latency, business metrics
        ./scripts/check-canary-health.sh
    - name: Promote or Rollback
      run: |
        if [ $CANARY_HEALTHY = true ]; then
          kubectl scale deployment/myapp --replicas=100%
        else
          kubectl rollout undo deployment/myapp
        fi

# .github/workflows/cd-canary.yml
deploy-canary:
  needs: deploy-staging
  environment: production
  steps:
    - name: Deploy Canary (10%)
      run: |
        kubectl set image deployment/myapp \
          myapp=ghcr.io/${{ github.repository }}:${{ github.sha }} \
          -n production --replicas=10%
    - name: Monitor Metrics (15 min)
      run: |
        # Check error rate, latency, business metrics
        ./scripts/check-canary-health.sh
    - name: Promote or Rollback
      run: |
        if [ $CANARY_HEALTHY = true ]; then
          kubectl scale deployment/myapp --replicas=100%
        else
          kubectl rollout undo deployment/myapp
        fi

# .github/workflows/ci.yml - caching example
jobs:
  build:
    steps:
      - uses: actions/checkout@v4

      # CMake/ccache
      - uses: actions/cache@v4
        with:
          path: |
            ~/.ccache
            ~/.cmake
          key: cmake-${{ runner.os }}-${{ hashFiles('CMakeLists.txt', 'CMakePresets.json') }}
          restore-keys: cmake-${{ runner.os }}-

      - uses: actions/cache@v4
        with:
          path: ~/.conan/data
          key: conan-${{ runner.os }}-${{ hashFiles('conanfile.txt') }}
          restore-keys: conan-${{ runner.os }}-

      - name: Build with ccache
        run: |
          export CC="ccache gcc"
          export CXX="ccache g++"
          cmake -Bbuild -DCMAKE_C_COMPILER_LAUNCHER=ccache -DCMAKE_CXX_COMPILER_LAUNCHER=ccache
          cmake --build build

# .github/workflows/ci.yml - caching example
jobs:
  build:
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-java@v4
        with:
          distribution: 'temurin'
          java-version: '21'

      - name: Cache Maven
        uses: actions/cache@v4
        with:
          path: ~/.m2/repository
          key: maven-${{ runner.os }}-${{ hashFiles('**/pom.xml') }}
          restore-keys: maven-${{ runner.os }}-

      - name: Cache Gradle
        uses: actions/cache@v4
        with:
          path: |
            ~/.gradle/caches
            ~/.gradle/wrapper
          key: gradle-${{ runner.os }}-${{ hashFiles('**/*.gradle*') }}
          restore-keys: gradle-${{ runner.os }}-

      - run: mvn -B verify

# .github/workflows/ci.yml - caching example
jobs:
  build:
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-dotnet@v4
        with:
          dotnet-version: '8.0.x'

      - name: Cache NuGet
        uses: actions/cache@v4
        with:
          path: ~/.nuget/packages
          key: nuget-${{ runner.os }}-${{ hashFiles('**/*.csproj') }}
          restore-keys: nuget-${{ runner.os }}-

      - name: Cache dotnet CLI
        uses: actions/cache@v4
        with:
          path: ~/.dotnet
          key: dotnetcli-${{ runner.os }

      - run: dotnet restore
      - run: dotnet build --no-restore --configuration Release
      - run: dotnet test --collect:"XPlat Code Coverage" --threshold=85

# Security gates in CI (C++)
jobs:
  security:
    steps:
      - uses: actions/checkout@v4
      # SAST - CodeQL
      - uses: github/codeql-action/analyze@v3
        with:
          languages: cpp
          queries: security-extended
      # SCA - Dependency check
      - uses: dependency-check/Dependency-Check_Action@main
        with:
          project: 'myapp'
          format: 'HTML'
          out: 'reports'
      # Container scan
      - uses: aquasecurity/trivy-action@master
        with:
          image-ref: 'ghcr.io/${{ github.repository }}:${{ github.sha }}'

# Security gates in CI (Java)
jobs:
  security:
    steps:
      - uses: actions/checkout@v4
      # SAST - CodeQL
      - uses: github/codeql-action/analyze@v3
        with:
          languages: java
      # SCA - OWASP Dependency Check
      - uses: dependency-check/Dependency-Check_Action@main
        with:
          project: 'myapp'
          format: 'XML'
      # Secret scanning
      - uses: trufflesecurity/trufflehog@main
        with:
          path: ./
      # Container scan
      - uses: aquasecurity/trivy-action@master
        with:
          image-ref: 'ghcr.io/${{ github.repository }}:${{ github.sha }}'

# Security gates in CI (C#)
jobs:
  security:
    steps:
      - uses: actions/checkout@v4
      # SAST - CodeQL
      - uses: github/codeql-action/analyze@v3
        with:
          languages: csharp
      # SCA - NuGet audit
      - run: dotnet nuget-audit --threshold High
      # Secret scanning
      - uses: trufflesecurity/trufflehog@main
        with:
          path: ./
      # Container scan
      - uses: aquasecurity/trivy-action@master
        with:
          image-ref: 'ghcr.io/${{ github.repository }}:${{ github.sha }}'

# CMakeLists.txt - C++ build infrastructure
cmake_minimum_required(VERSION 3.25)
project(MyApp VERSION 1.0.0 LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)

# Toolchain for vcpkg
set(CMAKE_TOOLCHAIN_FILE ${VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake)

find_package(fmt REQUIRED)
find_package(spdlog REQUIRED)
find_package(boost REQUIRED COMPONENTS system thread)

add_executable(main src/main.cpp)
target_link_libraries(main PRIVATE fmt::fmt spdlog::spdlog boost::system boost::thread)

# CI configuration
enable_testing()
add_subdirectory(tests)

// build.gradle.kts - Java/Gradle infrastructure
plugins {
    id("java")
    id("application")
    id("org.springframework.boot") version "3.2.0"
    id("io.spring.dependency-management") version "1.1.4"
}

java {
    toolchain.languageVersion.set(JavaLanguageVersion.of(21))
}

repositories {
    mavenCentral()
    maven { url = uri("https://repo.spring.io/milestone") }
}

dependencies {
    implementation(platform("org.springframework.boot:spring-boot-dependencies:3.2.0"))
    implementation("org.springframework.boot:spring-boot-starter-web")
    implementation("org.springframework.boot:spring-boot-starter-data-jpa")
    implementation("org.postgresql:postgresql")
    testImplementation("org.springframework.boot:spring-boot-starter-test")
}

tasks.withType(Test) {
    useJUnitPlatform()
    testLogging.events = setOf("passed", "failed", "skipped")
}

# azure-pipelines.yml - C#/Azure DevOps
trigger:
  - main

pool:
  vmImage: 'ubuntu-latest'

variables:
  buildConfiguration: 'Release'

steps:
- task: UseDotNet@2
  inputs:
    version: '8.0.x'
    performMultiLevelLookup: true

- task: DotNetCoreCLI@2
  displayName: 'Restore'
  inputs:
    command: 'restore'
    projects: '**/*.csproj'

- task: DotNetCoreCLI@2
  displayName: 'Build'
  inputs:
    command: 'build'
    arguments: '--configuration $(buildConfiguration) --no-restore'
    projects: '**/*.csproj'

- task: DotNetCoreCLI@2
  displayName: 'Test'
  inputs:
    command: 'test'
    projects: '**/*Tests.csproj'
    arguments: '--configuration $(buildConfiguration) --collect:"XPlat Code Coverage" --threshold 85'

- task: PublishCodeCoverageResults@1
  inputs:
    codeCoverageTool: 'Cobertura'
    summaryFileLocation: '**/coverage.cobertura.xml'

// Prometheus metrics in C++
#include <prometheus/counter.h>
#include <prometheus/histogram.h>
#include <prometheus/gauge.h>
#include <prometheus/exposer.h>

using prometheus::Counter;
using prometheus::Histogram;
using prometheus::Gauge;
using prometheus::Exposer;

Exposer exposer{"localhost:9090"};
auto registry = std::make_shared<prometheus::Registry>();

auto& requestCount = Counter::Build().Name("http_requests_total").Help("Total HTTP requests").Register(*registry);
auto& requestLatency = Histogram::Build().Name("http_request_duration_seconds").Help("Request latency").Register(*registry);
auto& activeConnections = Gauge::Build().Name("active_connections").Help("Active connections").Register(*registry);

class MetricsMiddleware {
public:
    void operator()(const Request& req, Response& res, std::function<void()> next) {
        auto start = std::chrono::steady_clock::now();
        next();
        auto elapsed = std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::steady_clock::now() - start);
        requestCount.Add({{"method", req.method}, {"path", req.path}, {"status", std::to_string(res.status)}})->Increment();
        requestLatency.Observe(elapsed.count() / 1e6);
    }
};

// Micrometer + Prometheus in Java
import io.micrometer.core.instrument.*;
import io.micrometer.prometheus.*;

MeterRegistry registry = new PrometheusMeterRegistry(PrometheusConfig.DEFAULT);

Counter requestCount = Counter.builder("http_requests_total")
    .description("Total HTTP requests")
    .register(registry);

Timer requestLatency = Timer.builder("http_request_duration_seconds")
    .description("Request latency")
    .register(registry);

Gauge.builder("active_connections", connectionPool, ConnectionPool::getActiveCount)
    .description("Active connections")
    .register(registry);

// Spring Boot actuator exposes /actuator/prometheus automatically

// Prometheus metrics in C#
using Prometheus;

var requestCount = Metrics.CreateCounter("http_requests_total", "Total HTTP requests", new[] { "method", "endpoint", "status" });
var requestLatency = Metrics.CreateHistogram("http_request_duration_seconds", "Request latency", new[] { "method", "endpoint" });
var activeConnections = Metrics.CreateGauge("active_connections", "Active connections");

app.Use(async (context, next) =>
{
    var start = DateTime.UtcNow;
    await next.Invoke();
    var elapsed = DateTime.UtcNow - start;

    requestCount.WithLabels(context.Request.Method, context.Request.Path, context.Response.StatusCode.ToString()).Inc();
    requestLatency.WithLabels(context.Request.Method, context.Request.Path).Observe(elapsed.TotalSeconds);
});

// Expose /metrics endpoint
app.MapMetrics();