3.1 Listahan ng mga antas ng kaganapan
Ang pag-log ay ang proseso ng pagtatala ng anumang mga kaganapan na nagaganap habang tumatakbo ang programa. Ang iyong tungkulin bilang isang programmer ay record everything importantdahil kung gayon, kapag productionmay kakaiba at / o malubhang mga pagkakamali, wala kang iba maliban sa mga log na ito.
Ang anumang error ay aalisin nang maraming beses nang mas mabilis kung mayroon ka ng lahat ng impormasyon tungkol dito at tungkol sa lahat ng kasaysayan ng mga tawag. Ngunit ang isang simpleng konklusyon ay sumusunod mula dito - upang mai-log ang lahat sa pangkalahatan: mga tawag sa lahat ng mga pamamaraan, mga halaga ng lahat ng mga parameter.
Hindi rin ito isang opsyon - masyadong maraming impormasyon ay kasing sama ng masyadong maliit. Kailangan namin ng matalinong pag-log. Ginawa ng tao para sa tao. At narito tayo sa unang katotohanan tungkol sa pag-log - lahat ng mga entry sa log ay nahahati sa mga kategorya kahit na sa oras ng kanilang paglikha.
Ang programmer, kapag nagsusulat ng isang kaganapan sa log, ay dapat magpasya para sa kanyang sarili kung gaano kahalaga ang impormasyong ito. Ang antas ng kalubhaan ng kaganapan ay pinili ng may-akda ng mensahe. Mayroong log4j5 antas ng kahalagahan ng naka-log na impormasyon:
DEBUGINFOWARNERRORFATAL
Sa ibaba ay sasabihin namin ang tungkol sa mga ito nang mas detalyado.
3.2 DEBUG
Ang antas DEBUGay itinuturing na hindi gaanong mahalaga. Ang impormasyong nakasulat sa log na may ganitong antas ng kahalagahan ay kailangan lamang sa panahon ng pag-debug ng application. Upang mag-log ng impormasyong kailangan sa panahon ng pag-debug, ginagamit ang paraan debug().
Halimbawa:
class Manager {
private static final Logger logger = LoggerFactory.getLogger(Manager.class);
public boolean processTask(Task task) {
logger.debug("processTask id = " + task.getId());
try {
task.start();
task.progress();
task.complete();
return true;
} catch (Exception e) {
logger.error("Unknown error", e);
return false;
}
}
}Bigyang-pansin, ang pamamaraan debugay nasa pinakadulo simula ng pamamaraan (ang pamamaraan ay wala pang oras upang gumawa ng anuman) at isinulat ang halaga ng variable na ipinasa sa pamamaraan sa log. Ito ang pinakakaraniwang kaso ng paggamit para sa pamamaraan debug().
3.3 IMPORMASYON at BABALA
Ang susunod na dalawang antas ay INFOat WARN. Mayroong dalawang paraan para sa kanila - info()at warn().
Ang antas INFOay ginagamit lamang para sa mga mensaheng nagbibigay-kaalaman: ito at iyon ang mangyayari. Kapag nagsimula kang mag-parse ng isang error sa log, maaari itong maging lubhang kapaki-pakinabang na basahin ang background nito. Ang pamamaraan ay perpekto para dito info().
Ang antas WARNay ginagamit upang magsulat ng mga babala (mula sa salitang babala ). Karaniwan, sa antas ng kahalagahan na ito, nakasulat ang impormasyon na may nangyaring mali, ngunit alam ng programa kung ano ang gagawin sa sitwasyong ito.
Halimbawa, sa proseso ng pagsulat ng isang file sa disk, lumabas na ang naturang file ay mayroon na. Dito maaaring mag-log ang programa ng isang babala (babala), ngunit ipakita sa gumagamit ang isang dialog box at mag-alok na pumili ng ibang pangalan ng file.
Halimbawa:
class FileManager {
private static final Logger logger = LoggerFactory.getLogger(FileManager.class);
public boolean saveFile(FileData file) {
logger.info(“save the file ” + file.getName());
boolean resultOK = SaveUtils.save(file);
if (resultOK) return true;
logger.warn(“file writing problem ” + file.getName());
String filename = Dialog.selectFile();
boolean result = SaveUtils.save(file, filename);
return result;
}3.4 ERROR at FATAL
Panghuli, ang dalawang pinakamahalagang antas ng pag-log ay ERRORat FATAL. Para sa kanila, mayroon ding mga espesyal na pamamaraan na may parehong mga pangalan: error()at fatal().
Napagpasyahan din nilang hatiin ang mga pagkakamali sa dalawang kategorya - mga ordinaryong pagkakamali at mga pagkakamaling nakamamatay . Ang isang nakamamatay na error ay kadalasang nagreresulta sa pag-crash ng application (para sa mga desktop application) o pag-crash ng serbisyo sa web (para sa mga web application).
Ang isa pang magandang halimbawa ay ang Windows operating system. Kung nag-crash lang ang iyong program, kung gayon mula sa punto ng view ng operating system, ito ay Error. At kung ang operating system mismo ay bumagsak at nakita mo ang Windows blue screen ng kamatayan, kung gayon ito ay Fatal error.
Sa mga application ng Java, ang mga kaganapan Erroray kadalasang Fatalnauugnay sa mga nakataas na pagbubukod. Halimbawa:
class Manager {
private static final Logger logger = LoggerFactory.getLogger(Manager.class);
public boolean processTask(Task task) {
logger.debug("processTask id = " + task.getId());
try {
task.start();
task.progress();
task.complete();
return true;
} catch (Exception e) {
logger.error("Unknown error", e);
return false;
}
}
}3.5 Ano ang dapat i-log
Siyempre, hindi sulit na i-log ang lahat nang sunud-sunod. Sa karamihan ng mga kaso, pinalala nito ang pagiging madaling mabasa ng log, at pagkatapos ng lahat, ang log ay isinulat sa unang lugar upang mabasa.
Bilang karagdagan, hindi ka maaaring magsulat ng iba't ibang personal at pinansyal na impormasyon sa log. Ngayon, sa mahigpit at madaling ito maaari kang magkaroon ng mga multa o demanda. Maaga o huli, ang naturang log ay tumagas sa gilid at pagkatapos ay walang mga problema.
Kaya ano ang dapat i-log?
Una, kailangan mong i-log ang simula ng application . Matapos magsimula ang application, inirerekumenda na i-log ang mode ng operasyon nito at iba't ibang mahahalagang setting - gagawin nitong mas madaling basahin ang log sa hinaharap.
Pangalawa, kailangan mong i-log ang katayuan ng lahat ng mga serbisyo ng third-party kung saan gumagana ang iyong aplikasyon: mga sistema ng pag-mail, anumang mga panlabas na serbisyo. Hindi bababa sa, kailangan mong i-secure ang sandali ng koneksyon sa kanila upang matiyak na gumagana ang mga ito nang maayos.
Pangatlo, ang lahat ng mga pagbubukod ay kailangang mai-log . Kung sila ay inaasahan, kung gayon ang impormasyon sa mga ito ay maaaring isulat nang compact. Ang kumpletong impormasyon tungkol sa mga pagbubukod ay nagbibigay ng 50%-80% ng mahalagang impormasyon kapag naghahanap ng isang bug.
Kailangan mo ring i-log ang application shutdown . Ang application ay dapat na wakasan nang normal at hindi magtapon ng dose-dosenang mga error sa log. Kadalasan sa lugar na ito makakahanap ka ng mga natigil na gawain, mga problema sa thread pool, o mga problema sa pagtanggal ng mga pansamantalang file.
Tiyaking i-log ang lahat ng nauugnay sa seguridad at awtorisasyon ng user . Kung sinubukan ng isang user na mag-login o i-reset ang kanilang password nang 10 beses na magkakasunod, dapat na makita ang impormasyong ito sa mga log.
Mag-log ng mas maraming impormasyon hangga't maaari tungkol sa mga asynchronous na gawain - ang mga pagbubukod ay madalas na nawala sa mga naturang thread. Para sa isang asynchronous na gawain, tiyaking i-log ang simula at pagtatapos nito. Ang matagumpay na pagkumpleto ay dapat na naka-log sa parehong paraan bilang isang may problema.
Ano pa? Paglulunsad ng mga naka-time na gawain, paglulunsad ng mga nakaimbak na gawain SQL-procedures, pag-synchronize ng data, lahat ng bagay na nauugnay sa mga ipinamamahaging transaksyon. Sa tingin ko, sapat na iyon para sa simula. Magdaragdag ka sa listahang ito sa hinaharap.