@Override
 @SuppressWarnings("ThrowableResultOfMethodCallIgnored")
 public synchronized String format(final LogRecord record) {
   dat.setTime(record.getMillis());
   String source;
   if (record.getSourceClassName() != null) {
     source = record.getSourceClassName();
     if (record.getSourceMethodName() != null) {
       source += "#" + record.getSourceMethodName();
     }
   } else {
     source = record.getLoggerName();
   }
   String message = formatMessage(record);
   String throwable = "";
   if (record.getThrown() != null) {
     StringWriter sw = new StringWriter();
     PrintWriter pw = new PrintWriter(sw);
     pw.println();
     record.getThrown().printStackTrace(pw);
     pw.close();
     throwable = sw.toString();
   }
   return String.format(
       FORMAT,
       dat,
       source,
       record.getLoggerName(),
       record.getLevel().getLocalizedName(),
       message,
       throwable);
 }
 @SuppressWarnings("unchecked")
 @Override
 public void publish(LogRecord record) {
   if (record.getLoggerName().endsWith("PluginExecutable")
       && record.getMessage().contains("PluginExecutable")) {
     try {
       Class<? extends IPluginExecutable> clazz =
           (Class<? extends IPluginExecutable>) Class.forName(record.getLoggerName());
       EventBus.getInstance().add(EventType.INFO, clazz, record.getSourceClassName());
     } catch (ClassNotFoundException e) {
       throw new RuntimeException(e);
     }
   }
 }
 @Override
 public void publish(final LogRecord record) {
   if (record.getLevel().intValue() < this.getLevel().intValue()
       || record.getLoggerName().equals(getClass().getName())) {
     return;
   }
   try {
     Mailer.instance()
         .send(
             (message) -> {
               message.addRecipient(
                   Message.RecipientType.TO,
                   new InternetAddress(
                       "clash.nanobot+log."
                           + record.getLevel().getName().toLowerCase()
                           + "@gmail.com"));
               message.setSubject(record.getLevel() + ": " + record.getMessage());
               String emailBody = "<table border=\"1\" cellspacing=\"0\" cellpadding=\"3\">";
               emailBody +=
                   "<tr><td>Version</td><td>" + BuildInfo.instance().getVersion() + "</td></tr>";
               emailBody +=
                   "<tr><td>BuildTime</td><td>"
                       + BuildInfo.instance().getTimestamp()
                       + "</td></tr>";
               emailBody += "<tr><td>Time</td><td>" + record.getMillis() + "</td></tr>";
               emailBody += "<tr><td>Thread</td><td>" + record.getThreadID() + "</td></tr>";
               emailBody += "<tr><td>Logger</td><td>" + record.getLoggerName() + "</td></tr>";
               emailBody += "<tr><td>Class</td><td>" + record.getSourceClassName() + "</td></tr>";
               emailBody +=
                   "<tr><td>Method</td><td>" + record.getSourceMethodName() + "</td></tr>";
               emailBody += "<tr><td>Level</td><td>" + record.getLevel() + "</td></tr>";
               emailBody += "<tr><td>Message</td><td>" + record.getMessage() + "</td></tr>";
               final Throwable e = record.getThrown();
               if (e != null) {
                 final StringWriter writer = new StringWriter();
                 e.printStackTrace(new PrintWriter(writer));
                 emailBody +=
                     "<tr><td>Exception</td><td>"
                         + writer.toString().replace("\n", "<br/>")
                         + "</td></tr>";
               }
               emailBody += "</table>";
               message.setContent(emailBody, "text/html");
             });
   } catch (final Exception e) {
     logger.log(Level.SEVERE, e.getMessage(), e);
   }
 }
