egullickson/motovaultpro
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[Feature]: Implement Unified Debug Logging System with Centralized Log Aggregation #80

New Issue
Closed
opened 2026-02-03 01:58:00 +00:00 by egullickson · 5 comments
egullickson commented 2026-02-03 01:58:00 +00:00
Owner
Copy Link

Problem / User Need

As a developer and operator, I need a unified logging system that:

  • Provides consistent log levels across all 6 containers (Frontend, Backend, OCR, PostgreSQL, Redis, Traefik)
  • Is controlled by a single LOG_LEVEL environment variable set in CI/CD
  • Aggregates all logs to a searchable, centralized system
  • Supports request correlation across services
  • Replaces the current manual debug process documented in docs/UX-DEBUGGING.md

Currently, enabling debug logging requires manually modifying vite.config.ts Terser/ESBuild options and rebuilding. There is no unified log level control, no correlation IDs, and no centralized log aggregation.

Proposed Solution

Implement a unified logging system with:

  1. Single Control Variable: LOG_LEVEL (DEBUG, INFO, WARN, ERROR) set in CI/CD
  2. Config Generator: scripts/ci/generate-log-config.sh maps single variable to per-container settings
  3. Application Logging: Custom logger (Frontend), Pino (Backend/OCR) with correlation IDs
  4. Database Logging: PostgreSQL and Redis configured via mapped environment variables
  5. Log Aggregation: Self-hosted Promtail + Loki + Grafana stack
  6. Docker Rotation: Aggressive rotation (10m x 3 files) - Docker as buffer, Loki as retention

Architecture

┌─────────────────────────────────────────────────────────────────────┐
│                         CI/CD PIPELINE                              │
│  LOG_LEVEL ──► generate-log-config.sh ──► .env.logging              │
└─────────────────────────────────────────────────────────────────────┘
                                │
                                ▼
┌─────────────────────────────────────────────────────────────────────┐
│                       APPLICATION LAYER                             │
│  Frontend   Backend    OCR      Postgres   Redis    Traefik         │
│  (console)  (Pino)    (Pino)   (stderr)   (stderr)  (stdout)        │
│      │         │         │         │         │         │            │
│   browser      └─────────┴─────────┴─────────┴─────────┘            │
│                          │                                          │
│                Docker Log Driver (json-file, 10m x 3)               │
└──────────────────────────│──────────────────────────────────────────┘
                           │
                           ▼
              Promtail ──► Loki (30-day retention) ──► Grafana

Unified LOG_LEVEL Mapping

LOG_LEVEL Frontend Backend OCR PostgreSQL Redis Traefik
DEBUG debug debug debug all queries, 0ms threshold debug DEBUG
INFO info info info DDL only, 500ms slow query verbose INFO
WARN warn warn warn errors + 1000ms slow query notice WARN
ERROR error error error errors only warning ERROR

Non-goals / Out of Scope

  • OpenTelemetry distributed tracing (future enhancement)
  • Log-based alerting rules (follow-up issue)
  • Query-comment correlation for PostgreSQL (Phase 2)
  • Development environment logging configuration
  • CLIENT SETNAME correlation for Redis

Acceptance Criteria (Feature Behavior)

Research Tasks

  • Investigate if Traefik currently generates/forwards X-Request-Id
  • Investigate current backend Pino configuration and request ID handling
  • Review OCR container logging implementation
  • Review current PostgreSQL logging configuration
  • Review current Redis logging configuration

Config Generator (scripts/ci/generate-log-config.sh)

  • Accept single LOG_LEVEL input (DEBUG, INFO, WARN, ERROR)
  • Generate .env.logging with all mapped variables
  • Validate input and fail on invalid LOG_LEVEL
  • Document usage in script header

Frontend

  • Create logger module respecting VITE_LOG_LEVEL
  • Implement log levels: debug, info, warn, error
  • Include requestId in API call logs for correlation
  • Implement token/sensitive data sanitization
  • Works on mobile viewport (320px)
  • Works on desktop viewport (1920px)

Backend

  • Configure Pino with LOG_LEVEL from environment
  • Add request ID middleware (generate if X-Request-Id missing)
  • Implement sensitive data redaction (tokens, passwords)
  • Include correlation fields: requestId, userId, vehicleId

OCR Container

  • Configure logging with LOG_LEVEL from environment
  • Implement jobId generation for long-running jobs
  • Propagate requestId from triggering request
  • Include correlation fields in all job logs

PostgreSQL

  • Configure to read log settings from environment variables
  • Ensure logs go to stderr (Docker captures)
  • Mapping: DEBUG=all/0ms, INFO=ddl/500ms, WARN=none/1000ms, ERROR=none/-1

Redis

  • Configure loglevel from REDIS_LOGLEVEL environment variable
  • Mapping: DEBUG=debug, INFO=verbose, WARN=notice, ERROR=warning

Traefik

  • Configure X-Request-Id header generation/forwarding
  • Configure log level from TRAEFIK_LOG_LEVEL
  • Ensure access logs include request ID

Infrastructure (docker-compose.yml)

  • Add logging config to ALL services (10m x 3 rotation)
  • Add Promtail container and configuration
  • Add Loki container with 30-day retention policy
  • Add Grafana container with Loki datasource
  • Create basic log exploration dashboard

CI/CD

  • Update staging pipeline to run generate-log-config.sh DEBUG
  • Update production pipeline to run generate-log-config.sh INFO
  • Source .env.logging before docker-compose up

Documentation

  • Update/replace docs/UX-DEBUGGING.md with new logging system
  • Document LOG_LEVEL options and behavior per container
  • Document correlation ID fields and usage
  • Document Grafana access and log querying

Integration Criteria (App Flow)

Navigation

  • Desktop sidebar: not needed (infrastructure feature)
  • Mobile bottom nav: not needed
  • Mobile hamburger menu: not needed

