tdlight-team/TDLightTelegramBots
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge pull request #60 from rubenlagus/dev

Browse Source 
Added logger
This commit is contained in:
Ruben Bermudez 2016-05-01 22:55:33 +02:00
commit 38d3a046ff
2 changed files with 371 additions and 7 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

355
src/main/java/org/telegram/telegrambots/BotLogger.java Normal file
View File

@ -0,0 +1,355 @@
package org.telegram.telegrambots;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.time.LocalDateTime;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
* @author Ruben Bermudez
* @version 2.0
* @brief Logger to file
* @date 21/01/15
*/
public class BotLogger {
private static final Object lockToWrite = new Object();
private static final String pathToLogs = "./";
private static final Logger logger = Logger.getLogger("Telegram Bots Api");
private static final ConcurrentLinkedQueue<String> logsToFile = new ConcurrentLinkedQueue<>();
private static volatile PrintWriter logginFile;
private static volatile String currentFileName;
private static volatile LocalDateTime lastFileDate;
private static LoggerThread loggerThread = new LoggerThread();
static {
logger.setLevel(Level.OFF);
loggerThread.start();
lastFileDate = LocalDateTime.now();
if ((currentFileName == null) || (currentFileName.compareTo("") == 0)) {
currentFileName = pathToLogs + dateFormatterForFileName(lastFileDate) + ".log";
try {
final File file = new File(currentFileName);
if (file.exists()) {
logginFile = new PrintWriter(new BufferedWriter(new FileWriter(currentFileName, true)));
} else {
final boolean created = file.createNewFile();
if (created) {
logginFile = new PrintWriter(new BufferedWriter(new FileWriter(currentFileName, true)));
} else {
throw new NullPointerException("File for logging error");
}
}
} catch (IOException ignored) {
}
}
}
public static void setLevel(Level level) {
logger.setLevel(level);
}
public static void registerLogger(Handler handler) {
logger.addHandler(handler);
}
public static void log(Level level, String tag, String msg) {
logger.log(level, String.format("[%s] %s", tag, msg));
logToFile(level, tag, msg);
}
public static void severe(String tag, String msg) {
logger.severe(String.format("[%s] %s", tag, msg));
logToFile(Level.SEVERE, tag, msg);
}
public static void warn(String tag, String msg) {
warning(tag, msg);
}
public static void debug(String tag, String msg) {
fine(tag, msg);
}
public static void error(String tag, String msg) {
severe(tag, msg);
}
public static void trace(String tag, String msg) {
finer(tag, msg);
}
public static void warning(String tag, String msg) {
logger.warning(String.format("[%s] %s", tag, msg));
logToFile(Level.WARNING, tag, msg);
}
public static void info(String tag, String msg) {
logger.info(String.format("[%s] %s", tag, msg));
logToFile(Level.INFO, tag, msg);
}
public static void config(String tag, String msg) {
logger.config(String.format("[%s] %s", tag, msg));
logToFile(Level.CONFIG, tag, msg);
}
public static void fine(String tag, String msg) {
logger.fine(String.format("[%s] %s", tag, msg));
logToFile(Level.FINE, tag, msg);
}
public static void finer(String tag, String msg) {
logger.finer(String.format("[%s] %s", tag, msg));
logToFile(Level.FINER, tag, msg);
}
public static void finest(String tag, String msg) {
logger.finest(String.format("[%s] %s", tag, msg));
logToFile(Level.FINEST, tag, msg);
}
public static void log(Level level, String tag, Throwable throwable) {
logger.log(level, String.format("[%s] Exception", tag), throwable);
logToFile(level, tag, throwable);
}
public static void log(Level level, String tag, String msg, Throwable thrown) {
logger.log(level, msg, thrown);
logToFile(level, msg, thrown);
}
public static void severe(String tag, Throwable throwable) {
logToFile(Level.SEVERE, tag, throwable);
}
public static void warning(String tag, Throwable throwable) {
logToFile(Level.WARNING, tag, throwable);
}
public static void info(String tag, Throwable throwable) {
logToFile(Level.INFO, tag, throwable);
}
public static void config(String tag, Throwable throwable) {
logToFile(Level.CONFIG, tag, throwable);
}
public static void fine(String tag, Throwable throwable) {
logToFile(Level.FINE, tag, throwable);
}
public static void finer(String tag, Throwable throwable) {
logToFile(Level.FINER, tag, throwable);
}
public static void finest(String tag, Throwable throwable) {
logToFile(Level.FINEST, tag, throwable);
}
public static void warn(String tag, Throwable throwable) {
warning(tag, throwable);
}
public static void debug(String tag, Throwable throwable) {
fine(tag, throwable);
}
public static void error(String tag, Throwable throwable) {
severe(tag, throwable);
}
public static void trace(String tag, Throwable throwable) {
finer(tag, throwable);
}
public static void severe(String msg, String tag, Throwable throwable) {
log(Level.SEVERE, tag, msg, throwable);
}
public static void warning(String msg, String tag, Throwable throwable) {
log(Level.WARNING, tag, msg, throwable);
}
public static void info(String msg, String tag, Throwable throwable) {
log(Level.INFO, tag, msg, throwable);
}
public static void config(String msg, String tag, Throwable throwable) {
log(Level.CONFIG, tag, msg, throwable);
}
public static void fine(String msg, String tag, Throwable throwable) {
log(Level.FINE, tag, msg, throwable);
}
public static void finer(String msg, String tag, Throwable throwable) {
log(Level.FINER, tag, msg, throwable);
}
public static void finest(String msg, String tag, Throwable throwable) {
log(Level.FINEST, msg, throwable);
}
public static void warn(String msg, String tag, Throwable throwable) {
log(Level.WARNING, tag, msg, throwable);
}
public static void debug(String msg, String tag, Throwable throwable) {
log(Level.FINE, tag, msg, throwable);
}
public static void error(String msg, String tag, Throwable throwable) {
log(Level.SEVERE, tag, msg, throwable);
}
public static void trace(String msg, String tag, Throwable throwable) {
log(Level.FINER, tag, msg, throwable);
}
private static boolean isCurrentDate(LocalDateTime dateTime) {
return dateTime.toLocalDate().isEqual(lastFileDate.toLocalDate());
}
private static String dateFormatterForFileName(LocalDateTime dateTime) {
String dateString = "";
dateString += dateTime.getDayOfMonth();
dateString += dateTime.getMonthValue();
dateString += dateTime.getYear();
return dateString;
}
private static String dateFormatterForLogs(LocalDateTime dateTime) {
String dateString = "[";
dateString += dateTime.getDayOfMonth() + "_";
dateString += dateTime.getMonthValue() + "_";
dateString += dateTime.getYear() + "_";
dateString += dateTime.getHour() + ":";
dateString += dateTime.getMinute() + ":";
dateString += dateTime.getSecond();
dateString += "] ";
return dateString;
}
private static void updateAndCreateFile(LocalDateTime dateTime) {
if (!isCurrentDate(dateTime)) {
lastFileDate = LocalDateTime.now();
currentFileName = pathToLogs + dateFormatterForFileName(lastFileDate) + ".log";
try {
logginFile.flush();
logginFile.close();
final File file = new File(currentFileName);
if (file.exists()) {
logginFile = new PrintWriter(new BufferedWriter(new FileWriter(currentFileName, true)));
} else {
final boolean created = file.createNewFile();
if (created) {
logginFile = new PrintWriter(new BufferedWriter(new FileWriter(currentFileName, true)));
} else {
throw new NullPointerException("Error updating log file");
}
}
} catch (IOException ignored) {
}
}
}
private static void logToFile(Level level, String tag, Throwable throwable) {
if (isLoggable(level)) {
synchronized (lockToWrite) {
final LocalDateTime currentDate = LocalDateTime.now();
final String dateForLog = dateFormatterForLogs(currentDate);
updateAndCreateFile(currentDate);
logThrowableToFile(level, tag, throwable, dateForLog);
}
}
}
private static void logToFile(Level level, String tag, String msg) {
if (isLoggable(level)) {
synchronized (lockToWrite) {
final LocalDateTime currentDate = LocalDateTime.now();
updateAndCreateFile(currentDate);
final String dateForLog = dateFormatterForLogs(currentDate);
logMsgToFile(level, tag, msg, dateForLog);
}
}
}
private static void logToFile(Level level, String tag, String msg, Throwable throwable) {
if (isLoggable(level)) {
synchronized (lockToWrite) {
final LocalDateTime currentDate = LocalDateTime.now();
updateAndCreateFile(currentDate);
final String dateForLog = dateFormatterForLogs(currentDate);
logMsgToFile(level, tag, msg, dateForLog);
logThrowableToFile(level, tag, throwable, dateForLog);
}
}
}
private static void logMsgToFile(Level level, String tag, String msg, String dateForLog) {
final String logMessage = String.format("%s{%s} %s - %s", dateForLog, level.toString(), tag, msg);
logsToFile.add(logMessage);
synchronized (logsToFile) {
logsToFile.notifyAll();
}
}
private static void logThrowableToFile(Level level, String tag, Throwable throwable, String dateForLog) {
String throwableLog = String.format("%s{%s} %s - %s", dateForLog, level.toString(), tag, throwable.toString());
for (StackTraceElement element : throwable.getStackTrace()) {
throwableLog += "\tat " + element + "\n";
}
logsToFile.add(throwableLog);
synchronized (logsToFile) {
logsToFile.notifyAll();
}
}
private static boolean isLoggable(Level level) {
return logger.isLoggable(level);
}
private static class LoggerThread extends Thread {
@Override
public void run() {
while (true) {
final ConcurrentLinkedQueue<String> stringsToLog = new ConcurrentLinkedQueue<>();
synchronized (logsToFile) {
if (logsToFile.isEmpty()) {
try {
logsToFile.wait();
} catch (InterruptedException e) {
return;
}
if (logsToFile.isEmpty()) {
continue;
}
}
stringsToLog.addAll(logsToFile);
logsToFile.clear();
}
stringsToLog.stream().forEach(logginFile::println);
logginFile.flush();
}
}
}
}