Exemple #4
0
  /**
   * This method sends the LogRecord to the remote logging service.
   *
   * @param logRecord The LogRecord to be published to the remote logging service.
   */
  public synchronized void publish(java.util.logging.LogRecord logRecord) {
    logName = logRecord.getLoggerName();
    String xml = getFormatter().format(logRecord);
    if (xml == null || xml.length() <= 0) {
      if (Debug.warningEnabled()) {
        Debug.warning(logName + ":RemoteHandler.publish : formatted xml is null");
      }
      return;
    }
    Request request = new Request(xml);

    if (logRecord instanceof ILogRecord) {
      Map logInfoMap = ((ILogRecord) logRecord).getLogInfoMap();
      String loggedBySid = (String) logInfoMap.get(LogConstants.LOGGED_BY_SID);
      if (loggedBySid != null) {
        RequestSet reqSet = (RequestSet) reqSetMap.get(loggedBySid);
        if (reqSet == null) {
          reqSet = new RequestSet("Logging");
        }
        reqSet.addRequest(request);
        reqSetMap.put(loggedBySid, reqSet);
      }
    }

    this.recCount++;
    if (this.recCount >= recCountLimit) {
      if (Debug.messageEnabled()) {
        Debug.message(
            logName + ":RemoteHandler.publish(): got " + recCount + " records, flushing all");
      }
      nonBlockingFlush();
    }
  }
 public String format(LogRecord record) {
   Object[] arguments = new Object[3];
   arguments[0] = record.getLoggerName();
   arguments[1] = record.getLevel();
   arguments[2] = record.getMessage();
   return messageFormat.format(arguments);
 }
Exemple #6
0
  public synchronized String format(LogRecord record) {
    StringBuffer sb = new StringBuffer();
    date.setTime(record.getMillis() + timeDiff);
    sb.append(dFormat.format(date));
    if (isShowingThreads) {
      Thread currentThread = Thread.currentThread();
      if (currentThread != lastThread) {
        lastThread = currentThread;
        lastThreadName = currentThread.getName();
      }
      sb.append(" [").append(lastThreadName).append(']');
    }
    sb.append(' ')
        .append(record.getLevel())
        .append(' ')
        .append(getAliasFor(record.getLoggerName()))
        .append('|')
        .append(record.getMessage())
        .append(EOL);

    if (record.getThrown() != null) {
      try {
        StringWriter out = new StringWriter();
        PrintWriter pout = new PrintWriter(out);
        record.getThrown().printStackTrace(pout);
        pout.close();
        sb.append(out.toString());
      } catch (Exception e) {
        // Ignore any errors while extracting stack trace
      }
    }

    return sb.toString();
  }
  /**
   * @param record
   * @param sb
   */
  private void printSourceClassName(LogRecord record, StringBuffer sb) {
    if (record.getSourceClassName() != null) {
      sb.append(record.getSourceClassName());
    } else {
      sb.append(record.getLoggerName());
    }

    sb.append(seperator);
  }
  public String formatClass(final LogRecord record) {
    final String append = "...";
    final String[] className = record.getLoggerName().split("\\.");
    final String name = className[className.length - 1];
    final int maxLen = 16;

    return String.format(
        name.length() > maxLen ? name.substring(0, maxLen - append.length()) + append : name);
  }
