Console sa Xcode: mga pangunahing konsepto, output ng data, at pag-debug

Ano ang Console sa Xcode

Console — bahagi ng Debug Area sa Xcode, na matatagpuan sa ibabang panel ng editor (View → Debug Area → Activate Console, shortcut Cmd + Shift + Y). Ipinapakita ng Console ang lahat ng text output ng tumatakbong app: mga mensahe mula sa NSLog, os_log, print, runtime warning, at awtomatikong exception dump kapag nag-crash ang app.

Ang Console ay gumagana kapwa sa simulator at sa pisikal na device. Sa simulator, dumarating agad ang mga mensahe sa pamamagitan ng local pipe, sa device — sa pamamagitan ng USB connection na may 1–3 frame na pagkaantala. Para sa production app, hindi available ang Console sa device — umaasa ang developer sa Crashlytics o Unified Logging na may remote collection sa pamamagitan ng log collect.

Hindi tulad ng system app na Console.app sa Mac, ang Console window sa Xcode ay nagpapakita lamang ng log ng kasalukuyang tumatakbong app (na may kakayahang mag-filter). Ang Console.app ay nangongolekta ng log ng lahat ng proseso sa Mac, kabilang ang iOS simulators. Gayunpaman, para sa pag-debug ng iOS apps, ginagamit ng mga developer ang built-in na Console Xcode dahil sa integrasyon nito sa LLDB debugger.

Logging API: NSLog, os_log, at print

Tatlong pangunahing API ang available sa iOS developer para sa output sa Console: NSLog (luma na), os_log (inirerekomenda), at print (Swift lang). Bawat isa ay may kanya-kanyang katangian sa performance, pag-format, at compatibility sa Unified Logging System.

NSLog — klasikong logging

NSLog — function mula sa Foundation, available sa Objective-C at Swift. Naglalabas ang NSLog ng mensahe na may timestamp, pangalan ng proseso, at PID. Mga disadvantages: sumusulat ang NSLog sa system buffer nang sabay-sabay (synchronously), hinaharangan ang kasalukuyang thread habang sumusulat. Sa madalas na pagtawag (halimbawa, sa loop), nagdudulot ang NSLog ng kapansin-pansing pagkaantala. Hindi inirerekomenda ng Apple ang NSLog para sa mga bagong proyekto, ngunit nananatili itong compatible sa lumang code at third-party libraries.

os_log — modernong pamantayan

os_log — API mula sa os.framework, ipinakilala sa iOS 10. Ang os_log ay asynchronous: ang mensahe ay inilalagay sa queue at isinusulat sa buffer nang hindi hinaharangan ang tumatawag na thread. Ayon sa WWDC 2016, ang os_log ay 50 beses na mas mabilis kaysa sa NSLog sa mga high-load na sitwasyon. Sinusuportahan din ng os_log ang dynamic na pamamahala: ang mga mensahe ng DEBUG level ay kinokolekta lamang sa Debug build, sa Release ay hindi pinapansin nang walang performance cost.

print() — Swift-only na output

print() — ang pinakasimpleng paraan ng output sa Swift. Sumusulat ang print sa stdout (standard output), na iriniruta ng Xcode papunta sa Console. Hindi nagdaragdag ang print ng metadata (oras, level), ngunit sinusuportahan nito ang stdout buffering. Para sa mabilis na pag-debug, ang print ay isang maginhawang tool, ngunit para sa permanenteng logging, ito ay mas mababa sa os_log sa functionality at kontrol.

import os.log

// NSLog — luma na, humaharang
NSLog("Application started")

// os_log — inirerekomenda, asynchronous
let log = OSLog(
    subsystem: "com.myapp",
    category: "lifecycle"
)
os_log("Application started", log: log)

// print — mabilis na Swift output
print("Application started")

Unified Logging: mga kategorya, level, at subsystem

Unified Logging System (ULS) — komprehensibong logging infrastructure ng Apple, ipinakilala sa iOS 10 at macOS Sierra. Kinokolekta ng ULS ang mga mensahe mula sa lahat ng system process sa iisang imbakan na may remote access sa pamamagitan ng log command-line tool sa Mac. Ginagamit ng developer ang os_log para sumulat sa ULS at ang Console para magbasa.

Mga subsystem at kategorya