Routing

  • Grafana accessible at dedicated URL (e.g., https://logs.motovaultpro.com or :3000)
  • Is this the default landing page after login? no
  • Replaces existing placeholder/route: none

State Management

  • Mobile screen type needed in navigation store? no
  • New Zustand store needed? no

Visual Integration (Design Consistency)

N/A - This is an infrastructure/backend feature. Grafana provides its own UI.

Implementation Notes

Current State

  • docs/UX-DEBUGGING.md documents manual Vite config modification process
  • frontend/vite.config.ts has Terser drop_console: true and ESBuild drop: ['console']
  • Backend uses Fastify with Pino (configuration needs investigation)
  • OCR container logging needs investigation
  • PostgreSQL/Redis logging not currently integrated

Files to Create/Modify

  • Create: scripts/ci/generate-log-config.sh
  • Create: frontend/src/utils/logger.ts
  • Create: config/promtail/config.yml
  • Create: config/loki/config.yml
  • Modify: docker-compose.yml (add 3 containers, add logging config to all)
  • Modify: frontend/vite.config.ts (respect VITE_LOG_LEVEL)
  • Modify: Backend Pino configuration
  • Modify: OCR container logging
  • Update: docs/UX-DEBUGGING.md
  • Modify: .gitea/workflows/staging.yaml
  • Modify: .gitea/workflows/production.yaml

Container Count Change

Before: 5 containers (Traefik, Frontend, Backend, PostgreSQL, Redis)
After: 8 containers (+ Promtail, Loki, Grafana)

Correlation ID Reference

Field Source Containers
requestId Traefik X-Request-Id or backend UUID Backend, OCR, Frontend
jobId OCR generates for async work OCR
userId Auth context Backend, OCR
vehicleId Request context Backend, OCR
(PostgreSQL/Redis) N/A Timestamp-based correlation

Test Plan

Unit tests:

  • Logger module respects log level settings
  • Config generator produces correct mappings
  • Sensitive data redaction works correctly

Integration tests:

  • End-to-end request with correlation ID propagation
  • Logs appear in Loki with correct labels
  • Log rotation works as expected

Manual testing:

  • Set LOG_LEVEL=DEBUG, verify all containers log at debug level
  • Set LOG_LEVEL=ERROR, verify only errors logged
  • Verify requestId flows from Traefik through Backend to OCR
  • Query logs in Grafana by requestId, userId, container
  • Verify no tokens appear in any logs
## Problem / User Need As a developer and operator, I need a unified logging system that: - Provides consistent log levels across all 6 containers (Frontend, Backend, OCR, PostgreSQL, Redis, Traefik) - Is controlled by a single `LOG_LEVEL` environment variable set in CI/CD - Aggregates all logs to a searchable, centralized system - Supports request correlation across services - Replaces the current manual debug process documented in `docs/UX-DEBUGGING.md` Currently, enabling debug logging requires manually modifying `vite.config.ts` Terser/ESBuild options and rebuilding. There is no unified log level control, no correlation IDs, and no centralized log aggregation. ## Proposed Solution Implement a unified logging system with: 1. **Single Control Variable**: `LOG_LEVEL` (DEBUG, INFO, WARN, ERROR) set in CI/CD 2. **Config Generator**: `scripts/ci/generate-log-config.sh` maps single variable to per-container settings 3. **Application Logging**: Custom logger (Frontend), Pino (Backend/OCR) with correlation IDs 4. **Database Logging**: PostgreSQL and Redis configured via mapped environment variables 5. **Log Aggregation**: Self-hosted Promtail + Loki + Grafana stack 6. **Docker Rotation**: Aggressive rotation (10m x 3 files) - Docker as buffer, Loki as retention ### Architecture ``` ┌─────────────────────────────────────────────────────────────────────┐ │ CI/CD PIPELINE │ │ LOG_LEVEL ──► generate-log-config.sh ──► .env.logging │ └─────────────────────────────────────────────────────────────────────┘ │ ▼ ┌─────────────────────────────────────────────────────────────────────┐ │ APPLICATION LAYER │ │ Frontend Backend OCR Postgres Redis Traefik │ │ (console) (Pino) (Pino) (stderr) (stderr) (stdout) │ │ │ │ │ │ │ │ │ │ browser └─────────┴─────────┴─────────┴─────────┘ │ │ │ │ │ Docker Log Driver (json-file, 10m x 3) │ └──────────────────────────│──────────────────────────────────────────┘ │ ▼ Promtail ──► Loki (30-day retention) ──► Grafana ``` ### Unified LOG_LEVEL Mapping | LOG_LEVEL | Frontend | Backend | OCR | PostgreSQL | Redis | Traefik | |-----------|----------|---------|-----|------------|-------|---------| | DEBUG | debug | debug | debug | all queries, 0ms threshold | debug | DEBUG | | INFO | info | info | info | DDL only, 500ms slow query | verbose | INFO | | WARN | warn | warn | warn | errors + 1000ms slow query | notice | WARN | | ERROR | error | error | error | errors only | warning | ERROR | ## Non-goals / Out of Scope - OpenTelemetry distributed tracing (future enhancement) - Log-based alerting rules (follow-up issue) - Query-comment correlation for PostgreSQL (Phase 2) - Development environment logging configuration - CLIENT SETNAME correlation for Redis ## Acceptance Criteria (Feature Behavior) ### Research Tasks - [ ] Investigate if Traefik currently generates/forwards `X-Request-Id` - [ ] Investigate current backend Pino configuration and request ID handling - [ ] Review OCR container logging implementation - [ ] Review current PostgreSQL logging configuration - [ ] Review current Redis logging configuration ### Config Generator (`scripts/ci/generate-log-config.sh`) - [ ] Accept single `LOG_LEVEL` input (DEBUG, INFO, WARN, ERROR) - [ ] Generate `.env.logging` with all mapped variables - [ ] Validate input and fail on invalid LOG_LEVEL - [ ] Document usage in script header ### Frontend - [ ] Create logger module respecting `VITE_LOG_LEVEL` - [ ] Implement log levels: debug, info, warn, error - [ ] Include `requestId` in API call logs for correlation - [ ] Implement token/sensitive data sanitization - [ ] Works on mobile viewport (320px) - [ ] Works on desktop viewport (1920px) ### Backend - [ ] Configure Pino with `LOG_LEVEL` from environment - [ ] Add request ID middleware (generate if `X-Request-Id` missing) - [ ] Implement sensitive data redaction (tokens, passwords) - [ ] Include correlation fields: requestId, userId, vehicleId ### OCR Container - [ ] Configure logging with `LOG_LEVEL` from environment - [ ] Implement `jobId` generation for long-running jobs - [ ] Propagate `requestId` from triggering request - [ ] Include correlation fields in all job logs ### PostgreSQL - [ ] Configure to read log settings from environment variables - [ ] Ensure logs go to stderr (Docker captures) - [ ] Mapping: DEBUG=all/0ms, INFO=ddl/500ms, WARN=none/1000ms, ERROR=none/-1 ### Redis - [ ] Configure `loglevel` from `REDIS_LOGLEVEL` environment variable - [ ] Mapping: DEBUG=debug, INFO=verbose, WARN=notice, ERROR=warning ### Traefik - [ ] Configure `X-Request-Id` header generation/forwarding - [ ] Configure log level from `TRAEFIK_LOG_LEVEL` - [ ] Ensure access logs include request ID ### Infrastructure (docker-compose.yml) - [ ] Add logging config to ALL services (10m x 3 rotation) - [ ] Add Promtail container and configuration - [ ] Add Loki container with 30-day retention policy - [ ] Add Grafana container with Loki datasource - [ ] Create basic log exploration dashboard ### CI/CD - [ ] Update staging pipeline to run `generate-log-config.sh DEBUG` - [ ] Update production pipeline to run `generate-log-config.sh INFO` - [ ] Source `.env.logging` before `docker-compose up` ### Documentation - [ ] Update/replace `docs/UX-DEBUGGING.md` with new logging system - [ ] Document LOG_LEVEL options and behavior per container - [ ] Document correlation ID fields and usage - [ ] Document Grafana access and log querying ## Integration Criteria (App Flow) ### Navigation - [ ] Desktop sidebar: not needed (infrastructure feature) - [ ] Mobile bottom nav: not needed - [ ] Mobile hamburger menu: not needed ### Routing - [ ] Grafana accessible at dedicated URL (e.g., `https://logs.motovaultpro.com` or `:3000`) - [ ] Is this the default landing page after login? no - [ ] Replaces existing placeholder/route: none ### State Management - [ ] Mobile screen type needed in navigation store? no - [ ] New Zustand store needed? no ## Visual Integration (Design Consistency) N/A - This is an infrastructure/backend feature. Grafana provides its own UI. ## Implementation Notes ### Current State - `docs/UX-DEBUGGING.md` documents manual Vite config modification process - `frontend/vite.config.ts` has Terser `drop_console: true` and ESBuild `drop: ['console']` - Backend uses Fastify with Pino (configuration needs investigation) - OCR container logging needs investigation - PostgreSQL/Redis logging not currently integrated ### Files to Create/Modify - Create: `scripts/ci/generate-log-config.sh` - Create: `frontend/src/utils/logger.ts` - Create: `config/promtail/config.yml` - Create: `config/loki/config.yml` - Modify: `docker-compose.yml` (add 3 containers, add logging config to all) - Modify: `frontend/vite.config.ts` (respect VITE_LOG_LEVEL) - Modify: Backend Pino configuration - Modify: OCR container logging - Update: `docs/UX-DEBUGGING.md` - Modify: `.gitea/workflows/staging.yaml` - Modify: `.gitea/workflows/production.yaml` ### Container Count Change Before: 5 containers (Traefik, Frontend, Backend, PostgreSQL, Redis) After: 8 containers (+ Promtail, Loki, Grafana) ### Correlation ID Reference | Field | Source | Containers | |-------|--------|------------| | `requestId` | Traefik X-Request-Id or backend UUID | Backend, OCR, Frontend | | `jobId` | OCR generates for async work | OCR | | `userId` | Auth context | Backend, OCR | | `vehicleId` | Request context | Backend, OCR | | (PostgreSQL/Redis) | N/A | Timestamp-based correlation | ## Test Plan **Unit tests:** - Logger module respects log level settings - Config generator produces correct mappings - Sensitive data redaction works correctly **Integration tests:** - End-to-end request with correlation ID propagation - Logs appear in Loki with correct labels - Log rotation works as expected **Manual testing:** - Set LOG_LEVEL=DEBUG, verify all containers log at debug level - Set LOG_LEVEL=ERROR, verify only errors logged - Verify requestId flows from Traefik through Backend to OCR - Query logs in Grafana by requestId, userId, container - Verify no tokens appear in any logs
egullickson added the
status
backlog
type
feature
 labels 2026-02-03 01:58:06 +00:00
egullickson added
status
in-progress
 and removed
status
backlog
 labels 2026-02-03 02:07:43 +00:00
egullickson commented 2026-02-03 02:14:23 +00:00
Author
Owner
Copy Link

Plan: Unified Debug Logging System

Phase: Planning | Agent: Orchestrator | Status: IN_PROGRESS

Codebase Analysis Summary

Current State Findings:

Component Status Details
Backend Logger Winston (not Pino) 79 files import logger.ts, hardcoded level: 'info'
Request IDs Missing No correlation ID propagation anywhere
Traefik Partial JSON access logs enabled, no X-Request-Id
Frontend Console only 242 console.log calls, no centralized logger
Docker Logging Default No log rotation, no aggregation
Container Count 6 (not 5) Traefik, Frontend, Backend, OCR, PostgreSQL, Redis

Key Gap: Issue assumes Pino, but backend uses Winston (79 files).

Architectural Decision: Winston vs Pino

Decision-Critic Verdict: REVISE - Migrate to Pino

Factor Winston (Current) Pino (Recommended)
Performance ~5K logs/sec ~30K logs/sec (6x faster)
Fastify Integration Manual Native (@fastify/pino)
Correlation IDs Must build manually Built-in request logging
Migration Cost Zero Low (wrapper pattern)
Maintenance Higher (custom integration) Lower (ecosystem maintained)

Decision: Migrate to Pino using a wrapper pattern in logger.ts that maintains API compatibility. This allows:

  • Zero changes to 79 importing files
  • Built-in correlation IDs via @fastify/pino
  • Long-term maintainability

Sub-Issue Breakdown

This feature is too large for a single AI context. Breaking into 7 smaller issues:

Sub-Issue Title Scope Dependencies
#80-A Config Generator Script scripts/ci/generate-log-config.sh None
#80-B Backend: Pino Migration + Correlation IDs backend/src/core/logging/, plugins #80-A
#80-C Traefik: X-Request-Id Middleware config/traefik/ None
#80-D Frontend Logger Module frontend/src/utils/logger.ts #80-A
#80-E Docker Logging + Rotation docker-compose.yml logging blocks None
#80-F Promtail + Loki + Grafana Stack New containers, configs #80-E
#80-G CI/CD Integration + Documentation Workflows, docs All above

Implementation Plan

Milestone 1: Foundation (Sub-issues #80-A, #80-C, #80-E)

Parallel execution possible

#80-A: Config Generator Script

  • Create scripts/ci/generate-log-config.sh
  • Accept LOG_LEVEL (DEBUG, INFO, WARN, ERROR)
  • Generate .env.logging with per-container mappings
  • Acceptance: Script runs, validates input, outputs correct mappings

#80-C: Traefik X-Request-Id

  • Add x-request-id middleware to config/traefik/dynamic/middleware.yml
  • Configure header generation if missing, forwarding if present
  • Add to api-chain, platform-chain middleware stacks
  • Acceptance: Requests have X-Request-Id header in access logs

#80-E: Docker Logging Configuration

  • Add logging: block to all 6 services in docker-compose.yml
  • Configure json-file driver with 10m max-size, 3 max-file
  • Acceptance: Log rotation working, no unbounded growth

Milestone 2: Backend Logging (Sub-issue #80-B)

Depends on #80-A

#80-B: Pino Migration + Correlation IDs

Files to modify:

  1. backend/src/core/logging/logger.ts - Replace Winston with Pino wrapper
  2. backend/src/core/plugins/logging.plugin.ts - Use @fastify/pino
  3. backend/package.json - Add pino, @fastify/pino; remove winston

Implementation:

// logger.ts - Pino wrapper maintaining Winston API
import pino from 'pino';

const pinoLogger = pino({
  level: process.env.LOG_LEVEL?.toLowerCase() || 'info',
  formatters: { level: (label) => ({ level: label }) },
});

// Wrapper maintains logger.info(msg, meta) API
export const logger = {
  info: (msg: string, meta?: object) => pinoLogger.info(meta || {}, msg),
  warn: (msg: string, meta?: object) => pinoLogger.warn(meta || {}, msg),
  error: (msg: string, meta?: object) => pinoLogger.error(meta || {}, msg),
  debug: (msg: string, meta?: object) => pinoLogger.debug(meta || {}, msg),
  child: (bindings: object) => {
    const childPino = pinoLogger.child(bindings);
    return {
      info: (msg: string, meta?: object) => childPino.info(meta || {}, msg),
      // ... same pattern
    };
  },
};

Correlation ID middleware:

  • Use @fastify/pino's built-in request logging
  • Extract X-Request-Id from headers or generate UUID
  • Store in AsyncLocalStorage for child logger access

Acceptance:

  • LOG_LEVEL env var controls verbosity
  • All logs include requestId
  • 79 importing files unchanged

Milestone 3: Frontend Logging (Sub-issue #80-D)

Depends on #80-A

#80-D: Frontend Logger Module

Create frontend/src/utils/logger.ts:

const LOG_LEVEL = import.meta.env.VITE_LOG_LEVEL || 'info';
const LEVELS = { debug: 0, info: 1, warn: 2, error: 3 };

const shouldLog = (level: keyof typeof LEVELS) => 
  LEVELS[level] >= LEVELS[LOG_LEVEL as keyof typeof LEVELS];

export const logger = {
  debug: (msg: string, meta?: object) => 
    shouldLog('debug') && console.debug(`[DEBUG] ${msg}`, meta),
  info: (msg: string, meta?: object) => 
    shouldLog('info') && console.log(`[INFO] ${msg}`, meta),
  warn: (msg: string, meta?: object) => 
    shouldLog('warn') && console.warn(`[WARN] ${msg}`, meta),
  error: (msg: string, meta?: object) => 
    shouldLog('error') && console.error(`[ERROR] ${msg}`, meta),
};

Modify frontend/vite.config.ts:

  • Add VITE_LOG_LEVEL to define() if not present
  • Keep drop_console: false (intentional per current config)

Update API client to include requestId in logs for correlation.

Acceptance:

  • VITE_LOG_LEVEL controls frontend verbosity
  • API calls logged with requestId
  • Sensitive data sanitized

Milestone 4: Log Aggregation Stack (Sub-issue #80-F)

Depends on #80-E

#80-F: Promtail + Loki + Grafana

Add to docker-compose.yml:

  • mvp-promtail: Scrapes Docker logs, forwards to Loki
  • mvp-loki: Log storage with 30-day retention
  • mvp-grafana: Visualization with Loki datasource

Create configs:

  • config/promtail/config.yml - Docker log scraping
  • config/loki/config.yml - Storage, retention, index

Container count: 6 → 9

Acceptance:

  • All 6 service logs visible in Grafana
  • Query by requestId, container, level
  • 30-day retention working

Milestone 5: CI/CD + Documentation (Sub-issue #80-G)

Depends on all above

#80-G: CI/CD Integration

Modify workflows:

  • .gitea/workflows/staging.yaml: Run generate-log-config.sh DEBUG
  • .gitea/workflows/production.yaml: Run generate-log-config.sh INFO
  • Source .env.logging before docker-compose up

Update documentation:

  • Replace docs/UX-DEBUGGING.md with new logging system docs
  • Update README.md container count (6 → 9)
  • Document Grafana access and LogQL queries

Acceptance:

  • Staging deploys with DEBUG
  • Production deploys with INFO
  • Documentation accurate and complete

Quality Gates

Gate Criteria
Plan-Completeness All sub-issues defined, dependencies clear
Plan-Code RULE 0/1/2 compliance assessed
Plan-Docs Documentation updates specified
Post-Implementation Per-milestone QR review
Final Review Quality Agent validates all rules

Test Plan

Unit Tests:

  • Config generator produces correct mappings for each LOG_LEVEL
  • Logger wrapper maintains API compatibility
  • Frontend logger respects VITE_LOG_LEVEL

Integration Tests:

  • Request with X-Request-Id flows through Traefik → Backend → logs
  • Logs appear in Loki with correct labels
  • Log rotation creates new files at 10MB

Manual Tests:

  • Set LOG_LEVEL=DEBUG, verify all containers log at debug
  • Set LOG_LEVEL=ERROR, verify only errors logged
  • Query Grafana by requestId across containers

Verdict: AWAITING_REVIEW | Next: QR plan-completeness review

## Plan: Unified Debug Logging System **Phase**: Planning | **Agent**: Orchestrator | **Status**: IN_PROGRESS --- ### Codebase Analysis Summary **Current State Findings:** | Component | Status | Details | |-----------|--------|---------| | Backend Logger | Winston (not Pino) | 79 files import `logger.ts`, hardcoded `level: 'info'` | | Request IDs | Missing | No correlation ID propagation anywhere | | Traefik | Partial | JSON access logs enabled, no X-Request-Id | | Frontend | Console only | 242 `console.log` calls, no centralized logger | | Docker Logging | Default | No log rotation, no aggregation | | Container Count | 6 (not 5) | Traefik, Frontend, Backend, OCR, PostgreSQL, Redis | **Key Gap**: Issue assumes Pino, but backend uses Winston (79 files). --- ### Architectural Decision: Winston vs Pino **Decision-Critic Verdict: REVISE - Migrate to Pino** | Factor | Winston (Current) | Pino (Recommended) | |--------|-------------------|-------------------| | Performance | ~5K logs/sec | ~30K logs/sec (6x faster) | | Fastify Integration | Manual | Native (@fastify/pino) | | Correlation IDs | Must build manually | Built-in request logging | | Migration Cost | Zero | Low (wrapper pattern) | | Maintenance | Higher (custom integration) | Lower (ecosystem maintained) | **Decision**: Migrate to Pino using a wrapper pattern in `logger.ts` that maintains API compatibility. This allows: - Zero changes to 79 importing files - Built-in correlation IDs via @fastify/pino - Long-term maintainability --- ### Sub-Issue Breakdown This feature is too large for a single AI context. Breaking into 7 smaller issues: | Sub-Issue | Title | Scope | Dependencies | |-----------|-------|-------|--------------| | #80-A | Config Generator Script | `scripts/ci/generate-log-config.sh` | None | | #80-B | Backend: Pino Migration + Correlation IDs | `backend/src/core/logging/`, plugins | #80-A | | #80-C | Traefik: X-Request-Id Middleware | `config/traefik/` | None | | #80-D | Frontend Logger Module | `frontend/src/utils/logger.ts` | #80-A | | #80-E | Docker Logging + Rotation | `docker-compose.yml` logging blocks | None | | #80-F | Promtail + Loki + Grafana Stack | New containers, configs | #80-E | | #80-G | CI/CD Integration + Documentation | Workflows, docs | All above | --- ### Implementation Plan #### Milestone 1: Foundation (Sub-issues #80-A, #80-C, #80-E) **Parallel execution possible** **#80-A: Config Generator Script** - Create `scripts/ci/generate-log-config.sh` - Accept LOG_LEVEL (DEBUG, INFO, WARN, ERROR) - Generate `.env.logging` with per-container mappings - Acceptance: Script runs, validates input, outputs correct mappings **#80-C: Traefik X-Request-Id** - Add `x-request-id` middleware to `config/traefik/dynamic/middleware.yml` - Configure header generation if missing, forwarding if present - Add to api-chain, platform-chain middleware stacks - Acceptance: Requests have X-Request-Id header in access logs **#80-E: Docker Logging Configuration** - Add `logging:` block to all 6 services in docker-compose.yml - Configure json-file driver with 10m max-size, 3 max-file - Acceptance: Log rotation working, no unbounded growth --- #### Milestone 2: Backend Logging (Sub-issue #80-B) **Depends on #80-A** **#80-B: Pino Migration + Correlation IDs** Files to modify: 1. `backend/src/core/logging/logger.ts` - Replace Winston with Pino wrapper 2. `backend/src/core/plugins/logging.plugin.ts` - Use @fastify/pino 3. `backend/package.json` - Add pino, @fastify/pino; remove winston Implementation: ```typescript // logger.ts - Pino wrapper maintaining Winston API import pino from 'pino'; const pinoLogger = pino({ level: process.env.LOG_LEVEL?.toLowerCase() || 'info', formatters: { level: (label) => ({ level: label }) }, }); // Wrapper maintains logger.info(msg, meta) API export const logger = { info: (msg: string, meta?: object) => pinoLogger.info(meta || {}, msg), warn: (msg: string, meta?: object) => pinoLogger.warn(meta || {}, msg), error: (msg: string, meta?: object) => pinoLogger.error(meta || {}, msg), debug: (msg: string, meta?: object) => pinoLogger.debug(meta || {}, msg), child: (bindings: object) => { const childPino = pinoLogger.child(bindings); return { info: (msg: string, meta?: object) => childPino.info(meta || {}, msg), // ... same pattern }; }, }; ``` Correlation ID middleware: - Use @fastify/pino's built-in request logging - Extract X-Request-Id from headers or generate UUID - Store in AsyncLocalStorage for child logger access Acceptance: - LOG_LEVEL env var controls verbosity - All logs include requestId - 79 importing files unchanged --- #### Milestone 3: Frontend Logging (Sub-issue #80-D) **Depends on #80-A** **#80-D: Frontend Logger Module** Create `frontend/src/utils/logger.ts`: ```typescript const LOG_LEVEL = import.meta.env.VITE_LOG_LEVEL || 'info'; const LEVELS = { debug: 0, info: 1, warn: 2, error: 3 }; const shouldLog = (level: keyof typeof LEVELS) => LEVELS[level] >= LEVELS[LOG_LEVEL as keyof typeof LEVELS]; export const logger = { debug: (msg: string, meta?: object) => shouldLog('debug') && console.debug(`[DEBUG] ${msg}`, meta), info: (msg: string, meta?: object) => shouldLog('info') && console.log(`[INFO] ${msg}`, meta), warn: (msg: string, meta?: object) => shouldLog('warn') && console.warn(`[WARN] ${msg}`, meta), error: (msg: string, meta?: object) => shouldLog('error') && console.error(`[ERROR] ${msg}`, meta), }; ``` Modify `frontend/vite.config.ts`: - Add VITE_LOG_LEVEL to define() if not present - Keep drop_console: false (intentional per current config) Update API client to include requestId in logs for correlation. Acceptance: - VITE_LOG_LEVEL controls frontend verbosity - API calls logged with requestId - Sensitive data sanitized --- #### Milestone 4: Log Aggregation Stack (Sub-issue #80-F) **Depends on #80-E** **#80-F: Promtail + Loki + Grafana** Add to docker-compose.yml: - `mvp-promtail`: Scrapes Docker logs, forwards to Loki - `mvp-loki`: Log storage with 30-day retention - `mvp-grafana`: Visualization with Loki datasource Create configs: - `config/promtail/config.yml` - Docker log scraping - `config/loki/config.yml` - Storage, retention, index Container count: 6 → 9 Acceptance: - All 6 service logs visible in Grafana - Query by requestId, container, level - 30-day retention working --- #### Milestone 5: CI/CD + Documentation (Sub-issue #80-G) **Depends on all above** **#80-G: CI/CD Integration** Modify workflows: - `.gitea/workflows/staging.yaml`: Run `generate-log-config.sh DEBUG` - `.gitea/workflows/production.yaml`: Run `generate-log-config.sh INFO` - Source `.env.logging` before docker-compose up Update documentation: - Replace `docs/UX-DEBUGGING.md` with new logging system docs - Update README.md container count (6 → 9) - Document Grafana access and LogQL queries Acceptance: - Staging deploys with DEBUG - Production deploys with INFO - Documentation accurate and complete --- ### Quality Gates | Gate | Criteria | |------|----------| | Plan-Completeness | All sub-issues defined, dependencies clear | | Plan-Code | RULE 0/1/2 compliance assessed | | Plan-Docs | Documentation updates specified | | Post-Implementation | Per-milestone QR review | | Final Review | Quality Agent validates all rules | --- ### Test Plan **Unit Tests:** - Config generator produces correct mappings for each LOG_LEVEL - Logger wrapper maintains API compatibility - Frontend logger respects VITE_LOG_LEVEL **Integration Tests:** - Request with X-Request-Id flows through Traefik → Backend → logs - Logs appear in Loki with correct labels - Log rotation creates new files at 10MB **Manual Tests:** - Set LOG_LEVEL=DEBUG, verify all containers log at debug - Set LOG_LEVEL=ERROR, verify only errors logged - Query Grafana by requestId across containers --- *Verdict*: AWAITING_REVIEW | *Next*: QR plan-completeness review
egullickson commented 2026-02-03 02:16:26 +00:00
Author
Owner
Copy Link

TW Review: Plan Revisions

Phase: Plan-Review | Agent: Technical Writer | Status: COMPLETE

Following QR plan-completeness review, the following additions are incorporated:

Revision A: Environment Defaults

Environment LOG_LEVEL Purpose
Development (.env.local) DEBUG Full debugging locally
Test (.env.test) ERROR Suppress noise in tests
Staging DEBUG Full debugging in staging
Production INFO Standard production logging

Revision B: Loki Failure Behavior

Failure Resilience:

  • Promtail retries with exponential backoff (10s to 1m)
  • Docker logs buffer locally with 10-minute rotation (3 files = ~30 min retention)
  • If Loki recovery fails, logs older than 30 min are lost
  • Mitigation: Loki container must be kept running; no graceful degradation
  • Acceptable Risk: Single-tenant app; operator can restart Loki during outage

Revision C: Implementation Risks

Risk Severity Impact Mitigation
Winston->Pino migration breaks API HIGH 79 files depend on logger.ts Wrapper maintains logger.info(msg, meta) API; regression testing
Traefik misses X-Request-Id on startup MEDIUM Early requests lack correlation Generate UUID if header missing (acceptable)
Loki unavailability MEDIUM Logs lost after 30-min buffer Keep Loki running; future: persistent queue
Container count increase (6->9) LOW Resource footprint <500MB combined for logging stack
Configuration complexity MEDIUM More env vars Single LOG_LEVEL + generate-log-config.sh automates

Revision D: Container Count Clarification

Current: 6 application containers (Traefik, Frontend, Backend, OCR, PostgreSQL, Redis)
After: 9 total (6 application + 3 logging: Promtail, Loki, Grafana)

Note: Logging containers optional for local development; mandatory for staging/production.

Revision E: PostgreSQL/Redis Assignment

Added to Sub-issue #80-B acceptance criteria:

PostgreSQL Logging:

  • Modify docker-compose.yml postgres environment with POSTGRES_LOG_CONFIG
  • Map LOG_LEVEL to log_statement: DEBUG=all, INFO=ddl, WARN=none, ERROR=none
  • Logs to Docker stdout/stderr

Redis Logging:

  • Modify docker-compose.yml redis environment with REDIS_LOGLEVEL
  • Map LOG_LEVEL: DEBUG=debug, INFO=verbose, WARN=notice, ERROR=warning
  • Logs to Docker stdout/stderr

Verdict: REVISIONS_APPLIED | Next: QR plan-code review

## TW Review: Plan Revisions **Phase**: Plan-Review | **Agent**: Technical Writer | **Status**: COMPLETE Following QR plan-completeness review, the following additions are incorporated: --- ### Revision A: Environment Defaults | Environment | LOG_LEVEL | Purpose | |-------------|-----------|---------| | Development (.env.local) | DEBUG | Full debugging locally | | Test (.env.test) | ERROR | Suppress noise in tests | | Staging | DEBUG | Full debugging in staging | | Production | INFO | Standard production logging | --- ### Revision B: Loki Failure Behavior **Failure Resilience:** - Promtail retries with exponential backoff (10s to 1m) - Docker logs buffer locally with 10-minute rotation (3 files = ~30 min retention) - If Loki recovery fails, logs older than 30 min are lost - **Mitigation**: Loki container must be kept running; no graceful degradation - **Acceptable Risk**: Single-tenant app; operator can restart Loki during outage --- ### Revision C: Implementation Risks | Risk | Severity | Impact | Mitigation | |------|----------|--------|-----------| | Winston->Pino migration breaks API | HIGH | 79 files depend on logger.ts | Wrapper maintains `logger.info(msg, meta)` API; regression testing | | Traefik misses X-Request-Id on startup | MEDIUM | Early requests lack correlation | Generate UUID if header missing (acceptable) | | Loki unavailability | MEDIUM | Logs lost after 30-min buffer | Keep Loki running; future: persistent queue | | Container count increase (6->9) | LOW | Resource footprint | <500MB combined for logging stack | | Configuration complexity | MEDIUM | More env vars | Single LOG_LEVEL + generate-log-config.sh automates | --- ### Revision D: Container Count Clarification **Current**: 6 application containers (Traefik, Frontend, Backend, OCR, PostgreSQL, Redis) **After**: 9 total (6 application + 3 logging: Promtail, Loki, Grafana) Note: Logging containers optional for local development; mandatory for staging/production. --- ### Revision E: PostgreSQL/Redis Assignment Added to **Sub-issue #80-B** acceptance criteria: **PostgreSQL Logging:** - Modify docker-compose.yml postgres environment with POSTGRES_LOG_CONFIG - Map LOG_LEVEL to log_statement: DEBUG=all, INFO=ddl, WARN=none, ERROR=none - Logs to Docker stdout/stderr **Redis Logging:** - Modify docker-compose.yml redis environment with REDIS_LOGLEVEL - Map LOG_LEVEL: DEBUG=debug, INFO=verbose, WARN=notice, ERROR=warning - Logs to Docker stdout/stderr --- *Verdict*: REVISIONS_APPLIED | *Next*: QR plan-code review
egullickson commented 2026-02-03 02:18:12 +00:00
Author
Owner
Copy Link

Plan Review Cycle Complete

Phase: Plan-Review | Agent: Quality Reviewer | Status: COMPLETE

Review Summary

Gate Verdict Key Findings
QR plan-completeness PASS_WITH_CONCERNS Missing dev defaults, Loki failure policy, risks
TW plan-scrub READY_WITH_REVISIONS Added Revisions A-E (see comment #892)
QR plan-code PASS_WITH_CONCERNS Add LOG_LEVEL validation, error handling
QR plan-docs NEEDS_CHANGES Container count clarification needed

Outstanding Items Addressed

QR plan-docs concerns resolved:

  1. Container Count Clarification:

    • Current: 6 containers (Traefik, Frontend, Backend, OCR, PostgreSQL, Redis)
    • After #80: 9 containers (+Promtail, +Loki, +Grafana)
    • README.md currently says "5-container" - this is a pre-existing error (OCR was added later)
    • Documentation update scope: 5→6 (current), then 6→9 (post-implementation)

  2. UX-DEBUGGING.md Scope:

    • Current content: Frontend Vite console config (out of sync)
    • Plan: REPLACE entirely with unified logging system docs
    • New doc covers: LOG_LEVEL per container, correlation IDs, Grafana access
    • Frontend debugging becomes a section within the new doc

  3. Documentation Acceptance Criteria (clarified):

    • LOG_LEVEL values: DEBUG, INFO, WARN, ERROR
    • Supported containers: All 6 application + OCR
    • Correlation ID field: requestId (UUID v4)
    • Grafana access: https://logs.motovaultpro.com or internal :3000

QR plan-code Fixes (incorporated into implementation)

  1. LOG_LEVEL Validation: Add validation with warning on invalid values
  2. Error Handling: Wrap frontend console calls in try-catch
  3. Type Safety: Use TypeScript string literal types for log levels

Final Plan Verdict

APPROVED FOR EXECUTION

All concerns have been addressed or have clear resolution paths during implementation. The plan is complete with:

  • 7 sub-issues with clear scope and dependencies
  • 5 milestones with parallel execution where possible
  • Risk acknowledgment and mitigations
  • Environment defaults specified
  • Acceptance criteria for each sub-issue
  • Documentation scope clarified

Next Steps

  1. Create sub-issues #80-A through #80-G in Gitea
  2. Create branch issue-80-unified-logging
  3. Execute Milestone 1 (Foundation) - parallel execution of #80-A, #80-C, #80-E
  4. Post milestone completion updates to this issue

Verdict: PLAN_APPROVED | Next: Create sub-issues and begin execution

## Plan Review Cycle Complete **Phase**: Plan-Review | **Agent**: Quality Reviewer | **Status**: COMPLETE --- ### Review Summary | Gate | Verdict | Key Findings | |------|---------|--------------| | QR plan-completeness | PASS_WITH_CONCERNS | Missing dev defaults, Loki failure policy, risks | | TW plan-scrub | READY_WITH_REVISIONS | Added Revisions A-E (see comment #892) | | QR plan-code | PASS_WITH_CONCERNS | Add LOG_LEVEL validation, error handling | | QR plan-docs | NEEDS_CHANGES | Container count clarification needed | --- ### Outstanding Items Addressed **QR plan-docs concerns resolved:** 1. **Container Count Clarification**: - Current: 6 containers (Traefik, Frontend, Backend, OCR, PostgreSQL, Redis) - After #80: 9 containers (+Promtail, +Loki, +Grafana) - README.md currently says "5-container" - this is a pre-existing error (OCR was added later) - Documentation update scope: 5→6 (current), then 6→9 (post-implementation) 2. **UX-DEBUGGING.md Scope**: - Current content: Frontend Vite console config (out of sync) - Plan: REPLACE entirely with unified logging system docs - New doc covers: LOG_LEVEL per container, correlation IDs, Grafana access - Frontend debugging becomes a section within the new doc 3. **Documentation Acceptance Criteria** (clarified): - LOG_LEVEL values: DEBUG, INFO, WARN, ERROR - Supported containers: All 6 application + OCR - Correlation ID field: `requestId` (UUID v4) - Grafana access: `https://logs.motovaultpro.com` or internal `:3000` --- ### QR plan-code Fixes (incorporated into implementation) 1. **LOG_LEVEL Validation**: Add validation with warning on invalid values 2. **Error Handling**: Wrap frontend console calls in try-catch 3. **Type Safety**: Use TypeScript string literal types for log levels --- ### Final Plan Verdict **APPROVED FOR EXECUTION** All concerns have been addressed or have clear resolution paths during implementation. The plan is complete with: - 7 sub-issues with clear scope and dependencies - 5 milestones with parallel execution where possible - Risk acknowledgment and mitigations - Environment defaults specified - Acceptance criteria for each sub-issue - Documentation scope clarified --- ### Next Steps 1. Create sub-issues #80-A through #80-G in Gitea 2. Create branch `issue-80-unified-logging` 3. Execute Milestone 1 (Foundation) - parallel execution of #80-A, #80-C, #80-E 4. Post milestone completion updates to this issue *Verdict*: PLAN_APPROVED | *Next*: Create sub-issues and begin execution
egullickson commented 2026-02-03 02:19:57 +00:00
Author
Owner
Copy Link

Planning Complete - Sub-Issues Created

Phase: Planning | Agent: Orchestrator | Status: COMPLETE

Sub-Issue Summary

Issue Title Type Milestone Dependencies
#81 Config Generator Script chore M1: Foundation None
#82 Backend Pino Migration + Correlation IDs feature M2: Backend #81
#83 Traefik X-Request-Id Middleware chore M1: Foundation None
#84 Frontend Logger Module feature M3: Frontend #81
#85 Docker Logging + Rotation chore M1: Foundation None
#86 Promtail + Loki + Grafana Stack feature M4: Aggregation #85
#87 CI/CD Integration + Documentation docs M5: Integration All

Execution Order

Milestone 1 (Parallel):
  #81 Config Generator ──┐
  #83 Traefik X-Request-Id ──┼── Can run in parallel
  #85 Docker Logging ────┘

Milestone 2:
  #82 Backend Pino (depends on #81)

Milestone 3:
  #84 Frontend Logger (depends on #81)

Milestone 4:
  #86 Promtail/Loki/Grafana (depends on #85)

Milestone 5:
  #87 CI/CD + Docs (depends on all)

Key Architectural Decisions

  1. Winston → Pino Migration: Approved via decision-critic. Wrapper pattern maintains API compatibility for 79 importing files.

  2. Container Architecture: 6 → 9 containers (adding Promtail, Loki, Grafana)

  3. Correlation Strategy: X-Request-Id generated by backend if not present from Traefik, propagated via AsyncLocalStorage

Next Steps

  1. Move sub-issues #81, #83, #85 to status/ready for Milestone 1
  2. Create branch issue-80-unified-logging
  3. Begin parallel execution of Milestone 1 sub-issues
  4. Post milestone completion updates to this issue

Verdict: PLANNING_COMPLETE | Next: Execution

## Planning Complete - Sub-Issues Created **Phase**: Planning | **Agent**: Orchestrator | **Status**: COMPLETE --- ### Sub-Issue Summary | Issue | Title | Type | Milestone | Dependencies | |-------|-------|------|-----------|--------------| | #81 | Config Generator Script | chore | M1: Foundation | None | | #82 | Backend Pino Migration + Correlation IDs | feature | M2: Backend | #81 | | #83 | Traefik X-Request-Id Middleware | chore | M1: Foundation | None | | #84 | Frontend Logger Module | feature | M3: Frontend | #81 | | #85 | Docker Logging + Rotation | chore | M1: Foundation | None | | #86 | Promtail + Loki + Grafana Stack | feature | M4: Aggregation | #85 | | #87 | CI/CD Integration + Documentation | docs | M5: Integration | All | --- ### Execution Order ``` Milestone 1 (Parallel): #81 Config Generator ──┐ #83 Traefik X-Request-Id ──┼── Can run in parallel #85 Docker Logging ────┘ Milestone 2: #82 Backend Pino (depends on #81) Milestone 3: #84 Frontend Logger (depends on #81) Milestone 4: #86 Promtail/Loki/Grafana (depends on #85) Milestone 5: #87 CI/CD + Docs (depends on all) ``` --- ### Key Architectural Decisions 1. **Winston → Pino Migration**: Approved via decision-critic. Wrapper pattern maintains API compatibility for 79 importing files. 2. **Container Architecture**: 6 → 9 containers (adding Promtail, Loki, Grafana) 3. **Correlation Strategy**: X-Request-Id generated by backend if not present from Traefik, propagated via AsyncLocalStorage --- ### Next Steps 1. Move sub-issues #81, #83, #85 to `status/ready` for Milestone 1 2. Create branch `issue-80-unified-logging` 3. Begin parallel execution of Milestone 1 sub-issues 4. Post milestone completion updates to this issue --- *Verdict*: PLANNING_COMPLETE | *Next*: Execution
egullickson commented 2026-02-05 03:01:25 +00:00
Author
Owner
Copy Link

Completion Summary

All sub-issues have been implemented and merged to main:

Issue Title PR
#81 Config Generator Script PR #88
#82 Backend Pino Migration + Correlation IDs PR #91
#83 Traefik X-Request-Id Middleware PR #89
#84 Frontend Logger Module PR #92
#85 Docker Logging Configuration PR #90
#86 Promtail + Loki + Grafana Stack PR #93
#87 CI/CD Integration + Documentation PR #94

Delivered Capabilities

  • Single LOG_LEVEL environment variable controls all services
  • Backend migrated from Winston to Pino with API-compatible wrapper
  • Correlation IDs (requestId) flow through Traefik -> Backend -> logs
  • Frontend logger with level filtering and sensitive data sanitization
  • Centralized log aggregation with Promtail + Loki + Grafana
  • Docker log rotation (10MB x 3 files per container)
  • Container architecture expanded: 6 -> 9 containers

Quality Checks

  • Frontend lint: 0 errors
  • Backend lint: 0 errors
  • Frontend type-check: passes
  • Backend type-check: passes

Documentation

  • docs/LOGGING.md - Complete logging system documentation
  • docs/UX-DEBUGGING.md - Deleted (replaced by LOGGING.md)

Verdict: PASS | All acceptance criteria met via sub-issues

## Completion Summary All sub-issues have been implemented and merged to main: | Issue | Title | PR | |-------|-------|-----| | #81 | Config Generator Script | PR #88 | | #82 | Backend Pino Migration + Correlation IDs | PR #91 | | #83 | Traefik X-Request-Id Middleware | PR #89 | | #84 | Frontend Logger Module | PR #92 | | #85 | Docker Logging Configuration | PR #90 | | #86 | Promtail + Loki + Grafana Stack | PR #93 | | #87 | CI/CD Integration + Documentation | PR #94 | ### Delivered Capabilities - Single `LOG_LEVEL` environment variable controls all services - Backend migrated from Winston to Pino with API-compatible wrapper - Correlation IDs (`requestId`) flow through Traefik -> Backend -> logs - Frontend logger with level filtering and sensitive data sanitization - Centralized log aggregation with Promtail + Loki + Grafana - Docker log rotation (10MB x 3 files per container) - Container architecture expanded: 6 -> 9 containers ### Quality Checks - Frontend lint: 0 errors - Backend lint: 0 errors - Frontend type-check: passes - Backend type-check: passes ### Documentation - `docs/LOGGING.md` - Complete logging system documentation - `docs/UX-DEBUGGING.md` - Deleted (replaced by LOGGING.md) *Verdict*: **PASS** | All acceptance criteria met via sub-issues
egullickson added
status
done
 and removed
status
in-progress
 labels 2026-02-05 03:01:29 +00:00
Sign in to join this conversation.
No Branch/Tag Specified
Branches Tags
Labels
Clear labels
status
backlog
status/blocked
status
done
status
in-progress
status
ready
status
review
type
bug
type
chore
type
docs
type
feature
No Label
status
done
type
feature
Milestone
No items
No Milestone
Projects
Clear projects
No project
Assignees
Clear assignees
egullickson
No Assignees
1 Participants
Notifications
Due Date
No due date set.
Dependencies

No dependencies set.

Reference: egullickson/motovaultpro#80
Delete Branch "%!s()"

Deleting a branch is permanent. Although the deleted branch may continue to exist for a short time before it actually gets removed, it CANNOT be undone in most cases. Continue?