AEM Performance Optimization: Enterprise Guide to Speed & Scalability

// Service Worker for Advanced Browser Caching
const CACHE_NAME = 'aem-site-v1';
const ASSETS_TO_CACHE = [
  '/etc/clientlibs/base.min.css',
  '/etc/clientlibs/base.min.js',
  '/content/dam/icons/logo.svg'
];

self.addEventListener('install', (event) => {
  event.waitUntil(
    caches.open(CACHE_NAME)
      .then((cache) => cache.addAll(ASSETS_TO_CACHE))
  );
});

self.addEventListener('fetch', (event) => {
  // Network first for HTML, cache first for assets
  if (event.request.destination === 'document') {
    event.respondWith(
      fetch(event.request)
        .then((response) => {
          // Cache successful HTML responses
          if (response.ok) {
            const responseClone = response.clone();
            caches.open(CACHE_NAME)
              .then((cache) => cache.put(event.request, responseClone));
          }
          return response;
        })
        .catch(() => caches.match(event.request))
    );
  } else {
    // Cache first for assets
    event.respondWith(
      caches.match(event.request)
        .then((response) => response || fetch(event.request))
    );
  }
});

// CDN Configuration for AEM
const cdnConfig = {
  // Cache behavior rules
  cacheBehaviors: [
    {
      pathPattern: '*.html',
      cachePolicyId: 'managed-caching-optimized',
      ttl: 900, // 15 minutes
      compress: true,
      viewerProtocolPolicy: 'redirect-to-https'
    },
    {
      pathPattern: '/etc/clientlibs/*',
      cachePolicyId: 'managed-caching-optimized-for-uncompressed-objects',
      ttl: 31536000, // 1 year
      compress: true,
      forwardedValues: {
        queryString: false,
        cookies: { forward: 'none' }
      }
    },
    {
      pathPattern: '/content/dam/*',
      cachePolicyId: 'managed-caching-optimized',
      ttl: 31536000, // 1 year
      compress: false, // Images already compressed
      forwardedValues: {
        queryString: true, // For dynamic media
        headers: ['Accept', 'CloudFront-Is-Mobile-Viewer']
      }
    }
  ],
  
  // Origin configuration
  origins: [
    {
      id: 'aem-dispatcher',
      domainName: 'dispatcher.enterprise.com',
      customOriginConfig: {
        httpPort: 80,
        httpsPort: 443,
        originProtocolPolicy: 'https-only',
        originSslProtocols: ['TLSv1.2'],
        originReadTimeout: 30,
        originKeepaliveTimeout: 5
      }
    }
  ],
  
  // Geographic restrictions and performance
  restrictions: {
    geoRestriction: {
      restrictionType: 'none'
    }
  },
  
  // Performance optimization
  httpVersion: 'http2',
  isIPV6Enabled: true,
  comment: 'AEM Enterprise CDN Distribution'
};

// Smart Cache Invalidation Service
@Component(service = {ResourceChangeListener.class, CacheInvalidationService.class})
@Property(name = ResourceChangeListener.PATHS, value = {"/content", "/conf"})
@Property(name = ResourceChangeListener.CHANGES, value = {"ADDED", "CHANGED", "REMOVED"})
public class SmartCacheInvalidationService implements ResourceChangeListener {
    
    @Reference
    private DispatcherFlushService dispatcherFlush;
    
    @Reference
    private ReplicationAgent replicationAgent;
    
    private final Map<String, Set<String>> dependencyGraph = new ConcurrentHashMap<>();
    
    @Override
    public void onChange(List<ResourceChange> changes) {
        Set<String> pathsToInvalidate = new HashSet<>();
        
        for (ResourceChange change : changes) {
            String changedPath = change.getPath();
            
            // Direct invalidation
            pathsToInvalidate.add(changedPath);
            
            // Find dependent resources
            Set<String> dependents = findDependentPaths(changedPath);
            pathsToInvalidate.addAll(dependents);
            
            // Special handling for different resource types
            if (changedPath.startsWith("/conf")) {
                // Configuration changes affect entire site
                invalidateConfigurationCache(changedPath);
            } else if (changedPath.contains("/dam/")) {
                // Asset changes
                invalidateAssetCache(changedPath);
            } else if (changedPath.startsWith("/content")) {
                // Content changes
                invalidateContentCache(changedPath);
            }
        }
        
        // Batch invalidation for efficiency
        if (!pathsToInvalidate.isEmpty()) {
            batchInvalidate(pathsToInvalidate);
        }
    }
    
