OpenSPCoop2Logger.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.  */




  24. package org.openspcoop2.pdd.logger;


  27. import java.io.File;
  28. import java.io.FileInputStream;
  29. import java.io.InputStream;
  30. import java.io.StringReader;
  31. import java.util.ArrayList;
  32. import java.util.Date;
  33. import java.util.Enumeration;
  34. import java.util.List;
  35. import java.util.Map;
  36. import java.util.Properties;

  38. import org.openspcoop2.core.commons.CoreException;
  39. import org.openspcoop2.core.config.MessaggiDiagnostici;
  40. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  41. import org.openspcoop2.core.id.IDServizio;
  42. import org.openspcoop2.core.id.IDSoggetto;
  43. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  44. import org.openspcoop2.core.statistiche.constants.TipoIntervalloStatistico;
  45. import org.openspcoop2.pdd.config.ClassNameProperties;
  46. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  47. import org.openspcoop2.pdd.core.CostantiPdD;
  48. import org.openspcoop2.pdd.core.IPdDContextSerializer;
  49. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  50. import org.openspcoop2.protocol.engine.builder.DateBuilder;
  51. import org.openspcoop2.protocol.engine.utils.NamingUtils;
  52. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  53. import org.openspcoop2.protocol.sdk.diagnostica.IDiagnosticProducer;
  54. import org.openspcoop2.protocol.sdk.diagnostica.MsgDiagnostico;
  55. import org.openspcoop2.protocol.sdk.dump.IDumpProducer;
  56. import org.openspcoop2.protocol.sdk.tracciamento.ITracciaProducer;
  57. import org.openspcoop2.utils.LoggerWrapperFactory;
  58. import org.openspcoop2.utils.Utilities;
  59. import org.openspcoop2.utils.properties.CollectionProperties;
  60. import org.openspcoop2.utils.properties.PropertiesUtilities;
  61. import org.openspcoop2.utils.resources.Charset;
  62. import org.openspcoop2.utils.resources.Loader;
  63. import org.slf4j.Logger;

  65. /**
  66.  * Contiene la definizione un Logger utilizzato dai nodi dell'infrastruttura di OpenSPCoop
  67.  * per la registrazione di messaggi riguardanti :.
  68.  * <ul>
  69.  * <li> Tracciamento
  70.  * <li> MsgDiagnostici
  71.  * </ul>
  72.  *
  73.  * @author Poli Andrea (apoli@link.it)
  74.  * @author Tommaso Burlon (tommaso.burlon@link.it)
  75.  * @author $Author$
  76.  * @version $Rev$, $Date$
  77.  */

  79. public class OpenSPCoop2Logger {

  81.     /**  Logger log4j utilizzato per scrivere i tracciamenti */
  82.     protected static Logger loggerTracciamento = null;
  83.     /** Logger log4j utilizzato per scrivere i tracciamenti: impostazione */
  84.     public static boolean loggerTracciamentoAbilitato = false;
  85.     /**  Logger log4j utilizzato per scrivere i msgDiagnostici */
  86.     protected static org.apache.logging.log4j.Logger loggerMsgDiagnostico = null;
  87.     /** Logger log4j utilizzato per scrivere i msg diagnostici: impostazione */
  88.     public static boolean loggerMsgDiagnosticoAbilitato = false;
  89.     /**  Logger log4j utilizzato per scrivere i msgDiagnostici */
  90.     protected static org.apache.logging.log4j.Logger loggerOpenSPCoop2 = null;
  91.     /** Logger log4j utilizzato per scrivere i msg diagnostici 'readable': impostazione */
  92.     public static boolean loggerMsgDiagnosticoReadableAbilitato = false;
  93.     /**  Logger log4j utilizzato per scrivere i msgDiagnostici del servizio di IntegrationManager */
  94.     protected static org.apache.logging.log4j.Logger loggerIntegrationManager = null;
  95.     /** Logger log4j utilizzato per scrivere i msg diagnostici 'readable' del servizio di IntegrationManager: impostazione */
  96.     public static boolean loggerIntegrationManagerAbilitato = false;
  97.     /**  Logger log4j utilizzato per effettuare un dump dei messaggi applicativi */
  98.     protected static Logger loggerDump = null;
  99.     /** Logger log4j utilizzato per scrivere i dump applicativi: impostazione */
  100.     public static boolean loggerDumpAbilitato = false;
  101.     /**  Logger log4j utilizzato per segnalare a video errori gravi (FATAL) o di informazione sull'inizializzazione (INFO)*/
  102.     protected static Logger loggerOpenSPCoopConsole = LoggerWrapperFactory.getLogger("govway.startup");
  103.     /** Logger log4j utilizzato per segnalare a video errori gravi (FATAL) o di informazione sull'inizializzazione (INFO) */
  104.     protected static boolean loggerOpenSPCoopConsoleStartupAgganciatoLog = false;
  105.     /**  Logger log4j utilizzato per il core di OpenSPCoop */
  106.     protected static Logger loggerOpenSPCoopCore = null;
  107.     /**  Logger log4j utilizzato per registrare le operazioni dei Timer che ripuliscono i repository buste e messaggi*/
  108.     protected static Logger loggerOpenSPCoopTimers = null;
  109.     /**  Logger log4j utilizzato per registrare le operazioni di monitoraggio delle risorse utilizzate dalla PdD (Timer che verficano le risorse della PdD) */
  110.     protected static Logger loggerOpenSPCoopResources = null;
  111.     protected static org.apache.logging.log4j.Logger loggerOpenSPCoopResourcesAsLoggerImpl = null;
  112.     /**  Logger log4j utilizzato per la configurazione di sistema */
  113.     protected static Logger loggerOpenSPCoopConfigurazioneSistema = null;
  114.     /**  Logger log4j utilizzato per il servizio proxy */
  115.     protected static Logger loggerOpenSPCoopProxy = null;
  116.     /**  Logger log4j utilizzato per i connettori */
  117.     protected static Logger loggerOpenSPCoopConnettori = null;
  118.     /**  Logger log4j utilizzato per i dati binari del servizio PD */
  119.     protected static Logger loggerOpenSPCoopDumpBinarioPD = null;
  120.     /**  Logger log4j utilizzato per i dati binari del servizio PA */
  121.     protected static Logger loggerOpenSPCoopDumpBinarioPA = null;
  122.     /**  Logger log4j utilizzato per gli eventi */
  123.     protected static Logger loggerOpenSPCoopEventi = null;
  124.     protected static Logger loggerOpenSPCoopEventiError = null;
  125.     /**  Logger log4j utilizzato per le transazioni */
  126.     protected static Logger loggerOpenSPCoopTransazioni = null;
  127.     protected static Logger loggerOpenSPCoopTransazioniError = null;
  128.     protected static Logger loggerOpenSPCoopTransazioniDevNull = null;
  129.     /**  Logger log4j utilizzato per le transazioni */
  130.     protected static Logger loggerOpenSPCoopTransazioniSql = null;
  131.     protected static Logger loggerOpenSPCoopTransazioniSqlError = null;
  132.     /**  Logger log4j utilizzato per le transazioni stateful */
  133.     protected static Logger loggerOpenSPCoopTransazioniStateful = null;
  134.     protected static Logger loggerOpenSPCoopTransazioniStatefulError = null;
  135.     /**  Logger log4j utilizzato per le transazioni stateful */
  136.     protected static Logger loggerOpenSPCoopTransazioniStatefulSql = null;
  137.     protected static Logger loggerOpenSPCoopTransazioniStatefulSqlError = null;
  138.     /**  Logger log4j utilizzato per le transazioni, per registrare le operazioni lente */
  139.     protected static Logger loggerOpenSPCoopTransazioniSlowLog = null;
  140.     /**  Logger log4j utilizzato per attività di file system recovery */
  141.     protected static Logger loggerOpenSPCoopFileSystemRecovery = null;
  142.     protected static Logger loggerOpenSPCoopFileSystemRecoveryError = null;
  143.     /**  Logger log4j utilizzato per attività di file system recovery (sql) */
  144.     protected static Logger loggerOpenSPCoopFileSystemRecoverySql = null;
  145.     protected static Logger loggerOpenSPCoopFileSystemRecoverySqlError = null;
  146.     /**  Logger log4j utilizzato per il Controllo del Traffico */
  147.     protected static Logger loggerOpenSPCoopControlloTraffico = null;
  148.     protected static Logger loggerOpenSPCoopControlloTrafficoError = null;
  149.     /**  Logger log4j utilizzato per il Controllo del Traffico (sql) */
  150.     protected static Logger loggerOpenSPCoopControlloTrafficoSql = null;
  151.     protected static Logger loggerOpenSPCoopControlloTrafficoSqlError = null;
  152.     /**  Logger log4j utilizzato per gli Allarmi */
  153.     protected static Logger loggerOpenSPCoopAllarmi = null;
  154.     protected static Logger loggerOpenSPCoopAllarmiError = null;
  155.     /**  Logger log4j utilizzato per gli Allarmi (sql) */
  156.     protected static Logger loggerOpenSPCoopAllarmiSql = null;
  157.     protected static Logger loggerOpenSPCoopAllarmiSqlError = null;
  158.     /**  Logger log4j utilizzato per le statistiche */
  159.     protected static Logger loggerOpenSPCoopStatisticheOrarie = null;
  160.     protected static Logger loggerOpenSPCoopStatisticheOrarieError = null;
  161.     protected static Logger loggerOpenSPCoopStatisticheGiornaliere = null;
  162.     protected static Logger loggerOpenSPCoopStatisticheGiornaliereError = null;
  163.     protected static Logger loggerOpenSPCoopStatisticheSettimanali = null;
  164.     protected static Logger loggerOpenSPCoopStatisticheSettimanaliError = null;
  165.     protected static Logger loggerOpenSPCoopStatisticheMensili = null;
  166.     protected static Logger loggerOpenSPCoopStatisticheMensiliError = null;
  167.     protected static Logger loggerOpenSPCoopStatistichePdndGenerazione = null;
  168.     protected static Logger loggerOpenSPCoopStatistichePdndGenerazioneError = null;
  169.     protected static Logger loggerOpenSPCoopStatistichePdndPubblicazione = null;
  170.     protected static Logger loggerOpenSPCoopStatistichePdndPubblicazioneError = null;
  171.     /**  Logger log4j utilizzato per le statistiche */
  172.     protected static Logger loggerOpenSPCoopStatisticheOrarieSql = null;
  173.     protected static Logger loggerOpenSPCoopStatisticheOrarieSqlError = null;
  174.     protected static Logger loggerOpenSPCoopStatisticheGiornaliereSql = null;
  175.     protected static Logger loggerOpenSPCoopStatisticheGiornaliereSqlError = null;
  176.     protected static Logger loggerOpenSPCoopStatisticheSettimanaliSql = null;
  177.     protected static Logger loggerOpenSPCoopStatisticheSettimanaliSqlError = null;
  178.     protected static Logger loggerOpenSPCoopStatisticheMensiliSql = null;
  179.     protected static Logger loggerOpenSPCoopStatisticheMensiliSqlError = null;
  180.     protected static Logger loggerOpenSPCoopStatistichePdndGenerazioneSql = null;
  181.     protected static Logger loggerOpenSPCoopStatistichePdndGenerazioneSqlError = null;
  182.     protected static Logger loggerOpenSPCoopStatistichePdndPubblicazioneSql = null;
  183.     protected static Logger loggerOpenSPCoopStatistichePdndPubblicazioneSqlError = null;
  184.     /**  Logger log4j utilizzato per consegna contenuti */
  185.     protected static Logger loggerOpenSPCoopConsegnaContenuti = null;
  186.     protected static Logger loggerOpenSPCoopConsegnaContenutiError = null;
  187.     /**  Logger log4j utilizzato per consegna contenuti */
  188.     protected static Logger loggerOpenSPCoopConsegnaContenutiSql = null;
  189.     protected static Logger loggerOpenSPCoopConsegnaContenutiSqlError = null;
  190.     /**  Logger log4j utilizzato per i Plugins */
  191.     protected static Logger loggerOpenSPCoopPlugins = null;
  192.     protected static Logger loggerOpenSPCoopPluginsError = null;
  193.     /**  Logger log4j utilizzato per i Plugins (sql) */
  194.     protected static Logger loggerOpenSPCoopPluginsSql = null;
  195.     protected static Logger loggerOpenSPCoopPluginsSqlError = null;
  196.     /**  Logger log4j utilizzato per il gestore delle chiavi PDND */
  197.     protected static Logger loggerOpenSPCoopGestoreChiaviPDND = null;
  198.     protected static Logger loggerOpenSPCoopGestoreChiaviPDNDError = null;
  199.     /**  Logger log4j utilizzato per il gestore delle operazioni remote */
  200.     protected static Logger loggerOpenSPCoopGestoreOperazioniRemote = null;
  201.     protected static Logger loggerOpenSPCoopGestoreOperazioniRemoteError = null;
  202.     /** Appender personalizzati per i messaggi diagnostici di OpenSPCoop */
  203.     public static List<IDiagnosticProducer> loggerMsgDiagnosticoOpenSPCoopAppender = new ArrayList<>(); 
  204.     public static List<String> tipoMsgDiagnosticoOpenSPCoopAppender = new ArrayList<>();
  205.     /** Appender personalizzati per i tracciamenti di OpenSPCoop */
  206.     public static List<ITracciaProducer> loggerTracciamentoOpenSPCoopAppender = new ArrayList<>(); 
  207.     public static List<String> tipoTracciamentoOpenSPCoopAppender = new ArrayList<>();
  208.     /** Appender personalizzati per i dump applicativi di OpenSPCoop */
  209.     public static List<IDumpProducer> loggerDumpOpenSPCoopAppender = new ArrayList<>(); 
  210.     public static List<String> tipoDumpOpenSPCoopAppender = new ArrayList<>();
  211.     /** PdDContextSerializer */
  212.     private static IPdDContextSerializer pddContextSerializer = null;
  213.     /** LogDir */
  214.     private static List<File> logDirs;
  215.     public static List<File> getLogDirs() {
  216.         return logDirs;
  217.     }

  219.     public static boolean isLoggerOpenSPCoopConsoleStartupAgganciatoLog(){
  220.         return OpenSPCoop2Logger.loggerOpenSPCoopConsoleStartupAgganciatoLog;
  221.     }
  222.     
  223.     private static final String APP_NAME = "govway";
  224.     
  225.     private static List<String> filesCheck;
  226.     private static void initializeLogDirs(Properties p, boolean append){
  227.         
  228.         if(!append) {
  229.             logDirs = new ArrayList<>();
  230.             filesCheck = new ArrayList<>();
  231.         }
  232.         
  233.         Enumeration<?> en = p.keys();
  234.         while (en.hasMoreElements()) {
  235.             String key = (String) en.nextElement();
  236.             key = key.trim();
  237.             String value = p.getProperty(key);
  238.             value = value.trim();
  239.             if(key.endsWith(".fileName") || key.endsWith(".filePattern")) {
  240.                 File fTmp = new File(value);
  241.                 if(fTmp.getParentFile()!=null) {
  242.                     if(filesCheck.contains(fTmp.getParentFile().getAbsolutePath())==false) {
  243.                         logDirs.add(fTmp.getParentFile());
  244.                         filesCheck.add(fTmp.getParentFile().getAbsolutePath());
  245.                     }
  246.                 }
  247.             }
  248.         }
  249.         
  250.     }
  251.     
  252.     /**
  253.      * Il Metodo si occupa di inizializzare il Logger utilizzato da OpenSPCoop (file,DB scelti da govway.log4j2.properties)
  254.      *
  255.      * @param logConsole Log console
  256.      * @return true in caso di inizializzazione con successo, false altrimenti.
  257.      * 
  258.      */
  259.     public static boolean initializeLogConsole(Logger logConsole){
  260.         InputStream isOp2 = null;
  261.         InputStream isLogger = null;
  262.         try{
  263.             isOp2 = OpenSPCoop2Logger.class.getResourceAsStream("/govway.properties");
  264.             String confDir = null;
  265.             if(isOp2!=null){
  266.                 java.util.Properties op2Properties = new java.util.Properties();
  267.                 op2Properties.load(isOp2);
  268.                 confDir = op2Properties.getProperty("org.openspcoop2.pdd.confDirectory");
  269.             }
  270.             
  271.             java.util.Properties loggerProperties = new java.util.Properties();
  272.             isLogger = OpenSPCoop2Logger.class.getResourceAsStream("/govway.log4j2.properties");
  273.             if(isLogger!=null){
  274.                 loggerProperties.load(isLogger);
  275.             }
  276.             
  277.             // Cerco eventuale ridefinizione
  278.             CollectionProperties loggerPropertiesRidefinito =  
  279.                     PropertiesUtilities.searchLocalImplementation(CostantiPdD.OPENSPCOOP2_LOCAL_HOME,LoggerWrapperFactory.getLogger(OpenSPCoop2Logger.class), 
  280.                             CostantiPdD.OPENSPCOOP2_LOGGER_PROPERTIES, CostantiPdD.OPENSPCOOP2_LOGGER_LOCAL_PATH, 
  281.                             confDir);
  282.             
  283.             if(loggerPropertiesRidefinito!=null && loggerPropertiesRidefinito.size()>0){
  284.                 Enumeration<?> ridefinito = loggerPropertiesRidefinito.keys();
  285.                 while (ridefinito.hasMoreElements()) {
  286.                     String key = (String) ridefinito.nextElement();
  287.                     String value = (String) loggerPropertiesRidefinito.get(key);
  288.                     if(loggerProperties.containsKey(key)){
  289.                         //Object o = 
  290.                         loggerProperties.remove(key);
  291.                     }
  292.                     loggerProperties.put(key, value);
  293.                     //System.out.println("CHECK NUOVO VALORE: "+loggerProperties.get(key));
  294.                 }
  295.             }
  296.             
  297.             LoggerWrapperFactory.patchLoggers(loggerProperties,  
  298.                     org.openspcoop2.utils.Costanti.ENV_LOG_GOVWAY,
  299.                     Map.of(org.openspcoop2.utils.Costanti.VAR_LOGGER_APPNAME, APP_NAME));
  300.             LoggerWrapperFactory.setLogConfiguration(loggerProperties);
  301.             initializeLogDirs(loggerProperties, false);
  302.             
  303.             return true;
  304.         }catch(Exception e){
  305.             OpenSPCoop2Logger.loggerOpenSPCoopConsole.error("Riscontrato errore durante l'inizializzazione del sistema di logging di OpenSPCoop: "
  306.                     +e.getMessage(),e);
  307.             return false;
  308.         }finally{
  309.             try{
  310.                 if(isOp2!=null){
  311.                     isOp2.close();
  312.                 }
  313.             }catch(Exception eClose){
  314.                 // close
  315.             }
  316.             try{
  317.                 if(isLogger!=null){
  318.                     isLogger.close();
  319.                 }
  320.             }catch(Exception eClose){
  321.                 // close
  322.             }
  323.         }
  324.     }
  325.     
  326.     
  327.     public static boolean initialize(Logger logConsole,String rootDirectory,Properties objectProperties,
  328.             boolean allarmiEnabled){
  329.         return initialize(logConsole, rootDirectory, objectProperties, true,
  330.                 allarmiEnabled);
  331.     }
  332.     public static boolean initialize(Logger logConsole,String rootDirectory,Properties objectProperties, boolean loadExternalConfiguration,
  333.             boolean allarmiEnabled){
  334.         try{
  335.             
  336.             // Originale
  337.             java.util.Properties loggerProperties = new java.util.Properties();
  338.             java.io.File loggerFile = new java.io.File(rootDirectory+"govway.log4j2.properties");
  339.             if(!loggerFile .exists() ){
  340.                 loggerProperties.load(OpenSPCoop2Logger.class.getResourceAsStream("/govway.log4j2.properties"));
  341.             }else{
  342.                 FileInputStream fin = null;
  343.                 try{
  344.                     fin = new java.io.FileInputStream(loggerFile);
  345.                     loggerProperties.load(fin);
  346.                 }finally{
  347.                     try{
  348.                         if(fin!=null){
  349.                             fin.close();
  350.                         }
  351.                     }catch(Exception eClose){
  352.                         // close
  353.                     }
  354.                 }
  355.             }
  356.             
  357.             if(loadExternalConfiguration){
  358.             
  359.                 loadExternal(logConsole, CostantiPdD.OPENSPCOOP2_LOGGER_PROPERTIES ,CostantiPdD.OPENSPCOOP2_LOGGER_LOCAL_PATH, 
  360.                         rootDirectory, loggerProperties, objectProperties);
  361.                 
  362.             }
  363.             
  364.             
  365.             
  366.             LoggerWrapperFactory.patchLoggers(loggerProperties, 
  367.                     org.openspcoop2.utils.Costanti.ENV_LOG_GOVWAY,
  368.                     Map.of(org.openspcoop2.utils.Costanti.VAR_LOGGER_APPNAME, APP_NAME));
  369.             
  370.             LoggerWrapperFactory.setLogConfiguration(loggerProperties);
  371.             initializeLogDirs(loggerProperties, false);
  372.             
  373.             // STARTUP CONSOLE
  374.             String tmp = loggerProperties.getProperty("logger.govway_startup.level");
  375.             if(tmp!=null){
  376.                 if(!tmp.equalsIgnoreCase("OFF")){
  377.                     OpenSPCoop2Logger.loggerOpenSPCoopConsoleStartupAgganciatoLog = true;
  378.                 }
  379.             }
  380.             
  381.             // TRACCIAMENTO
  382.             OpenSPCoop2Logger.loggerTracciamento = LoggerWrapperFactory.getLogger("govway.tracciamento");
  383.             if(OpenSPCoop2Logger.loggerTracciamento==null)
  384.                 throw new CoreException("Logger govway.tracciamento non trovato");
  385.             // Abilitazione log da Log4j
  386.             tmp = loggerProperties.getProperty("logger.govway_tracciamento.level");
  387.             if(tmp!=null){
  388.                 tmp = tmp.trim();
  389.                 if(tmp.equalsIgnoreCase("OFF")){
  390.                     OpenSPCoop2Logger.loggerOpenSPCoopConsole.info("Sistema di logging delle tracce disabilitato da log4j (OFF).");
  391.                     OpenSPCoop2Logger.loggerTracciamentoAbilitato = false;
  392.                 }
  393.                 else
  394.                     OpenSPCoop2Logger.loggerTracciamentoAbilitato = true;
  395.             }
  396.             
  397.             // MESSAGGI DIAGNOSTICI
  398.             OpenSPCoop2Logger.loggerMsgDiagnostico = LoggerWrapperFactory.getLoggerImpl("govway.msgDiagnostico");
  399.             if(OpenSPCoop2Logger.loggerMsgDiagnostico==null)
  400.                 throw new CoreException("Logger govway.msgDiagnostico non trovato");
  401.             // Abilitazione log da Log4j
  402.             tmp = loggerProperties.getProperty("logger.govway_diagnostici.level");
  403.             if(tmp!=null){
  404.                 tmp = tmp.trim();
  405.                 if(tmp.equalsIgnoreCase("OFF")){
  406.                     OpenSPCoop2Logger.loggerOpenSPCoopConsole.info("Sistema di logging dei messaggi diagnostici disabilitato da log4j (OFF).");
  407.                     OpenSPCoop2Logger.loggerMsgDiagnosticoAbilitato = false;
  408.                 }else
  409.                     OpenSPCoop2Logger.loggerMsgDiagnosticoAbilitato = true;
  410.             }
  411.             
  412.             // MESSAGGI DIAGNOSTICI LEGGIBILI
  413.             OpenSPCoop2Logger.loggerOpenSPCoop2 = LoggerWrapperFactory.getLoggerImpl("govway.portaDiDominio");
  414.             if(OpenSPCoop2Logger.loggerOpenSPCoop2==null)
  415.                 throw new CoreException("Logger govway.portaDiDominio non trovato");
  416.             // Abilitazione log da Log4j
  417.             tmp = loggerProperties.getProperty("logger.govway_portaDiDominio.level");
  418.             if(tmp!=null){
  419.                 tmp = tmp.trim();
  420.                 if(tmp.equalsIgnoreCase("OFF")){
  421.                     OpenSPCoop2Logger.loggerOpenSPCoopConsole.info("Sistema di logging dei messaggi diagnostici 'readable' disabilitato da log4j (OFF).");
  422.                     OpenSPCoop2Logger.loggerMsgDiagnosticoReadableAbilitato = false;
  423.                 }else
  424.                     OpenSPCoop2Logger.loggerMsgDiagnosticoReadableAbilitato = true;
  425.             }
  426.             
  427.             // MESSAGGI DIAGNOSTICI DELL'INTEGRATION MANAGER
  428.             OpenSPCoop2Logger.loggerIntegrationManager = LoggerWrapperFactory.getLoggerImpl("govway.integrationManager");
  429.             if(OpenSPCoop2Logger.loggerIntegrationManager==null)
  430.                 throw new CoreException("Logger govway.integrationManager non trovato");
  431.             // Abilitazione log da Log4j
  432.             tmp = loggerProperties.getProperty("logger.govway_integrationManager.level");
  433.             if(tmp!=null){
  434.                 tmp = tmp.trim();
  435.                 if(tmp.equalsIgnoreCase("OFF")){
  436.                     OpenSPCoop2Logger.loggerOpenSPCoopConsole.info("Sistema di logging dei messaggi diagnostici 'readable' per il servizio di IntegrationManager disabilitato da log4j (OFF).");
  437.                     OpenSPCoop2Logger.loggerIntegrationManagerAbilitato = false;
  438.                 }else
  439.                     OpenSPCoop2Logger.loggerIntegrationManagerAbilitato = true;
  440.             }
  441.             
  442.             // DUMP APPLICATIVO
  443.             OpenSPCoop2Logger.loggerDump = LoggerWrapperFactory.getLogger("govway.dump");
  444.             if(OpenSPCoop2Logger.loggerDump==null)
  445.                 throw new CoreException("Logger govway.dump non trovato");
  446.             // Abilitazione log da Log4j
  447.             tmp = loggerProperties.getProperty("logger.govway_dump.level");
  448.             if(tmp!=null){
  449.                 tmp = tmp.trim();
  450.                 if(tmp.equalsIgnoreCase("OFF")){
  451.                     OpenSPCoop2Logger.loggerOpenSPCoopConsole.info("Sistema di logging dei contenuti applicativi (dump) disabilitato da log4j (OFF).");
  452.                     OpenSPCoop2Logger.loggerDumpAbilitato = false;
  453.                 }
  454.                 else
  455.                     OpenSPCoop2Logger.loggerDumpAbilitato = true;
  456.             }

  458.             // OPENSPCOOP CORE
  459.             OpenSPCoop2Logger.loggerOpenSPCoopCore = LoggerWrapperFactory.getLogger("govway.core");
  460.             if(OpenSPCoop2Logger.loggerOpenSPCoopCore==null)
  461.                 throw new CoreException("Logger govway.core non trovato");
  462.             
  463.             // TIMERS LOG
  464.             OpenSPCoop2Logger.loggerOpenSPCoopTimers = LoggerWrapperFactory.getLogger("govway.timers");
  465.             if(OpenSPCoop2Logger.loggerOpenSPCoopTimers==null)
  466.                 throw new CoreException("Logger govway.timers non trovato");
  467.             
  468.             // RESOURCES LOG
  469.             OpenSPCoop2Logger.loggerOpenSPCoopResources = LoggerWrapperFactory.getLogger("govway.resources");
  470.             if(OpenSPCoop2Logger.loggerOpenSPCoopResources==null)
  471.                 throw new CoreException("Logger govway.resources non trovato");
  472.             OpenSPCoop2Logger.loggerOpenSPCoopResourcesAsLoggerImpl = LoggerWrapperFactory.getLoggerImpl("govway.resources");
  473.             if(OpenSPCoop2Logger.loggerOpenSPCoopResourcesAsLoggerImpl==null)
  474.                 throw new CoreException("Logger(Impl) govway.resources non trovato");
  475.             
  476.             // CONFIGURAZIONE SISTEMA LOG
  477.             OpenSPCoop2Logger.loggerOpenSPCoopConfigurazioneSistema = LoggerWrapperFactory.getLogger("govway.configurazioneSistema");
  478.             if(OpenSPCoop2Logger.loggerOpenSPCoopConfigurazioneSistema==null)
  479.                 throw new CoreException("Logger govway.configurazioneSistema non trovato");
  480.             
  481.             // PROXY LOG
  482.             OpenSPCoop2Logger.loggerOpenSPCoopProxy = LoggerWrapperFactory.getLogger("govway.proxy");
  483.             if(OpenSPCoop2Logger.loggerOpenSPCoopProxy==null)
  484.                 throw new CoreException("Logger govway.proxy non trovato");
  485.             
  486.             // CONNETTORI LOG
  487.             OpenSPCoop2Logger.loggerOpenSPCoopConnettori = LoggerWrapperFactory.getLogger("govway.connettori");
  488.             if(OpenSPCoop2Logger.loggerOpenSPCoopConnettori==null)
  489.                 throw new CoreException("Logger govway.connettori non trovato");
  490.                         
  491.             // RAW DATA SERVIZIO PD LOG
  492.             OpenSPCoop2Logger.loggerOpenSPCoopDumpBinarioPD = LoggerWrapperFactory.getLogger("govway.dumpBinarioPD");
  493.             if(OpenSPCoop2Logger.loggerOpenSPCoopDumpBinarioPD==null)
  494.                 throw new CoreException("Logger govway.dumpBinarioPD non trovato");
  495.             
  496.             // RAW DATA SERVIZIO PD LOG
  497.             OpenSPCoop2Logger.loggerOpenSPCoopDumpBinarioPA = LoggerWrapperFactory.getLogger("govway.dumpBinarioPA");
  498.             if(OpenSPCoop2Logger.loggerOpenSPCoopDumpBinarioPA==null)
  499.                 throw new CoreException("Logger govway.dumpBinarioPA non trovato");
  500.             
  501.             // EVENTI LOG
  502.             OpenSPCoop2Logger.loggerOpenSPCoopEventi = LoggerWrapperFactory.getLogger("govway.eventi");
  503.             if(OpenSPCoop2Logger.loggerOpenSPCoopEventi==null)
  504.                 throw new CoreException("Logger govway.eventi non trovato");
  505.             
  506.             // TRANSAZIONI LOG
  507.             OpenSPCoop2Logger.loggerOpenSPCoopTransazioni = LoggerWrapperFactory.getLogger("govway.transazioni");
  508.             if(OpenSPCoop2Logger.loggerOpenSPCoopTransazioni==null)
  509.                 throw new CoreException("Logger govway.transazioni non trovato");
  510.             
  511.             // TRANSAZIONI LOG (ERROR)
  512.             OpenSPCoop2Logger.loggerOpenSPCoopTransazioniError = LoggerWrapperFactory.getLogger("govway.transazioni.error");
  513.             if(OpenSPCoop2Logger.loggerOpenSPCoopTransazioniError==null)
  514.                 throw new CoreException("Logger govway.transazioni.error non trovato");
  515.             
  516.             // TRANSAZIONI LOG (DEVNULL)
  517.             OpenSPCoop2Logger.loggerOpenSPCoopTransazioniDevNull = LoggerWrapperFactory.getLogger("govway.transazioni.devnull");
  518.             if(OpenSPCoop2Logger.loggerOpenSPCoopTransazioniDevNull==null)
  519.                 throw new CoreException("Logger govway.transazioni.devnull non trovato");
  520.             
  521.             // TRANSAZIONI SQL LOG
  522.             OpenSPCoop2Logger.loggerOpenSPCoopTransazioniSql = LoggerWrapperFactory.getLogger("govway.transazioni.sql");
  523.             if(OpenSPCoop2Logger.loggerOpenSPCoopTransazioniSql==null)
  524.                 throw new CoreException("Logger govway.transazioni.sql non trovato");
  525.             
  526.             // TRANSAZIONI SQL LOG (ERROR)
  527.             OpenSPCoop2Logger.loggerOpenSPCoopTransazioniSqlError = LoggerWrapperFactory.getLogger("govway.transazioni.sql.error");
  528.             if(OpenSPCoop2Logger.loggerOpenSPCoopTransazioniSqlError==null)
  529.                 throw new CoreException("Logger govway.transazioni.sql.error non trovato");
  530.             
  531.             // TRANSAZIONI STATEFUL LOG
  532.             OpenSPCoop2Logger.loggerOpenSPCoopTransazioniStateful = LoggerWrapperFactory.getLogger("govway.transazioni.stateful");
  533.             if(OpenSPCoop2Logger.loggerOpenSPCoopTransazioniStateful==null)
  534.                 throw new CoreException("Logger govway.transazioni.stateful non trovato");
  535.             
  536.             // TRANSAZIONI STATEFUL LOG (ERROR)
  537.             OpenSPCoop2Logger.loggerOpenSPCoopTransazioniStatefulError = LoggerWrapperFactory.getLogger("govway.transazioni.stateful.error");
  538.             if(OpenSPCoop2Logger.loggerOpenSPCoopTransazioniStatefulError==null)
  539.                 throw new CoreException("Logger govway.transazioni.stateful.error non trovato");
  540.             
  541.             // TRANSAZIONI STATEFUL SQL LOG
  542.             OpenSPCoop2Logger.loggerOpenSPCoopTransazioniStatefulSql = LoggerWrapperFactory.getLogger("govway.transazioni.stateful.sql");
  543.             if(OpenSPCoop2Logger.loggerOpenSPCoopTransazioniStatefulSql==null)
  544.                 throw new CoreException("Logger govway.transazioni.stateful.sql non trovato");
  545.             
  546.             // TRANSAZIONI STATEFUL SQL LOG (ERROR)
  547.             OpenSPCoop2Logger.loggerOpenSPCoopTransazioniStatefulSqlError = LoggerWrapperFactory.getLogger("govway.transazioni.stateful.sql.error");
  548.             if(OpenSPCoop2Logger.loggerOpenSPCoopTransazioniStatefulSqlError==null)
  549.                 throw new CoreException("Logger govway.transazioni.stateful.sql.error non trovato");
  550.             
  551.             // TRANSAZIONI SLOW LOG
  552.             OpenSPCoop2Logger.loggerOpenSPCoopTransazioniSlowLog = LoggerWrapperFactory.getLogger("govway.transazioni.slowLog");
  553.             if(OpenSPCoop2Logger.loggerOpenSPCoopTransazioniSlowLog==null)
  554.                 throw new CoreException("Logger govway.transazioni.slowLog non trovato");
  555.             
  556.             // EVENTI LOG (ERROR)
  557.             OpenSPCoop2Logger.loggerOpenSPCoopEventiError = LoggerWrapperFactory.getLogger("govway.eventi.error");
  558.             if(OpenSPCoop2Logger.loggerOpenSPCoopEventiError==null)
  559.                 throw new CoreException("Logger govway.eventi.error non trovato");
  560.             
  561.             // FILE SYSTEM RECOVERY LOG
  562.             OpenSPCoop2Logger.loggerOpenSPCoopFileSystemRecovery = LoggerWrapperFactory.getLogger("govway.recoveryFileSystem");
  563.             if(OpenSPCoop2Logger.loggerOpenSPCoopFileSystemRecovery==null)
  564.                 throw new CoreException("Logger govway.recoveryFileSystem non trovato");
  565.             
  566.             // FILE SYSTEM RECOVERY LOG (ERROR)
  567.             OpenSPCoop2Logger.loggerOpenSPCoopFileSystemRecoveryError = LoggerWrapperFactory.getLogger("govway.recoveryFileSystem.error");
  568.             if(OpenSPCoop2Logger.loggerOpenSPCoopFileSystemRecoveryError==null)
  569.                 throw new CoreException("Logger govway.recoveryFileSystem.error non trovato");
  570.             
  571.             // FILE SYSTEM RECOVERY SQL LOG
  572.             OpenSPCoop2Logger.loggerOpenSPCoopFileSystemRecoverySql = LoggerWrapperFactory.getLogger("govway.recoveryFileSystem.sql");
  573.             if(OpenSPCoop2Logger.loggerOpenSPCoopFileSystemRecoverySql==null)
  574.                 throw new CoreException("Logger govway.recoveryFileSystem.sql non trovato");
  575.             
  576.             // FILE SYSTEM RECOVERY SQL LOG (ERROR)
  577.             OpenSPCoop2Logger.loggerOpenSPCoopFileSystemRecoverySqlError = LoggerWrapperFactory.getLogger("govway.recoveryFileSystem.sql.error");
  578.             if(OpenSPCoop2Logger.loggerOpenSPCoopFileSystemRecoverySqlError==null)
  579.                 throw new CoreException("Logger govway.recoveryFileSystem.sql.error non trovato");
  580.             
  581.             // CONTROLLO TRAFFICO LOG
  582.             OpenSPCoop2Logger.loggerOpenSPCoopControlloTraffico = LoggerWrapperFactory.getLogger("govway.controlloTraffico");
  583.             if(OpenSPCoop2Logger.loggerOpenSPCoopControlloTraffico==null)
  584.                 throw new CoreException("Logger govway.controlloTraffico non trovato");
  585.             
  586.             // CONTROLLO TRAFFICO LOG (ERROR)
  587.             OpenSPCoop2Logger.loggerOpenSPCoopControlloTrafficoError = LoggerWrapperFactory.getLogger("govway.controlloTraffico.error");
  588.             if(OpenSPCoop2Logger.loggerOpenSPCoopControlloTrafficoError==null)
  589.                 throw new CoreException("Logger govway.controlloTraffico.error non trovato");
  590.             
  591.             // CONTROLLO TRAFFICO SQL LOG
  592.             OpenSPCoop2Logger.loggerOpenSPCoopControlloTrafficoSql = LoggerWrapperFactory.getLogger("govway.controlloTraffico.sql");
  593.             if(OpenSPCoop2Logger.loggerOpenSPCoopControlloTrafficoSql==null)
  594.                 throw new CoreException("Logger govway.controlloTraffico.sql non trovato");
  595.             
  596.             // CONTROLLO TRAFFICO SQL LOG (ERROR)
  597.             OpenSPCoop2Logger.loggerOpenSPCoopControlloTrafficoSqlError = LoggerWrapperFactory.getLogger("govway.controlloTraffico.sql.error");
  598.             if(OpenSPCoop2Logger.loggerOpenSPCoopControlloTrafficoSqlError==null)
  599.                 throw new CoreException("Logger govway.controlloTraffico.sql.error non trovato");
  600.             
  601.             if(allarmiEnabled) {
  602.             
  603.                 // ALLARMI LOG
  604.                 OpenSPCoop2Logger.loggerOpenSPCoopAllarmi = LoggerWrapperFactory.getLogger("govway.controlloAllarmi");
  605.                 if(OpenSPCoop2Logger.loggerOpenSPCoopAllarmi==null)
  606.                     throw new CoreException("Logger govway.controlloAllarmi non trovato");
  607.                 
  608.                 // ALLARMI LOG (ERROR)
  609.                 OpenSPCoop2Logger.loggerOpenSPCoopAllarmiError = LoggerWrapperFactory.getLogger("govway.controlloAllarmi.error");
  610.                 if(OpenSPCoop2Logger.loggerOpenSPCoopAllarmiError==null)
  611.                     throw new CoreException("Logger govway.controlloAllarmi.error non trovato");
  612.                 
  613.                 // ALLARMI SQL LOG
  614.                 OpenSPCoop2Logger.loggerOpenSPCoopAllarmiSql = LoggerWrapperFactory.getLogger("govway.controlloAllarmi.sql");
  615.                 if(OpenSPCoop2Logger.loggerOpenSPCoopAllarmiSql==null)
  616.                     throw new CoreException("Logger govway.controlloAllarmi.sql non trovato");
  617.                 
  618.                 // ALLARMI SQL LOG (ERROR)
  619.                 OpenSPCoop2Logger.loggerOpenSPCoopAllarmiSqlError = LoggerWrapperFactory.getLogger("govway.controlloAllarmi.sql.error");
  620.                 if(OpenSPCoop2Logger.loggerOpenSPCoopAllarmiSqlError==null)
  621.                     throw new CoreException("Logger govway.controlloAllarmi.sql.error non trovato");
  622.                 
  623.             }
  624.             
  625.             // STATISTICHE LOG 'Orarie'
  626.             OpenSPCoop2Logger.loggerOpenSPCoopStatisticheOrarie = LoggerWrapperFactory.getLogger("govway.statistiche_orarie.generazione");
  627.             if(OpenSPCoop2Logger.loggerOpenSPCoopStatisticheOrarie==null)
  628.                 throw new CoreException("Logger govway.statistiche.generazione non trovato");
  629.             
  630.             // STATISTICHE LOG (ERROR) 'Orarie'
  631.             OpenSPCoop2Logger.loggerOpenSPCoopStatisticheOrarieError = LoggerWrapperFactory.getLogger("govway.statistiche_orarie.generazione.error");
  632.             if(OpenSPCoop2Logger.loggerOpenSPCoopStatisticheOrarieError==null)
  633.                 throw new CoreException("Logger govway.statistiche.generazione.error non trovato");
  634.             
  635.             // STATISTICHE SQL LOG 'Orarie'
  636.             OpenSPCoop2Logger.loggerOpenSPCoopStatisticheOrarieSql = LoggerWrapperFactory.getLogger("govway.statistiche_orarie.generazione.sql");
  637.             if(OpenSPCoop2Logger.loggerOpenSPCoopStatisticheOrarieSql==null)
  638.                 throw new CoreException("Logger govway.statistiche.generazione.sql non trovato");
  639.             
  640.             // STATISTICHE SQL LOG (ERROR) 'Orarie'
  641.             OpenSPCoop2Logger.loggerOpenSPCoopStatisticheOrarieSqlError = LoggerWrapperFactory.getLogger("govway.statistiche_orarie.generazione.sql.error");
  642.             if(OpenSPCoop2Logger.loggerOpenSPCoopStatisticheOrarieSqlError==null)
  643.                 throw new CoreException("Logger govway.statistiche.generazione.sql.error non trovato");
  644.                         
  645.             // STATISTICHE LOG 'Giornaliere'
  646.             OpenSPCoop2Logger.loggerOpenSPCoopStatisticheGiornaliere = LoggerWrapperFactory.getLogger("govway.statistiche_giornaliere.generazione");
  647.             if(OpenSPCoop2Logger.loggerOpenSPCoopStatisticheGiornaliere==null)
  648.                 throw new CoreException("Logger govway.statistiche.generazione non trovato");
  649.             
  650.             // STATISTICHE LOG (ERROR) 'Giornaliere'
  651.             OpenSPCoop2Logger.loggerOpenSPCoopStatisticheGiornaliereError = LoggerWrapperFactory.getLogger("govway.statistiche_giornaliere.generazione.error");
  652.             if(OpenSPCoop2Logger.loggerOpenSPCoopStatisticheGiornaliereError==null)
  653.                 throw new CoreException("Logger govway.statistiche.generazione.error non trovato");
  654.             
  655.             // STATISTICHE SQL LOG 'Giornaliere'
  656.             OpenSPCoop2Logger.loggerOpenSPCoopStatisticheGiornaliereSql = LoggerWrapperFactory.getLogger("govway.statistiche_giornaliere.generazione.sql");
  657.             if(OpenSPCoop2Logger.loggerOpenSPCoopStatisticheGiornaliereSql==null)
  658.                 throw new CoreException("Logger govway.statistiche.generazione.sql non trovato");
  659.             
  660.             // STATISTICHE SQL LOG (ERROR) 'Giornaliere'
  661.             OpenSPCoop2Logger.loggerOpenSPCoopStatisticheGiornaliereSqlError = LoggerWrapperFactory.getLogger("govway.statistiche_giornaliere.generazione.sql.error");
  662.             if(OpenSPCoop2Logger.loggerOpenSPCoopStatisticheGiornaliereSqlError==null)
  663.                 throw new CoreException("Logger govway.statistiche.generazione.sql.error non trovato");
  664.             
  665.             // STATISTICHE LOG 'Settimanali'
  666.             OpenSPCoop2Logger.loggerOpenSPCoopStatisticheSettimanali = LoggerWrapperFactory.getLogger("govway.statistiche_settimanali.generazione");
  667.             if(OpenSPCoop2Logger.loggerOpenSPCoopStatisticheSettimanali==null)
  668.                 throw new CoreException("Logger govway.statistiche.generazione non trovato");
  669.             
  670.             // STATISTICHE LOG (ERROR) 'Settimanali'
  671.             OpenSPCoop2Logger.loggerOpenSPCoopStatisticheSettimanaliError = LoggerWrapperFactory.getLogger("govway.statistiche_settimanali.generazione.error");
  672.             if(OpenSPCoop2Logger.loggerOpenSPCoopStatisticheSettimanaliError==null)
  673.                 throw new CoreException("Logger govway.statistiche.generazione.error non trovato");
  674.             
  675.             // STATISTICHE SQL LOG 'Settimanali'
  676.             OpenSPCoop2Logger.loggerOpenSPCoopStatisticheSettimanaliSql = LoggerWrapperFactory.getLogger("govway.statistiche_settimanali.generazione.sql");
  677.             if(OpenSPCoop2Logger.loggerOpenSPCoopStatisticheSettimanaliSql==null)
  678.                 throw new CoreException("Logger govway.statistiche.generazione.sql non trovato");
  679.             
  680.             // STATISTICHE SQL LOG (ERROR) 'Settimanali'
  681.             OpenSPCoop2Logger.loggerOpenSPCoopStatisticheSettimanaliSqlError = LoggerWrapperFactory.getLogger("govway.statistiche_settimanali.generazione.sql.error");
  682.             if(OpenSPCoop2Logger.loggerOpenSPCoopStatisticheSettimanaliSqlError==null)
  683.                 throw new CoreException("Logger govway.statistiche.generazione.sql.error non trovato");
  684.                 
  685.             // STATISTICHE LOG 'Mensili'
  686.             OpenSPCoop2Logger.loggerOpenSPCoopStatisticheMensili = LoggerWrapperFactory.getLogger("govway.statistiche_mensili.generazione");
  687.             if(OpenSPCoop2Logger.loggerOpenSPCoopStatisticheMensili==null)
  688.                 throw new CoreException("Logger govway.statistiche.generazione non trovato");
  689.             
  690.             // STATISTICHE LOG (ERROR) 'Mensili'
  691.             OpenSPCoop2Logger.loggerOpenSPCoopStatisticheMensiliError = LoggerWrapperFactory.getLogger("govway.statistiche_mensili.generazione.error");
  692.             if(OpenSPCoop2Logger.loggerOpenSPCoopStatisticheMensiliError==null)
  693.                 throw new CoreException("Logger govway.statistiche.generazione.error non trovato");
  694.             
  695.             // STATISTICHE SQL LOG 'Mensili'
  696.             OpenSPCoop2Logger.loggerOpenSPCoopStatisticheMensiliSql = LoggerWrapperFactory.getLogger("govway.statistiche_mensili.generazione.sql");
  697.             if(OpenSPCoop2Logger.loggerOpenSPCoopStatisticheMensiliSql==null)
  698.                 throw new CoreException("Logger govway.statistiche.generazione.sql non trovato");
  699.             
  700.             // STATISTICHE SQL LOG (ERROR) 'Mensili'
  701.             OpenSPCoop2Logger.loggerOpenSPCoopStatisticheMensiliSqlError = LoggerWrapperFactory.getLogger("govway.statistiche_mensili.generazione.sql.error");
  702.             if(OpenSPCoop2Logger.loggerOpenSPCoopStatisticheMensiliSqlError==null)
  703.                 throw new CoreException("Logger govway.statistiche.generazione.sql.error non trovato");

  705.             // STATISTICHE LOG 'Pdnd Generazione'
  706.             OpenSPCoop2Logger.loggerOpenSPCoopStatistichePdndGenerazione = LoggerWrapperFactory
  707.                     .getLogger("govway.statistiche_pdnd_tracciamento.generazione");
  708.             if (OpenSPCoop2Logger.loggerOpenSPCoopStatistichePdndGenerazione == null)
  709.                 throw new CoreException("Logger govway.statistiche_pdnd_tracciamento.generazione non trovato");

  711.             // STATISTICHE LOG (ERROR) 'Pdnd Generazione'
  712.             OpenSPCoop2Logger.loggerOpenSPCoopStatistichePdndGenerazioneError = LoggerWrapperFactory
  713.                     .getLogger("govway.statistiche_pdnd_tracciamento.generazione.error");
  714.             if (OpenSPCoop2Logger.loggerOpenSPCoopStatistichePdndGenerazioneError == null)
  715.                 throw new CoreException("Logger govway.statistiche_pdnd_tracciamento.generazione.error non trovato");

  717.             // STATISTICHE SQL LOG 'Pdnd Generazione'
  718.             OpenSPCoop2Logger.loggerOpenSPCoopStatistichePdndGenerazioneSql = LoggerWrapperFactory
  719.                     .getLogger("govway.statistiche_pdnd_tracciamento.generazione.sql");
  720.             if (OpenSPCoop2Logger.loggerOpenSPCoopStatistichePdndGenerazioneSql == null)
  721.                 throw new CoreException("Loggergovway.statistiche_pdnd_tracciamento.generazione.sql non trovato");

  723.             // STATISTICHE SQL LOG (ERROR) 'Pdnd Generazione'
  724.             OpenSPCoop2Logger.loggerOpenSPCoopStatistichePdndGenerazioneSqlError = LoggerWrapperFactory
  725.                     .getLogger("govway.statistiche_pdnd_tracciamento.generazione.sql.error");
  726.             if (OpenSPCoop2Logger.loggerOpenSPCoopStatistichePdndGenerazioneSqlError == null)
  727.                 throw new CoreException("Logger govway.statistiche_pdnd_tracciamento.generazione.sql.error non trovato");
  728.             
  729.             // STATISTICHE LOG 'Pdnd Pubblicazione'
  730.             OpenSPCoop2Logger.loggerOpenSPCoopStatistichePdndPubblicazione = LoggerWrapperFactory
  731.                     .getLogger("govway.statistiche_pdnd_tracciamento.pubblicazione");
  732.             if (OpenSPCoop2Logger.loggerOpenSPCoopStatistichePdndPubblicazione == null)
  733.                 throw new CoreException("Logger govway.statistiche_pdnd_tracciamento.pubblicazione non trovato");

  735.             // STATISTICHE LOG (ERROR) 'Pdnd Pubblicazione'
  736.             OpenSPCoop2Logger.loggerOpenSPCoopStatistichePdndPubblicazioneError = LoggerWrapperFactory
  737.                     .getLogger("govway.statistiche_pdnd_tracciamento.pubblicazione.error");
  738.             if (OpenSPCoop2Logger.loggerOpenSPCoopStatistichePdndPubblicazioneError == null)
  739.                 throw new CoreException("Logger govway.statistiche_pdnd_tracciamento.pubblicazione.error non trovato");

  741.             // STATISTICHE SQL LOG 'Pdnd Pubblicazione'
  742.             OpenSPCoop2Logger.loggerOpenSPCoopStatistichePdndPubblicazioneSql = LoggerWrapperFactory
  743.                     .getLogger("govway.statistiche_pdnd_tracciamento.pubblicazione.sql");
  744.             if (OpenSPCoop2Logger.loggerOpenSPCoopStatistichePdndPubblicazioneSql == null)
  745.                 throw new CoreException("Logger govway.statistiche_pdnd_tracciamento.pubblicazione.sql non trovato");

  747.             // STATISTICHE SQL LOG (ERROR) 'Pdnd Pubblicazione'
  748.             OpenSPCoop2Logger.loggerOpenSPCoopStatistichePdndPubblicazioneSqlError = LoggerWrapperFactory
  749.                     .getLogger("govway.statistiche_pdnd_tracciamento.pubblicazione.sql.error");
  750.             if (OpenSPCoop2Logger.loggerOpenSPCoopStatistichePdndPubblicazioneSqlError == null)
  751.                 throw new CoreException("Logger govway.statistiche_pdnd_tracciamento.pubblicazione.sql.error non trovato");
  752.             
  753.             // CONSEGNA_CONTENUTI LOG
  754.             OpenSPCoop2Logger.loggerOpenSPCoopConsegnaContenuti = LoggerWrapperFactory.getLogger("govway.consegna_messaggi");
  755.             if(OpenSPCoop2Logger.loggerOpenSPCoopConsegnaContenuti==null)
  756.                 throw new CoreException("Logger govway.consegna_messaggi non trovato");
  757.             
  758.             // CONSEGNA_CONTENUTI LOG (ERROR)
  759.             OpenSPCoop2Logger.loggerOpenSPCoopConsegnaContenutiError = LoggerWrapperFactory.getLogger("govway.consegna_messaggi.error");
  760.             if(OpenSPCoop2Logger.loggerOpenSPCoopConsegnaContenutiError==null)
  761.                 throw new CoreException("Logger govway.consegna_messaggi.error non trovato");
  762.             
  763.             // CONSEGNA_CONTENUTI SQL LOG
  764.             OpenSPCoop2Logger.loggerOpenSPCoopConsegnaContenutiSql = LoggerWrapperFactory.getLogger("govway.consegna_messaggi.sql");
  765.             if(OpenSPCoop2Logger.loggerOpenSPCoopConsegnaContenutiSql==null)
  766.                 throw new CoreException("Logger govway.consegna_messaggi.sql non trovato");
  767.             
  768.             // CONSEGNA_CONTENUTI SQL LOG (ERROR)
  769.             OpenSPCoop2Logger.loggerOpenSPCoopConsegnaContenutiSqlError = LoggerWrapperFactory.getLogger("govway.consegna_messaggi.sql.error");
  770.             if(OpenSPCoop2Logger.loggerOpenSPCoopConsegnaContenutiSqlError==null)
  771.                 throw new CoreException("Logger govway.consegna_messaggi.sql.error non trovato");

  773.             // PLUGINS LOG
  774.             OpenSPCoop2Logger.loggerOpenSPCoopPlugins = LoggerWrapperFactory.getLogger("govway.plugins");
  775.             if(OpenSPCoop2Logger.loggerOpenSPCoopPlugins==null)
  776.                 throw new CoreException("Logger govway.plugins non trovato");
  777.             
  778.             // PLUGINS LOG (ERROR)
  779.             OpenSPCoop2Logger.loggerOpenSPCoopPluginsError = LoggerWrapperFactory.getLogger("govway.plugins.error");
  780.             if(OpenSPCoop2Logger.loggerOpenSPCoopPluginsError==null)
  781.                 throw new CoreException("Logger govway.plugins.error non trovato");
  782.             
  783.             // PLUGINS SQL LOG
  784.             OpenSPCoop2Logger.loggerOpenSPCoopPluginsSql = LoggerWrapperFactory.getLogger("govway.plugins.sql");
  785.             if(OpenSPCoop2Logger.loggerOpenSPCoopPluginsSql==null)
  786.                 throw new CoreException("Logger govway.plugins.sql non trovato");
  787.             
  788.             // PLUGINS SQL LOG (ERROR)
  789.             OpenSPCoop2Logger.loggerOpenSPCoopPluginsSqlError = LoggerWrapperFactory.getLogger("govway.plugins.sql.error");
  790.             if(OpenSPCoop2Logger.loggerOpenSPCoopPluginsSqlError==null)
  791.                 throw new CoreException("Logger govway.plugins.sql.error non trovato");
  792.             
  793.             // GESTORE CHIAVI PDND LOG
  794.             OpenSPCoop2Logger.loggerOpenSPCoopGestoreChiaviPDND = LoggerWrapperFactory.getLogger("govway.gestoreChiaviPDND");
  795.             if(OpenSPCoop2Logger.loggerOpenSPCoopGestoreChiaviPDND==null)
  796.                 throw new CoreException("Logger govway.gestoreChiaviPDND non trovato");
  797.             
  798.             // GESTORE CHIAVI PDND LOG (ERROR)
  799.             OpenSPCoop2Logger.loggerOpenSPCoopGestoreChiaviPDNDError = LoggerWrapperFactory.getLogger("govway.gestoreChiaviPDND.error");
  800.             if(OpenSPCoop2Logger.loggerOpenSPCoopGestoreChiaviPDNDError==null)
  801.                 throw new CoreException("Logger govway.gestoreChiaviPDND.error non trovato");
  802.             
  803.             // GESTORE OPERAZIONI REMOTE LOG
  804.             OpenSPCoop2Logger.loggerOpenSPCoopGestoreOperazioniRemote = LoggerWrapperFactory.getLogger("govway.gestoreOperazioniRemote");
  805.             if(OpenSPCoop2Logger.loggerOpenSPCoopGestoreOperazioniRemote==null)
  806.                 throw new CoreException("Logger govway.gestoreOperazioniRemote non trovato");
  807.             
  808.             // GESTORE OPERAZIONI REMOTE LOG (ERROR)
  809.             OpenSPCoop2Logger.loggerOpenSPCoopGestoreOperazioniRemoteError = LoggerWrapperFactory.getLogger("govway.gestoreOperazioniRemote.error");
  810.             if(OpenSPCoop2Logger.loggerOpenSPCoopGestoreOperazioniRemoteError==null)
  811.                 throw new CoreException("Logger govway.gestoreOperazioniRemote.error non trovato");
  812.             
  813.             // CONSOLE
  814.             OpenSPCoop2Logger.loggerOpenSPCoopConsole.info("Sistema di logging correttamente inizializzato.");
  815.             
  816.             // PddContextSerializer
  817.             OpenSPCoop2Properties propertiesReader = OpenSPCoop2Properties.getInstance();
  818.             String pddContextSerializerClass = propertiesReader.getPddContextSerializer();
  819.             if(pddContextSerializerClass!=null && !CostantiConfigurazione.NONE.equals(pddContextSerializerClass)){
  820.                 try{
  821.                     OpenSPCoop2Logger.pddContextSerializer = (IPdDContextSerializer) Loader.getInstance().newInstance(pddContextSerializerClass);
  822.                 }catch(Exception e){
  823.                     throw new CoreException("Inizializzione IPdDContextSerializer non riuscita ["+pddContextSerializerClass+"]:"+e.getMessage(),e);
  824.                 }
  825.             }
  826.             
  827.             return true;
  828.         }catch(Exception e){
  829.             OpenSPCoop2Logger.loggerOpenSPCoopConsole.error("Riscontrato errore durante l'inizializzazione del sistema di logging di OpenSPCoop: "
  830.                     +e.getMessage(),e);
  831.             return false;
  832.         }
  833.     }
  834.     
  835.     private static void loadExternal(Logger logConsole, String loggerProperty, String loggerPath, String rootDirectory,
  836.             java.util.Properties loggerProperties, Properties objectProperties) {
  837.             
  838.         // File Local Implementation
  839.         CollectionProperties loggerPropertiesRidefinito =  
  840.             PropertiesUtilities.searchLocalImplementation(CostantiPdD.OPENSPCOOP2_LOCAL_HOME,logConsole, loggerProperty ,loggerPath, rootDirectory);
  841.         if(loggerPropertiesRidefinito!=null && loggerPropertiesRidefinito.size()>0){
  842.             Enumeration<?> ridefinito = loggerPropertiesRidefinito.keys();
  843.             while (ridefinito.hasMoreElements()) {
  844.                 String key = (String) ridefinito.nextElement();
  845.                 String value = loggerPropertiesRidefinito.get(key);
  846.                 if(loggerProperties.containsKey(key)){
  847.                     //Object o = 
  848.                     loggerProperties.remove(key);
  849.                 }
  850.                 loggerProperties.put(key, value);
  851.                 //System.out.println("CHECK NUOVO VALORE: "+loggerProperties.get(key));
  852.             }
  853.         }
  854.         
  855.         // File Object Implementation
  856.         if(objectProperties!=null && objectProperties.size()>0){
  857.             Enumeration<?> ridefinito = objectProperties.keys();
  858.             while (ridefinito.hasMoreElements()) {
  859.                 String key = (String) ridefinito.nextElement();
  860.                 String value = (String) objectProperties.get(key);
  861.                 if(loggerProperties.containsKey(key)){
  862.                     //Object o = 
  863.                     loggerProperties.remove(key);
  864.                 }
  865.                 loggerProperties.put(key, value);
  866.                 //System.out.println("CHECK NUOVO VALORE: "+loggerProperties.get(key));
  867.             }
  868.         }

  870.     }
  871.     
  872.     public static boolean initializeProtocolLogger(Logger logConsole, boolean loadExternalConfiguration,String rootDirectory,
  873.             Properties objectProperties) {
  874.         
  875.         try{
  876.         
  877.             ProtocolFactoryManager protocolFactoryManager = ProtocolFactoryManager.getInstance();
  878.             Enumeration<String> protocolNames = protocolFactoryManager.getProtocolNames();
  879.             while (protocolNames.hasMoreElements()) {
  880.                 String protocol = (String) protocolNames.nextElement();
  881.                 if(protocolFactoryManager.isSupportedProtocolLogger(protocol)) {
  882.                     
  883.                     java.util.Properties loggerPropertiesProtocolAdjunct = null;
  884.                     InputStream isLoggerProtocol = OpenSPCoop2Logger.class.getResourceAsStream("/govway.protocolAdjunct.log4j2.properties");
  885.                     if(isLoggerProtocol!=null){
  886.                         String content = Utilities.getAsString(isLoggerProtocol, Charset.UTF_8.getValue());
  887.                         if(content!=null) {
  888.                             content = content.replaceAll(CostantiPdD.OPENSPCOOP2_LOGGER_PROTOCOL_ID_PROTOCOLLO, protocol);
  889.                             loggerPropertiesProtocolAdjunct = new java.util.Properties();
  890.                             StringReader sr = new StringReader(content);
  891.                             loggerPropertiesProtocolAdjunct.load(sr);
  892.                             sr.close();
  893.                         }
  894.                     }
  895.                     if(loadExternalConfiguration){
  896.                         
  897.                         loadExternal(logConsole, CostantiPdD.getOpenspcoop2LoggerProtocolProperties(protocol),
  898.                                 CostantiPdD.getOpenspcoop2LoggerProtocolLocalPath(protocol) ,
  899.                                 rootDirectory, loggerPropertiesProtocolAdjunct, objectProperties);
  900.                         
  901.                     }
  902.                     logConsole.info("Protocol '"+protocol+"': Log4j config append");
  903.                     if(loggerPropertiesProtocolAdjunct!=null) {
  904.                         LoggerWrapperFactory.patchLoggers(loggerPropertiesProtocolAdjunct,  
  905.                                 org.openspcoop2.utils.Costanti.ENV_LOG_GOVWAY,
  906.                                 Map.of(org.openspcoop2.utils.Costanti.VAR_LOGGER_APPNAME, APP_NAME));
  907.                         LoggerWrapperFactory.setLogConfiguration(loggerPropertiesProtocolAdjunct,true);
  908.                         initializeLogDirs(loggerPropertiesProtocolAdjunct, true);
  909.                     }
  910.                     
  911.                     Logger log = LoggerWrapperFactory.getLogger(CostantiPdD.getOpenspcoop2LoggerFactoryName(protocol));
  912.                     protocolFactoryManager.getProtocolFactoryByName(protocol).initProtocolLogger(log);
  913.                     log.info("Inizializzazione completata");
  914.                     
  915.                 }
  916.             }
  917.             
  918.             return true;
  919.             
  920.         }catch(Exception e){
  921.             OpenSPCoop2Logger.loggerOpenSPCoopConsole.error("Riscontrato errore durante l'inizializzazione del sistema di logging di OpenSPCoop per i protocolli: "
  922.                     +e.getMessage(),e);
  923.             return false;
  924.         }
  925.     }

  927.     /**
  928.      * Il Metodo si occupa di inizializzare gli appender personalizzati di OpenSPCoop che permettono di effettuare log dei msg diagnostici senza passare da log4j
  929.      * @param msgDiagConfig Configurazione
  930.      * @return true in caso di inizializzazione con successo, false altrimenti.
  931.      */
  932.     public static boolean initializeMsgDiagnosticiOpenSPCoopAppender(MessaggiDiagnostici msgDiagConfig){
  933.         try{
  934.             // Inizializzazione msg diagnostici appender personalizzati
  935.             if(msgDiagConfig!=null){
  936.                 ClassNameProperties prop = ClassNameProperties.getInstance();
  937.                 for(int i=0; i< msgDiagConfig.sizeOpenspcoopAppenderList(); i++){

  939.                     // MsgDiagAppenderClass
  940.                     String msgDiagAppenderClass = prop.getMsgDiagnosticoOpenSPCoopAppender(msgDiagConfig.getOpenspcoopAppender(i).getTipo());
  941.                     if(msgDiagAppenderClass == null){
  942.                         throw new CoreException("Riscontrato errore durante il caricamento del msg diagnostico appender ["+msgDiagConfig.getOpenspcoopAppender(i).getTipo()+"]: appender non registrato.");
  943.                     }

  945.                     // Carico appender richiesto
  946.                     IDiagnosticProducer appender = null;
  947.                     try{
  948.                         appender = (IDiagnosticProducer) Loader.getInstance().newInstance(msgDiagAppenderClass);
  949.                         appender.initializeAppender(msgDiagConfig.getOpenspcoopAppender(i));
  950.                     }catch(ClassNotFoundException e){
  951.                         throw new CoreException("Riscontrato errore durante il caricamento del msg diagnostico appender specificato ["+msgDiagConfig.getOpenspcoopAppender(i).getTipo()+"]: "+e.getMessage());
  952.                     }catch(Exception e){
  953.                         throw new CoreException("Riscontrato errore durante l'inizializzazione del msg diagnostico appender specificato ["+msgDiagConfig.getOpenspcoopAppender(i).getTipo()+"]: "+e.getMessage());
  954.                     }
  955.                     
  956.                     // Aggiungo agli appender registrati
  957.                     OpenSPCoop2Logger.loggerMsgDiagnosticoOpenSPCoopAppender.add(appender);
  958.                     OpenSPCoop2Logger.tipoMsgDiagnosticoOpenSPCoopAppender.add(msgDiagConfig.getOpenspcoopAppender(i).getTipo());
  959.                     
  960.                     OpenSPCoop2Logger.loggerOpenSPCoopConsole.info("Sistema di logging: MsgDiagnosticoOpenSPCoopAppender di tipo ["+msgDiagConfig.getOpenspcoopAppender(i).getTipo()+"] correttamente inizializzato.");
  961.                     
  962.                 }
  963.             }
  964.             return true;
  965.         }catch(Exception e){
  966.             // Azzero gli appender personalizzati
  967.             OpenSPCoop2Logger.loggerMsgDiagnosticoOpenSPCoopAppender.clear(); 
  968.             OpenSPCoop2Logger.loggerOpenSPCoopConsole.error("Riscontrato errore durante l'inizializzazione degli appender personalizzati per msg diagnostici: "
  969.                     +e.getMessage());
  970.             return false;
  971.         }
  972.     }

  974.     
  975.     /**
  976.      * Il Metodo si occupa di inizializzare gli appender personalizzati di OpenSPCoop che permettono di effettuare log dei tracciamenti senza passare da log4j
  977.      * @param tracciamentoConfig Configurazione
  978.      * @return true in caso di inizializzazione con successo, false altrimenti.
  979.      */
  980.     public static boolean initializeTracciamentoOpenSPCoopAppender(org.openspcoop2.core.config.Tracciamento tracciamentoConfig){
  981.         try{
  982.             // Inizializzazione tracciamento appender personalizzati
  983.             if(tracciamentoConfig!=null){
  984.                 ClassNameProperties prop = ClassNameProperties.getInstance();
  985.                 for(int i=0; i< tracciamentoConfig.sizeOpenspcoopAppenderList(); i++){
  986.                     
  987.                     // Tracciamento appender class
  988.                     String tracciamentoAppenderClass = prop.getTracciamentoOpenSPCoopAppender(tracciamentoConfig.getOpenspcoopAppender(i).getTipo());
  989.                     if(tracciamentoAppenderClass == null){
  990.                         throw new CoreException("Riscontrato errore durante il caricamento del tracciamento appender ["+tracciamentoConfig.getOpenspcoopAppender(i).getTipo()+"]: appender non registrato.");
  991.                     }

  993.                     // Carico appender richiesto
  994.                     ITracciaProducer appender = null;
  995.                     try{
  996.                         appender = (ITracciaProducer) Loader.getInstance().newInstance(tracciamentoAppenderClass);
  997.                         appender.initializeAppender(tracciamentoConfig.getOpenspcoopAppender(i));
  998.                     }catch(ClassNotFoundException e){
  999.                         throw new CoreException("Riscontrato errore durante il caricamento del tracciamento appender specificato ["+tracciamentoConfig.getOpenspcoopAppender(i).getTipo()+"]: "+e.getMessage());
  1000.                     }catch(Exception e){
  1001.                         throw new CoreException("Riscontrato errore durante l'inizializzazione del tracciamento appender specificato ["+tracciamentoConfig.getOpenspcoopAppender(i).getTipo()+"]: "+e.getMessage());
  1002.                     }
  1003.                     
  1004.                     // Aggiungo agli appender registrati
  1005.                     OpenSPCoop2Logger.loggerTracciamentoOpenSPCoopAppender.add(appender);
  1006.                     OpenSPCoop2Logger.tipoTracciamentoOpenSPCoopAppender.add(tracciamentoConfig.getOpenspcoopAppender(i).getTipo());
  1007.                     
  1008.                     OpenSPCoop2Logger.loggerOpenSPCoopConsole.info("Sistema di logging: TracciamentoOpenSPCoopAppender di tipo ["+tracciamentoConfig.getOpenspcoopAppender(i).getTipo()+"] correttamente inizializzato.");
  1009.                     
  1010.                 }
  1011.             }
  1012.             return true;
  1013.         }catch(Exception e){
  1014.             // Azzero gli appender personalizzati
  1015.             OpenSPCoop2Logger.loggerTracciamentoOpenSPCoopAppender.clear(); 
  1016.             OpenSPCoop2Logger.loggerOpenSPCoopConsole.error("Riscontrato errore durante l'inizializzazione degli appender personalizzati per il tracciamento: "
  1017.                     +e.getMessage());
  1018.             return false;
  1019.         }
  1020.     }
  1021.     
  1022.     /**
  1023.      * Il Metodo si occupa di inizializzare gli appender personalizzati di OpenSPCoop che permettono di effettuare log dei dump applicativi senza passare da log4j
  1024.      * @param dumpConfig Configurazione
  1025.      * @return true in caso di inizializzazione con successo, false altrimenti.
  1026.      */
  1027.     public static boolean initializeDumpOpenSPCoopAppender(org.openspcoop2.core.config.Dump dumpConfig){
  1028.         try{
  1029.             // Inizializzazione dump appender personalizzati
  1030.             if(dumpConfig!=null){
  1031.                 ClassNameProperties prop = ClassNameProperties.getInstance();
  1032.                 for(int i=0; i< dumpConfig.sizeOpenspcoopAppenderList(); i++){
  1033.                     
  1034.                     // Dump Appender class
  1035.                     String dumpAppenderClass = prop.getDumpOpenSPCoopAppender(dumpConfig.getOpenspcoopAppender(i).getTipo());
  1036.                     if(dumpAppenderClass == null){
  1037.                         throw new CoreException("Riscontrato errore durante il caricamento del dump appender ["+dumpConfig.getOpenspcoopAppender(i).getTipo()+"]: appender non registrato.");
  1038.                     }

  1040.                     // Carico appender richiesto
  1041.                     IDumpProducer appender = null;
  1042.                     try{
  1043.                         appender = (IDumpProducer) Loader.getInstance().newInstance(dumpAppenderClass);
  1044.                         appender.initializeAppender(dumpConfig.getOpenspcoopAppender(i));
  1045.                     }catch(ClassNotFoundException e){
  1046.                         throw new CoreException("Riscontrato errore durante il caricamento del dump appender specificato ["+dumpConfig.getOpenspcoopAppender(i).getTipo()+"]: "+e.getMessage());
  1047.                     }catch(Exception e){
  1048.                         throw new CoreException("Riscontrato errore durante l'inizializzazione del dump appender specificato ["+dumpConfig.getOpenspcoopAppender(i).getTipo()+"]: "+e.getMessage());
  1049.                     }
  1050.                     
  1051.                     // Aggiungo agli appender registrati
  1052.                     OpenSPCoop2Logger.loggerDumpOpenSPCoopAppender.add(appender);
  1053.                     OpenSPCoop2Logger.tipoDumpOpenSPCoopAppender.add(dumpConfig.getOpenspcoopAppender(i).getTipo());
  1054.                     
  1055.                     OpenSPCoop2Logger.loggerOpenSPCoopConsole.info("Sistema di logging: DumpOpenSPCoopAppender di tipo ["+dumpConfig.getOpenspcoopAppender(i).getTipo()+"] correttamente inizializzato.");
  1056.                 }
  1057.             }
  1058.             return true;
  1059.         }catch(Exception e){
  1060.             // Azzero gli appender personalizzati
  1061.             OpenSPCoop2Logger.loggerDumpOpenSPCoopAppender.clear(); 
  1062.             OpenSPCoop2Logger.loggerOpenSPCoopConsole.error("Riscontrato errore durante l'inizializzazione degli appender personalizzati per il dump applicativo: "
  1063.                     +e.getMessage());
  1064.             return false;
  1065.         }
  1066.     }
  1067.     

  1069.     public static String humanReadable(MsgDiagnostico msgDiag,IProtocolFactory<?> protocolFactory){
  1070.         return humanReadable(msgDiag, null, null, 
  1071.                 null, false, null, null, null, protocolFactory);
  1072.     }
  1073.     /**
  1074.      * Trasforma il messaggio diagnostico in una forma leggibile.
  1075.      * 
  1076.      * @param msgDiag MSg diagnostico
  1077.      * @param idCorrelazioneApplicativa Identificativo di correlazione applicativa
  1078.      * @param porta Identificativo della Porta
  1079.      * @param delegata Indicazione se siamo in un contesto di porta delegata o applicativa
  1080.      * @param fruitore Fruitore
  1081.      * @param servizio Servizio
  1082.      * @param servizioApplicativo Servizio Applicativo
  1083.      * @return messaggio diagnostico in una forma leggibile.
  1084.      */
  1085.     public static String humanReadable(MsgDiagnostico msgDiag,String idCorrelazioneApplicativa,String idCorrelazioneApplicativaRisposta,
  1086.             String porta,boolean delegata,IDSoggetto fruitore,IDServizio servizio,String servizioApplicativo,IProtocolFactory<?> protocolFactory){

  1088.         String protocol = null;
  1089.         if(protocolFactory!=null) {
  1090.             protocol = protocolFactory.getProtocol();
  1091.         }
  1092.         
  1093.         boolean formatValues = false;
  1094.         if(protocol!=null) {
  1095.             formatValues = OpenSPCoop2Properties.getInstance().isRegistrazioneDiagnosticaFile_intestazione_formatValues();
  1096.         }
  1097.         
  1098.         Date gdo = msgDiag.getGdo();
  1099.         String idPorta = msgDiag.getIdSoggetto().getCodicePorta()+"."+msgDiag.getIdSoggetto().toString();
  1100.         if(formatValues) {
  1101.             try {
  1102.                 idPorta = NamingUtils.getLabelSoggetto(protocol, msgDiag.getIdSoggetto());
  1103.             }catch(Exception e) {}
  1104.         }
  1105.         String idFunzione = msgDiag.getIdFunzione();
  1106.         int valueLivello = msgDiag.getSeverita();
  1107.         String text = msgDiag.getMessaggio();
  1108.         String idBusta = msgDiag.getIdBusta();
  1109.         String codiceDiagnostico = msgDiag.getCodice();
  1110.         
  1111.         StringBuilder showMsg = new StringBuilder();
  1112.         
  1113.         if(protocol!=null) {
  1114.             String labelP = protocol;
  1115.             if(formatValues) {
  1116.                 try {
  1117.                     labelP = NamingUtils.getLabelProtocollo(protocol);
  1118.                 }catch(Exception e) {}
  1119.             }
  1120.             showMsg.append("<").append(labelP).append(">");
  1121.         }
  1122.         
  1123.         if(msgDiag.getIdTransazione()!=null) {
  1124.             if(showMsg.length()>0){
  1125.                 showMsg.append(" ");
  1126.             }
  1127.             showMsg.append(msgDiag.getIdTransazione());
  1128.         }
  1129.         
  1130.         if(OpenSPCoop2Logger.pddContextSerializer!=null){
  1131.             Map<String, String> contextSerializerParameters = OpenSPCoop2Logger.pddContextSerializer.getLoggerKeywords();
  1132.             if(contextSerializerParameters!=null && contextSerializerParameters.size()>0){
  1133.                 for (String keyword : contextSerializerParameters.keySet()) {
  1134.                     if(msgDiag.getPropertiesNames()!=null){
  1135.                         String [] propertyNames = msgDiag.getPropertiesNames();
  1136.                         for (int i = 0; i < propertyNames.length; i++) {
  1137.                             if(keyword.equals(propertyNames[i])){
  1138.                                 if(showMsg.length()>0){
  1139.                                     showMsg.append(" ");
  1140.                                 }
  1141.                                 showMsg.append(propertyNames[i]+":");
  1142.                                 showMsg.append(msgDiag.getProperty(propertyNames[i]));
  1143.                             }
  1144.                         }
  1145.                     }
  1146.                 }
  1147.             }
  1148.         }
  1149.         
  1150.         if(codiceDiagnostico!=null){
  1151.             if(showMsg.length()>0){
  1152.                 showMsg.append(" ");
  1153.             }
  1154.             showMsg.append(codiceDiagnostico);
  1155.             showMsg.append(" ");
  1156.         }
  1157.         showMsg.append(idPorta);
  1158.         showMsg.append(" ");
  1159.         showMsg.append(idFunzione);
  1160.         showMsg.append(" <");
  1161.         showMsg.append(DateBuilder.getDate_Format(gdo));
  1162.         showMsg.append("> ");
  1163.         showMsg.append("(");
  1164.         showMsg.append((LogLevels.toLog4J(valueLivello)).toString());
  1165.         showMsg.append(")");
  1166.         if(idBusta!=null){
  1167.             showMsg.append(" ID:");
  1168.             showMsg.append(idBusta);
  1169.         }
  1170.         if(idCorrelazioneApplicativa!=null){
  1171.             showMsg.append(" IDApplicativo:");
  1172.             showMsg.append(idCorrelazioneApplicativa);
  1173.         }
  1174.         if(idCorrelazioneApplicativaRisposta!=null){
  1175.             showMsg.append(" IDApplicativoRisposta:");
  1176.             showMsg.append(idCorrelazioneApplicativaRisposta);
  1177.         }
  1178.         if(porta!=null && !"".equals(porta)) {
  1179.             String labelPorta = porta;
  1180.             // E' meglio vedere esattamente il nome della PD/PA. O in alternativa levarlo proprio. Senno' le PD/PA specific come si visualizzano??
  1181. //          if(formatValues) {
  1182. //              try {
  1183. //                  org.openspcoop2.protocol.utils.PorteNamingUtils utils = new org.openspcoop2.protocol.utils.PorteNamingUtils(protocolFactory);
  1184. //                  if(delegata) {
  1185. //                      labelPorta = utils.normalizePD(porta);
  1186. //                  }
  1187. //                  else {
  1188. //                      labelPorta = utils.normalizePA(porta);
  1189. //                  }
  1190. //              }catch(Exception e) {}
  1191. //          }
  1192.             if(delegata) {
  1193.                 showMsg.append(" OUT:"+labelPorta);
  1194.             }else {
  1195.                 showMsg.append(" IN:"+labelPorta);
  1196.             }
  1197.         }
  1198.         if(servizioApplicativo!=null){
  1199.             if(formatValues) {
  1200.                 if(delegata && !CostantiPdD.SERVIZIO_APPLICATIVO_ANONIMO.equals(servizioApplicativo)) {
  1201.                     showMsg.append(" Applicativo:"+servizioApplicativo);
  1202.                 }
  1203.             }
  1204.             else {
  1205.                 showMsg.append(" SA:"+servizioApplicativo);
  1206.             }
  1207.         }
  1208.         if( fruitore!=null && fruitore.getNome()!=null ){
  1209.             showMsg.append(" FR:");
  1210.             String fruitoreLabel = fruitore.toString();
  1211.             if(formatValues) {
  1212.                 try {
  1213.                     fruitoreLabel = NamingUtils.getLabelSoggetto(protocol, fruitore);
  1214.                 }catch(Exception e) {}
  1215.             }
  1216.             showMsg.append(fruitoreLabel);
  1217.         }
  1218.         if( fruitore!=null && servizio!=null)
  1219.             showMsg.append(" -> ");
  1220.         if( servizio!=null ){
  1221.             if(servizio.getNome()!=null){
  1222.                 showMsg.append(" S:");
  1223.                 String servizioLabel = null;
  1224.                 try{
  1225.                     servizioLabel = IDServizioFactory.getInstance().getUriFromIDServizio(servizio);
  1226.                 }catch(Exception e){
  1227.                     servizioLabel = servizio.toString(false);
  1228.                 }
  1229.                 if(formatValues) {
  1230.                     try {
  1231.                         servizioLabel = NamingUtils.getLabelAccordoServizioParteSpecifica(protocol, servizio);
  1232.                     }catch(Exception e) {}
  1233.                 }
  1234.                 showMsg.append(servizioLabel);
  1235.             }else if(servizio.getSoggettoErogatore()!=null){
  1236.                 showMsg.append(" ER:");
  1237.                 String erogatoreLabel = servizio.getSoggettoErogatore().toString();
  1238.                 if(formatValues) {
  1239.                     try {
  1240.                         erogatoreLabel = NamingUtils.getLabelSoggetto(protocol, servizio.getSoggettoErogatore());
  1241.                     }catch(Exception e) {}
  1242.                 }
  1243.                 showMsg.append(erogatoreLabel);
  1244.             }
  1245.             
  1246.             if(servizio.getAzione()!=null){
  1247.                 showMsg.append(" A:");
  1248.                 showMsg.append(servizio.getAzione());
  1249.             }
  1250.         }
  1251.                 
  1252.         showMsg.append("\n");
  1253.         showMsg.append(text);
  1254.         showMsg.append("\n");

  1256.         return showMsg.toString();


  1259.     }

  1261.     public static Logger getLoggerOpenSPCoopConsole() {
  1262.         return OpenSPCoop2Logger.loggerOpenSPCoopConsole;
  1263.     }

  1265.     public static Logger getLoggerOpenSPCoopCore() {
  1266.         return OpenSPCoop2Logger.loggerOpenSPCoopCore;
  1267.     }
  1268.     
  1269.     public static Logger getLoggerOpenSPCoopTimers() {
  1270.         return OpenSPCoop2Logger.loggerOpenSPCoopTimers;
  1271.     }
  1272.     
  1273.     public static Logger getLoggerOpenSPCoopResources() {
  1274.         return OpenSPCoop2Logger.loggerOpenSPCoopResources;
  1275.     }

  1277.     public static Logger getLoggerOpenSPCoopConfigurazioneSistema() {
  1278.         return OpenSPCoop2Logger.loggerOpenSPCoopConfigurazioneSistema;
  1279.     }

  1281.     public static Logger getLoggerOpenSPCoopProxy() {
  1282.         return OpenSPCoop2Logger.loggerOpenSPCoopProxy;
  1283.     }
  1284.     
  1285.     public static Logger getLoggerOpenSPCoopConnettori() {
  1286.         return OpenSPCoop2Logger.loggerOpenSPCoopConnettori;
  1287.     }
  1288.     
  1289.     public static Logger getLoggerOpenSPCoopDumpBinarioPD() {
  1290.         return OpenSPCoop2Logger.loggerOpenSPCoopDumpBinarioPD;
  1291.     }
  1292.     
  1293.     public static Logger getLoggerOpenSPCoopDumpBinarioPA() {
  1294.         return OpenSPCoop2Logger.loggerOpenSPCoopDumpBinarioPA;
  1295.     }
  1296.     
  1297.     public static Logger getLoggerOpenSPCoopTransazioni(boolean debug) {
  1298.         if(debug) {
  1299.             return OpenSPCoop2Logger.loggerOpenSPCoopTransazioni;
  1300.         }
  1301.         else {
  1302.             return OpenSPCoop2Logger.loggerOpenSPCoopTransazioniError;
  1303.         }
  1304.     }
  1305.     public static Logger getLoggerOpenSPCoopTransazioniDevNull() {
  1306.         return OpenSPCoop2Logger.loggerOpenSPCoopTransazioniDevNull;
  1307.     }
  1308.     
  1309.     public static Logger getLoggerOpenSPCoopTransazioniSql(boolean debug) {
  1310.         if(debug) {
  1311.             return OpenSPCoop2Logger.loggerOpenSPCoopTransazioniSql;
  1312.         }
  1313.         else {
  1314.             return OpenSPCoop2Logger.loggerOpenSPCoopTransazioniSqlError;
  1315.         }
  1316.     }
  1317.     
  1318.     public static Logger getLoggerOpenSPCoopTransazioniStateful(boolean debug) {
  1319.         if(debug) {
  1320.             return OpenSPCoop2Logger.loggerOpenSPCoopTransazioniStateful;
  1321.         }
  1322.         else {
  1323.             return OpenSPCoop2Logger.loggerOpenSPCoopTransazioniStatefulError;
  1324.         }
  1325.     }
  1326.     
  1327.     public static Logger getLoggerOpenSPCoopTransazioniStatefulSql(boolean debug) {
  1328.         if(debug) {
  1329.             return OpenSPCoop2Logger.loggerOpenSPCoopTransazioniStatefulSql;
  1330.         }
  1331.         else {
  1332.             return OpenSPCoop2Logger.loggerOpenSPCoopTransazioniStatefulSqlError;
  1333.         }
  1334.     }
  1335.     
  1336.     public static Logger getLoggerOpenSPCoopTransazioniSlowLog() {
  1337.         return OpenSPCoop2Logger.loggerOpenSPCoopTransazioniSlowLog;
  1338.     }
  1339.     
  1340.     public static Logger getLoggerOpenSPCoopEventi(boolean debug) {
  1341.         if(debug) {
  1342.             return OpenSPCoop2Logger.loggerOpenSPCoopEventi;
  1343.         }
  1344.         else {
  1345.             return OpenSPCoop2Logger.loggerOpenSPCoopEventiError;
  1346.         }
  1347.     }
  1348.     
  1349.     public static Logger getLoggerOpenSPCoopFileSystemRecovery(boolean debug) {
  1350.         if(debug) {
  1351.             return OpenSPCoop2Logger.loggerOpenSPCoopFileSystemRecovery;
  1352.         }
  1353.         else {
  1354.             return OpenSPCoop2Logger.loggerOpenSPCoopFileSystemRecoveryError;
  1355.         }
  1356.     }
  1357.     
  1358.     public static Logger getLoggerOpenSPCoopFileSystemRecoverySql(boolean debug) {
  1359.         if(debug) {
  1360.             return OpenSPCoop2Logger.loggerOpenSPCoopFileSystemRecoverySql;
  1361.         }
  1362.         else {
  1363.             return OpenSPCoop2Logger.loggerOpenSPCoopFileSystemRecoverySqlError;
  1364.         }
  1365.     }
  1366.     
  1367.     public static Logger getLoggerOpenSPCoopControlloTraffico(boolean debug) {
  1368.         if(debug) {
  1369.             return OpenSPCoop2Logger.loggerOpenSPCoopControlloTraffico;
  1370.         }
  1371.         else {
  1372.             return OpenSPCoop2Logger.loggerOpenSPCoopControlloTrafficoError;
  1373.         }
  1374.     }
  1375.     
  1376.     public static Logger getLoggerOpenSPCoopControlloTrafficoSql(boolean debug) {
  1377.         if(debug) {
  1378.             return OpenSPCoop2Logger.loggerOpenSPCoopControlloTrafficoSql;
  1379.         }
  1380.         else {
  1381.             return OpenSPCoop2Logger.loggerOpenSPCoopControlloTrafficoSqlError;
  1382.         }
  1383.     }
  1384.     
  1385.     public static Logger getLoggerOpenSPCoopAllarmi(boolean debug) {
  1386.         if(debug) {
  1387.             return OpenSPCoop2Logger.loggerOpenSPCoopAllarmi;
  1388.         }
  1389.         else {
  1390.             return OpenSPCoop2Logger.loggerOpenSPCoopAllarmiError;
  1391.         }
  1392.     }
  1393.     
  1394.     public static Logger getLoggerOpenSPCoopAllarmiSql(boolean debug) {
  1395.         if(debug) {
  1396.             return OpenSPCoop2Logger.loggerOpenSPCoopAllarmiSql;
  1397.         }
  1398.         else {
  1399.             return OpenSPCoop2Logger.loggerOpenSPCoopAllarmiSqlError;
  1400.         }
  1401.     }
  1402.     
  1403.     public static Logger getLoggerOpenSPCoopStatistiche(TipoIntervalloStatistico tipoStatistica, boolean debug) {
  1404.         if(debug) {
  1405.             switch (tipoStatistica) {
  1406.             case STATISTICHE_ORARIE:
  1407.                 return OpenSPCoop2Logger.loggerOpenSPCoopStatisticheOrarie;
  1408.             case STATISTICHE_GIORNALIERE:
  1409.                 return OpenSPCoop2Logger.loggerOpenSPCoopStatisticheGiornaliere;
  1410.             case STATISTICHE_SETTIMANALI:
  1411.                 return OpenSPCoop2Logger.loggerOpenSPCoopStatisticheSettimanali;
  1412.             case STATISTICHE_MENSILI:
  1413.                 return OpenSPCoop2Logger.loggerOpenSPCoopStatisticheMensili;
  1414.             case PDND_GENERAZIONE_TRACCIAMENTO:
  1415.                 return OpenSPCoop2Logger.loggerOpenSPCoopStatistichePdndGenerazione;
  1416.             case PDND_PUBBLICAZIONE_TRACCIAMENTO:
  1417.                 return OpenSPCoop2Logger.loggerOpenSPCoopStatistichePdndPubblicazione;
  1418.             }
  1419.         }
  1420.         else {
  1421.             switch (tipoStatistica) {
  1422.             case STATISTICHE_ORARIE:
  1423.                 return OpenSPCoop2Logger.loggerOpenSPCoopStatisticheOrarieError;
  1424.             case STATISTICHE_GIORNALIERE:
  1425.                 return OpenSPCoop2Logger.loggerOpenSPCoopStatisticheGiornaliereError;
  1426.             case STATISTICHE_SETTIMANALI:
  1427.                 return OpenSPCoop2Logger.loggerOpenSPCoopStatisticheSettimanaliError;
  1428.             case STATISTICHE_MENSILI:
  1429.                 return OpenSPCoop2Logger.loggerOpenSPCoopStatisticheMensiliError;
  1430.             case PDND_GENERAZIONE_TRACCIAMENTO:
  1431.                 return OpenSPCoop2Logger.loggerOpenSPCoopStatistichePdndGenerazioneError;
  1432.             case PDND_PUBBLICAZIONE_TRACCIAMENTO:
  1433.                 return OpenSPCoop2Logger.loggerOpenSPCoopStatistichePdndPubblicazioneError;
  1434.             }
  1435.         }
  1436.         return null;
  1437.     }
  1438.     
  1439.     public static Logger getLoggerOpenSPCoopStatisticheSql(TipoIntervalloStatistico tipoStatistica, boolean debug) {
  1440.         if(debug) {
  1441.             switch (tipoStatistica) {
  1442.             case STATISTICHE_ORARIE:
  1443.                 return OpenSPCoop2Logger.loggerOpenSPCoopStatisticheOrarieSql;
  1444.             case STATISTICHE_GIORNALIERE:
  1445.                 return OpenSPCoop2Logger.loggerOpenSPCoopStatisticheGiornaliereSql;
  1446.             case STATISTICHE_SETTIMANALI:
  1447.                 return OpenSPCoop2Logger.loggerOpenSPCoopStatisticheSettimanaliSql;
  1448.             case STATISTICHE_MENSILI:
  1449.                 return OpenSPCoop2Logger.loggerOpenSPCoopStatisticheMensiliSql;
  1450.             case PDND_GENERAZIONE_TRACCIAMENTO:
  1451.                 return OpenSPCoop2Logger.loggerOpenSPCoopStatistichePdndGenerazioneSql;
  1452.             case PDND_PUBBLICAZIONE_TRACCIAMENTO:
  1453.                 return OpenSPCoop2Logger.loggerOpenSPCoopStatistichePdndPubblicazioneSql;
  1454.             }
  1455.         }
  1456.         else {
  1457.             switch (tipoStatistica) {
  1458.             case STATISTICHE_ORARIE:
  1459.                 return OpenSPCoop2Logger.loggerOpenSPCoopStatisticheOrarieSqlError;
  1460.             case STATISTICHE_GIORNALIERE:
  1461.                 return OpenSPCoop2Logger.loggerOpenSPCoopStatisticheGiornaliereSqlError;
  1462.             case STATISTICHE_SETTIMANALI:
  1463.                 return OpenSPCoop2Logger.loggerOpenSPCoopStatisticheSettimanaliSqlError;
  1464.             case STATISTICHE_MENSILI:
  1465.                 return OpenSPCoop2Logger.loggerOpenSPCoopStatisticheMensiliSqlError;
  1466.             case PDND_GENERAZIONE_TRACCIAMENTO:
  1467.                 return OpenSPCoop2Logger.loggerOpenSPCoopStatistichePdndGenerazioneSqlError;
  1468.             case PDND_PUBBLICAZIONE_TRACCIAMENTO:
  1469.                 return OpenSPCoop2Logger.loggerOpenSPCoopStatistichePdndPubblicazioneSqlError;
  1470.             }
  1471.         }
  1472.         return null;
  1473.     }
  1474.     
  1475.     public static Logger getLoggerOpenSPCoopConsegnaContenuti(boolean debug) {
  1476.         if(debug) {
  1477.             return OpenSPCoop2Logger.loggerOpenSPCoopConsegnaContenuti;
  1478.         }
  1479.         else {
  1480.             return OpenSPCoop2Logger.loggerOpenSPCoopConsegnaContenutiError;
  1481.         }
  1482.     }
  1483.     
  1484.     public static Logger getLoggerOpenSPCoopConsegnaContenutiSql(boolean debug) {
  1485.         if(debug) {
  1486.             return OpenSPCoop2Logger.loggerOpenSPCoopConsegnaContenutiSql;
  1487.         }
  1488.         else {
  1489.             return OpenSPCoop2Logger.loggerOpenSPCoopConsegnaContenutiSqlError;
  1490.         }
  1491.     }
  1492.     
  1493.     public static Logger getLoggerOpenSPCoopPlugins(boolean debug) {
  1494.         if(debug) {
  1495.             return OpenSPCoop2Logger.loggerOpenSPCoopPlugins;
  1496.         }
  1497.         else {
  1498.             return OpenSPCoop2Logger.loggerOpenSPCoopPluginsError;
  1499.         }
  1500.     }
  1501.     
  1502.     public static Logger getLoggerOpenSPCoopPluginsSql(boolean debug) {
  1503.         if(debug) {
  1504.             return OpenSPCoop2Logger.loggerOpenSPCoopPluginsSql;
  1505.         }
  1506.         else {
  1507.             return OpenSPCoop2Logger.loggerOpenSPCoopPluginsSqlError;
  1508.         }
  1509.     }
  1510.     
  1511.     public static Logger getLoggerOpenSPCoopGestoreChiaviPDND(boolean debug) {
  1512.         if(debug) {
  1513.             return OpenSPCoop2Logger.loggerOpenSPCoopGestoreChiaviPDND;
  1514.         }
  1515.         else {
  1516.             return OpenSPCoop2Logger.loggerOpenSPCoopGestoreChiaviPDNDError;
  1517.         }
  1518.     }
  1519.     
  1520.     public static Logger getLoggerOpenSPCoopGestoreOperazioniRemote(boolean debug) {
  1521.         if(debug) {
  1522.             return OpenSPCoop2Logger.loggerOpenSPCoopGestoreOperazioniRemote;
  1523.         }
  1524.         else {
  1525.             return OpenSPCoop2Logger.loggerOpenSPCoopGestoreOperazioniRemoteError;
  1526.         }
  1527.     }
  1528.     
  1529.     public static List<IDiagnosticProducer> getLoggerMsgDiagnosticoOpenSPCoopAppender() {
  1530.         return OpenSPCoop2Logger.loggerMsgDiagnosticoOpenSPCoopAppender;
  1531.     }

  1533.     public static List<String> getTipoMsgDiagnosticoOpenSPCoopAppender() {
  1534.         return OpenSPCoop2Logger.tipoMsgDiagnosticoOpenSPCoopAppender;
  1535.     }

  1537.     public static List<ITracciaProducer> getLoggerTracciamentoOpenSPCoopAppender() {
  1538.         return OpenSPCoop2Logger.loggerTracciamentoOpenSPCoopAppender;
  1539.     }

  1541.     public static List<String> getTipoTracciamentoOpenSPCoopAppender() {
  1542.         return OpenSPCoop2Logger.tipoTracciamentoOpenSPCoopAppender;
  1543.     }

  1545. }

Created with JaCoCo 0.8.8.202204050719