లాగర్

"ఓహ్, మీరు ఉన్నారు! ఈ రోజు మనకు మరో పాఠం ఉందని మీకు గుర్తుందా?"

"లేదు, నేను నీ కోసమే వెతుకుతున్నాను. దాదాపు..."

"అద్భుతం, అప్పుడు ప్రారంభిద్దాం. ఈ రోజు నేను మీకు లాగింగ్ గురించి చెప్పాలనుకుంటున్నాను."

"లాగ్ అనేది సంభవించిన సంఘటనల జాబితా. దాదాపు ఓడ యొక్క లాగ్ లేదా డైరీ లాగా ఉంటుంది. లేదా Twitter — బహుశా మీరు దానితో మరింత మెరుగ్గా సంబంధం కలిగి ఉండవచ్చు. ఆశ్చర్యకరంగా, లాగర్ అనేది మీరు లాగింగ్ కోసం ఉపయోగించే వస్తువు."

"ప్రోగ్రామింగ్‌లో, దాదాపు ప్రతిదానిని లాగిన్ చేయడం ఆచారం. మరియు జావాలో, మేము ప్రతిదానిని మరియు కొంచెం ఎక్కువ లాగ్ చేస్తాము."

"వాస్తవం ఏమిటంటే, జావా ప్రోగ్రామ్‌లు చాలా తరచుగా UI, కన్సోల్ మొదలైనవి లేకుండా పెద్ద సర్వర్ అప్లికేషన్‌లు. అవి ఒకే సమయంలో వేలకొద్దీ వినియోగదారు అభ్యర్థనలను ప్రాసెస్ చేస్తాయి మరియు తరచుగా వివిధ లోపాలు ఉంటాయి. ప్రత్యేకించి వేర్వేరు థ్రెడ్‌లు ఒకదానితో ఒకటి జోక్యం చేసుకోవడం ప్రారంభించినప్పుడు."

"వాస్తవానికి, ఈ పరిస్థితులలో అరుదుగా పునరుత్పత్తి చేయగల దోషాలు మరియు వైఫల్యాల కోసం శోధించడానికి ఏకైక మార్గం ప్రతి థ్రెడ్‌లో జరిగే ప్రతిదాన్ని లాగ్ చేయడం."

"చాలా తరచుగా, లాగ్ మెథడ్ ఆర్గ్యుమెంట్‌లు, ఏవైనా క్యాచ్ చేసిన ఎర్రర్‌లు మరియు చాలా ఇంటర్మీడియట్ సమాచారం గురించి సమాచారాన్ని కలిగి ఉంటుంది."

"లాగ్‌ను ఎంత పూర్తి చేస్తే, ఈవెంట్‌ల క్రమాన్ని పునరుత్పత్తి చేయడం మరియు వైఫల్యాలు లేదా బగ్‌ల కారణాలను ట్రాక్ చేయడం సులభం."

"కొన్నిసార్లు లాగ్‌లు రోజుకు అనేక గిగాబైట్‌లకు చేరుకుంటాయి. ఇది సాధారణం."

"కొన్ని గిగాబైట్‌లు? O_o"

"అవును. చాలా తరచుగా, సంబంధిత తేదీ సూచనతో లాగ్ ఫైల్‌లు స్వయంచాలకంగా ఆర్కైవ్ చేయబడతాయి."

"ఓహో."

"ఉహ్-హుహ్. ప్రారంభంలో, జావాకు దాని స్వంత లాగర్ లేదు. ఫలితంగా, అనేక స్వతంత్ర లాగర్లు వ్రాయబడ్డాయి. వీటిలో అత్యంత సాధారణమైనది log4j."

"కొన్ని సంవత్సరాల తరువాత, జావా దాని స్వంత లాగర్‌ను పొందింది, కానీ దాని కార్యాచరణ చాలా తక్కువగా ఉంది మరియు ఇది విస్తృతంగా ఉపయోగించబడలేదు."

" జావా అధికారిక లాగర్‌ని కలిగి ఉండటం వాస్తవం , కానీ జావా ప్రోగ్రామర్ల మొత్తం సంఘం ఇతర లాగర్‌లను ఉపయోగించడానికి ఇష్టపడుతుంది. "

"తరువాత, log4j ఆధారంగా మరిన్ని లాగర్లు వ్రాయబడ్డాయి."