    private void batchInvalidate(Set<String> paths) {
        log.info("Batch invalidating {} cache entries", paths.size());
        
        // Group by cache type for efficient processing
        Map<String, List<String>> groupedPaths = paths.stream()
            .collect(Collectors.groupingBy(this::getCacheType));
        
        // Trigger dispatcher flush
        try {
            FlushRequest flushRequest = FlushRequest.builder()
                .paths(paths)
                .type(FlushType.INVALIDATE)
                .build();
                
            replicationAgent.replicate(flushRequest);
            log.info("Triggered dispatcher flush for {} paths", paths.size());
        } catch (Exception e) {
            log.error("Failed to trigger dispatcher flush", e);
        }
    }
}

// Enterprise Application Cache Manager
@Component(service = CacheManager.class)
@Designate(ocd = CacheManager.Config.class)
public class EnterpriseCacheManager implements CacheManager {
    
    @ObjectClassDefinition(name = "Enterprise Cache Manager")
    public @interface Config {
        @AttributeDefinition(name = "L1 Cache Size")
        int l1CacheSize() default 1000;
        
        @AttributeDefinition(name = "L2 Cache Size") 
        int l2CacheSize() default 10000;
        
        @AttributeDefinition(name = "Default TTL (seconds)")
        int defaultTtl() default 3600;
    }
    
    // L1 Cache: In-memory for ultra-fast access
    private Cache<String, Object> l1Cache;
    
    // L2 Cache: Distributed cache for scalability
    @Reference
    private DistributedCacheService distributedCache;
    
    @Activate
    protected void activate(Config config) {
        this.l1Cache = CacheBuilder.newBuilder()
            .maximumSize(config.l1CacheSize())
            .expireAfterWrite(Duration.ofSeconds(config.defaultTtl()))
            .recordStats()
            .removalListener(this::onL1Eviction)
            .build();
    }
    
    @Override
    public <T> Optional<T> get(String key, Class<T> type) {
        // Check L1 cache first
        Object cached = l1Cache.getIfPresent(key);
        if (cached != null) {
            return Optional.of(type.cast(cached));
        }
        
        // Check L2 cache
        Optional<T> l2Result = distributedCache.get(key, type);
        if (l2Result.isPresent()) {
            // Promote to L1 cache
            l1Cache.put(key, l2Result.get());
            return l2Result;
        }
        
        return Optional.empty();
    }
    
    // Component-specific caching
    public void cacheComponent(String componentPath, String html, Duration ttl) {
        String key = "component:" + componentPath;
        put(key, html, ttl);
    }
    
    // Page-level caching
    public void cachePage(String pagePath, PageData pageData, Duration ttl) {
        String key = "page:" + pagePath;
        put(key, pageData, ttl);
    }
    
    // Cache warming for critical content
    @Scheduled(fixedDelay = 300000) // 5 minutes
    public void warmCriticalContent() {
        List<String> criticalPaths = getCriticalContentPaths();
        
        criticalPaths.parallelStream().forEach(path -> {
            try {
                if (!getCachedPage(path).isPresent()) {
                    PageData pageData = contentService.loadPage(path);
                    if (pageData != null) {
                        cachePage(path, pageData, Duration.ofHours(1));
                    }
                }
            } catch (Exception e) {
                log.warn("Failed to warm cache for path: {}", path, e);
            }
        });
    }
}

// Custom Oak Index Definition for Performance
{
  "jcr:primaryType": "oak:QueryIndexDefinition",
  "type": "lucene",
  "compatVersion": 2,
  "async": "async",
  "includedPaths": ["/content/enterprise"],
  "excludedPaths": ["/content/enterprise/archive"],
  "indexRules": {
    "jcr:primaryType": "nt:unstructured",
    "cq:Page": {
      "jcr:primaryType": "nt:unstructured",
      "properties": {
        "jcr:primaryType": "nt:unstructured",
        "jcr:title": {
          "jcr:primaryType": "nt:unstructured",
          "name": "jcr:title",
          "propertyIndex": true,
          "analyzed": true
        },
        "cq:template": {
          "jcr:primaryType": "nt:unstructured",
          "name": "cq:template",
          "propertyIndex": true,
          "analyzed": false
        },
        "lastModified": {
          "jcr:primaryType": "nt:unstructured",
          "name": "jcr:content/cq:lastModified",
          "propertyIndex": true,
          "ordered": true
        }
      }
    }
  }
}

// Query Performance Monitoring Service
@Component(service = QueryPerformanceMonitor.class)
public class QueryPerformanceMonitor {
    