Exemple #9
0
    @Override
    public void publish(final LogRecord record) {
      final String loggerName = record.getLoggerName();

      if (record.getLevel().intValue() >= logLevel
          && loggerName.startsWith("org.glassfish.jersey")
          && !loggerName.startsWith("org.glassfish.jersey.test")) {
        records.add(record);
      }
    }
        @Override
        public String format(final LogRecord record) {
          final String[] className = record.getLoggerName().split("\\.");
          final String name = className[className.length - 1];
          final int maxLen = 22;
          final String append = "...";

          return String.format(
              "[%s] %-" + maxLen + "s %s %s",
              dateFormat.format(record.getMillis()),
              name.length() > maxLen ? name.substring(0, maxLen - append.length()) + append : name,
              record.getMessage(),
              StringUtil.throwableToString(record.getThrown()));
        }
  private void logOnServer(
      LogRecord lr,
      String strongName,
      StackTraceDeobfuscator deobfuscator,
      String loggerNameOverride)
      throws RemoteLoggingServiceUtil.RemoteLoggingException {
    if (deobfuscator != null) {
      lr = deobfuscateLogRecord(deobfuscator, lr, strongName);
    }

    String loggerName = (null == loggerNameOverride) ? lr.getLoggerName() : loggerNameOverride;
    Logger log = Logger.getLogger(loggerName);
    log.log(lr);
  }
  public void publish(LogRecord record, int nLogType) {
    // first see if this entry should be filtered out
    try {
      if (record != null) {

        // MARKED by zhaoxy@20101119
        /*
           if (getFilter() != null) {
        	if (!getFilter().isLoggable(record))
        		return;
        }
        */

        if (isLoggable(record)) {
          String HmuImei = null;
          String Message = record.getMessage();
          try {
            int HmuImeiPos = Message.indexOf("HMU:");
            if (HmuImeiPos >= 0) {
              HmuImei = Message.substring(HmuImeiPos + 4);
              Message = Message.substring(0, HmuImeiPos);
            }
          } catch (Exception e) {
          }

          // now store the log entry into the table
          if (activeConnection()) {
            try {
              prepInsert.setInt(1, record.getLevel().intValue());
              prepInsert.setString(2, truncate(record.getLoggerName(), 63));
              prepInsert.setString(3, truncate(Message, 255));
              prepInsert.setLong(4, record.getSequenceNumber());
              prepInsert.setString(5, truncate(record.getSourceClassName(), 63));
              prepInsert.setString(6, truncate(record.getSourceMethodName(), 31));
              prepInsert.setInt(7, record.getThreadID());
              prepInsert.setTimestamp(8, new Timestamp(System.currentTimeMillis()));
              prepInsert.setString(9, truncate(HmuImei, 15));
              prepInsert.setInt(10, nLogType);
              prepInsert.executeUpdate();
            } catch (SQLException e) {
              System.err.println("Exception on publish(record,nLogType)." + e);
            }
          }
        }
      }
    } catch (Exception e) {
    }
  }
 private synchronized void logToFile(LogRecord record) {
   try {
     try (PrintWriter out = new PrintWriter(new FileWriter(logToFile, true))) {
       out.println(
           record.getMillis()
               + " "
               + getLogLevel(record)
               + " "
               + record.getLoggerName()
               + ": "
               + getFormattedMessage(record));
     }
   } catch (IOException e) {
     e.printStackTrace();
   }
 }
Exemple #14
0
  @Override
  public void publish(LogRecord record) {
    final Map<String, Object> map = Loggly.getMap();

    String level = "UNKN";
    if (record.getLevel().equals(Level.WARNING)) {
      level = "WARN";
    } else if (record.getLevel().equals(Level.SEVERE)) {
      level = "SEVR";
    } else if (record.getLevel().equals(Level.INFO)) {
      level = "INFO";
    } else if (record.getLevel().equals(Level.FINE)) {
      level = "FINE";
    } else if (record.getLevel().equals(Level.FINEST)) {
      level = "FNST";
    } else if (record.getLevel().equals(Level.FINER)) {
      level = "FINR";
    } else if (record.getLevel().equals(Level.CONFIG)) {
      level = "CONF";
    } else if (record.getLevel().equals(Level.OFF)) {
      level = "OFF ";
    } else if (record.getLevel().equals(Level.ALL)) {
      level = "ALL ";
    }

    // and the log message itself
    if (record.getParameters() != null && record.getParameters().length > 0) {
      java.util.Formatter formatter = new java.util.Formatter();
      formatter.format(record.getMessage(), record.getParameters());
      map.put("message", formatter.toString());
    } else {
      map.put("message", record.getMessage());
    }

    // finally, other metadata
    map.put("thread", Thread.currentThread().getName());
    map.put("loggerName", record.getLoggerName());
    map.put("level", level);

    if (record.getThrown() != null) {
      StringWriter sw = new StringWriter();
      record.getThrown().printStackTrace(new PrintWriter(sw));
      map.put("stackTrace", sw.toString());
    }

    pool.submit(new LogglySample(map));
  }
