java.nio.channels.ClosedSelectorException#org.slf4j.event.Level源码实例Demo

/**
   * 测试client重连方法不会导致重连线程失效.
   */
  @Test
  public void testClientReconnectMethod() throws RemotingException, InterruptedException{
      int port = NetUtils.getAvailablePort();
      String url = "exchange://127.0.0.3:"+port + "/client.reconnect.test?check=false&"
      +Constants.RECONNECT_KEY+"="+10 //1ms reconnect,保证有足够频率的重连
      +"&reconnect.waring.period=1";
      DubboAppender.doStart();
      Client client = Exchangers.connect(url);
      try {
	client.reconnect();
} catch (Exception e) {
	//do nothing
}
      Thread.sleep(1500);//重连线程的运行
      Assert.assertTrue("have more then one warn msgs . bug was :" + LogUtil.findMessage(Level.WARN, "client reconnect to "),LogUtil.findMessage(Level.WARN, "client reconnect to ") >1);
      DubboAppender.doStop();
  }
 

/**
 * Override this to easily change the logging level etc.
 */
protected void performLogging(Logger log, Marker marker, String logMessage) {
    if (loggingLevel == Level.INFO) {
        log.info(marker, logMessage);
    } else if (loggingLevel == Level.DEBUG) {
        log.debug(marker, logMessage);
    } else if (loggingLevel == Level.ERROR) {
        log.error(marker, logMessage);
    } else if (loggingLevel == Level.TRACE) {
        log.trace(marker, logMessage);
    } else if (loggingLevel == Level.WARN) {
        log.warn(marker, logMessage);
    } else {
        log.info(marker, logMessage);
    }
}
 

protected BaseModuleIntegTestAbstract(
            final ModuleAbstract module,
            final IntrospectionMode introspectionMode) {

    super(new LogConfig(Level.INFO,
            logPrintStream(Level.DEBUG)),

            new ModuleForTesting(
                    module,
                    new GotenbergRenderingFakeModule(),
                    new FakeCommsServiceModule()
            ).withConfigurationProperty(
                SpecificationLoader.CONFIG_PROPERTY_MODE.of(introspectionMode)
            ).withConfigurationProperty(
                "isis.services.eventbus.implementation", "axon"
            )
    );
}
 

@Override
void start() {
  log(Level.DEBUG, "Running, Ordered Queues: {}", null, queues);
  while (true) {
    try {
      String queue = getQueueToPollOrWait();
      if (queue == null) {
        return;
      }
      if (queue.equals(BLANK)) {
        TimeoutUtils.sleepLog(getPollingInterval(), false);
      } else {
        lastFetchedTime.put(queue, System.currentTimeMillis());
        QueueThread queueThread = queueNameToThread.get(queue);
        QueueDetail queueDetail = queueNameToDetail.get(queue);
        poll(-1, queue, queueDetail, queueThread);
      }
    } catch (Exception e) {
      log(Level.ERROR, "Exception in the poller {}", e, e.getMessage());
      if (shouldExit()) {
        return;
      }
    }
  }
}
 

@BeforeEach
public void init() {
	DSSDocument document = getDocumentToExtend();
	
	CertificateVerifier completeCertificateVerifier = getCompleteCertificateVerifier();
	completeCertificateVerifier.setCheckRevocationForUntrustedChains(true);
	completeCertificateVerifier.setAlertOnMissingRevocationData(new LogOnStatusAlert(Level.WARN));
	completeCertificateVerifier.setAlertOnRevokedCertificate(new LogOnStatusAlert(Level.ERROR));

	PAdESService service = new PAdESService(completeCertificateVerifier);
	service.setTspSource(getCompositeTsa());
	
	PAdESSignatureParameters signatureParameters = new PAdESSignatureParameters();
	signatureParameters.setSignatureLevel(SignatureLevel.PAdES_BASELINE_LTA);
	
	extendedDocument = service.extendDocument(document, signatureParameters);
}
 

@Override
public boolean setLogLevel(AccessContext accCtx, Level level, Level linstorLevel)
    throws AccessDeniedException
{
    accCtx.getEffectivePrivs().requirePrivileges(Privilege.PRIV_SYS_ALL);
    boolean success = true;
    if (level != null && linstorLevel != null)
    {
        success = setLogLevelImpl(level, linstorLevel);
    }
    else
    if (level != null)
    {
        success = setLogLevelImpl(level, null);
    }
    else
    if (linstorLevel != null)
    {
        success = setLogLevelImpl(null, linstorLevel);
    }
    return success;
}
 