23
src/main/java/org/telegram/telegrambots/updatesreceivers/BotSession.java
View File

@ -14,6 +14,7 @@ import org.apache.http.util.EntityUtils;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import org.telegram.telegrambots.BotLogger;
import org.telegram.telegrambots.Constants;
import org.telegram.telegrambots.api.methods.updates.GetUpdates;
import org.telegram.telegrambots.api.objects.Update;
@ -32,6 +33,7 @@ import java.util.concurrent.TimeUnit;
* @date 20 of June of 2015
*/
public class BotSession {
private static final String LOGTAG = "BOTSESSION";
private static final int SOCKET_TIMEOUT = 30 * 1000;
private final ITelegramLongPollingBot callback;
@ -64,8 +66,9 @@ public class BotSession {
{
httpclient.close();
httpclient = null;
} catch (IOException ignored) {
}
} catch (IOException e) {
BotLogger.severe(LOGTAG, e);
}
}
}
@ -123,17 +126,21 @@ public class BotSession {
synchronized (this) {
this.wait(500);
}
} catch (InterruptedException ignored) {
} catch (InterruptedException e) {
BotLogger.severe(LOGTAG, e);
}
}
} catch (JSONException ignored) {
} catch (InvalidObjectException | JSONException e) {
BotLogger.severe(LOGTAG, e);
}
} catch (Exception e) {
} catch (Exception global) {
BotLogger.severe(LOGTAG, global);
try {
synchronized (this) {
this.wait(500);
}
} catch (InterruptedException ignored) {
} catch (InterruptedException e) {
BotLogger.severe(LOGTAG, e);
}
}
}
@ -152,6 +159,7 @@ public class BotSession {
try {
receivedUpdates.wait();
} catch (InterruptedException e) {
BotLogger.severe(LOGTAG, e);
continue;
}
update = receivedUpdates.pollLast();
@ -161,7 +169,8 @@ public class BotSession {
}
}
callback.onUpdateReceived(update);
} catch (Exception ignored) {
} catch (Exception e) {
BotLogger.severe(LOGTAG, e);
}
}
}