Exemple #15
0
 @Override
 public String format(final LogRecord record) {
   final StringBuilder result =
       new StringBuilder()
           .append("[")
           .append(record.getLevel().getName())
           .append("] ")
           .append(new Date(record.getMillis()))
           .append(": ")
           .append(record.getLoggerName())
           .append(": ")
           .append(record.getMessage())
           .append(StringUtil.throwableToString(record.getThrown()));
   if (appendNewLine) {
     result.append(LogFormatter.LINE_SEPARATOR);
   }
   return result.toString();
 }
  @Override
  public LogRecord deobfuscateLogRecord(LogRecord value) {
    // don't deobfuscate DevMode, there's no symbol map
    if ("HostedMode".equals(getPermutationStrongName())) {
      return value;
    }

    StackTraceDeobfuscator deobf = StackTraceDeobfuscator.fromUrl(getSymbolMapUrl());

    HttpServletRequest threadLocalRequest = getThreadLocalRequest();
    String strongName = null;
    if (threadLocalRequest != null) {
      // can be null during tests
      strongName = threadLocalRequest.getHeader(RpcRequestBuilder.STRONG_NAME_HEADER);
    }
    LogRecord newRecord = RemoteLoggingServiceUtil.deobfuscateLogRecord(deobf, value, strongName);
    Logger.getLogger(value.getLoggerName()).log(newRecord);
    return newRecord;
  }
  /*
   * @see java.util.logging.Handler#publish(java.util.logging.LogRecord)
   */
  @Override
  public synchronized void publish(final @Nullable LogRecord record) {
    if ((record == null) || !isLoggable(record)) {
      return;
    }

    final String message;
    try {
      message = formatter_.format(record);
    } catch (final Exception e) {
      reportError(null, e, ErrorManager.FORMAT_FAILURE);
      return;
    }

    final FrameworkLogEntry logEntry =
        new FrameworkLogEntry(
            record.getLoggerName(), getSeverity(record), 0, message, 0, record.getThrown(), null);
    frameworkLog_.log(logEntry);
  }
Exemple #18
0
 /** A Custom format implementation that is designed for brevity. */
 public String format(LogRecord record) {
   String loggerName = record.getLoggerName();
   if (loggerName == null) {
     loggerName = "root";
   }
   StringBuilder output =
       new StringBuilder()
           .append(calcDate(record.getMillis()))
           .append('|')
           .append(record.getLevel())
           .append('|')
           .append(Thread.currentThread().getName())
           .append('|')
           .append(loggerName)
           .append("|")
           .append(record.getMessage())
           .append(lineSep);
   return output.toString();
 }
Exemple #19
0
 /**
  * Loggable - Don't log core java classes
  *
  * @param record log record
  * @return true
  */
 public boolean isLoggable(LogRecord record) {
   if (record.getLevel() == Level.SEVERE || record.getLevel() == Level.WARNING) return true;
   //
   String loggerName = record.getLoggerName();
   if (loggerName != null) {
     //	if (loggerName.toLowerCase().indexOf("focus") != -1)
     //		return true;
     if (loggerName.startsWith("sun.")
         || loggerName.startsWith("java.awt.")
         || loggerName.startsWith("javax.")) return false;
   }
   String className = record.getSourceClassName();
   if (className != null) {
     if (className.startsWith("sun.")
         || className.startsWith("java.awt.")
         || className.startsWith("javax.")) return false;
   }
   return true;
 } //	isLoggable
  @Override
  public final String format(final LogRecord record) {

    // Create The Date Of Logging
    Date date = new Date(record.getMillis());

    // Create The Thread Of Logging
    Thread thread = Thread.currentThread();

    // Create The Name Of Logger
    String name = record.getLoggerName();

    // Create The Stack Trace
    Object[] trace = record.getParameters();

    // Create The Method Name
    Object method = trace[2];

    // Create The String For Logging
    String message =
        record.getLevel()
            + " to "
            + "STDERR"
            + " on "
            + date
            + " by "
            + name
            + " in "
            + thread
            + " at "
            + method;

    // Append The User Message
    message +=
        Preferences.sSYSPROPS_LINE_SEPR
            + record.getMessage() // The Message
            + Preferences.sSYSPROPS_LINE_SEPR
            + Preferences.sSYSPROPS_LINE_SEPR;

    // return The Final Log Message
    return message;
  }
  protected void appendPrefix(LogRecord record, StringBuilder prefix) {
    String levelName = record.getLevel().getName();
    String padding = BLANKS.substring(0, MAX_LEVEL_LENGTH - levelName.length());
    prefix.append(padding).append(levelName).append(": ");

    String loggerName = record.getLoggerName();
    if (loggerName != null) {
      prefix.append(Thread.currentThread().getName()).append(" - ");

      String loggerShortName = loggerName.substring(loggerName.lastIndexOf('.') + 1);
      prefix.append(loggerShortName);

      String methodName = record.getSourceMethodName();
      if (methodName != null) {
        prefix.append("." + methodName);
      }

      prefix.append(": ");
    }
  }
  @Override
  public String format(LogRecord r) {

    Date date = new Date(r.getMillis());
    String[] srcPkg =
        r.getSourceClassName()
            .split("\\."); // Won't work properly for sub-classes.  Who the f**k cares?

    return (date.toString()
        + "["
        + r.getLoggerName()
        + "]["
        + srcPkg[srcPkg.length - 1]
        + ":"
        + r.getSourceMethodName()
        + "]["
        + r.getLevel()
        + "]"
        + r.getMessage()
        + "\n");
  }
  /**
   * Format the given LogRecord.
   *
   * @param record the log record to be formatted.
   * @return a formatted log record
   */
  @Override
  public synchronized String format(LogRecord record) {
    StringBuffer sb = m_buffer;
    sb.setLength(0);

    m_timestamp.setTime(record.getMillis());
    String tmp = record.getSourceClassName();
    m_args[1] = tmp == null ? record.getLoggerName() : tmp;
    m_args[2] = formatMessage(record);
    s_tsFormatter.format(m_args, sb, null);

    Throwable thrown = record.getThrown();
    if (thrown != null) {
      sb.append(s_lineSeparator);
      StringWriter sw = new StringWriter();
      PrintWriter pw = new PrintWriter(sw);
      record.getThrown().printStackTrace(pw);
      pw.close();
      sb.append(sw.toString());
    }
    return sb.toString();
  }