@Override
public String reportError(
    Level logLevel,
    Throwable errorInfo,
    AccessContext accCtx,
    Peer client,
    String contextInfo
)
{
    return reportErrorImpl(logLevel, errorInfo, accCtx, client, contextInfo);
}
 

@Test
public void trace_marker_format_argSupplier1() throws Exception {
    lambdaLogger.trace(testMarker, "trace format", () -> "arg1");

    verify(lambdaLogger).doLog(eq(testMarker), eq(Level.TRACE), eq("trace format"), argSuppliersCaptor.capture(), eq(null));

    Supplier[] suppliers = argSuppliersCaptor.getValue();
    assertThat(suppliers.length).isEqualTo(1);
    assertThat(suppliers[0].get()).isEqualTo("arg1");
}
 

public Level getLevelFor(final String loggerName) {
    return loggerLevelMap.keySet().stream().
            filter(v -> loggerName.startsWith(v)).
            sorted((a, b) -> a.compareTo(b)).
            findFirst().
            map(v -> loggerLevelMap.get(v)).
            orElse(getGlobalLevel());
}
 

private Collection<LogEntry> getDbEntries(int limit, int fromLogEntryId, Level minLevel) throws SQLException {
    Collection<LogEntry> entries = new ArrayList<LogEntry>();
    SQLiteDatabase db = openDatabase();
    Cursor cursor = null;

    try {
        DefaultDBNameResolver dbNameResolver = getDbNameResolver();
        QueryBuilder qb = new QueryBuilder(dbNameResolver);
        cursor = db.rawQuery(qb.buildQuery(limit, fromLogEntryId, minLevel), new String[] {});
        while (cursor.moveToNext()) {
            LogEntry entry = new LogEntry();
            entry.setContext(0);
            entry.setId(cursor.getInt(cursor.getColumnIndex(mDbNameResolver.getColumnName(ColumnName.EVENT_ID))));
            entry.setLevel(cursor.getString(cursor.getColumnIndex(dbNameResolver.getColumnName(ColumnName.LEVEL_STRING))));
            entry.setMessage(cursor.getString(cursor.getColumnIndex(dbNameResolver.getColumnName(ColumnName.FORMATTED_MESSAGE))));
            entry.setTimestamp(cursor.getLong(cursor.getColumnIndex(dbNameResolver.getColumnName(ColumnName.TIMESTMP))));
            entry.setLoggerName(cursor.getString(cursor.getColumnIndex(dbNameResolver.getColumnName(ColumnName.LOGGER_NAME))));
            if ("ERROR".equals(entry.getLevel())) {
                entry.setStackTrace(getStackTrace(entry.getId()));
            }
            entries.add(entry);
        }
    } catch (SQLiteException e) {
        throw new SQLException("Cannot retrieve log entries", e);
    } finally {
        if (cursor != null) {
            cursor.close();
        }
        if (db != null) {
            db.close();
        }
    }

    return entries;
}
 

@Override
public String reportProblem(
    Level logLevel,
    LinStorException errorInfo,
    AccessContext accCtx,
    Peer client,
    String contextInfo
)
{
    unexpected.add(errorInfo);
    return null; // no error report, no logName
}
 

/**
 * This method will process the given DiffTask and send him to the specified
 * output.
 *
 * @param task
 *            DiffTask
 *
 * @throws ConfigurationException
 *             if problems occurred while initializing the components
 *
 * @throws IOException
 *             if problems occurred while writing the output (to file or
 *             archive)
 *
 * @throws SQLConsumerException
 *             if problems occurred while writing the output (to the sql
 *             producer database)
 */
@Override
public void process(final Task<Diff> task)
	throws ConfigurationException, IOException, SQLConsumerException
{

	long startTime = System.currentTimeMillis();

	TaskTypes type = task.getTaskType();

	if (type == TaskTypes.TASK_FULL || type == TaskTypes.TASK_PARTIAL_FIRST) {

		this.sqlEncoder.init();
		this.processingTimeSQL = 0;
	}

	super.process(task);

	this.processingTimeSQL += System.currentTimeMillis() - startTime;

	if (type == TaskTypes.TASK_FULL || type == TaskTypes.TASK_PARTIAL_LAST) {

		ArticleInformation info = task.getHeader();
		info.setEncodedSize(this.sqlEncoder.getEncodedSize());
		info.setEncodedSQLSize(this.sqlEncoder.getEncodedSQLSize());
		info.setExitingTime(System.currentTimeMillis());
		info.setProcessingTimeSQL(processingTimeSQL);

		String succesReport = info.toString();
		// System.out.println(succesReport);
		this.outputLogger.logMessage(Level.INFO, "\r\n" + succesReport);
	}
}
 