    private static final Logger LOG = LoggerFactory.getLogger(QueryPerformanceMonitor.class);
    private static final int SLOW_QUERY_THRESHOLD = 1000; // 1 second
    
    @Reference
    private QueryEngine queryEngine;
    
    @Reference
    private MetricsService metricsService;
    
    public Result executeMonitoredQuery(String query, String language) {
        long startTime = System.currentTimeMillis();
        
        try {
            Result result = queryEngine.executeQuery(query, language, Long.MAX_VALUE, 0, Collections.emptyMap(), Collections.emptyMap());
            
            long duration = System.currentTimeMillis() - startTime;
            
            // Record metrics
            metricsService.recordTimer("aem.query.duration", duration, 
                Tag.of("language", language),
                Tag.of("slow", String.valueOf(duration > SLOW_QUERY_THRESHOLD)));
            
            // Log slow queries
            if (duration > SLOW_QUERY_THRESHOLD) {
                LOG.warn("Slow query detected: {} ms - {}", duration, query);
                
                // Analyze query plan
                String plan = getQueryPlan(query, language);
                LOG.debug("Query plan: {}", plan);
            }
            
            return result;
            
        } catch (Exception e) {
            metricsService.recordCounter("aem.query.errors", 
                Tag.of("language", language));
            throw new QueryExecutionException("Query failed: " + query, e);
        }
    }
    
    private String getQueryPlan(String query, String language) {
        try {
            // Get explain plan from Oak
            return queryEngine.getQueryPlan(query, language);
        } catch (Exception e) {
            LOG.warn("Failed to get query plan", e);
            return "Unknown";
        }
    }
}

// Optimized Content Structure Guidelines
public class ContentStructureOptimizer {
    
    // Optimal node hierarchy depth
    private static final int MAX_HIERARCHY_DEPTH = 6;
    
    // Recommended children per node
    private static final int OPTIMAL_CHILDREN_COUNT = 100;
    private static final int MAX_CHILDREN_COUNT = 1000;
    
    public void validateContentStructure(Resource resource) {
        // Check hierarchy depth
        int depth = getHierarchyDepth(resource);
        if (depth > MAX_HIERARCHY_DEPTH) {
            LOG.warn("Deep hierarchy detected: {} levels at {}", depth, resource.getPath());
        }
        
        // Check children count
        Iterator<Resource> children = resource.listChildren();
        int childrenCount = 0;
        while (children.hasNext()) {
            children.next();
            childrenCount++;
        }
        
        if (childrenCount > MAX_CHILDREN_COUNT) {
            LOG.warn("Too many children: {} at {}", childrenCount, resource.getPath());
            suggestOptimization(resource, childrenCount);
        }
    }
    
    private void suggestOptimization(Resource resource, int childrenCount) {
        // Suggest bucketing strategy
        if (childrenCount > MAX_CHILDREN_COUNT) {
            LOG.info("Consider implementing date-based or alphabetical bucketing for: {}", 
                    resource.getPath());
        }
        
        // Suggest pagination
        if (isListComponent(resource)) {
            LOG.info("Consider implementing pagination for list component: {}", 
                    resource.getPath());
        }
    }
    
    private boolean isListComponent(Resource resource) {
        ValueMap properties = resource.getValueMap();
        String resourceType = properties.get("sling:resourceType", String.class);
        return resourceType != null && resourceType.contains("list");
    }
}

// Performance Baseline Measurement
const performanceBaseline = {
  pageLoadTime: measurePageLoadTime(),
  serverResponseTime: measureServerResponse(), 
  cacheHitRatio: measureCacheEfficiency(),
  userExperienceScore: measureCoreWebVitals(),
  businessMetrics: measureConversionImpact()
};

// Core Optimization Checklist
const coreOptimizations = [
  'dispatcher_cache_rules_optimization',
  'cdn_integration_and_configuration',
  'asset_delivery_pipeline_setup',
  'database_query_optimization',
  'component_level_caching_implementation'
];

// Advanced Performance Monitoring
const monitoringSetup = {
  realTimeMetrics: setupRealTimeMonitoring(),
  alertingSystem: configurePerformanceAlerts(),
  automatedTesting: implementPerformanceTests(),
  optimizationLoop: setupContinuousImprovement()
};

// Continuous Improvement Process  
const improvementProcess = {
  monthlyReviews: schedulePerformanceAudits(),
  quarterlyPlanning: planOptimizationRoadmap(), 
  technologyIntegration: evaluateNewTechniques(),
  teamTraining: maintainExpertiseLevel()
};