Exemple #24
0
  /**
   * Overrides SimpleFormatter format function. Writes the output without displaying the
   * date/timestamp.
   *
   * @param iRecord The log record that needs formatted.
   * @return A string formatted for a logging message
   */
  public synchronized String format(LogRecord iRecord) {
    StringBuffer sb = new StringBuffer();

    if (iRecord.getSourceClassName() != null) {
      sb.append(iRecord.getSourceClassName());
    } else {
      sb.append(iRecord.getLoggerName());
    }
    if (iRecord.getSourceMethodName() != null) {
      sb.append(" ");
      sb.append(iRecord.getSourceMethodName());
    }
    sb.append(" ");

    String message = formatMessage(iRecord);
    sb.append(iRecord.getLevel().getLocalizedName());
    sb.append(": ");
    sb.append(message);
    sb.append(mLineSeparator);

    return sb.toString();
  }
Exemple #25
0
  /**
   * Passes a record to registered handlers, provided the record is considered as loggable both by
   * {@link #isLoggable(Level)} and a possibly installed custom {@link #setFilter(Filter) filter}.
   *
   * <p>If the logger has been configured to use parent handlers, the record will be forwarded to
   * the parent of this logger in addition to being processed by the handlers registered with this
   * logger.
   *
   * <p>The other logging methods in this class are convenience methods that merely create a new
   * LogRecord and pass it to this method. Therefore, subclasses usually just need to override this
   * single method for customizing the logging behavior.
   *
   * @param record the log record to be inspected and possibly forwarded.
   */
  public void log(LogRecord record) {
    synchronized (lock) {
      if (!isLoggable(record.getLevel())) return;

      if ((filter != null) && !filter.isLoggable(record)) return;

      /*
       * If no logger name has been set for the log record, use the name of
       * this logger.
       */
      if (record.getLoggerName() == null) record.setLoggerName(name);

      /*
       * Avoid that some other thread is changing the logger hierarchy while
       * we are traversing it.
       */
      synchronized (LogManager.getLogManager()) {
        Logger curLogger = this;

        do {
          /*
           * The Sun J2SE 1.4 reference implementation seems to call the
           * filter only for the logger whose log method is called, never
           * for any of its parents. Also, parent loggers publish log
           * record whatever their level might be. This is pretty weird,
           * but GNU Classpath tries to be as compatible as possible to
           * the reference implementation.
           */
          for (int i = 0; i < curLogger.handlers.length; i++) curLogger.handlers[i].publish(record);

          if (curLogger.getUseParentHandlers() == false) break;

          curLogger = curLogger.getParent();
        } while (parent != null);
      }
    }
  }
  public String format(LogRecord record) {
    try {
      StringBuilder sb = new StringBuilder();

      String level = "UNKN";
      if (record.getLevel().equals(Level.WARNING)) {
        level = "WARN";
      } else if (record.getLevel().equals(Level.SEVERE)) {
        level = "SEVR";
      } else if (record.getLevel().equals(Level.INFO)) {
        level = "INFO";
      } else if (record.getLevel().equals(Level.FINE)) {
        level = "FINE";
      } else if (record.getLevel().equals(Level.FINEST)) {
        level = "FNST";
      } else if (record.getLevel().equals(Level.FINER)) {
        level = "FINR";
      } else if (record.getLevel().equals(Level.CONFIG)) {
        level = "CONF";
      } else if (record.getLevel().equals(Level.OFF)) {
        level = "OFF ";
      } else if (record.getLevel().equals(Level.ALL)) {
        level = "ALL ";
      }

      sb.append(level).append(" ");

      SimpleDateFormat sdf = new SimpleDateFormat("MM/dd HH:mm:ss");
      sdf.setTimeZone(TimeZone.getTimeZone("UTC"));
      sb.append(sdf.format(new Date(record.getMillis()))).append(" ");

      String className = record.getLoggerName();
      int classNameLength = className.length();
      int before = sb.length();
      if (classNameLength > CLASS_LENGTH) {
        int index = -1;
        while (true) {
          sb.append(className.charAt(index + 1));

          int oldIndex = index;
          index = className.indexOf(".", index + 1);

          if (index == -1) {
            String str = className.substring(oldIndex + 2);
            int rem = CLASS_LENGTH - (sb.length() - before);

            if (str.length() > rem) {
              str = str.substring(0, rem - 1) + '~';
            }

            sb.append(str);

            break;
          } else {
            sb.append('.');
          }
        }
      } else {
        sb.append(className);
      }
      int after = sb.length();

      for (int i = (after - before); i <= CLASS_LENGTH - 1; i++) {
        sb.append(' ');
      }

      sb.append(" - ");
      if (record.getParameters() != null && record.getParameters().length > 0) {
        java.util.Formatter formatter = new java.util.Formatter(sb);
        formatter.format(record.getMessage(), record.getParameters());
        formatter.format("\n");
      } else {
        sb.append(record.getMessage()).append("\n");
      }

      if (record.getThrown() != null) {
        StringWriter sw = new StringWriter();
        record.getThrown().printStackTrace(new PrintWriter(sw));
        sb.append(sw.toString());
      }

      return sb.toString();
    } catch (Exception e) {
      System.err.println("*******************************************************");
      System.err.println("There was a problem formatting a log statement:");
      e.printStackTrace();
      System.err.println("We will return the raw message and print any stack now");
      System.err.println("*******************************************************");

      if (record.getThrown() != null) {
        System.err.println("Root stack trace:");
        record.getThrown().printStackTrace();
        System.err.println("*******************************************************");
      }

      return record.getMessage() + "\n";
    }
  }
Exemple #27
0
 public boolean isLoggable(LogRecord record) {
   return record.getLoggerName().equalsIgnoreCase("audit");
 }
Exemple #28
0
 @Override
 public boolean isLoggable(LogRecord record) {
   return record.getLoggerName().equalsIgnoreCase("item");
 }
Exemple #29
0
 @Nullable
 protected Logger getSLF4JLogger(@Nonnull LogRecord record) {
   final String name = record.getLoggerName();
   return logger(name != null ? name : UNKNOWN_LOGGER_NAME);
 }
Exemple #30
0
 /**
  * Check to see if the filter is in the logrecord
  *
  * @param logRecord the log record to format
  * @return boolean true if the filter exists in the logRecord
  */
 public boolean isLoggable(LogRecord logRecord) {
   return (logRecord.getLoggerName().indexOf(logFilterValue) > -1);
 }