"అప్పుడు ఇప్పుడు విస్తృతంగా ఉపయోగించబడుతున్న ప్రత్యేక యూనివర్సల్ లాగర్ slf4j, వీటన్నింటి కోసం వ్రాయబడింది. ఇది log4jకి చాలా పోలి ఉంటుంది, కాబట్టి లాగింగ్‌ను వివరించేటప్పుడు నేను దానిని ఉదాహరణగా ఉపయోగిస్తాను."

"మొత్తం లాగింగ్ ప్రక్రియ మూడు భాగాలను కలిగి ఉంటుంది."

" మొదట , సమాచారాన్ని సేకరించండి."

" రెండవది , సేకరించిన సమాచారాన్ని ఫిల్టర్ చేయండి."

" మూడవది , ఎంచుకున్న సమాచారాన్ని రికార్డ్ చేయండి."

"సేకరణతో ప్రారంభిద్దాం. లాగ్ అయ్యే తరగతికి ఒక సాధారణ ఉదాహరణ ఇక్కడ ఉంది:"

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 – లాగర్ ఆబ్జెక్ట్‌ను  సృష్టించండి . దాదాపు ప్రతి తరగతిలో ఇటువంటి స్టాటిక్ ఆబ్జెక్ట్ సృష్టించబడుతుంది! సరే, డేటాను నిల్వ చేయడం తప్ప మరేమీ చేయని తరగతులకు మినహా."

" లాగర్‌ఫ్యాక్టరీ అనేది లాగర్‌లను సృష్టించడానికి ఒక ప్రత్యేక తరగతి, మరియు getLogger దాని స్టాటిక్ పద్ధతుల్లో ఒకటి. ప్రస్తుత వస్తువు సాధారణంగా ఆమోదించబడుతుంది, కానీ వివిధ ఎంపికలు సాధ్యమే."

" లైన్ 7 - పద్ధతి కాల్ గురించిన సమాచారం లాగర్‌కు వ్రాయబడుతుంది. ఇది పద్ధతి యొక్క మొదటి పంక్తి అని గమనించండి. పద్ధతిని పిలిచిన వెంటనే, మేము వెంటనే లాగ్‌కు సమాచారాన్ని వ్రాస్తాము."

"మేము డీబగ్ పద్ధతిని పిలుస్తాము, అంటే సమాచారం యొక్క ప్రాముఖ్యత DEBUG స్థాయి. ఇది ఫిల్టరింగ్ కోసం ఉపయోగించబడుతుంది. నేను దాని గురించి రెండు నిమిషాల్లో మీకు చెప్తాను."

" 17వ పంక్తి - మేము ఒక మినహాయింపును పొందుతాము మరియు... వెంటనే దానిని లాగ్‌కు వ్రాస్తాము! ఇది ఖచ్చితంగా చేయాలి."

"ఈసారి మేము లోపం పద్ధతిని పిలుస్తాము, ఇది సమాచారం లోపం స్థాయి అని వెంటనే సూచిస్తుంది"

"ప్రస్తుతానికి అంతా క్లియర్‌గా ఉంది. సరే, మా సంభాషణ మధ్యలో తేలినంత వరకు."

"అద్భుతం, అప్పుడు మనం మెసేజ్ ఫిల్టరింగ్‌కి వెళ్దాం."

"సాధారణంగా, ప్రతి లాగ్ సందేశం దాని స్వంత ప్రాముఖ్యత స్థాయిని కలిగి ఉంటుంది, మీరు కొన్ని సందేశాలను విస్మరించడానికి ఉపయోగించవచ్చు. ఇక్కడ నేను పేర్కొన్న ప్రాముఖ్యత స్థాయిలు ఉన్నాయి:"

సందేశాలను ఫిల్టర్ చేసేటప్పుడు కూడా ఈ స్థాయిలు ఉపయోగించబడతాయి.

మీరు లాగింగ్ స్థాయిని WARNకి సెట్ చేసారని అనుకుందాం. అప్పుడు WARN కంటే తక్కువ ప్రాముఖ్యత కలిగిన అన్ని సందేశాలు విస్మరించబడతాయి: TRACE, DEBUG, INFO.

మీరు ఫిల్టరింగ్ స్థాయిని FATALకి సెట్ చేస్తే, ERROR సందేశాలు కూడా విస్మరించబడతాయి.

"ఫిల్టర్ చేసేటప్పుడు మరో రెండు ముఖ్యమైన స్థాయిలు ఉపయోగించబడతాయి: OFF, ఇది అన్ని సందేశాలను విస్మరిస్తుంది; మరియు ALL, ఇది అన్ని సందేశాలను చూపుతుంది (ఏదీ విస్మరించబడలేదు)."

