More Related Content Similar to Exception&log (20) More from Nam Hyeonuk (20) Exception&log3. 01 Exception
โข Structured Exception Handling(SEH)
ํ๋ก๊ทธ๋จ์ ์๋ฌด๋ฆฌ ์ ๋ง๋ค์ด๋ ์์ธ ์ํฉ(Exception)์ ํผํ ์ ์๋ค. ์์ธ๋ ํ๋ก๊ทธ๋จ ์ธ๋ถ
์ ๋ถ๊ฐํญ๋ ฅ์ ์ธ ์ํฉ๋๋ฌธ์ ๋ฐ์ํ๋ ๊ฒฝ์ฐ๊ฐ ๋ง๊ธฐ ๋๋ฌธ์ด๋ค(์กด์ฌํด์ผ ํ ํ์ผ์ด ์กด์ฌํ์ง ์
๊ฑฐ๋, ๋ฉ๋ชจ๋ฆฌ ํ ๋น์ ๋ฐ์์ผํ๋๋ฐ ๋ฉ๋ชจ๋ฆฌ๊ฐ ๋ถ์กฑํ๊ฑฐ๋, ๊ธฐํ ๋ฑ๋ฑ). ์ด๋ฐ ์์ธ ์ํฉ์ ์ฒ๋ฆฌํ
๊ธฐ ์ํด ์๋์ฐ์ฆ์์๋ SEH๋ฅผ ์ด์ฉํ๋ค. SEH๋ฅผ ์ด์ฉํ๋ฉด ์คํ ์ฝ๋์ ์์ธ์ฒ๋ฆฌ ์ฝ๋๋ฅผ ๋ถ๋ฆฌ
์์ผ ์ฝ๋์ ๊ฐ๋
์ฑ, ์ ์ง ๋ณด์์ฑ์ ๋์ฌ์ค๋ค๋ ์ฅ์ ์ ๊ฐ๊ณ ์๋ค. ๊ตฌ์กฐ๋ ์ฌ์ฉ๋ฐฉ๋ฒ์ C++ try
catch ๊ตฌ๋ฌธ๊ณผ ๊ฑฐ์ ๋๊ฐ๋ค.
__try : ์คํ ์ฝ๋ ๋ธ๋ญ
__except ( exception filter ) : ์์ธ ์ํฉ ๋ฐ์์ ์์ธ์ ๋ฐ๋ผ ์คํ.
4. 01 Exception
โข Exception Filter
SEH์์ __except๋ ์ธ์๋ก exception filter๋ฅผ ๋ฐ๋๋ค. ์ด ํํฐ๋ ์์ธ๋ฅผ ๋๊ฐ ์ฒ๋ฆฌํ ์ง, ์
์ธ๋ฅผ ์ฒ๋ฆฌํ ๋ค์์ ์ด๋ป๊ฒ ํ ๊ฒ์ธ์ง ๋ฑ๋ฑ์ ์ง์ ํ๋ ์ญํ ์ ๋ด๋นํ๋ค. exception filter์๋
์๋ ์ธ ๊ฐ์ง ์ข
๋ฅ๊ฐ ์๋ค. ์๋ ์ธ ๊ฐ์ง ๊ฐ์ excpt.h ํ์ผ์ ์ ์๋์ด ์์.
โข EXCEPTION_EXECUTE_HANDLER
โข EXCEPTION_CONTINUE_EXECUTION
โข EXCEPTION_CONTINUE_SEARCH
5. 01 Exception
โข Exception Filter
EXCEPTION_EXECUTE_HANDLER
์ด ํํฐ๊ฐ ์ ์ฉ๋ ๊ฒฝ์ฐ, __try ๋ธ๋ก์์ ์์ธ๊ฐ ๋ฐ์ํ ์์ ์ ๊ทธ ์ดํ __try ์ฝ๋ ๋ธ๋ก์ ์คํ์
๋ชจ๋ ์๋ตํ๊ณ global unwind๋ฅผ ์ํํ ํ __except๋ธ๋ก์ ์ฝ๋ ๋ฐ ๊ทธ ์ดํ ์ฝ๋๋ค์ ์ํํ
๊ฒ ๋๋ค.
int main()
{
int a = 0, b = 0;
__try
{
b = 5 / a; //divide by 0
printf("ignore.");
}
__except(EXCEPTION_EXECUTE_HANDLER)
{ printf("execption."); }
printf("after exception.");
}
//์คํ์ execption. after exception. ์ถ๋ ฅ
6. 01 Exception
โข Exception Filter
EXCEPTION_CONTINUE_EXECUTION
์ด ๊ฑด ์ ํํฐ์ ์ ๋ฐ๋๋ก ๋์ํ๋ค. ์ด ํํฐ๊ฐ ์ง์ ๋์ด ์์ ๊ฒฝ์ฐ __try ๋ธ๋ก์์ ์์ธ๊ฐ ๋ฐ์
ํ๋ ์ฝ๋๋ก ๋ค์ ๋์๊ฐ ํด๋น ์ฝ๋๋ฅผ ์ํํ๋ค. ์ฆ ์ด ํํฐ๊ฐ ์ง์ ๋์ด ์์ ๊ฒฝ์ฐ ๋ฐ๋ณต ์ํ์์
๋ญ๊ฐ ์์ธ ์ํฉ์ ํด๊ฒฐํ ์ ์๋ ์ฒ๋ฆฌ๋ฅผ ํด์ฃผ์ด์ผํ๋ค๋ ๊ฒ์ด๋ค. ๊ทธ๋ ์ง ์์ ๊ฒฝ์ฐ ๋ค๋ฅธ ๋ฌธ์ ๊ฐ
๋ฐ์ํ๊ฑฐ๋ ์์ธ๋ ๋ชจ๋ฅธ ์ฑ ํ๋ก๊ทธ๋จ์ด ์ฃฝ๊ฑฐ๋ ํ ์ ์๋ค.
int main()
{
int a = 0, b = 0;
//divide by 0
__try{ b = 5/a; }
__except(ExceptHandle(&a))
{}
}
int ExceptHandle(int* divider)
{
scanf("%d",÷r);
return divider ?
EXCEPTION_EXECUTE_HANDLER :
EXCEPTION_CONTINUE_EXECUTION;
}
์คํ์ 0์ผ๋ก ๋๋ ๊ฒ์์ ์๋ฌ ๋ฐ์ -> 0 ์๋
์ ๋์ฌ ๋๊น์ง ๋ฐ๋ณต ์คํ -> 0 ์๋ ์ ๋์ค๋ฉด
__except ์์ ์ฝ๋ ์คํ ํ ๋ค์ ์ฝ๋๋ก ์งํ.
7. 01 Exception
โข Exception Filter
EXCEPTION_CONTINUE_SEARCH
์ด ํํฐ๊ฐ ์ง์ ๋์ด ์์ ๊ฒฝ์ฐ ํ์ฌ ์ง์ ๋ __except์์ ์์ธ ์ฒ๋ฆฌ๋ฅผ ์ํํ์ง ์๊ณ ์ฝ์คํ์
๊ฑฐ๊พธ๋ก ๋์ฐพ์๊ฐ๋ฉด์ ๋ค๋ฅธ __except ๋ธ๋ก์ ์ฒ๋ฆฌ๋ฅผ ๋๊ธด๋ค(๊ฑฐ๊ธฐ์๋ EXCEPTION_CONTIN-
UE_SEARCH๋ผ๋ฉด ๋ค์ ๊ทธ๊ฒ๋ณด๋ค ๋ ๋จผ์ ํธ์ถํ ํจ์์ชฝ์ผ๋ก ์ญ ์งํ). ๊ทธ๋ฌ๋ค๊ฐ ์๋ฌด๋ฐ ํธ๋ค๋ฌ
๋ ์ฐพ์ง ๋ชปํ๋ค๋ฉด ์ข
๋ฃ๋๋ค.
void foo()
{
int a = 0, b = 0;
__try
{ b = 5 / a; // divide by 0 }
__except
(EXCEPTION_CONTINUE_SEARCH)
{ printf("ignore."); }
}
int main()
{
__try
{ foo(); }
__except
(EXCEPTION_EXECUTE_HANDLER)
{ printf("exception."); }
}
์คํ์ exception. ์ถ๋ ฅ๋จ.
8. 01 Exception
โข Unhandled Exception
์์ ํํฐ๋ค์ ํตํด ์์ธ๊ฐ ๋ฐ์ํ์ ๋ SEH๋ฅผ ํตํด ์ด๋ค์์ผ๋ก ์์ธ๋ฅผ ์ฒ๋ฆฌํ ์ ์๋์ง
์ดํด๋ณด์๋ค. ๊ทธ๋ฐ๋ฐ ์ด๋ฐ ์์ธ ์ค์์ ์ฒ๋ฆฌ๋์ง ์์ ์์ธ๊ฐ ๋ฐ์ํ์ ๋ ํน์ ํธ๋ค๋ฌ๋ฅผ
ํธ์ถํ๊ณ ์ถ์ ์ ์๋ค. ์๋ฅผ ๋ค์ด ์๊น์ ์ EXCEPTION_CONTINUE_SEARCH ํํฐ๋ฅผ
์ค์ ํ์ ๊ฒฝ์ฐ ๋๊น์ง ํธ๋ค๋ฌ๋ฅผ ์ฐพ์ง ๋ชปํ๋ฉด ๊ทธ๋ฅ ํ๋ก๊ทธ๋จ์ด ์ฃฝ์ด๋ฒ๋ฆฌ๋๋ฐ, ์ด๋ฐ ์ํฉ์
Unhandled Exception filter๋ฅผ ์ค์ ํด์ฃผ๋ฉด ํด๋น ํจ์๊ฐ ํธ์ถ๋๋ค. ์ฒ๋ฆฌ๋์ง ์์ ์์ธ๊ฐ
๋ฐ์ํ์ ๋ ํ๋ก๊ทธ๋จ์ dump๋ฅผ ๋ฌ ๋ค์ ํ๋ก๊ทธ๋จ์ ์ข
๋ฃ์ํค๊ฑฐ๋ ํ๋ ์ฒ๋ฆฌ๋ฅผ ํ ์๊ฐ ์๋
๊ฒ์ด๋ค. ์ด ์ค์ ์ windows์ SetUnhandledExceptionFilter ํจ์๋ฅผ ํตํด ํ ์ ์๋ค.
LPTOP_LEVEL_EXCEPTION_FILTER WINAPI SetUnhandledExceptionFilter(
_In_ LPTOP_LEVEL_EXCEPTION_FILTER lpTopLevelExceptionFilter
);
LPTOP_LVEL_EXCEPTION_FILTER๋ LPEXCEPTION_POINTERS๋ฅผ ์ธ์๋ก ๋ฐ๊ณ LONG์
๋ฆฌํดํ๋ WINAPI ํธ์ถ ๊ท์ฝ์ ํจ์ ํฌ์ธํฐ์ด๋ค.
( LONG WINAPI filter(LPEXCEPTION_POINTERS * info); )
9. 01 Exception
โข Dump
ํ๋ก๊ทธ๋จ์ด ์ฃฝ์ ๋ ๋คํ ์ ๋ณด๋ฅผ ๋จ๊ธฐ๋ ค๋ฉด ์ด๋ป๊ฒ ํด์ผ ํ ๊น?๋คํ ํ์ผ์ ๋ง๋ค์ด์ฃผ๋ ํจ์๋ฅผ
๋ง๋ ๋ค์ ์ด ํจ์๋ฅผ SetUnhandledExceptionFilter ํจ์๋ฅผ ์ด์ฉํด ๋ฑ๋กํ๋ฉด ์ฒ๋ฆฌ๋์ง ์์
์์ธ๊ฐ ๋ฐ์ํ์๋ ์ด ํจ์๊ฐ ํธ์ถ๋์ด ์๋์ผ๋ก ๋คํ ํ์ผ์ ๋ง๋ค์ด์ค ๊ฒ์ด๋ค. ๋คํ๋ฅผ ๋ง๋ค๊ธฐ
์ํด MiniDumpWriteDump ํจ์๋ฅผ ์ธ ์ ์๋ค.
BOOL WINAPI MiniDumpWriteDump(
_In_ HANDLE hProcess, // ๋คํ ๋ฐ ํ๋ก์ธ์ค ํธ๋ค
_In_ DWORD ProcessId, // ๋คํ ๋ฐ ํ๋ก์ธ์ค ์์ด๋
_In_ HANDLE hFile, // ๋คํ ๊ธฐ๋กํ ํ์ผ ํธ๋ค
_In_ MINIDUMP_TYPE DumpType, // ๊ธฐ๋กํ ๋คํ์ ํ์
(ํ์ )
//๋คํ ๋ฐ ์ํฉ์ด ๋ฐ์ํ๊ฒ ๋ง๋ ์์ธ ์ ๋ณด(NULL์ด๋ฉด ๊ธฐ๋ก๋์ง ์์)
_In_ PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam,
//๋คํ ํ์ผ์ ๊ธฐ๋กํ ์ฌ์ฉ์ ์ ์ ์ ๋ณด(NULL์ด๋ฉด ๊ธฐ๋ก๋์ง ์์)
_In_ PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam,
//ํ์ฅ๋ ๋ฏธ๋ ๋คํ ์ ๋ณด๋ฅผ ๋ฐ์ ์ฝ๋ฐฑ ๋ฃจํด(NULL์ด๋ฉด ์๋ฌด ์ฝ๋ฐฑ๋ ํธ์ถ ์ ๋จ)
_In_ PMINIDUMP_CALLBACK_INFORMATION CallbackParam
);
10. 01 Exception
โข Dump
์ฌ์ฉ๊ฐ๋ฅํ MiniDump์ ํ์
์๋ ๊ต์ฅํ ๋ง์ ์ข
๋ฅ๊ฐ ์๋ค. ์ ์ฒด ๋ชฉ๋ก ๋ฐ ๊ฐ๊ฐ์
๊ธฐ๋ฅ์ด ๊ถ๊ธํ๋ค๋ฉด MSDN์ MINIDUMP_TYPE ๋ฌธ์๋ฅผ ๋ณด๋ฉด ๋๋ค. ๋ํ์ ์ธ 2๊ฐ์ง๋
MiniDumpNormal๊ณผ MiniDumpWithFullMemory์ด๋ค. MiniDumpNormal์ ๋ก์ปฌ
๋ ์ง์คํฐ ๊ฐ์ ํฌํจํด์ ๋คํ๋ฅผ ๋จ๊ณ , MiniDumpWithFullMemory๋ ์ ์ฒด ๋ฉ๋ชจ๋ฆฌ ๊ฐ์
ํฌํจํ์ฌ ๋คํ๋ฅผ ๋ฌ๋ค.
์ฌ์ฉ ์์
MINIDUMP_EXCEPTION_INFORMATION exceptionInfo;
exceptionInfo.ThreadId = GetCurrentThreadId();
exceptionInfo.ExceptionPointers = e;
exceptionInfo.ClientPointers = FALSE;
HANDLE hProcess = GetCurrentProcess();
DWORD dwProcessID = GetCurrentProcessId();
DWORD dwThreadID = GetCurrentThreadId();
MiniDumpWriteDump(hProcess, dwProcessId, hFile,
MiniDumpWithFullMemory, &exceptionInfo, NULL, NULL);
11. 01 Exception
โข StackWalk64
์ค๋ ๋์ ์คํ ์ ๋ณด๋ฅผ ๊ธฐ๋กํ๊ณ ์ถ๋ค๋ฉด StackWalk64 ํจ์๋ฅผ ์ฐ๋ฉด ๋๋ค. ์ธ์๊ฐ ๊ต์ฅํ ๋ง๊ณ
๋ณต์กํ๋ค.
BOOL WINAPI StackWalk64(
_In_ DWORD MachineType,
_In_ HANDLE hProcess,
_In_ HANDLE hThread,
_Inout_ LPSTACKFRAME64 StackFrame,
_Inout_ PVOID ContextRecord,
_In_opt_ PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemoryRoutine,
_In_opt_ PFUNCTION_TABLE_ACCESS_ROUTINE64
FunctionTableAccessRoutine,
_In_opt_ PGET_MODULE_BASE_ROUTINE64 GetModuleBaseRoutine,
_In_opt_ PTRANSLATE_ADDRESS_ROUTINE64 TranslateAddress
);
12. 01 Exception
โข StackWalk64
MachineType
์์ฑํ ์คํ ์ถ์ ์ ๋ณด์ ์ปดํจํฐ ์ํคํ
์ณ ์ข
๋ฅ์ด๋ค. ์๋ 3๊ฐ์ง ๊ฐ์ค ํ๋๋ฅผ ๊ฐ์ง๋ค.
โข IMAGE_FILE_MACHINE_I386 Intel x86 ์ํคํ
์ณ
โข IMAGE_FILE_MACHINE_IA64 Intel Itanium ์ํคํ
์ณ
โข IMAGE_FILE_MACHINE_AMD64 x64(AMD64 or EM64T) ์ํคํ
์ณ
hProcess, hThread
์คํ์ ์ถ์ ํ ํ๋ก์ธ์ค ๋ฐ ์ค๋ ๋ ํธ๋ค.
StackFrame
STACKFRAME64 ๊ตฌ์กฐ์ฒด์ ๋ํ ํฌ์ธํฐ. StackWalk64 ํจ์ ํธ์ถ์ด ์ฑ๊ณต์ ์ผ๋ก ์ด๋ฃจ์ด์ง๋ฉด
์ด ํฌ์ธํฐ์ ๋ค์ ์คํ ํ๋ ์์ ๋ํ ์ ๋ณด๊ฐ ๋ค์ด๊ฐ๋ค.
13. 01 Exception
โข StackWalk64
ContextRecord
CONTEXT ๊ตฌ์กฐ์ฒด์ ๋ํ ํฌ์ธํฐ. MachineType ์ธ์๊ฐ IMAGE_FILE_MACHINE_I386
์ด ์๋ ๋๋ง ํ์ํ๋ค(ํด๋น MachineType์ด ์๋๋ผ๋ ์ฌ์ฉ๊ฐ๋ฅํ context record
๊ฐ์ ๋๊ธฐ๋๊ฒ ๊ถ์ฅ๋๋ค๊ณ ํจ). ์ด ์ธ์๋ก ๋์ด๊ฐ ContextRecord ๊ฐ์ ์์ ๋ ์ ์๋ค.
RtlCaptureContext ํจ์๋ก ์ป์ด์ฌ ์ ์๋ค๊ณ ํ๋ค.
ReadMemoryRoutine
๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ฝ์ด์ค๋ ๋ฐ ํ์ํ ํจ์๋ฅผ ์ง์ ํ๋ค. ์๋ฌด๊ฒ๋ ์ง์ ํ์ง ์์ ๊ฒฝ์ฐ ๊ธฐ๋ณธ๊ฐ
(ReadProcessMemoryPros64)๋ก ์ง์ ๋จ.
FunctionTableAccessRoutine (optional)
ํ๋ก์ธ์ค์ run time function table์ ๋ํ ์ ๊ทผ์ ์ ๊ณตํ๋ ํจ์๋ฅผ ์ง์ .
SymFunctionTableAccess64 ๋ผ๋ ํจ์๋ฅผ ๋ณดํต ์ด๋ค๊ณ ํ๋ค
15. 01 Exception
โข StackWalk64
์ฌ์ฉ ์์
StackWalk64๋ฅผ ์ฐ๊ธฐ ์ํ ๊ธฐ๋ณธ ๋ณ์๋ค
BOOL res;
HANDLE hProcess;
HANDLE hThread;
CONTEXT context = {0, };
STACKFRAME64 stack = {0, };
ULONG frame;
const int MaxNameLen = 255;
SYMBOL_INFO* symbol =
(SYMBOL_INFO*)malloc(sizeof(SYMBOL_INFO) + MaxNameLen);
DWORD64 displacement64 = 0;
DWORD displacement = 0;
IMAGEHLP_LINE64 imageHelpLine;
DWORD dwSymOptions = SymGetOptions();
16. 01 Exception
โข StackWalk64
์ฌ์ฉ ์์
Symbol Option ์ด๊ธฐํ
dwSymOptions |= SYMOPT_LOAD_LINES;
dwSymOptions |= SYMOPT_UNDNAME;
dwSymOptions |= SYMOPT_EXACT_SYMBOLS;
SymSetOptions(dwSymOptions);
memset(symbol, 0, sizeof(SYMBOL_INFO) + MaxNameLen);
symbol->SizeOfStruct = sizeof(SYMBOL_INFO);
symbol->MaxNameLen = MaxNameLen;
memset(&imageHelpLine, 0, sizeof(imageHelpLine));
imageHelpLine.SizeOfStruct = sizeof(imageHelpLine);
SymInitialize(GetCurrentProcess(), ".", 1);
17. 01 Exception
โข StackWalk64
์ฌ์ฉ ์์
stack ๊ตฌ์กฐ์ฒด ์ด๊ธฐํ ๋ฐ context ์ ๋ณด ๊ฐ์ ธ์ค๊ธฐ
RtlCaptureContext(&context);
memset(&stack, 0, sizeof(STACKFRAME64));
hProcess = GetCurrentProcess();
hThread = GetCurrentThread();
stack.AddrPC.Offset = context.Eip;
stack.AddrPC.Mode = AddrModeFlat;
stack.AddrStack.Offset = context.Esp;
stack.AddrStack.Mode = AddrModeFlat;
stack.AddrFrame.Offset = context.Ebp;
stack.AddrFrame.Mode = AddrModeFlat;
stack.AddrBStore.Mode = AddrModeFlat;
stack.AddrReturn.Mode = AddrModeFlat;
19. 01 Exception
โข StackWalk64
์ฌ์ฉ ์์
์ฌ๋ณผ ์ ๋ณด ๊ฐ์ ธ์ค๊ธฐ ๋ฐ ์ถ๋ ฅ
SymFromAddr(hProcess, stack.AddrPC.Offset,
&displacement64, symbol);
SymGetLineFromAddr64(hProcess, stack.AddrPC.Offset,
&displacement, &imageHelpLine);
printf
(
"Frame %lu:nSymbol name: %snFile Name : %sn"
"Line Number : %dnPC address: 0x%08LXn"
"Frame address: 0x%08LXn",
frame, symbol->Name, imageHelpLine.FileName,
imageHelpLine.LineNumber, (ULONG64)stack.AddrPC.Offset,
(ULONG64)stack.AddrStack.Offset,
(ULONG64)stack.AddrFrame.Offset
);
22. 02 Log
โข C++ Log Library
C++์๋ ์ด๋ฏธ ์ ๋ง๋ค์ด์ง ๋ก๊ทธ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ค์ด ๋ง๋ค. ๊ทธ ์ค ๋ช ๊ฐ์ง๋ง ์ดํด๋ณด์.
glog
๊ตฌ๊ธ์์ ๋ง๋ C++ ๋ก๊ทธ ๋ผ์ด๋ธ๋ฌ๋ฆฌ. ์ดํ๋ฆฌ์ผ์ด์
์์ค์ ๋ก๊น
์ ๊ตฌํ. ๋๋ฒ๊ทธ ๋ชจ๋์์๋ง ๋ก
๊ทธ๋ฅผ ์ถ๋ ฅํ๋ ๊ธฐ๋ฅ, ํน์ ์ํ์์๋ง ๋ก๊ทธ๋ฅผ ๊ธฐ๋กํ๋ ๊ธฐ๋ฅ ๋ฑ๋ฑ์ ์ง์ํ๋ค.
์ฌ์ฉ๋ฒ ๊ด๋ จ ๋งํฌ : http://jjalidev.blogspot.kr/2013/10/glog.html
log4Cxx
log4j๋ฅผ ๋ณธ๋ฐ C++ ๋ฒ์ ผ์ผ๋ก ๋ง๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ. ๋น ๋ฅด๊ณ ํ์ฅ์ฑ์ด ์ข๋ค๊ณ ํ๋ค. ํ๊ฐ๊ฐ ์ข์ ํธ์ด
์ง๋ง 2008๋
์ดํ๋ก ์
๋ฐ์ดํธ๊ฐ ์๋ค.
์ฌ์ฉ๋ฒ ๊ด๋ จ ๋งํฌ : http://mindgear.tistory.com/184
23. 02 Log
โข Boost::log
C++ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ค ๊ฐ์ฅ ์ ๋ช
ํ๊ณ ๋ง์ด ์ฐ์ด๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ธ Boost ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ log ๊ธฐ๋ฅ์
ํ ๋ฒ ์จ๋ณด์. Boost ์ค์น๋ ๋งํฌ ์ฐธ์กฐ. ๊ธ์ ์ ํ ๊ฑธ ๊ทธ๋๋ก ๋ฐ๋ผํ๊ธฐ๋ง ํ๋ฉด ์๊ฐ๋ณด๋ค ์ด๋ ต์ง
์๊ฒ ์ค์นํ ์ ์๋ค. Simplicity, Extensibility, Performance๋ฅผ ๊ฐ์ง ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ๋ชฉํ๋ก
๋ง๋ค์๋ค๊ณ ํจ. ๋ฉ๋ด์ผ ๋งํฌ
24. 02 Log
โข Boost::log
๊ฐ๋ตํ ๊ตฌ์กฐ ์ค๋ช
( ์ ์ฌ๋ผ์ด๋์ ๊ทธ๋ฆผ ์ฐธ์กฐ)
Logging Sources
logger๋ ์ค์ ๊ธฐ๋ก๋ ๋ฉ์์ง๋ฅผ ํ์ํ(format)ํ๊ธฐ ์ํ ์คํธ๋ฆผ์ ์ ๊ณตํด์ฃผ๋ ์ค๋ธ์ ํธ๋ค.
๋ผ์ด๋ธ๋ฌ๋ฆฌ์์ ๋ค์ํ logger๋ฅผ ์ง์ํ๋ฉฐ ์ง์ logger๋ฅผ ๋ง๋ค์ด ์ฐ๊ฑฐ๋ ํ์ฅํด ์ธ ์ ์๋ค.
Attributes and attribute values
log source๋ฅผ ์ด๊ธฐํํ๊ธฐ ์ํด์๋ log record์ ๊ด๋ จ๋ ๋ชจ๋ ์ ๋ณด๋ฅผ logging core์ ๋๊ฒจ์ฃผ
์ด์ผํ๋ค. ์ด ๋ฐ์ดํฐ๋ค์ attribute๋ค์ ์งํฉ์ผ๋ก ๊ตฌ์ฑ๋์ด ์์ผ๋ฉฐ ๊ฐ๊ฐ์ attribute๋ค์ ๊ธฐ๋ณธ
์ ์ผ๋ก ํ๋์ ํจ์์ด๋ค. attribute set์๋ global / thread-specific, source-specific์
์ธ ๊ฐ์ง ์ข
๋ฅ๊ฐ ์๋ค.
Logging core and filtering
attribute value ์งํฉ์ด ๋ชจ๋ ๊ตฌ์ฑ๋๋ฉด, logging core๋ ํด๋น log record๊ฐ ๊ธฐ๋ก๋์ด์ผ ํ๋
log์ธ์ง ํ๋จํ๊ณ ํ์์์ผ๋ฉด ๋ฒ๋ฆฐ๋ค(filtering).
Sinks and formatting
ํํฐ๋ง์ ํต๊ณผํ๋ฉด ํด๋น record๋ฅผ ์ ์ ํ ํ์ํํด์ ํด๋น record๊ฐ ๊ธฐ๋ก๋์ด์ผ ํ sink๋ก ๋ณด
๋ธ๋ค. front-end / back-end๋ก ๊ตฌ์ฑ.
25. 02 Log
โข Boost::log
Trivial logging
์ ์ผ ๊ฐ๋จํ ๋ก๊น
. ๊ทธ๋ฅ ํด๋น ๋ฉ์์ง ์ฝ์ ์ฐฝ์ ์ถ๋ ฅํ๋ ๊ธฐ๋ฅ์ ํ๋ค(std::cout).
#include <boost/log/trivial.hpp>
int main()
{
BOOST_LOG_TRIVIAL(trace) << "A trace severity message";
BOOST_LOG_TRIVIAL(debug) << "A debug severity message";
BOOST_LOG_TRIVIAL(info) << "An informational severity message";
BOOST_LOG_TRIVIAL(warning) << "A warning severity message";
BOOST_LOG_TRIVIAL(error) << "An error severity message";
BOOST_LOG_TRIVIAL(fatal) << "A fatal severity message";
return 0;
}
26. 02 Log
โข Boost::log
Setup Sink
log๊ฐ ์ถ๋ ฅ๋ sink๋ฅผ ์ง์ ์ค์ ํด์ ์ฐ๊ธฐ.
namespace logging = boost::log;
namespace src = boost::log::sources;
namespace sinks = boost::log::sinks;
namespace keywords = boost::log::keywords;
int main()
{
using namespace logging::trivial;
logging::add_file_log
(
keywords::file_name =
"sample_%N.log",
keywords::rotation_size =
10 * 1024 * 1024,
keywords::format =
"[%TimeStamp%] : %Message%"
);
logging::core::get()->set_filter
(
severity >= info
);
logging::add_common_attributes();
src::severity_logger<severity_level> lg;
BOOST_LOG_SEV(lg, trace) <<
"A trace severity message";
BOOST_LOG_SEV(lg, debug) <<
"A debug severity message";
BOOST_LOG_SEV(lg, info) <<
"An informational severity message";
BOOST_LOG_SEV(lg, warning) <<
"A warning severity message";
BOOST_LOG_SEV(lg, error) <<
"An error severity message";
BOOST_LOG_SEV(lg, fatal) <<
"A fatal severity message";
return 0;
}
์ฌ์ฉ๋ฒ์ด ์๋นํ ๋ฐฉ๋ํด์ ์์ ๋ ์ด์ ๋๋ก..
๋ฉ๋ด์ผ ๋ฌธ์์ ํํ ๋ฆฌ์ผ์ด ๊ต์ฅํ ์ ์ ๋ฆฌ๋์ด
์์ผ๋ ๊ทธ๊ฑธ ์ฐธ๊ณ ํ์!
27. 02 Log
โข ๋ฉํฐ ์ค๋ ๋์์์ ๋ก๊ทธ
์ฑ๊ธ ์ค๋ ๋์์๋ ์๋ฌด ๋ฌธ์ ๊ฐ ์์ง๋ง, ์ญ์๋ ๋ฉํฐ ์ค๋ ๋๊ฐ ๋ผ๋ฉด ๋ฌธ์ ๊ฐ ๋ณต์กํด์ง๋ค. ์ฌ๋ฌ ์ค
๋ ๋์์ ๋์์ ์ด๋ฐ ์ ๋ฐ ๋ด์ฉ๋ค์ ๋ก๊น
ํ๋ ค๊ณ ํ ๋ ์์๊ฐ ๊ผฌ์ผ ์ ์๊ธฐ ๋๋ฌธ์ด๋ค. boost ๊ฐ
์ ๊ฒฝ์ฐ์๋ sink์์ frond-end์ back-end๋ฅผ ๋๋ ๋ค front-end์์ ์ค๋ ๋๊ฐ ๋๊ธฐํ ๋ฑ
์ ์์
์ ์ํํ๊ฒ ๋ง๋ค๊ณ back-end์์ ์ค์ ๋ก ๋ก๊ทธ๋ฅผ ๊ธฐ๋กํ๋ ์์
์ ์ํํ๋ ์์ผ๋ก ์ด
๋ฐ ์์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ค(์ค์ ๋ด๋ถ ๊ตฌ์กฐ๊ฐ ์ด๋ค ์์ผ๋ก ๋์ํ๋์ง๋ ์ ๋ชจ๋ฅด๊ฒ ๋ค). ๊ฐ์ธ์ ์ผ๋ก
์๊ฐํ๊ธฐ์๋ ์๋ 2๊ฐ์ง ๋ฐฉ๋ฒ ์ ๋๊ฐ ์์ ๊ฒ ๊ฐ๋ค.
queue ์ด์ฉํ๊ธฐ
thread-safeํ queue๋ฅผ ๋ง๋ค์ด์ ๊ฑฐ๊ธฐ ๋ก๊ทธํ ๋ด์ฉ์ ์ง์ด๋ฃ์ ๋ค ๊บผ๋ด์ ์ค์ ๋ก ๊ธฐ๋กํ๋
๊ฒ์ด๋ค.
GCE ๊ฐ์ ๊ตฌ์กฐ ์ด์ฉํ๊ธฐ
์ฝ๋ฉ ๊ณผ์ ์ ์๋ GCE ํด๋์ค์ฒ๋ผ ๋ง๋ค๋ฉด lock ์ ๊ฑธ๊ณ ์์ ๋ณด์ฅํ๋ log ๊ธฐ๋ก์ด ๊ฐ๋ฅํ ๊ฒ ๊ฐ
๋ค.(GCE๋ ๊ทธ๋ฐ ์ญํ ์ ํ๋๊น) log๋ฅผ ๊ธฐ๋กํ๋ ์ ๊ฐ ์๋ฌด๋ ์์ผ๋ฉด ์ง์ ๊ธฐ๋กํ๊ณ , ๋๊ตฐ๊ฐ log
๋ฅผ ๊ธฐ๋ก ์ค์ด๋ผ๋ฉด ๊ฑํํ
์๊ธฐ๊ฐ ํด์ผํ log๊น์ง ๋ ๋งก๊ธฐ๊ณ ๊ทธ๋ฅ ์๊ธฐ ํ ์ผ ํ๋ ๋ฐฉ์.