docs: @FFDCIgnore(CacheException.class)
      private void cacheInit() {
          final boolean trace = TraceComponent.isAnyTracingEnabled();
  
          // Attempt lazy initialization if necessary
          try{
              if (cacheStoreService.cacheManager == null)
                  cacheStoreService.activateLazily();
  
              // Build a unique per-application cache name by starting with the application context root and percent encoding
              // the / and : characters (JCache spec does not allow these in cache names)
              // and also the % character (which is necessary because of percent encoding)
              String a = PERCENT.matcher(_iStore.getId()).replaceAll("%25"); // must be done first to avoid replacing % that is added when replacing the others
              a = SLASH.matcher(a).replaceAll(".");
              a = COLON.matcher(a).replaceAll(".");
  
              // Session Meta Information Cache
  
              String metaCacheName = new StringBuilder(24 + a.length()).append("com.ibm.ws.session.meta.").append(a).toString();
  
              if (trace && tc.isDebugEnabled())
                  tcInvoke(cacheStoreService.tcCacheManager, "getCache", metaCacheName, "String", "ArrayList");
  
              sessionMetaCache = cacheStoreService.cacheManager.getCache(metaCacheName, String.class, ArrayList.class);
              boolean create;
              if (create = sessionMetaCache == null) {
                  if (trace && tc.isDebugEnabled())
                      tcReturn(cacheStoreService.tcCacheManager, "getCache", "null");
  
                  @SuppressWarnings("rawtypes")
                  MutableConfiguration<String, ArrayList> config = new MutableConfiguration<String, ArrayList>()
                  .setTypes(String.class, ArrayList.class)
                  .setExpiryPolicyFactory(EternalExpiryPolicy.factoryOf());
                  if (cacheStoreService.supportsStoreByReference)
                      config = config.setStoreByValue(false);
                  try {
                      if (trace && tc.isDebugEnabled())
                          tcInvoke(cacheStoreService.tcCacheManager, "createCache", metaCacheName, config);
  
                      sessionMetaCache = cacheStoreService.cacheManager.createCache(metaCacheName, config);
                  } catch (CacheException x) {
                      create = false;
                      if (trace && tc.isDebugEnabled()) {
                          tcReturn(cacheStoreService.tcCacheManager, "createCache", x);
                          tcInvoke(cacheStoreService.tcCacheManager, "getCache", metaCacheName, "String", "ArrayList");
                      }
                      sessionMetaCache = cacheStoreService.cacheManager.getCache(metaCacheName, String.class, ArrayList.class);
                      if (sessionMetaCache == null)
                          throw x;
                  }
              }
  
              tcSessionMetaCache = "MetaCache" + Integer.toHexString(System.identityHashCode(sessionMetaCache));
              if (trace && tc.isDebugEnabled())
                  tcReturn(cacheStoreService.tcCacheManager, create ? "createCache" : "getCache", tcSessionMetaCache, sessionMetaCache);
  
              cacheStoreService.configureMonitoring(metaCacheName);
  
              // Session Attributes Cache
  
              String attrCacheName = new StringBuilder(24 + a.length()).append("com.ibm.ws.session.attr.").append(a).toString();
  
              if (trace && tc.isDebugEnabled())
                  tcInvoke(cacheStoreService.tcCacheManager, "getCache", attrCacheName, "String", "byte[]");
  
              sessionAttributeCache = cacheStoreService.cacheManager.getCache(attrCacheName, String.class, byte[].class);
  
              if (create = sessionAttributeCache == null) {
                  if (trace && tc.isDebugEnabled())
                      tcReturn(cacheStoreService.tcCacheManager, "getCache", "null");
  
                  MutableConfiguration<String, byte[]> config = new MutableConfiguration<String, byte[]>()
                                  .setTypes(String.class, byte[].class)
                                  .setExpiryPolicyFactory(EternalExpiryPolicy.factoryOf());
                  if (cacheStoreService.supportsStoreByReference)
                      config = config.setStoreByValue(false);
                  try {
                      if (trace && tc.isDebugEnabled())
                          tcInvoke(cacheStoreService.tcCacheManager, "createCache", attrCacheName, config);
  
                      sessionAttributeCache = cacheStoreService.cacheManager.createCache(attrCacheName, config);
                  } catch (CacheException x) {
                      create = false;
                      if (trace && tc.isDebugEnabled()) {
                          tcReturn(cacheStoreService.tcCacheManager, "createCache", x);
                          tcInvoke(cacheStoreService.tcCacheManager, "getCache", attrCacheName, "String", "byte[]");
                      }
                      sessionAttributeCache = cacheStoreService.cacheManager.getCache(attrCacheName, String.class, byte[].class);
                      if (sessionAttributeCache == null)
                          throw x;
                  }
              }
  
              tcSessionAttrCache = "AttrCache" + Integer.toHexString(System.identityHashCode(sessionAttributeCache));
              if (trace && tc.isDebugEnabled())
                  tcReturn(cacheStoreService.tcCacheManager, create ? "createCache" : "getCache", tcSessionAttrCache, sessionAttributeCache);
  
              cacheStoreService.configureMonitoring(attrCacheName);
          } catch(Exception ex) {
              //auto ffdc
              Tr.error(tc, "ERROR_SESSION_INIT", ex);
              throw new RuntimeException(Tr.formatMessage(tc, "INTERNAL_SERVER_ERROR"));
          }
      }