docs: @Override
      public synchronized void update(LogProviderConfig config) {
          LogProviderConfigImpl trConfig = (LogProviderConfigImpl) config;
          logHeader = trConfig.getLogHeader();
          javaLangInstrument = trConfig.hasJavaLangInstrument();
          consoleLogLevel = trConfig.getConsoleLogLevel();
          copySystemStreams = trConfig.copySystemStreams();
          hideMessageids = trConfig.getMessagesToHide();
          //add hideMessageIds to log header, only for default logging, since for binary logging, the messages will be only hidden in console.log.
          //This is printed when its configured in bootstrap.properties
          if (hideMessageids.size() > 0 && !isHpelEnabled) {
              logHeader = logHeader.concat("Suppressed message ids: " + hideMessageids).concat((LoggingConstants.nl));
          }
          if (formatter == null || trConfig.getTraceFormat() != formatter.getTraceFormat()) {
              formatter = new BaseTraceFormatter(trConfig.getTraceFormat());
          }
  
          //Gets the configured boolean value to determine if the date and time should be in ISO-8601 format
          isoDateFormat = trConfig.getIsoDateFormat();
          if (isoDateFormat != BaseTraceFormatter.useIsoDateFormat) {
              BaseTraceFormatter.useIsoDateFormat = isoDateFormat;
          }
  
          initializeWriters(trConfig);
          if (hideMessageids.size() > 0) {
              String msgKey = isHpelEnabled ? "MESSAGES_CONFIGURED_HIDDEN_HPEL" : "MESSAGES_CONFIGURED_HIDDEN_2";
              Tr.info(TraceSpecification.getTc(), msgKey, new Object[] { hideMessageids });
          }
  
          /*
           * Need to know the values of wlpServerName and wlpUserDir
           * They are passed into the handlers for use as part of the jsonified output
           */
          serverName = trConfig.getServerName();
          wlpUserDir = trConfig.getWlpUsrDir();
  
          //Retrieve collectormgrPiplineUtils
          if (collectorMgrPipelineUtils == null) {
              collectorMgrPipelineUtils = CollectorManagerPipelineUtils.getInstance();
          }
  
          //Sources
          logSource = collectorMgrPipelineUtils.getLogSource();
          traceSource = collectorMgrPipelineUtils.getTraceSource();
  
          //Conduits
          logConduit = collectorMgrPipelineUtils.getLogConduit();
          traceConduit = collectorMgrPipelineUtils.getTraceConduit();
  
          /*
           * Retrieve the format setting for message.log and console
           */
          String messageFormat = trConfig.getMessageFormat();
          String consoleFormat = trConfig.getConsoleFormat();
  
          //Retrieve the source lists of both message and console
          List<String> messageSourceList = new ArrayList<String>(trConfig.getMessageSource());
          List<String> consoleSourceList = new ArrayList<String>(trConfig.getConsoleSource());
  
          /*
           * Filter out Message and Trace from messageSourceList
           * This is so that Handler doesn't 'subscribe' message or trace
           * and kicks off an undesired BufferManagerImpl instance.
           */
          List<String> filterdMessageSourceList = filterSourcelist(messageSourceList);
          List<String> filterdConsoleSourceList = filterSourcelist(consoleSourceList);
  
          /*
           * Create the MessageLogHandler and ConsoleLogHandler if they do not exist yet.
           * If we do not then they will not be appropriately registered with CollectorManager
           * when the CollectorManagerConfigurator is registering services. The consequence is that
           * if the user wishes to switch to 'json' messages or console at a later time (other than
           * startup) they will not be able to subscribe to accessLog and ffdc sources.
           */
          if (messageLogHandler == null && messagesLog != null) {
              messageLogHandler = new MessageLogHandler(serverName, wlpUserDir, filterdMessageSourceList);
              collectorMgrPipelineUtils.setMessageHandler(messageLogHandler);
              messageLogHandler.setWriter(messagesLog);
          }
  
          if (consoleLogHandler == null) {
              consoleLogHandler = new ConsoleLogHandler(serverName, wlpUserDir, filterdConsoleSourceList);
              collectorMgrPipelineUtils.setConsoleHandler(consoleLogHandler);
              consoleLogHandler.setWriter(systemOut, systemErr);
              consoleLogHandler.setBaseTraceService(this);
          }
  
          commonMessageLogHandlerUpdates();
          commonConsoleLogHandlerUpdates();
  
          /*
           * If messageFormat has been configured to 'basic' - ensure that we are not connecting conduits/bufferManagers to the handler
           * otherwise we would have the undesired effect of writing both 'basic' and 'json' formatted message events
           */
          if (messageFormat.toLowerCase().equals(LoggingConstants.DEFAULT_MESSAGE_FORMAT)) {
              if (messageLogHandler != null) {
                  messageLogHandler.setFormat(LoggingConstants.DEFAULT_MESSAGE_FORMAT);
                  messageLogHandler.modified(new ArrayList<String>());
                  ArrayList<String> filteredList = new ArrayList<String>();
                  filteredList.add(LoggingConstants.DEFAULT_CONSOLE_SOURCE);
                  updateConduitSyncHandlerConnection(filteredList, messageLogHandler);
              }
          }
  
          /*
           * If consoleFormat has been configured to 'basic' - ensure that we are not connecting conduits/bufferManagers to the handler
           * otherwise we would have the undesired effect of writing both 'basic' and 'json' formatted message events
           */
          if (consoleFormat.toLowerCase().equals(LoggingConstants.DEFAULT_CONSOLE_FORMAT)) {
              if (consoleLogHandler != null) {
                  consoleLogHandler.setFormat(LoggingConstants.DEFAULT_CONSOLE_FORMAT);
                  ArrayList<String> filteredList = new ArrayList<String>();
                  filteredList.add(LoggingConstants.DEFAULT_CONSOLE_SOURCE);
                  if (traceLog == systemOut) {
                      filteredList.add(LoggingConstants.DEFAULT_TRACE_SOURCE);
                      consoleLogHandler.setTraceStdout(true);
                  } else {
                      consoleLogHandler.setTraceStdout(false);
                  }
                  consoleLogHandler.modified(new ArrayList<String>());
                  updateConduitSyncHandlerConnection(filteredList, consoleLogHandler);
              }
          }
  
          /*
           * If messageFormat has been configured to 'json', create the messageLogHandler as necessary or
           * call modified as necessary, provide it to the collectorMgrPipleLinUtils as necessary and set the
           * messageJsonConfigured flag as appropriate and update the connection between the unique message
           * and trace conduits to the handler.
           */
          if (messageFormat.toLowerCase().equals(LoggingConstants.JSON_FORMAT)) {
              if (messageLogHandler != null) {
                  messageLogHandler.setFormat(LoggingConstants.JSON_FORMAT);
                  //Connect the conduits to the handler as necessary
                  messageLogHandler.modified(filterdMessageSourceList);
                  updateConduitSyncHandlerConnection(messageSourceList, messageLogHandler);
              }
  
          }
  
          /*
           * If consoleFormat has been configured to 'json', create the consoleLogHandler as necessary or
           * call modified as necessary, provide it to the collectorMgrPipleLinUtils as necessary and set the
           * consoleJsonConfigured flag as appropriate and update the connection between the unique message
           * and trace conduits to the handler.
           */
          if (consoleFormat.toLowerCase().equals(LoggingConstants.JSON_FORMAT)) {
              if (consoleLogHandler != null) {
                  consoleLogHandler.setFormat(LoggingConstants.JSON_FORMAT);
                  //Connect the conduits to the handler as necessary
                  //if json && messages, trace sourcelist
                  consoleLogHandler.modified(filterdConsoleSourceList);
                  updateConduitSyncHandlerConnection(consoleSourceList, consoleLogHandler);
              }
          }
      }