@Test
public void debugTest2() {
    TransformationTemplate transformationTemplate = getNewTestTransformationTemplate();
    assertEquals(transformationTemplate.getUtilities().size(), 0);
    transformationTemplate.debug("test {}", "ATT");
    assertEquals(transformationTemplate.getUtilities().size(), 1);
    Log log = (Log) transformationTemplate.getUtilities().get(0);

    assertEquals(log.getLogLevel(), Level.DEBUG);
    assertEquals(log.getLogMessage(), "test {}");
    assertEquals(log.getAttributeNames(), new String[]{"ATT"});
}
 

public void setDebugMode(boolean on) {
    if(on) {
        setLoggerLevel("com.paypal.butterfly", Level.DEBUG);
    } else {
        setLoggerLevel("com.paypal.butterfly", Level.INFO);
    }
}
 

/**
 * Logs an RPC call detailed message containing full request/response + headers. The level chosen
 * will depend on the response status (OK=DEBUG, FAILURE=INFO). Also checks if the logger is
 * enabled for the RPC status and logger configuration before computing message params.
 */
private void logDetail(
    Status responseStatus,
    MethodDescriptor method,
    ImmutableMap<String, String> requestHeaders,
    String endpoint,
    Object request,
    Metadata responseHeaders,
    Metadata responseTrailers,
    Object response) {
  Level level = getDetailLevel(responseStatus);
  if (requestLogger.isDetailEnabled(level)) {
    String methodName = getMethodName(method);
    boolean isSuccess = isSuccess(responseStatus);
    Event.Detail event =
        Event.Detail.builder()
            .setResponseStatus(responseStatus)
            .setSuccess(isSuccess)
            .setMethodName(methodName)
            .setRawRequestHeaders(requestHeaders)
            .setScrubbedRequestHeaders(scrubbedRequestHeaders)
            .setEndpoint(endpoint)
            .setRequest(request)
            .setResponseHeaderMetadata(responseHeaders)
            .setResponseTrailerMetadata(responseTrailers)
            .setResponse(response)
            .build();
    requestLogger.logDetail(level, event);
  }
}
 

private String getQueueToPollOrWait() {
  String queueToPoll = getQueueToPoll();
  if (queueToPoll == null) {
    if (shouldExit()) {
      return null;
    }
    queueToPoll = "";
  }
  log(Level.DEBUG, "Queue to be poll : {}", null, queueToPoll);
  return queueToPoll;
}
 

/**
 * check if log level is enabled in the underlying logger
 *
 * @param underlyingLogger real Slf4j Logger implementation
 * @param logLevel log level
 * @param marker marker
 * @return true if log level is enabled or false.
 */
public static boolean isLogLevelEnabled(Logger underlyingLogger, Level logLevel, Marker marker) {
    switch (logLevel) {
        case TRACE:
            if (marker == null) {
                return underlyingLogger.isTraceEnabled();
            }
            return underlyingLogger.isTraceEnabled(marker);
        case DEBUG:
            if (marker == null) {
                return underlyingLogger.isDebugEnabled();
            }
            return underlyingLogger.isDebugEnabled(marker);
        case INFO:
            if (marker == null) {
                return underlyingLogger.isInfoEnabled();
            }
            return underlyingLogger.isInfoEnabled(marker);
        case WARN:
            if (marker == null) {
                return underlyingLogger.isWarnEnabled();
            }
            return underlyingLogger.isWarnEnabled(marker);
        case ERROR:
            if (marker == null) {
                return underlyingLogger.isErrorEnabled();
            }
            return underlyingLogger.isErrorEnabled(marker);
        default:
            break;
    }
    return false;
}
 

@Test
public void iToLogSingleTest() {
    log.error("This is an error",iToLog);

    assertEquals(entries.toString(),1,entries.size());
    JsonTestUtils.assertJsonMessage(entries,0);
    assertMessage(entries,0,Level.ERROR,"{\"message\":\"This is an error\",\"userName\":\"Test User\",\"tenantId\":\"TEST_TENANT\"}", false);
}
 

/**
 * Logs the occurance of an TaskOutOfMemoryError while reading a revision
 * task.
 *
 * @param logger
 *            reference to the logger
 * @param task
 *            reference to the revision task
 * @param e
 *            reference to the error
 */
