pp/05_GracefulDegradation.gs at main · te-df/pp

710 lines (602 loc) · 20 KB
 * @file 05_GracefulDegradation.gs
 * @description Sistema de Degradação Graciosa para resiliência do sistema
 * @version 1.0.0
 * @author Sistema TE-DF-PP
 * @since 2025-12-14
 * FUNCIONALIDADES:
 * - Fallback automático para operações críticas
 * - Modo offline com sincronização posterior
 * - Cache de emergência para dados críticos
 * - Recuperação automática de serviços
 * - Priorização de operações em modo degradado
// ============================================================================
// CONFIGURAÇÃO DE DEGRADAÇÃO
// ============================================================================
const DEGRADATION_CONFIG = Object.freeze({
  // Níveis de degradação
  LEVELS: {
    NORMAL: 'NORMAL',           // Sistema operando normalmente
    DEGRADED: 'DEGRADED',       // Funcionalidades reduzidas
    EMERGENCY: 'EMERGENCY',     // Apenas operações críticas
    OFFLINE: 'OFFLINE'          // Modo offline
  // Prioridades de operação
  PRIORITIES: {
    CRITICAL: 1,    // Autenticação, dados de sessão
    HIGH: 2,        // CRUD principal
    MEDIUM: 3,      // Relatórios, exportações
    LOW: 4          // Logs, telemetria
  // Timeouts por nível
  TIMEOUTS: {
    NORMAL: 30000,      // 30s
    DEGRADED: 15000,    // 15s
    EMERGENCY: 5000,    // 5s
    OFFLINE: 1000       // 1s (apenas cache)
  // Cache de emergência
  EMERGENCY_CACHE_TTL: 3600,  // 1 hora
  // Retry em modo degradado
  DEGRADED_MAX_RETRIES: 1,
  // Operações permitidas por nível
  ALLOWED_OPERATIONS: {
    NORMAL: ['*'],
    DEGRADED: ['auth', 'read', 'create', 'update'],
    EMERGENCY: ['auth', 'read'],
    OFFLINE: ['read_cache']
// ============================================================================
// GRACEFUL DEGRADATION SERVICE
// ============================================================================
const GracefulDegradation = (function() {
  'use strict';
  // Estado atual do sistema
  let currentLevel = DEGRADATION_CONFIG.LEVELS.NORMAL;
  let lastHealthCheck = null;
  let failureCount = 0;
  let recoveryAttempts = 0;
  // Cache de emergência
  const emergencyCache = CacheService.getScriptCache();
  // Métricas
  const metrics = {
    degradations: 0,
    recoveries: 0,
    fallbacksUsed: 0,
    operationsBlocked: 0
  // ============================================================================
  // CORE FUNCTIONS
  // ============================================================================
   * Obtém nível atual de degradação
   * @return {string} Nível atual
  function getCurrentLevel() {
    return currentLevel;
   * Define nível de degradação
   * @param {string} level - Novo nível
   * @param {string} reason - Motivo da mudança
  function setLevel(level, reason) {
    const oldLevel = currentLevel;
    currentLevel = level;
    if (oldLevel !== level) {
      _logLevelChange(oldLevel, level, reason);
      if (_isMoreDegraded(level, oldLevel)) {
        metrics.degradations++;
      } else {
        metrics.recoveries++;
   * Executa operação com degradação graciosa
   * @param {Object} options - Opções da operação
   * @param {Function} options.operation - Operação principal
   * @param {Function} options.fallback - Operação de fallback
   * @param {string} options.type - Tipo da operação (auth, read, write, etc)
   * @param {number} options.priority - Prioridade (1-4)
   * @param {string} options.cacheKey - Chave para cache de emergência

10BC0
   * @return {Object} Resultado da operação
  function execute(options) {
    const { operation, fallback, type, priority, cacheKey } = options;
    // Verifica se operação é permitida no nível atual
    if (!_isOperationAllowed(type)) {
      metrics.operationsBlocked++;
      return _createBlockedResponse(type);
    // Obtém timeout baseado no nível
    const timeout = _getTimeout();
      // Tenta operação principal
      const result = _executeWithTimeout(operation, timeout);
      // Sucesso - atualiza cache de emergência se aplicável
      if (cacheKey && result.success) {
        _updateEmergencyCache(cacheKey, result.data);
      // Considera recuperação se estava degradado
      _considerRecovery();
      return result;
    } catch (error) {
      // Falha - incrementa contador
      failureCount++;
      // Avalia se deve degradar
      _evaluateDegradation(error);
      // Tenta fallback
      if (fallback && typeof fallback === 'function') {
        try {
          metrics.fallbacksUsed++;
          const fallbackResult = fallback(error);
          return {
            success: true,
            data: fallbackResult,
            source: 'fallback',
            originalError: error.message
        } catch (fallbackError) {
          // Fallback também falhou
      // Tenta cache de emergência
      if (cacheKey) {
        const cached = _getFromEmergencyCache(cacheKey);
        if (cached) {
          return {
            success: true,
            data: cached,
            source: 'emergency_cache',
            stale: true,
            originalError: error.message
      // Nenhuma alternativa disponível
      return {
        success: false,
        error: error.message,
        level: currentLevel
   * Wrapper para operações de leitura com fallback automático
   * @param {Function} readOperation - Operação de leitura
   * @param {string} cacheKey - Chave do cache
   * @param {*} defaultValue - Valor padrão se tudo falhar
   * @return {*} Dados lidos ou fallback
  function safeRead(readOperation, cacheKey, defaultValue) {
    return execute({
      operation: readOperation,
      fallback: () => defaultValue,
      type: 'read',
      priority: DEGRADATION_CONFIG.PRIORITIES.HIGH,
      cacheKey: cacheKey
   * Wrapper para operações de escrita com queue offline
   * @param {Function} writeOperation - Operação de escrita
   * @param {Object} data - Dados a serem escritos
   * @param {string} entityType - Tipo da entidade
   * @return {Object} Resultado
  function safeWrite(writeOperation, data, entityType) {
    if (currentLevel === DEGRADATION_CONFIG.LEVELS.OFFLINE) {
      // Em modo offline, adiciona à fila
      _queueOfflineOperation('write', entityType, data);
      return {
        success: true,
        queued: true,
        message: 'Operação adicionada à fila offline'
    return execute({
      operation: writeOperation,
      fallback: () => {
        _queueOfflineOperation('write', entityType, data);
        return { queued: true };
      type: 'write',
      priority: DEGRADATION_CONFIG.PRIORITIES.HIGH
  // ============================================================================
  // HEALTH MONITORING
  // ============================================================================
   * Executa verificação de saúde e ajusta nível
   * @return {Object} Status de saúde
  function checkHealth() {
      const checks = {
        spreadsheet: _checkSpreadsheetHealth(),
        cache: _checkCacheHealth(),
        properties: _checkPropertiesHealth()
      lastHealthCheck = {
        timestamp: new Date().toISOString(),
        checks: checks
      // Determina nível baseado nos checks
      const failedChecks = Object.values(checks).filter(c => !c.healthy).length;
      if (failedChecks === 0) {
        setLevel(DEGRADATION_CONFIG.LEVELS.NORMAL, 'All health checks passed');
      } else if (failedChecks === 1) {
        setLevel(DEGRADATION_CONFIG.LEVELS.DEGRADED, 'One service degraded');
      } else if (failedChecks === 2) {
        setLevel(DEGRADATION_CONFIG.LEVELS.EMERGENCY, 'Multiple services failing');
      } else {
        setLevel(DEGRADATION_CONFIG.LEVELS.OFFLINE, 'Critical failure');
      return {
        level: currentLevel,
        checks: checks,
        timestamp: lastHealthCheck.timestamp
    } catch (error) {
      setLevel(DEGRADATION_CONFIG.LEVELS.EMERGENCY, 'Health check failed: ' + error.message);
      return {
        level: currentLevel,
        error: error.message
   * Tenta recuperação do sistema
   * @return {boolean} Se recuperou
  function attemptRecovery() {
    if (currentLevel === DEGRADATION_CONFIG.LEVELS.NORMAL) {
      return true;
    recoveryAttempts++;
    const health = checkHealth();
    if (health.level === DEGRADATION_CONFIG.LEVELS.NORMAL) {
      // Processa fila offline se houver
      _processOfflineQueue();
      return true;
    return false;
  // ============================================================================
  // OFFLINE QUEUE
  // ============================================================================
   * Processa fila de operações offline
   * @return {Object} Resultado do processamento
  function processOfflineQueue() {
    return _processOfflineQueue();
   * Obtém tamanho da fila offline
   * @return {number} Número de operações pendentes
  function getOfflineQueueSize() {
      const queueStr = emergencyCache.get('offline_queue');
      if (!queueStr) return 0;
      const queue = JSON.parse(queueStr);
      return Array.isArray(queue) ? queue.length : 0;
    } catch (e) {
      return 0;
  // ============================================================================
  // METRICS
  // ============================================================================
   * Obtém métricas do sistema de degradação
   * @return {Object} Métricas
  function getMetrics() {
    return {
      currentLevel: currentLevel,
      failureCount: failureCount,
      recoveryAttempts: recoveryAttempts,
      offlineQueueSize: getOfflineQueueSize(),
      lastHealthCheck: lastHealthCheck,
      stats: { ...metrics }
   * Reseta métricas
  function resetMetrics() {
    failureCount = 0;
    recoveryAttempts = 0;
    metrics.degradations = 0;
    metrics.recoveries = 0;
    metrics.fallbacksUsed = 0;
    metrics.operationsBlocked = 0;
  // ============================================================================
  // PRIVATE HELPERS
  // ============================================================================
  function _isOperationAllowed(type) {
    const allowed = DEGRADATION_CONFIG.ALLOWED_OPERATIONS[currentLevel];
    return allowed.includes('*') || allowed.includes(type);
  function _getTimeout() {
    return DEGRADATION_CONFIG.TIMEOUTS[currentLevel] || DEGRADATION_CONFIG.TIMEOUTS.NORMAL;
  function _executeWithTimeout(operation, timeout) {
    // GAS não suporta timeout real, mas podemos usar para logging
    const start = Date.now();
    const result = operation();
    const duration = Date.now() - start;
    if (duration > timeout) {
      Logger.log(`[GracefulDegradation] Operação excedeu timeout: ${duration}ms > ${timeout}ms`);
    return { success: true, data: result, duration: duration };
  function _updateEmergencyCache(key, data) {
      const cacheKey = 'emergency_' + key;
      emergencyCache.put(cacheKey, JSON.stringify({
        data: data,
        timestamp: Date.now()
      }), DEGRADATION_CONFIG.EMERGENCY_CACHE_TTL);
    } catch (e) {
      // Silently fail
  function _getFromEmergencyCache(key) {
      const cacheKey = 'emergency_' + key;
      const cached = emergencyCache.get(cacheKey);
      if (cached) {
        const parsed = JSON.parse(cached);
        return parsed.data;
    } catch (e) {
      // Silently fail
    return null;
  function _queueOfflineOperation(type, entityType, data) {
      const queueStr = emergencyCache.get('offline_queue') || '[]';
      const queue = JSON.parse(queueStr);
      queue.push({
        id: 'op_' + Date.now(),
        type: type,
        entityType: entityType,
        data: data,
        timestamp: Date.now()
      // Limita tamanho da fila
      while (queue.length > 100) {
        queue.shift();
      emergencyCache.put('offline_queue', JSON.stringify(queue), 86400); // 24h
    } catch (e) {
      Logger.log('[GracefulDegradation] Erro ao enfileirar operação: ' + e.message);
  function _processOfflineQueue() {
    const results = { processed: 0, failed: 0, remaining: 0 };
      const queueStr = emergencyCache.get('offline_queue');
      if (!queueStr) return results;
      const queue = JSON.parse(queueStr);
      const remaining = [];
      for (const op of queue) {
        try {
          // Tenta processar operação
          // Aqui você integraria com o DataService real
          Logger.log(`[GracefulDegradation] Processando operação offline: ${op.type} ${op.entityType}`);
          results.processed++;
        } catch (e) {
          remaining.push(op);
          results.failed++;
      results.remaining = remaining.length;
      if (remaining.length > 0) {
        emergencyCache.put('offline_queue', JSON.stringify(remaining), 86400);
      } else {
        emergencyCache.remove('offline_queue');
    } catch (e) {
      Logger.log('[GracefulDegradation] Erro ao processar fila: ' + e.message);
    return results;
  function _evaluateDegradation(error) {
    const errorMsg = error.message || '';
    // Erros que indicam problemas graves
    if (errorMsg.includes('Service invoked too many times') ||
        errorMsg.includes('Rate limit') ||
        errorMsg.includes('Quota exceeded')) {
      setLevel(DEGRADATION_CONFIG.LEVELS.EMERGENCY, 'Quota/Rate limit exceeded');
    } else if (errorMsg.includes('timeout') || errorMsg.includes('Timeout')) {
      if (failureCount >= 3) {
        setLevel(DEGRADATION_CONFIG.LEVELS.DEGRADED, 'Multiple timeouts');
    } else if (failureCount >= 5) {
      setLevel(DEGRADATION_CONFIG.LEVELS.DEGRADED, 'High failure count');
  function _considerRecovery() {
    if (currentLevel !== DEGRADATION_CONFIG.LEVELS.NORMAL && failureCount === 0) {
      // Sucesso após falhas - considera recuperação gradual
      if (currentLevel === DEGRADATION_CONFIG.LEVELS.DEGRADED) {
        setLevel(DEGRADATION_CONFIG.LEVELS.NORMAL, 'Recovered from degraded state');
      } else if (currentLevel === DEGRADATION_CONFIG.LEVELS.EMERGENCY) {
        setLevel(DEGRADATION_CONFIG.LEVELS.DEGRADED, 'Partial recovery');
    // Reset failure count após sucesso
    failureCount = Math.max(0, failureCount - 1);
  function _isMoreDegraded(newLevel, oldLevel) {
    const order = [
      DEGRADATION_CONFIG.LEVELS.NORMAL,
      DEGRADATION_CONFIG.LEVELS.DEGRADED,
      DEGRADATION_CONFIG.LEVELS.EMERGENCY,
      DEGRADATION_CONFIG.LEVELS.OFFLINE
    return order.indexOf(newLevel) > order.indexOf(oldLevel);
  function _logLevelChange(oldLevel, newLevel, reason) {
    Logger.log(`[GracefulDegradation] Level changed: ${oldLevel} → ${newLevel} (${reason})`);
      if (typeof getLogger === 'function') {
        getLogger().warn('Degradation level changed', {
          from: oldLevel,
          to: newLevel,
          reason: reason
        });
    } catch (e) {
      // Silently fail
  function _createBlockedResponse(type) {
    return {
      success: false,
      blocked: true,
      message: `Operação '${type}' não permitida no nível ${currentLevel}`,
      level: currentLevel
  function _checkSpreadsheetHealth() {
      // Usa timeout para evitar travamento
      const startTime = Date.now();
      const timeout = 5000; // 5 segundos
      const ss = SpreadsheetApp.getActiveSpreadsheet();
      if (!ss) return { healthy: false, error: 'No spreadsheet' };
      // Verifica se não excedeu timeout
      if (Date.now() - startTime > timeout) {
        return { healthy: false, error: 'Timeout' };
      ss.getSheets(); // Testa acesso
      return { healthy: true };
    } catch (e) {
      return { healthy: false, error: e.message };
  function _checkCacheHealth() {
      const cache = CacheService.getScriptCache();
      const testKey = 'health_' + Date.now();
      // Timeout implícito de 5s
      cache.put(testKey, 'test', 10);
      const result = cache.get(testKey) === 'test';
      cache.remove(testKey);
      return { healthy: result };
    } catch (e) {
      return { healthy: false, error: e.message };
  function _checkPropertiesHealth() {
      const props = PropertiesService.getScriptProperties();
      // Testa leitura sem modificar dados reais
      const testKey = '_health_check_' + Date.now();
      props.setProperty(testKey, 'test');
      const result = props.getProperty(testKey) === 'test';
      props.deleteProperty(testKey);
      return { healthy: result };
    } catch (e) {
      return { healthy: false, error: e.message };
  // ============================================================================
  // PUBLIC API
  // ============================================================================
    // Core
    getCurrentLevel: getCurrentLevel,
    setLevel: setLevel,
    execute: execute,
    // Wrappers
    safeRead: safeRead,
    safeWrite: safeWrite,
    // Health
    checkHealth: checkHealth,
    attemptRecovery: attemptRecovery,
    // Offline Queue
    processOfflineQueue: processOfflineQueue,
    getOfflineQueueSize: getOfflineQueueSize,
    // Metrics
    getMetrics: getMetrics,
    resetMetrics: resetMetrics,
    // Config
    LEVELS: DEGRADATION_CONFIG.LEVELS,
    PRIORITIES: DEGRADATION_CONFIG.PRIORITIES
// ============================================================================
// FUNÇÕES GLOBAIS DE CONVENIÊNCIA
// ============================================================================
 * Obtém nível atual de degradação
 * @return {string}
function getDegradationLevel() {
  return GracefulDegradation.getCurrentLevel();
 * Verifica se sistema está em modo degradado
 * @return {boolean}
function isSystemDegraded() {
  return GracefulDegradation.getCurrentLevel() !== DEGRADATION_CONFIG.LEVELS.NORMAL;
 * Executa health check e ajusta nível
 * @return {Object}
function checkSystemDegradation() {
  return GracefulDegradation.checkHealth();
// ============================================================================
// ============================================================================
<
506C
/div>
 * Testa o sistema de degradação graciosa
function testGracefulDegradation() {
  Logger.log('🛡️ Testando Graceful Degradation...\n');
  // Teste 1: Nível inicial
  Logger.log('Teste 1: Nível inicial');
  Logger.log('  Nível: ' + GracefulDegradation.getCurrentLevel());
  // Teste 2: Operação bem-sucedida
  Logger.log('\nTeste 2: Operação bem-sucedida');
  const result1 = GracefulDegradation.execute({
    operation: () => ({ data: 'test' }),
    type: 'read',
    priority: 2
  Logger.log('  Resultado: ' + JSON.stringify(result1));
  // Teste 3: Operação com fallback
  Logger.log('\nTeste 3: Operação com fallback');
  const result2 = GracefulDegradation.execute({
    operation: () => { throw new Error('Simulated failure'); },
    fallback: () => ({ fallback: true }),
    type: 'read',
    priority: 2
  Logger.log('  Resultado: ' + JSON.stringify(result2));
  // Teste 4: Health check
  Logger.log('\nTeste 4: Health check');
  const health = GracefulDegradation.checkHealth();
  Logger.log('  Health: ' + JSON.stringify(health, null, 2));
  // Teste 5: Métricas
  Logger.log('\nTeste 5: Métricas');
  const metrics = GracefulDegradation.getMetrics();
  Logger.log('  Métricas: ' + JSON.stringify(metrics, null, 2));
  Logger.log('\n✅ Testes concluídos!');
FilesExpand file tree

05_GracefulDegradation.gs

Latest commit

History

05_GracefulDegradation.gs

File metadata and controls
