src/java.net.http/share/classes/jdk/internal/net/http/common/DebugLogger.java
changeset 49944 4690a2871b44
parent 49765 ee6f7a61f3a5
child 56507 2294c51eae30
equal deleted inserted replaced
49943:8e1ed2a15845 49944:4690a2871b44
    50     final static String WS_NAME  = "jdk.internal.httpclient.websocket.debug";
    50     final static String WS_NAME  = "jdk.internal.httpclient.websocket.debug";
    51     final static String HPACK_NAME = "jdk.internal.httpclient.hpack.debug";
    51     final static String HPACK_NAME = "jdk.internal.httpclient.hpack.debug";
    52     final static System.Logger HTTP = System.getLogger(HTTP_NAME);
    52     final static System.Logger HTTP = System.getLogger(HTTP_NAME);
    53     final static System.Logger WS = System.getLogger(WS_NAME);
    53     final static System.Logger WS = System.getLogger(WS_NAME);
    54     final static System.Logger HPACK = System.getLogger(HPACK_NAME);
    54     final static System.Logger HPACK = System.getLogger(HPACK_NAME);
       
    55     private static final DebugLogger NO_HTTP_LOGGER =
       
    56             new DebugLogger(HTTP, "HTTP"::toString, Level.OFF, Level.OFF);
       
    57     private static final DebugLogger NO_WS_LOGGER =
       
    58             new DebugLogger(HTTP, "WS"::toString, Level.OFF, Level.OFF);
       
    59     private static final DebugLogger NO_HPACK_LOGGER =
       
    60             new DebugLogger(HTTP, "HPACK"::toString, Level.OFF, Level.OFF);
    55     final static long START_NANOS = System.nanoTime();
    61     final static long START_NANOS = System.nanoTime();
    56 
    62 
    57     private final Supplier<String> dbgTag;
    63     private final Supplier<String> dbgTag;
    58     private final Level errLevel;
    64     private final Level errLevel;
    59     private final Level outLevel;
    65     private final Level outLevel;
   110     public String getName() {
   116     public String getName() {
   111         return logger.getName();
   117         return logger.getName();
   112     }
   118     }
   113 
   119 
   114     private boolean isEnabled(Level level) {
   120     private boolean isEnabled(Level level) {
       
   121         return levelEnabledFor(level, outLevel, errLevel, logger);
       
   122     }
       
   123 
       
   124     @Override
       
   125     public final boolean on() {
       
   126         return debugOn;
       
   127     }
       
   128 
       
   129     static boolean levelEnabledFor(Level level, Level outLevel, Level errLevel,
       
   130                                    System.Logger logger) {
   115         if (level == Level.OFF) return false;
   131         if (level == Level.OFF) return false;
   116         int severity = level.getSeverity();
   132         int severity = level.getSeverity();
   117         return severity >= errLevel.getSeverity()
   133         return severity >= errLevel.getSeverity()
   118                 || severity >= outLevel.getSeverity()
   134                 || severity >= outLevel.getSeverity()
   119                 || logger.isLoggable(level);
   135                 || logger.isLoggable(level);
   120     }
       
   121 
       
   122     @Override
       
   123     public final boolean on() {
       
   124         return debugOn;
       
   125     }
   136     }
   126 
   137 
   127     @Override
   138     @Override
   128     public boolean isLoggable(Level level) {
   139     public boolean isLoggable(Level level) {
   129         // fast path, we assume these guys never change.
   140         // fast path, we assume these guys never change.
   249     }
   260     }
   250 
   261 
   251     public static DebugLogger createHttpLogger(Supplier<String> dbgTag,
   262     public static DebugLogger createHttpLogger(Supplier<String> dbgTag,
   252                                                Level outLevel,
   263                                                Level outLevel,
   253                                                Level errLevel) {
   264                                                Level errLevel) {
   254         return new DebugLogger(HTTP, dbgTag, outLevel, errLevel);
   265         if (levelEnabledFor(Level.DEBUG, outLevel, errLevel, HTTP)) {
       
   266             return new DebugLogger(HTTP, dbgTag, outLevel, errLevel);
       
   267         } else {
       
   268             // return a shared instance if debug logging is not enabled.
       
   269             return NO_HTTP_LOGGER;
       
   270         }
   255     }
   271     }
   256 
   272 
   257     public static DebugLogger createWebSocketLogger(Supplier<String> dbgTag,
   273     public static DebugLogger createWebSocketLogger(Supplier<String> dbgTag,
   258                                                     Level outLevel,
   274                                                     Level outLevel,
   259                                                     Level errLevel) {
   275                                                     Level errLevel) {
   260         return new DebugLogger(WS, dbgTag, outLevel, errLevel);
   276         if (levelEnabledFor(Level.DEBUG, outLevel, errLevel, WS)) {
       
   277             return new DebugLogger(WS, dbgTag, outLevel, errLevel);
       
   278         } else {
       
   279             // return a shared instance if logging is not enabled.
       
   280             return NO_WS_LOGGER;
       
   281         }
   261     }
   282     }
   262 
   283 
   263     public static DebugLogger createHpackLogger(Supplier<String> dbgTag,
   284     public static DebugLogger createHpackLogger(Supplier<String> dbgTag,
   264                                                 Level outLevel,
   285                                                 Level outLevel,
   265                                                 Level errLevel) {
   286                                                 Level errLevel) {
   266         return new DebugLogger(HPACK, dbgTag, outLevel, errLevel);
   287         if (levelEnabledFor(Level.DEBUG, outLevel, errLevel, HPACK)) {
       
   288             return new DebugLogger(HPACK, dbgTag, outLevel, errLevel);
       
   289         } else {
       
   290             // return a shared instance if logging is not enabled.
       
   291             return NO_HPACK_LOGGER;
       
   292         }
   267     }
   293     }
   268 }
   294 }