"నేను ఫిల్టరింగ్‌ని ఎలా మరియు ఎక్కడ సెటప్ చేయాలి?"

"మరేం మాట్లాడకుండా చెప్తాను."

"సాధారణంగా, log4j లాగర్ సెట్టింగ్‌లు log4j.properties ఫైల్‌లో పేర్కొనబడతాయి."

మీరు ఈ ఫైల్‌లో బహుళ అనుబంధ వస్తువులను పేర్కొనవచ్చు. ఈ వస్తువులకు డేటా వ్రాయబడుతుంది. డేటా మూలాలు ఉన్నాయి మరియు అనుబంధాలు ఉన్నాయి - వ్యతిరేక ప్రయోజనాలను కలిగి ఉన్న వస్తువులు. డేటా నీటిలోకి ప్రవహించే వస్తువులు.

"ఇవి కొన్ని ఉదాహరణలు:"

# Root logger option
log4j.rootLogger = INFO, stdout

# Direct log messages to stdout
log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target = System.out
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern = %d{yyyy-MM-dd HH:mm:ss}

1 మరియు 4 లైన్లు - ఇవి వ్యాఖ్యలు

లైన్ 2 - మనకు కావలసిన లాగింగ్ స్థాయిని మేము సూచిస్తాము. అన్ని తక్కువ ముఖ్యమైన స్థాయిలు (డీబగ్, ట్రేస్) విస్మరించబడతాయి.

అదే స్థలంలో, మేము కామాను జోడించి, ఆపై లాగ్ వ్రాయబడే ఆబ్జెక్ట్ పేరును (మేము మనతో ముందుకు వస్తాము) సూచిస్తాము. 5-9 పంక్తులు దాని సెట్టింగులను కలిగి ఉంటాయి.

పంక్తి 5 - మేము అనుబంధ రకాన్ని ( కన్సోల్అపెండర్ ) పేర్కొంటాము.

లైన్ 6 - మనం ఎక్కడ వ్రాస్తున్నామో ఖచ్చితంగా సూచిస్తాము ( System.out. ).

లైన్ 7 - మేము మార్పిడి నమూనాలను నిర్వహించే తరగతిని సెట్ చేసాము (నమూనా లేఅవుట్).

లైన్ 8 - మేము వ్రాయడానికి ఉపయోగించే మార్పిడి నమూనాను సెట్ చేసాము. పై ఉదాహరణలో, ఇది తేదీ మరియు సమయం.

"మరియు ఫైల్‌కి వ్రాయడం ఎలా ఉంటుందో ఇక్కడ ఉంది:"

# Root logger option
log4j.rootLogger = INFO, file

# Direct log messages to a log file
log4j.appender.file = org.apache.log4j.RollingFileAppender
log4j.appender.file.File = C:\\loging.log
log4j.appender.file.MaxFileSize = 1MB
log4j.appender.file.MaxBackupIndex = 1
log4j.appender.file.layout = org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern = %-5p %c{1}:%L - %m%n

"పంక్తి 2 సందేశ వడపోత స్థాయిని మరియు అనుబంధ వస్తువు (సింక్) పేరును సెట్ చేస్తుంది."

"లైన్ 5 - మేము ఫైల్ అనుబంధ రకాన్ని ( RollingFileAppender ) పేర్కొంటాము."

"లైన్ 6 - లాగ్ వ్రాయబడే ఫైల్ పేరును మేము పేర్కొంటాము."

"లైన్ 7 - మేము గరిష్ట లాగ్ పరిమాణాన్ని పేర్కొంటాము. ఈ పరిమాణ పరిమితిని అధిగమించినప్పుడు, కొత్త ఫైల్ సృష్టించబడుతుంది."

"లైన్ 8 - నిల్వ చేయవలసిన పాత లాగ్ ఫైల్‌ల సంఖ్యను మేము పేర్కొంటాము."

"పంక్తులు 9-10 - మార్పిడి నమూనాను సెట్ చేయండి."

"ఇక్కడ ఏమి జరుగుతుందో నాకు తెలియదు, కానీ నేను ఊహించగలను. అది ప్రోత్సాహకరంగా ఉంది."

"ఇది చాలా బాగుంది. ఫైల్ మరియు కన్సోల్‌కి లాగ్‌ను ఎలా వ్రాయాలి అనేదానికి ఇక్కడ ఒక ఉదాహరణ ఉంది:"

# Root logger option
log4j.rootLogger = INFO, file, stdout

