LoggerWrapperFactory.java

  1. /*
  2.  * GovWay - A customizable API Gateway 
  3.  * https://govway.org
  4.  * 
  5.  * Copyright (c) 2005-2025 Link.it srl (https://link.it). 
  6.  * 
  7.  * This program is free software: you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License version 3, as published by
  9.  * the Free Software Foundation.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  *
  19.  */


  22. package org.openspcoop2.utils;

  24. import java.io.File;
  25. import java.io.FileOutputStream;
  26. import java.net.URI;
  27. import java.net.URISyntaxException;
  28. import java.net.URL;
  29. import java.nio.file.Files;
  30. import java.nio.file.Path;
  31. import java.util.HashSet;
  32. import java.util.Iterator;
  33. import java.util.List;
  34. import java.util.Map;
  35. import java.util.Objects;
  36. import java.util.Properties;
  37. import java.util.Set;
  38. import java.util.regex.Matcher;
  39. import java.util.regex.Pattern;
  40. import java.util.stream.Collectors;

  42. import org.apache.commons.lang.StringUtils;
  43. import org.apache.logging.log4j.Level;
  44. import org.apache.logging.log4j.LogManager;
  45. import org.apache.logging.log4j.core.Appender;
  46. import org.apache.logging.log4j.core.LoggerContext;
  47. import org.apache.logging.log4j.core.appender.ConsoleAppender;
  48. import org.apache.logging.log4j.core.config.Configuration;
  49. import org.apache.logging.log4j.core.config.ConfigurationFactory;
  50. import org.apache.logging.log4j.core.config.Configurator;
  51. import org.apache.logging.log4j.core.config.LoggerConfig;
  52. import org.apache.logging.log4j.core.config.builder.api.AppenderComponentBuilder;
  53. import org.apache.logging.log4j.core.config.builder.api.ComponentBuilder;
  54. import org.apache.logging.log4j.core.config.builder.api.ConfigurationBuilder;
  55. import org.apache.logging.log4j.core.config.builder.api.ConfigurationBuilderFactory;
  56. import org.apache.logging.log4j.core.config.builder.api.LayoutComponentBuilder;
  57. import org.apache.logging.log4j.core.config.builder.api.RootLoggerComponentBuilder;
  58. import org.apache.logging.log4j.core.config.builder.impl.BuiltConfiguration;
  59. import org.apache.logging.log4j.core.config.json.JsonConfigurationFactory;
  60. import org.apache.logging.log4j.core.config.properties.PropertiesConfigurationFactory;
  61. import org.apache.logging.log4j.core.config.xml.XmlConfigurationFactory;
  62. import org.apache.logging.log4j.core.config.yaml.YamlConfigurationFactory;

  64. /**
  65.  * Libreria contenente metodi di utilità per gestire i log con log4j2
  66.  *
  67.  *
  68.  * @author Poli Andrea (apoli@link.it)
  69.  * @author Tommaso Burlon (tommaso.burlon@link.it)
  70.  * @author $Author$
  71.  * @version $Rev$, $Date$
  72.  */
  73. public class LoggerWrapperFactory {
  74.     
  75.     private LoggerWrapperFactory () {}

  77.     
  78.     
  79.     // ** Ritorna il logger */
  80.     
  81.     // NAME[org.apache.logging.slf4j.Log4jLogger] FACT[org.apache.logging.slf4j.Log4jLoggerFactory]
  82.     // I valori sopra sono se si possiede un corretto binding di log4j su slf.
  83.     // Se esistono più jar contenenti l'implementazione di un binding, non è detto che venga preso log4j.
  84.     
  85.     public static org.slf4j.Logger getLogger(Class<?> c){
  86.         return org.slf4j.LoggerFactory.getLogger(c);
  87.     }
  88.     public static org.slf4j.Logger getLogger(String name){
  89.         return org.slf4j.LoggerFactory.getLogger(name);
  90.     }
  91.     public static org.apache.logging.log4j.Logger getLoggerImpl(Class<?> c){
  92.         return org.apache.logging.log4j.LogManager.getLogger(c);
  93.     }
  94.     public static org.apache.logging.log4j.Logger getLoggerImpl(String name){
  95.         return org.apache.logging.log4j.LogManager.getLogger(name);
  96.     }
  97.     
  98.     
  99.     
  100.     
  101.     // ** Imposta tipo di ConnectionFactory (Default is xml) */
  102.     
  103.     public static void setPropertiesConfigurationFactory(){
  104.         ConfigurationFactory.setConfigurationFactory(new PropertiesConfigurationFactory());
  105.     }
  106.     public static void setJSonConfigurationFactory(){
  107.         ConfigurationFactory.setConfigurationFactory(new JsonConfigurationFactory());
  108.     }
  109.     public static void setXmlConfigurationFactory(){
  110.         ConfigurationFactory.setConfigurationFactory(new XmlConfigurationFactory());
  111.     }
  112.     public static void setYamlConfigurationFactory(){
  113.         ConfigurationFactory.setConfigurationFactory(new YamlConfigurationFactory());
  114.     }
  115.     
  116.     
  117.     
  118.     
  119.     // ** Ritorna Context log4J2 */
  120.     
  121.     private static LoggerContext getContext(){
  122.         return (org.apache.logging.log4j.core.LoggerContext) LogManager.getContext(false);
  123.     }
  124.     @SuppressWarnings("unused")
  125.     private static LoggerContext getContext(boolean currentContext){
  126.         return (org.apache.logging.log4j.core.LoggerContext) LogManager.getContext(currentContext);
  127.     }
  128.     

  130.     // ** Imposta proprietà in configurazione log4J2 */
  131.     
  132.     private static final String FORMAT_MSG = "%p <%d{dd-MM-yyyy HH:mm:ss.SSS}> %C.%M(%L): %m %n %n";
  133.     
  134.     public static void setDefaultConsoleLogConfiguration(Level level) {
  135.         setDefaultLogConfiguration(level, true, FORMAT_MSG, null, null);
  136.     }
  137.     public static void setDefaultConsoleLogConfiguration(Level level,
  138.             String layout) {
  139.         setDefaultLogConfiguration(level, true, layout, null, null);
  140.     }
  141.     public static void setDefaultLogConfiguration(Level level,boolean console,String layoutConsole,
  142.             File file,String layoutFile) {
  143.         
  144.         if(layoutConsole==null){
  145.             layoutConsole=FORMAT_MSG;
  146.         }
  147.         if(layoutFile==null){
  148.             layoutFile=FORMAT_MSG;
  149.         }
  150.         
  151.         ConfigurationBuilder<BuiltConfiguration> builder = ConfigurationBuilderFactory.newConfigurationBuilder();
  152.         builder.setConfigurationName("ConsoleDefault");
  153.         builder.setStatusLevel(Level.ERROR);
  154.         // Console Appender
  155.         if(console){
  156.             AppenderComponentBuilder appenderBuilder = builder.newAppender("Stdout", "CONSOLE").
  157.                     addAttribute("target",  ConsoleAppender.Target.SYSTEM_OUT);
  158.             appenderBuilder.add(builder.newLayout("PatternLayout")
  159.                     .addAttribute("pattern", layoutConsole));
  160.             builder.add(appenderBuilder);
  161.         }
  162.         if(file!=null){
  163.             // create a rolling file appender
  164.             LayoutComponentBuilder layoutBuilder = builder.newLayout("PatternLayout")
  165.                 .addAttribute("pattern", layoutFile);
  166.             ComponentBuilder<?> triggeringPolicy = builder.newComponent("Policies")
  167.                 .addComponent(builder.newComponent("CronTriggeringPolicy").addAttribute("schedule", "0 0 0 * * ?"))
  168.                 .addComponent(builder.newComponent("SizeBasedTriggeringPolicy").addAttribute("size", "100M"));
  169.             AppenderComponentBuilder appenderBuilder = builder.newAppender("rolling", "RollingFile")
  170.                 .addAttribute("fileName", file.getAbsolutePath())
  171.                 .addAttribute("filePattern", file.getAbsolutePath()+".%i")
  172.                 .add(layoutBuilder)
  173.                 .addComponent(triggeringPolicy);
  174.             builder.add(appenderBuilder);
  175.         }
  176.         // RootLogger
  177.         RootLoggerComponentBuilder rootLoggerBuilder = builder.newRootLogger(level);
  178.         if(console){
  179.             rootLoggerBuilder.add(builder.newAppenderRef("Stdout"));
  180.         }
  181.         if(file!=null){
  182.             rootLoggerBuilder.add(builder.newAppenderRef("rolling"));
  183.         }
  184.         builder.add(rootLoggerBuilder);
  185.         // Initialize
  186.         Configurator.initialize(builder.build());
  187.     }
  188.     
  189.     public static void setLogConfiguration(File file) throws UtilsException{
  190.         setLogConfiguration(getContext(), file, false);
  191.     }
  192.     public static void setLogConfiguration(File file,boolean append) throws UtilsException{
  193.         setLogConfiguration(getContext(), file, append);
  194.     }
  195.     private static void setLogConfiguration(LoggerContext context, File file,boolean append) throws UtilsException{
  196.         String filePath = "fs";
  197.         try{
  198.             if(file==null){
  199.                 throw new UtilsException("Resource file undefined");
  200.             }
  201.             filePath = file.getAbsolutePath();
  202.             if(file.exists()){
  203.                 if(append){
  204.                     appendConfiguration(context, file.toURI());
  205.                 }
  206.                 else{
  207.                     newConfiguration(context, file.toURI());
  208.                 }
  209.             }
  210.             else{
  211.                 throw new UtilsException("Resource not exists");
  212.             }
  213.         }catch(Exception e){
  214.             throw new UtilsException("Setting Logging Configuration (resource ["+filePath+"]): "+e.getMessage(),e);
  215.         }
  216.     }
  217.     public static void setLogConfiguration(String name) throws UtilsException{
  218.         setLogConfiguration(getContext(), name, false);
  219.     }
  220.     public static void setLogConfiguration(String name,boolean append) throws UtilsException{
  221.         setLogConfiguration(getContext(), name, append);
  222.     }
  223.     private static void setLogConfiguration(LoggerContext context, String name,boolean append) throws UtilsException{
  224.         try{
  225.             if(name==null){
  226.                 throw new UtilsException("Resource name undefined");
  227.             }
  228.             File f = new File(name);
  229.             setLogConfiguration(context, name, append, f);
  230.         }catch(Exception e){
  231.             throw new UtilsException("Setting Logging Configuration failed (resource ["+name+"]): "+e.getMessage(),e);
  232.         }
  233.     }
  234.     private static void setLogConfiguration(LoggerContext context, String name,boolean append, File f) throws UtilsException, URISyntaxException{
  235.         if(f.exists()){
  236.             if(append){
  237.                 appendConfiguration(context, f.toURI());
  238.             }
  239.             else{
  240.                 newConfiguration(context, f.toURI());
  241.             }
  242.         }
  243.         else{
  244.             String newName = null;
  245.             if(name.trim().startsWith("/")){
  246.                 newName = name;
  247.             }
  248.             else{
  249.                 newName = "/" + name;
  250.             }
  251.             URL url = Utilities.class.getResource(newName);
  252.             if(url!=null){
  253.                 if(append){
  254.                     appendConfiguration(context, url.toURI());
  255.                 }
  256.                 else{
  257.                     newConfiguration(context, url.toURI());
  258.                 }
  259.             }
  260.             else{
  261.                 throw new UtilsException("Resource ["+name+"] not found");
  262.             }
  263.         }
  264.     }
  265.     public static void setLogConfiguration(URL url) throws UtilsException{
  266.         setLogConfiguration(getContext(), url, false);
  267.     }
  268.     public static void setLogConfiguration(URL url,boolean append) throws UtilsException{
  269.         setLogConfiguration(getContext(), url, append);
  270.     }
  271.     private static void setLogConfiguration(LoggerContext context, URL url,boolean append) throws UtilsException{
  272.         try{
  273.             if(url==null){
  274.                 throw new UtilsException("Resource URL undefined");
  275.             }
  276.             if(append){
  277.                 appendConfiguration(context, url.toURI());
  278.             }
  279.             else{
  280.                 newConfiguration(context, url.toURI());
  281.             }
  282.         }catch(Exception e){
  283.             throw new UtilsException("Setting Logging Configuration failed (url ["+url+"]): "+e.getMessage(),e);
  284.         }
  285.     }
  286.     public static void setLogConfiguration(URI uri) throws UtilsException{
  287.         setLogConfiguration(getContext(), uri, false);
  288.     }
  289.     public static void setLogConfiguration(URI uri,boolean append) throws UtilsException{
  290.         setLogConfiguration(getContext(), uri, append);
  291.     }
  292.     private static void setLogConfiguration(LoggerContext context, URI uri,boolean append) throws UtilsException{
  293.         try{
  294.             if(uri==null){
  295.                 throw new UtilsException("Resource URI undefined");
  296.             }
  297.             if(append){
  298.                 appendConfiguration(context, uri);
  299.             }
  300.             else{
  301.                 newConfiguration(context, uri);
  302.             }
  303.         }catch(Exception e){
  304.             throw new UtilsException("Setting Logging Configuration failed (uri ["+uri+"]): "+e.getMessage(),e);
  305.         }
  306.     }
  307.     public static void setLogConfiguration(Properties props) throws UtilsException{
  308.         setLogConfiguration(getContext(), props, false);
  309.     }
  310.     public static void setLogConfiguration(Properties props,boolean append) throws UtilsException{
  311.         setLogConfiguration(getContext(), props, append);
  312.     }
  313.     private static void setLogConfiguration(LoggerContext context, Properties props,boolean append) throws UtilsException{
  314.         if(props==null){
  315.             throw new UtilsException("Resource Properties undefined");
  316.         }
  317.         
  318.         File fTmp = null;
  319.         try {
  320.             fTmp = Utilities.createTempPath("op2_log", ".properties").toFile();
  321.         }catch(Exception e){
  322.             throw new UtilsException("Setting Logging Configuration failed: "+e.getMessage(),e);
  323.         }
  324.         
  325.         try(FileOutputStream foutTmp = new FileOutputStream(fTmp);){
  326.             props.store(foutTmp, "Tmp Configuration");
  327.             foutTmp.flush();
  328.             
  329.             if(append){
  330.                 appendConfiguration(context, fTmp.toURI());
  331.             }
  332.             else{
  333.                 newConfiguration(context, fTmp.toURI());
  334.             }
  335.             
  336.         }catch(Exception e){
  337.             throw new UtilsException("Setting Logging Configuration failed: "+e.getMessage(),e);
  338.         }finally{
  339.             try{
  340.                 if(fTmp!=null){
  341.                     Files.delete(fTmp.toPath());
  342.                 }
  343.             }catch(Exception e){
  344.                 // close
  345.             }
  346.         }
  347.     }

  349.     
  350.     private static void newConfiguration(LoggerContext context, URI configUri) {
  351.         context.setConfigLocation(configUri);
  352.     }
  353.     private static synchronized void appendConfiguration(LoggerContext context, URI configUri) {
  354.         
  355.         /**System.out.println("APPEND LOG ["+configUri+"]");*/
  356.         
  357.         Configuration actualConfiguration = context.getConfiguration();
  358.         
  359.         ConfigurationFactory configurationFactory = ConfigurationFactory.getInstance();
  360.         Configuration appendConfiguration = configurationFactory.getConfiguration(new LoggerContext(actualConfiguration.getName()), actualConfiguration.getName(), configUri);
  361.         appendConfiguration.initialize();
  362.         
  363.         Map<String, Appender> mapAppenders = appendConfiguration.getAppenders();
  364.         if(mapAppenders.size()>0){
  365.             Iterator<String> appenderNameIterator = mapAppenders.keySet().iterator();
  366.             while (appenderNameIterator.hasNext()) {
  367.                 String appenderName = appenderNameIterator.next();
  368.                 Appender appender = mapAppenders.get(appenderName);
  369.                 appender.start();
  370.                 /**System.out.println("ADD APPENDER ["+appenderName+"]");*/
  371.                 actualConfiguration.addAppender(appender);
  372.             }
  373.         }
  374.         
  375.         Map<String, LoggerConfig> mapLoggers = appendConfiguration.getLoggers();
  376.         if(mapLoggers.size()>0){
  377.             Iterator<String> loggerNameIterator = mapLoggers.keySet().iterator();
  378.             while (loggerNameIterator.hasNext()) {
  379.                 String loggerName = loggerNameIterator.next();              
  380.                 LoggerConfig logger = mapLoggers.get(loggerName);
  381.                 /**System.out.println("ADD LOGGER ["+loggerName+"]");*/
  382.                 actualConfiguration.addLogger(loggerName, logger);
  383.             }
  384.         }
  385.         
  386.         /**System.out.println("APPEND LOG ["+configUri+"] FINE");*/
  387.         
  388.     }
  389.     
  390.     
  391.     private static String readProperty(Properties loggerProperties, 
  392.             String propName, Map<String, String> applicationEnv, String defaultValue) {
  393.         String value = System.getenv(applicationEnv.get(propName));
  394.         if (value != null && StringUtils.isNotEmpty(value))
  395.             return value;
  396.         
  397.         value = System.getenv(Costanti.ENV_LOG.get(propName));
  398.         if (value != null && StringUtils.isNotEmpty(value))
  399.             return value;
  400.         
  401.         value = System.getProperty(applicationEnv.get(propName));
  402.         if (value != null && StringUtils.isNotEmpty(value))
  403.             return value;
  404.         
  405.         value = System.getProperty(Costanti.ENV_LOG.get(propName));
  406.         if (value != null && StringUtils.isNotEmpty(value))
  407.             return value;
  408.         
  409.         value = loggerProperties.getProperty(propName);
  410.         if (value != null && StringUtils.isNotEmpty(value))
  411.             return value.trim();
  412.         
  413.         return defaultValue;
  414.     }
  415.     
  416.     private static final String LOGGER_CATEGORY_NAME_SUFFIX = ".name";
  417.     
  418.     private static Set<String> getLoggersIdByName(Properties loggerProperties, List<String> loggerNames) {
  419.         Set<String> enabledLoggers = new HashSet<>(loggerNames);
  420.         Set<String> loggersId = new HashSet<>();
  421.         boolean enabledAll = enabledLoggers.contains(Boolean.TRUE.toString());
  422.         
  423.         if (enabledLoggers.contains(Boolean.FALSE.toString()) && enabledLoggers.size() == 1)
  424.             return loggersId;
  425.         
  426.         for (Map.Entry<Object, Object> p : loggerProperties.entrySet()) {
  427.             String key = p.getKey().toString().trim();
  428.             
  429.             
  430.             if (key.startsWith("logger.") && key.endsWith(LOGGER_CATEGORY_NAME_SUFFIX)) {
  431.                 String value = p.getValue().toString().trim();
  432.                 
  433.                 if (enabledAll || enabledLoggers.contains(value)) {
  434.                     String loggerId = key.substring(0, key.length() - LOGGER_CATEGORY_NAME_SUFFIX.length());
  435.                     loggersId.add(loggerId);
  436.                 }
  437.             }
  438.         }
  439.         
  440.         return loggersId;
  441.     }
  442.     
  443.     private static Set<String> getLoggersIdByName(Properties loggerProperties, String propName, Map<String, String> applicationEnv) {
  444.         List<String> enabledList = List.of(readProperty(loggerProperties, propName, applicationEnv, "false").split(","));
  445.         enabledList = enabledList.stream().map(String::trim).collect(Collectors.toList());
  446.         return getLoggersIdByName(loggerProperties, enabledList);
  447.     }
  448.     
  449.     private static final String LOGGER_APPENDER_PREFIX = "appender.";
  450.     private static final String LOGGER_APPENDER_NAME_SUFFIX = ".name";
  451.     
  452.     private static Set<String> getAppendersIdByName(Properties loggerProperties, Set<String> appenderNames) {
  453.         Set<String> appenderIds = new HashSet<>();
  454.         for (Map.Entry<Object, Object> p : loggerProperties.entrySet()) {
  455.             String key = p.getKey().toString().trim();
  456.             
  457.             
  458.             if (key.startsWith(LOGGER_APPENDER_PREFIX) 
  459.                     && key.endsWith(LOGGER_APPENDER_NAME_SUFFIX)
  460.                     && appenderNames.contains(p.getValue().toString().trim())) {
  461.                 
  462.                     String appenderId = key.substring(0, key.length() - LOGGER_APPENDER_NAME_SUFFIX.length());
  463.                     appenderIds.add(appenderId);
  464.                 }
  465.             
  466.         }
  467.         
  468.         return appenderIds;
  469.     }
  470.     
  471.     private static Set<String> getAppenderIdByLoggerName(Properties loggerProperties, String propName, Map<String, String> applicationEnv) {
  472.         Set<String> loggerIds = getLoggersIdByName(loggerProperties, propName, applicationEnv);
  473.         Set<String> appenderNames = new HashSet<>();
  474.         
  475.         if (loggerIds.isEmpty())
  476.             return Set.of();
  477.         
  478.         for (Map.Entry<Object, Object> p : loggerProperties.entrySet()) {
  479.             String key = p.getKey().toString().trim();
  480.             
  481.             
  482.             if (key.startsWith("logger.") && key.endsWith(".ref")) {
  483.                 String loggerId = key.substring(0, key.indexOf(".appenderRef"));
  484.                 if (loggerIds.contains(loggerId)) {
  485.                     appenderNames.add(p.getValue().toString().trim());
  486.                 }
  487.             }
  488.         }
  489.         
  490.         return getAppendersIdByName(loggerProperties, appenderNames);
  491.     }
  492.     
  493.     
  494.     /**
  495.      * Applica le patch necessarie per far utilizzare ai logger indicati lo stdout come appender
  496.      * @param loggerProperties
  497.      * @param applicationEnv
  498.      * @param vars
  499.      * @return
  500.      */
  501.     private static final Pattern LOG_VARIABLE_PATTERN = Pattern.compile("%\\{([^\\}]+)\\}");
  502.     private static Properties patchLoggersStdout(Properties loggerProperties, Map<String, String> applicationEnv, Map<String, String> vars) {
  503.         Set<String> loggerIds = getLoggersIdByName(loggerProperties, 
  504.                 Costanti.PROP_ENABLE_STDOUT, 
  505.                 applicationEnv);
  506.         
  507.         for (String loggerId : loggerIds) {
  508.             loggerProperties.put(loggerId + ".appenderRef.stdout.ref", "STDOUT");
  509.         }
  510.         
  511.         for (Map.Entry<Object, Object> p : loggerProperties.entrySet()) {
  512.             String key = p.getKey().toString().trim();
  513.             if (key.startsWith(LOGGER_APPENDER_PREFIX)
  514.                     && key.endsWith(LAYOUT_PATTERN_SUFFIX)) {
  515.                 String value = p.getValue().toString().trim();
  516.                 Matcher matcher = LOG_VARIABLE_PATTERN.matcher(value);
  517.                 
  518.                 value = matcher.replaceAll(m -> {
  519.                     String out = vars.get(m.group(1).trim());
  520.                     return Objects.requireNonNullElse(out, m.group());
  521.                 });
  522.                 
  523.                 p.setValue(value);
  524.             }
  525.             
  526.         }
  527.         
  528.         return loggerProperties;
  529.     }
  530.     
  531.     private static final String LAYOUT_TYPE_SUFFIX = ".layout.type";
  532.     private static final String LAYOUT_PATTERN_SUFFIX= ".layout.pattern";
  533.     private static final String LAYOUT_EVENT_TEMPLATE_URI_SUFFIX= ".layout.eventTemplateUri";
  534.     
  535.     /**
  536.      * Applica le patch necessarie per formattare in JSON l'output dei vari logger indicati
  537.      * @param loggerProperties
  538.      * @param applicationEnv
  539.      * @param vars
  540.      * @return
  541.      */
  542.     private static Properties patchLoggersJSON(Properties loggerProperties, Map<String, String> applicationEnv, Map<String, String> vars) {
  543.         Set<String> appenderIds = getAppenderIdByLoggerName(
  544.                 loggerProperties, 
  545.                 Costanti.PROP_ENABLE_JSON, 
  546.                 applicationEnv);
  547.         
  548.         String jsonTemplate = readProperty(loggerProperties, 
  549.                 Costanti.PROP_ENABLE_JSON_TEMPLATE,
  550.                 applicationEnv,
  551.                 "classpath:JsonLayout.json");
  552.         if (jsonTemplate != null) {
  553.             for (String appenderId : appenderIds) {
  554.                 loggerProperties.remove(appenderId + LAYOUT_TYPE_SUFFIX);
  555.                 loggerProperties.remove(appenderId + LAYOUT_PATTERN_SUFFIX);
  556.                 loggerProperties.put(appenderId + LAYOUT_TYPE_SUFFIX, "JsonTemplateLayout");
  557.                 loggerProperties.put(appenderId + LAYOUT_EVENT_TEMPLATE_URI_SUFFIX, jsonTemplate.trim());
  558.             }
  559.         }
  560.         
  561.         return applyPatchLoggersJSON(loggerProperties, vars);
  562.     }
  563.     private static Properties applyPatchLoggersJSON(Properties loggerProperties, Map<String, String> vars) {
  564.         
  565.         Set<String> patchedAppenderIds = new HashSet<>();
  566.         for (Map.Entry<Object, Object> p : loggerProperties.entrySet()) {
  567.             String key = p.getKey().toString().trim();
  568.             addPatchLoggersJSONAppender(key, patchedAppenderIds, p, loggerProperties, vars);
  569.         }
  570.         
  571.         return loggerProperties;
  572.     }
  573.     private static void addPatchLoggersJSONAppender(String key, Set<String> patchedAppenderIds, Map.Entry<Object, Object> p, Properties loggerProperties, Map<String, String> vars) {
  574.         if (key.startsWith("appender")
  575.                 && key.endsWith(LAYOUT_TYPE_SUFFIX)) {
  576.             String value = p.getValue().toString().trim();
  577.             if (!value.equals("JsonTemplateLayout"))
  578.                 return;
  579.             
  580.             String appenderId = key.substring(0, key.length() - LAYOUT_TYPE_SUFFIX.length());
  581.             if (patchedAppenderIds.contains(appenderId))
  582.                 return;
  583.                 
  584.             int counter = 0;
  585.             final String TEMPLATE_ADDITIONAL_FIELD = "%s.layout.eventTemplateAdditionalField[%d]";
  586.             while(counter < 1000 && loggerProperties.contains(String.format(TEMPLATE_ADDITIONAL_FIELD, appenderId, counter) + ".key")) {
  587.                 counter++;
  588.             }
  589.             for (Map.Entry<String, String> variable : vars.entrySet()) {
  590.                 loggerProperties.put(String.format(TEMPLATE_ADDITIONAL_FIELD, appenderId, counter) + ".type", "EventTemplateAdditionalField");
  591.                 loggerProperties.put(String.format(TEMPLATE_ADDITIONAL_FIELD, appenderId, counter) + ".key", variable.getKey());
  592.                 loggerProperties.put(String.format(TEMPLATE_ADDITIONAL_FIELD, appenderId, counter) + ".value", variable.getValue());
  593.             }
  594.                 
  595.             patchedAppenderIds.add(appenderId);
  596.         }
  597.     }
  598.     
  599.     
  600.     private static String clusterIdEnv;
  601.     private static String clusterIdStrategy;
  602.     private static Set<String> clusterId;
  603.     

  605.     /**
  606.      * Modifica il percorso di un file aggiungendo un identificativo univoco del
  607.      * nodo
  608.      * @param filePath percorso originario del file
  609.      * @param id id della risorsa da modificare
  610.      * @return
  611.      */
  612.     public static String applyClusterIdStrategy(String filePath, String id) {
  613.         if (clusterId!=null &&
  614.                 (clusterId.contains(id) || clusterId.contains(Boolean.TRUE.toString()))
  615.                 ) {
  616.             return applyClusterIdStrategy(filePath);
  617.         }
  618.         return filePath;
  619.     }
  620.     
  621.     private static String applyClusterIdStrategy(String filePath) {
  622.         if(filePath==null) {
  623.             return null;
  624.         }
  625.         Path oldPath = Path.of(filePath);
  626.         if(oldPath==null || oldPath.getFileName()==null) {
  627.             return null;
  628.         }
  629.         String fileName = oldPath.getFileName().toString();
  630.         Path dir = oldPath.getParent();
  631.         if(dir==null) {
  632.             return null;
  633.         }
  634.         
  635.         if (clusterIdStrategy.equals(Costanti.LOG_CLUSTERID_STRATEGY_FILENAME)) {
  636.             int index = fileName.lastIndexOf('.');
  637.             index = index == -1 ? fileName.length() : index;
  638.             String name = fileName.substring(0, index);
  639.             String extension = fileName.substring(index);
  640.             fileName = name + "." + clusterIdEnv + extension;
  641.         } else if (clusterIdStrategy.equals(Costanti.LOG_CLUSTERID_STRATEGY_DIRECTORY)) {
  642.             dir = dir.resolve(clusterIdEnv);
  643.         }
  644.         
  645.         return (dir.resolve(fileName).toString());
  646.     }
  647.     
  648.     /**
  649.      * Inserisce le informazioni relative al cluster Id nel path del file di log,
  650.      * usato per condividere lo stesso file system da nodi diversi mantenendo log separati
  651.      * @param loggerProperties proprieta dei logger
  652.      * @param applicationEnv mappa contenente le variabile d'ambiente delle applicazioni
  653.      * @return
  654.      */
  655.     private static Properties patchClusterIdPath(Properties loggerProperties, Map<String, String> applicationEnv) {
  656.         clusterIdEnv = readProperty(loggerProperties, 
  657.                 Costanti.PROP_ENABLE_LOG_CLUSTERID_ENV, 
  658.                 applicationEnv, null);
  659.         if(clusterIdEnv!=null && StringUtils.isNotEmpty(clusterIdEnv)) {
  660.             String id = clusterIdEnv;
  661.             clusterIdEnv = System.getenv(id);
  662.             if(clusterIdEnv==null || StringUtils.isEmpty(clusterIdEnv)) {
  663.                 clusterIdEnv = System.getProperty(id);
  664.             }
  665.         }
  666.         if(clusterIdEnv==null || StringUtils.isEmpty(clusterIdEnv)) {
  667.             clusterIdEnv = System.getenv("HOSTNAME");
  668.         }
  669.         if(clusterIdEnv==null || StringUtils.isEmpty(clusterIdEnv)) {
  670.             clusterIdEnv = System.getProperty("HOSTNAME");
  671.         }
  672.         if (clusterIdEnv == null || StringUtils.isEmpty(clusterIdEnv)) {
  673.             return loggerProperties;
  674.         }
  675.         clusterId = List.of(readProperty(loggerProperties, 
  676.                 Costanti.PROP_ENABLE_LOG_CLUSTERID, 
  677.                 applicationEnv,
  678.                 Boolean.FALSE.toString()).split(","))
  679.                 .stream()
  680.                 .map(String::trim)
  681.                 .collect(Collectors.toSet());

  683.         Set<String> appenderIds = LoggerWrapperFactory.getAppenderIdByLoggerName(loggerProperties, 
  684.                 Costanti.PROP_ENABLE_LOG_CLUSTERID, 
  685.                 applicationEnv);
  686.         
  687.         if (appenderIds.isEmpty())
  688.             return loggerProperties;
  689.         
  690.         return applyPatchClusterIdPath(loggerProperties, applicationEnv, appenderIds);
  691.     }
  692.     private static Properties applyPatchClusterIdPath(Properties loggerProperties, Map<String, String> applicationEnv, Set<String> appenderIds) {   
  693.     
  694.         clusterIdStrategy = readProperty(loggerProperties, 
  695.                 Costanti.PROP_ENABLE_LOG_CLUSTERID_STRATEGY, 
  696.                 applicationEnv,
  697.                 Costanti.LOG_CLUSTERID_STRATEGY_DIRECTORY);
  698.         clusterIdStrategy = clusterIdStrategy.trim();
  699.         
  700.         for (Map.Entry<Object, Object> p : loggerProperties.entrySet()) {
  701.             String key = p.getKey().toString().trim();
  702.             String appenderId = null;
  703.             
  704.             if (key.startsWith(LOGGER_APPENDER_PREFIX)) {
  705.                 if (key.endsWith(".fileName"))
  706.                     appenderId = key.substring(0, key.length() - ".fileName".length());
  707.                 if (key.endsWith(".filePattern"))
  708.                     appenderId = key.substring(0, key.length() - ".filePattern".length());
  709.             }
  710.             
  711.             if (appenderId != null && appenderIds.contains(appenderId)) {
  712.                     String value = p.getValue().toString().trim();
  713.                     p.setValue(applyClusterIdStrategy(value));
  714.             }
  715.             
  716.         }
  717.         
  718.         
  719.         return loggerProperties;
  720.     }
  721.     
  722.     /**
  723.      * Aggiorna i logger per usufruire di tutti i servizi pilotati tramite variabili d'ambiente
  724.      * o proprieta nei vari file log4j2.properties, le varie proprieta sono presenti nella classe
  725.      * org.openspcoop2.utils.Costanti
  726.      * @param loggerProperties
  727.      * @param propertyToEnv
  728.      * @param vars
  729.      * @return
  730.      */
  731.     public static Properties patchLoggers(Properties loggerProperties, Map<String, String> propertyToEnv, Map<String, String> vars) {
  732.         patchClusterIdPath(loggerProperties, propertyToEnv);
  733.         patchLoggersStdout(loggerProperties, propertyToEnv, vars);
  734.         patchLoggersJSON(loggerProperties, propertyToEnv, vars);
  735.         return loggerProperties;
  736.     }


  739. }
Created with JaCoCo 0.8.8.202204050719