public static void logReadTaskOutOfMemoryError(final Logger logger,
		final Task<Revision> task, final OutOfMemoryError e)
{

	if (task != null) {
		logger.logError(Level.WARN, "Error while reading a task: "
				+ task.toString(), e);
	}
	else {
		logger.logError(Level.WARN,
				"Error while reading an unknown task", e);
	}
}
 

@Override
public void run() {
  try {
    start();
  } catch (Exception e) {
    log(Level.ERROR, "Failed {}", e, e.getMessage());
  }
}
 

@Test
public void info_msgSupplier_throwable() throws Exception {
    lambdaLogger.info(() -> "info message sup", testException);

    verify(lambdaLogger).doLog(eq(null), eq(Level.INFO), msgSupplierCaptor.capture(), eq(testException));

    assertThat(msgSupplierCaptor.getValue().get()).isEqualTo("info message sup");
}
 

@Test
public void singleKeyNullValueTest() {
    log.error("This is an error","user",null);

    assertEquals(entries.toString(),1,entries.size());
    JsonTestUtils.assertJsonMessage(entries,0);
    assertMessage(entries,0,Level.ERROR,"{\"message\":\"This is an error\",\"user\":null}",false);
}
 

public boolean checkUserPassword(final ServerSession session, final String user, final String pwd) {
	final StringBuilder sb = new StringBuilder(40);
	boolean traceInfo = false;
	boolean authOk = false;
	try {
		if (!isEnabledUser(user)) {
			sb.append("[user disabled]");
			return authOk;
		}
		final String value = getValue(user, PROP_PWD);
		if (value == null) {
			sb.append("[no password]");
			return authOk;
		}
		final boolean isCrypted = PasswordEncrypt.isCrypted(value);
		authOk = isCrypted ? PasswordEncrypt.checkPassword(value, pwd) : value.equals(pwd);
		if (!isCrypted) {
			sb.append("[config-unencrypted]");
		}
		traceInfo = isCrypted;
	} finally {
		sb.append("[").append(authOk ? "OK" : "FAIL").append("]");
		if (authOk) {
			logger.authPasswordPostLogin(session, user, (traceInfo ? Level.INFO : Level.WARN), sb.toString());
		} else {
			logger.authPasswordPostLogin(session, user, Level.ERROR, sb.toString());
		}
	}
	return authOk;
}
 

@Test
public void doLog_format_arguments_enabled_args_null() throws Exception {
    when(underlyingLogger.isWarnEnabled(testMarker)).thenReturn(true);

    lambdaLogger.doLog(testMarker, Level.WARN, "message format", null, testException);

    verify(underlyingLogger, times(1)).warn(eq(testMarker), eq("message format"), eq(testException));
}
 

private ResponseEntity<Map<String, Object>> handleError(HttpServletRequest request,
                                                        HttpStatus status, Throwable ex, Level logLevel) {
  String message = ex.getMessage();
  printLog(message, ex, logLevel);

  Map<String, Object> errorAttributes = new HashMap<>();
  boolean errorHandled = false;

  if (ex instanceof HttpStatusCodeException) {
    try {
      //try to extract the original error info if it is thrown from apollo programs, e.g. admin service
      errorAttributes = gson.fromJson(((HttpStatusCodeException) ex).getResponseBodyAsString(), mapType);
      status = ((HttpStatusCodeException) ex).getStatusCode();
      errorHandled = true;
    } catch (Throwable th) {
      //ignore
    }
  }

  if (!errorHandled) {
    errorAttributes.put("status", status.value());
    errorAttributes.put("message", message);
    errorAttributes.put("timestamp",
        LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_DATE_TIME));
    errorAttributes.put("exception", ex.getClass().getName());

  }

  HttpHeaders headers = new HttpHeaders();
  headers.setContentType(MediaType.APPLICATION_JSON_UTF8);
  return new ResponseEntity<>(errorAttributes, headers, status);
}
 

default void info(Marker marker, String format, Object arg1, Object arg2) {
    doLog(marker, Level.INFO, format, new Object[]{arg1, arg2}, null);
}
 

@Override
public void info(final String message) {
    log(Level.INFO, null, message, null);
}
 

@Override
public void warn(String msg) {
    entries.add(new LogEntry(Level.WARN,msg,Optional.empty()));
}
 

public static void isTrue(boolean expression, int code, String message, Level logLevel) {
    HyenaAssert.isTrue(expression, code, message, logLevel, HyenaStatusException.class);
}
 

@Test
public void info_format_arg() throws Exception {
    lambdaLogger.info("info format {}", "arg 1");

    verify(lambdaLogger).doLog(null, Level.INFO, "info format {}", new Object[]{"arg 1"}, null);
}