Bawat OSLog ay natutukoy ng isang pares ng subsystem (hal., com.myapp.network) at category (hal., http, websocket). Ang subsystem ay domain ng app (isang app ay maaaring magkaroon ng maraming subsystem para sa iba't ibang module). Ang kategorya ay isang component sa loob ng subsystem. Ang kombinasyon ng subsystem + category ay nagbibigay-daan sa flexible na pag-filter ng log sa Console at log collect.

Mga level ng logging ng OSLog

log collect — remote na pagkolekta ng log

Ang command na log collect sa Mac ay nangongolekta ng mga naka-archive na log mula sa nakakonektang iOS device sa isang .logarchive file. Ang file na ito ay maaaring buksan sa Console.app sa Mac para sa detalyadong pagsusuri, kabilang ang os_log na mga mensahe, crash log, at system diagnostics. Upang paganahin ang pagkolekta sa device, kailangan mong i-on ang Developer Mode at ikonekta ang device sa pamamagitan ng USB.

Pagtatrabaho sa Console: step-by-step na pag-debug at pagsusuri ng crash log

Praktikal na trabaho sa Console ay sumasaklaw sa tatlong pangunahing sitwasyon: aktibong logging sa panahon ng pag-develop, pagsusuri ng crash log pagkatapos ng crash, at remote diagnostics sa pamamagitan ng .logarchive. Para sa bawat sitwasyon, mayroong pinakamainam na set ng mga tool at setting.

Pag-configure ng Console para sa pag-develop

Inirerekomenda na gumawa ng hiwalay na OSLog para sa bawat module ng app na may mga level: debug (detalyadong pag-debug), info (mahahalagang transition ng estado), error (mga exception at failure). Sa Console Xcode, paganahin ang filter ayon sa subsystem ng iyong app upang ibukod ang mga system message na lumilikha ng ingay at nakakaabala sa lohika ng app.

Pagsusuri ng crash log

Kapag nag-crash ang app, awtomatikong hihinto ang Xcode ng execution at ipapakita ang thread kung saan nangyari ang crash, na may kumpletong stack trace sa Console. Ang unang linya ng crash log ay naglalaman ng exception type (NSException, EXC_BAD_ACCESS) at dahilan (reason). Pag-aralan ang stack trace mula ibaba pataas: ang huling tinawag na pamamaraan ay ang lokasyon ng crash. Para sa mga naka-encrypt na address (sa Release), kinakailangan ang symbolication sa pamamagitan ng dSYM.

// Halimbawa ng modular na OSLog configuration
extension OSLog {
    static let uiLifecycle = OSLog(
        subsystem: "com.myapp.ui",
        category: "lifecycle"
    )
    static let network = OSLog(
        subsystem: "com.myapp.network",
        category: "http"
    )
    static let database = OSLog(
        subsystem: "com.myapp.data",
        category: "core-data"
    )
}

// Paggamit na may mga level
os_log("View did load", log: .uiLifecycle, type: .debug)
os_log("HTTP 200 received", log: .network, type: .info)
os_log("Failed to save: \(error.localizedDescription)",
    log: .database, type: .error)

Mga Advanced na Feature: breakpoint log at custom na format

Xcode Console ay sumusuporta sa maraming advanced na function na lampas sa simpleng logging. Ang breakpoint log ay nagbibigay-daan sa pag-output ng mga mensahe sa Console nang hindi humihinto ang execution, at ang LLDB commands sa Debugger Command ay nagbibigay ng buong kontrol sa pag-format ng output.

Breakpoint log nang walang paghinto

Maaari kang mag-configure ng breakpoint upang mag-output ito ng mensahe sa Console at awtomatikong magpatuloy ng execution. Maglagay ng breakpoint sa nais na linya, i-right click → Edit Breakpoint → magdagdag ng Debugger Command: “po self” o “expr @import UIKit” + Debugger Command: “po self.view”. Lagyan ng tsek ang Automatically continue after evaluating. Pagkatapos ng pagtakbo, ang breakpoint ay magpapakita ng resulta ng command sa Console sa bawat pag-abot sa linya, nang hindi naaabala ang thread.

LLDB commands sa Console

Ang Console Xcode ay sumusuporta sa pag-execute ng arbitrary na LLDB commands habang naka-hinto sa breakpoint. Ang po (print object) ay nagpapakita ng paglalarawan ng object, p (print) — primitive values, at expr — nag-execute ng Swift/ObjC expressions. Para sa formatted output, gamitin ang p/CGRectGetWidth. Ang LLDB output ay ipinapakita sa Console kaagad pagkatapos maabot ang breakpoint.

func processUserData(user: User) {
    // Breakpoint dito na may Debugger Command:
    // po "User name: \(user.name)"
    // expr user.age = 30
    print("Processing user: \(user.name)")
}

// Halimbawa ng custom logging na may pagkakasunod-sunod
func trackMethodCall(
    file: String = #file,
    function: String = #function
) {
    os_log("[\(function)] called",
        log: .uiLifecycle, type: .debug)
}

Integrasyon sa Instruments

Console Xcode ay malapit na isinama sa Instruments — ang profiling tool ng Xcode. Kapag pinatakbo ang app sa pamamagitan ng Product → Profile na may Logging template, lahat ng os_log na mensahe ay naitala sa Instruments tracks na may timestamp. Ito ay nagpapahintulot na makita ang log, performance, at system events nang sabay-sabay sa isang time scale, na mahalaga para sa pag-diagnose ng race condition at performance regression.