# Direct log messages to a log file
log4j.appender.file = org.apache.log4j.RollingFileAppender
log4j.appender.file.File = C:\\loging.log
log4j.appender.file.MaxFileSize = 1MB
log4j.appender.file.MaxBackupIndex = 1
log4j.appender.file.layout = org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern = %-5p %c{1}:%L - %m%n

# Direct log messages to stdout
log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target = System.out
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern = %d{yyyy-MM-dd HH:mm:ss}

"ఆహ్, మీరు అలా చేయగలరా? చాలా బాగుంది!"

"అవును. మీరు మీకు కావలసినంత మంది అనుబంధాలను ప్రకటించవచ్చు మరియు ఒక్కొక్కరిని అనుకూలీకరించవచ్చు."

ఇంకా, ప్రతి అనుబంధం సందేశ వడపోత కోసం చాలా సౌకర్యవంతమైన సెట్టింగ్‌లను కలిగి ఉంటుంది. మేము ప్రతి అనుబంధానికి వ్యక్తిగత సందేశ వడపోత స్థాయిని కేటాయించడమే కాకుండా, ప్యాకేజీ ద్వారా సందేశాలను కూడా ఫిల్టర్ చేయవచ్చు! అందుకే మీరు లాగర్‌ను సృష్టించేటప్పుడు తరగతిని పేర్కొనాలి (నేను LoggerFactory.getLogger గురించి మాట్లాడుతున్నాను ).

"ఉదాహరణకి:"

# Root logger option
log4j.rootLogger = INFO, file, stdout

# Direct log messages to a log file
log4j.appender.file = org.apache.log4j.RollingFileAppender
log4j.appender.file.threshold = DEBUG
log4j.appender.file.File = C:\\loging.log
log4j.appender.file.MaxFileSize = 1MB
log4j.appender.file.MaxBackupIndex = 1
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern = %-5p %c{1}:%L - %m%n

# Direct log messages to stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.threshold = ERROR
log4j.appender.stdout.Target = System.out
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern = %d{yyyy-MM-dd HH:mm:ss}

log4j.logger.org.springframework = ERROR
log4j.logger.org.hibernate = ERROR
log4j.logger.com.codegym = DEBUG
log4j.logger.org.apache.cxf = ERROR

"లైన్లు 6 మరియు 15 - మేము ప్రతి అనుబంధానికి మా స్వంత ఫిల్టరింగ్ స్థాయిని సెట్ చేసాము."

"పంక్తులు 20-23 – మేము దాని సందేశాల కోసం ప్యాకేజీ పేరు మరియు ఫిల్టరింగ్ స్థాయిని పేర్కొంటాము. Log4j.logger ఒక ఉపసర్గ: ప్యాకేజీ పేరు నారింజ రంగులో హైలైట్ చేయబడింది."

"నిజంగానా? నువ్వు కూడా అలా చేయగలవు. సరే, కూల్!"

"అయితే, JDKలో log4j లేదా slf4j చేర్చబడలేదు. మీరు వాటిని విడిగా డౌన్‌లోడ్ చేసుకోవాలి. మీరు దానిని ఇక్కడ చేయవచ్చు . కానీ మరొక మార్గం ఉంది:"

" దశ 1 . తరగతికి దిగుమతులను జోడించండి:"

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

" దశ 2 . కర్సర్‌ను ఈ పంక్తులపై ఉంచండి మరియు IntelliJ IDEAలో Alt+Enter నొక్కండి"

" దశ 3 . 'ఫైల్ జార్ ఆన్ వెబ్» మెను ఐటెమ్‌ను ఎంచుకోండి.'

" దశ 4 . 'slf4j-log4j13.jar'ని ఎంచుకోండి"

" దశ 5 . లైబ్రరీ (జార్) ఎక్కడ డౌన్‌లోడ్ చేయాలో పేర్కొనండి"

" దశ 6 . మీకు అవసరమైన తరగతులను ఉపయోగించండి."

"అయ్యో! ఈ రోజు ఏమైంది. చాలా కొత్తగా ఉంది మరియు చాలా బాగుంది!"

"లాగింగ్‌పై మరో మంచి కథనం ఇక్కడ ఉంది: https://docs.oracle.com/javase/10/core/java-logging-overview.htm#JSCOR-GUID-48004124-2C00-49F7-A640-0C0DDA271DBC "

"సరే, అది చాలు. రిలాక్స్ అవ్వండి, ప్రోగ్రామర్."