모바일 로그

API 사용하여 모바일 앱 로그를 뉴렐릭으로 보낼 수 있습니다. 귀하의 로그는 분석할 수 있는 한 곳에 보관됩니다.

모바일 로그 활성화

새로 생성된 모바일 엔티티의 경우 기본적으로 100% 샘플링 속도와 WARN 의 로그 레벨로 모바일 로깅이 활성화됩니다.

이전에 로깅이 비활성화된 기존 엔티티의 경우 또는 설정을 확인하려면 다음을 참조하십시오.

one.newrelic.com > All capabilities 으)로 이동합니다.
Mobile 을(를) 클릭합니다.
모바일 앱을 클릭하세요.
Settings 아래의 왼쪽 창에서 Application Settings 클릭합니다.
Mobile Logs 을 켭니다.
Save 을(를) 클릭합니다.

로그 구성

샘플링 속도 또는 로그인 레벨을 구성하려면:

뉴렐릭에서 모바일 앱으로 이동합니다.
Settings 아래의 왼쪽 창에서 Application Settings 클릭합니다.
샘플링 속도를 변경하려면 Sample rate of total sessions [총 세션의 샘플링 속도] 아래 필드에서 새 값을 선택합니다.
로그 레벨을 변경하려면 드롭다운 메뉴의 Logs verbosity [로그 세부 정보] 아래에서 원하는 로그 레벨을 선택하세요.

로그 레벨을 조정하여 수집되는 데이터 양을 제어할 수 있습니다. 지원되는 레벨은 다음과 같습니다.

ERROR
WARN (새 앱의 기본값)
INFO
VERBOSE
DEBUG

팁

임시 문제 해결, 해결을 위해 로그 레벨을 VERBOSE 또는 DEBUG 로만 높이세요. 이러한 수준에서는 데이터 수집이 크게 늘어납니다. 릴리스 빌드에는 WARN 또는 ERROR 사용하는 것을 권장합니다.

중요

서버 측 설정: 모바일 로그 설정은 서버 측에서 제어됩니다. 즉, 토글, 샘플링 속도 또는 로그인 레벨에 대한 변경 사항을 적용하기 위해 앱의 새 버전을 구현하거나 배포할 필요가 없습니다. 에이전트는 다음 앱 등장 또는 설정 가져오기에서 새로운 설정을 선택합니다.

로그 수집 방법

수동 API 수집(권장): 당사 API를 사용하여 특정 로그 메시지, 속성 및 예외를 전송하십시오.
자동 수집: 에이전트는 표준 출력(stdout) 및 표준 오류(stderr)로 전송되는 로그를 자동으로 캡처할 수 있습니다.
- 필수 조건: 자동 수집은 기본적으로 비활성화 되어 있어야 합니다. 활성화하려면:
  1. 앱 초기화 코드에서 NRFeatureFlag_AutoCollectLogs 기능 플래그를 활성화해야 합니다.
  2. New Relic UI에서 Mobile Logs [모바일 로그] 토글이 On [켜짐]으로 설정되어 있습니다.

뉴렐릭에서 로그인 보기

UI에서 로그를 보려면:

모바일 앱으로 이동합니다.
왼쪽 창의 Triage 아래에서 Logs 클릭합니다.

모바일 로깅이 일부 지연될 수 있습니다.

로그가 Logs 페이지에 나타나려면 최대 15분이 걸립니다.
로그 토글, 샘플링 속도, 로그 레벨을 변경하는 데 최대 15분이 소요됩니다. 이 변경 사항은 모바일 애플리케이션에 반영됩니다.

API를 사용하여 로그 캡처

아래 API는 애플리케이션에서 다양한 유형의 정보와 이벤트를 캡처하기 위한 포괄적인 로깅 방법 세트를 제공합니다. 이러한 방법을 사용하면 다양한 심각도 수준(정보, 경고, 디버그, 자세한 정보, 오류)으로 메시지를 로깅하고, 사용자 지정 로깅 수준과 throwables(예외) 및 속성과 같은 추가 컨텍스트를 로깅할 수 있습니다.

로깅 API 사용할 때 에이전트 디버깅 로그를 보려면 디버그 로그 레벨만 사용해야 한다는 점을 명심하세요.

통사론

자바

NewRelic.logInfo(String message)

NewRelic.logWarning(String message)

NewRelic.logDebug(String message)

NewRelic.logVerbose(String message)

NewRelic.logError(String message)

NewRelic.log(LogLevel logLevel, String message)

NewRelic.logThrowable(LogLevel logLevel, String message, Throwable throwable)

NewRelic.logAttributes(Map<String, Object> attributes)

NewRelic.logAll(Throwable throwable, Map<String, Object> attributes)

코틀린 [#kotlin]

NewRelic.logInfo(String message)

NewRelic.logWarning(String message)

NewRelic.logDebug(String message)

NewRelic.logVerbose(String message)

NewRelic.logError(String message)

NewRelic.log(LogLevel logLevel, String message)

NewRelic.logThrowable(LogLevel logLevel, String message, Throwable throwable)

NewRelic.logAttributes(Map<String, Object> attributes)

NewRelic.logAll(Throwable throwable, Map<String, Object> attributes)

예시 [#example]

자바 [#java]

// Log info
NewRelic.logInfo("This is an info message");

// Log warning
NewRelic.logWarning("This is a warning message");

// Log debug
NewRelic.logDebug("This is a debug message");

// Log verbose
NewRelic.logVerbose("This is a verbose message");

// Log error
NewRelic.logError("This is an error message");

// Log with specific log level
NewRelic.log(LogLevel.INFO, "This is a log message with INFO level");

// Log throwable with specific log level
try {
    throw new Exception("This is a test exception");
} catch (Exception e) {
    NewRelic.logThrowable(LogLevel.ERROR, "Exception occurred", e);
}

// Log attributes
Map<String, Object> attributes = new HashMap<>();
attributes.put("key1", "value1");
attributes.put("key2", 123);
NewRelic.logAttributes(attributes);

// Log all with throwable and attributes
try {
    throw new Exception("This is another test exception");
} catch (Exception e) {
    NewRelic.logAll(e, attributes);
}

코틀린 [#kotlin]

// Log info
NewRelic.logInfo("This is an info message")

// Log warning
NewRelic.logWarning("This is a warning message")

// Log debug
NewRelic.logDebug("This is a debug message")

// Log verbose
NewRelic.logVerbose("This is a verbose message")

// Log error
NewRelic.logError("This is an error message")

// Log with specific log level
NewRelic.log(LogLevel.INFO, "This is a log message with INFO level")

// Log throwable with specific log level
try {
    throw Exception("This is a test exception")
} catch (e: Exception) {
    NewRelic.logThrowable(LogLevel.ERROR, "Exception occurred", e)
}

// Log attributes
val attributes = mapOf("key1" to "value1", "key2" to 123)
NewRelic.logAttributes(attributes)

통사론

목표-c

(void) logInfo:(NSString* __nonnull) message;
(void) logError:(NSString* __nonnull) message;
(void) logVerbose:(NSString* __nonnull) message;
(void) logWarning:(NSString* __nonnull) message;
(void) logAudit:(NSString* __nonnull) message;
(void) logDebug:(NSString* __nonnull) message;
(void) log:(NSString* __nonnull) message level:(NRLogLevels)level;
(void) logAll:(NSDictionary* __nonnull) dict;
(void) logAttributes:(NSDictionary* __nonnull) dict;
(void) logErrorObject:(NSError* __nonnull) error;

빠른 [#swift]

func logInfo(_ message: String)
func logError(_ message: String)
func logVerbose(_ message: String)
func logWarning(_ message: String)
func logAudit(_ message: String)
func logDebug(_ message: String)
func log(_ message: String, level: NRLogLevels)
func logAll(_ dict: [String: Any])
func logAttributes(_ dict: [String: Any])
func logErrorObject(_ error: NSError)

예시 [#example]

목표-c [#objective-c]

[NewRelic logInfo:@"This is an info message"];

[NewRelic logError:@"This is an error message"];

[NewRelic logVerbose:@"This is a verbose message"];

[NewRelic logWarning:@"This is a warning message"];

[NewRelic logAudit:@"This is an audit message"];

[NewRelic logDebug:@"This is a debug message"];

[NewRelic log:@"This is a custom log level message" level:NRLogLevelsCustom];

NSDictionary *logDict = @{@"key1": @"value1", @"key2": @"value2"};
[NewRelic logAll:logDict];

NSDictionary *attributesDict = @{@"attribute1": @"value1", @"attribute2": @"value2"};
[NewRelic logAttributes:attributesDict];

NSError *error = [NSError errorWithDomain:@"com.example" code:100 userInfo:@{NSLocalizedDescriptionKey: @"This is an error description"}];
[NewRelic logErrorObject:error];

빠른 [#swift]

NewRelic.logError("Encountered error=error=\(error.localizedDescription).")

NewRelic.logWarning("Warning text.")

NewRelic.logInfo("Info text.")

NewRelic.logVerbose("NewRelic.start was called.")

NewRelic.logDebug("Debug text.")

do {
    try errorMethod()
} catch {
    NewRelic.logErrorObject(error)
}

NewRelic.logAll([
    "logLevel": "WARN",
    "message": "This is a test message for the New Relic logging system."
])

NewRelic.logAttributes([
    "logLevel": "WARN",
    "message": "This is a test message for the New Relic logging system.",
    "additionalAttribute1": "attribute1",
    "additionalAttribute2": "attribute2"
])

통사론

NewRelicCapacitorPlugin.logInfo(options: { message: string}) => void

NewRelicCapacitorPlugin.logVerbose(options: { message: string}) => void

NewRelicCapacitorPlugin.logError(options: { message: string}) => void

NewRelicCapacitorPlugin.logWarn(options: { message: string}) => void

NewRelicCapacitorPlugin.logDebug(options: { message: string}) => void

NewRelicCapacitorPlugin.logAll(options: { error: string; attributes: object; }): void

NewRelicCapacitorPlugin.logAttributes(options: { attributes: object; }): void

예시 [#example]

NewRelicCapacitorPlugin.logInfo({message: "User profile loaded successfully"});

NewRelicCapacitorPlugin.logVerbose({message:"Verbose logging example"});

NewRelicCapacitorPlugin.logError({message:"Error loading user profile"});

NewRelicCapacitorPlugin.logWarn({message: "Low disk space warning"});

NewRelicCapacitorPlugin.logDebug({message:"Debugging session started"});

NewRelicCapacitorPlugin.logAll({
  error: "UnexpectedError",
  attributes: { "errorCode": "500", "errorMessage": "Internal Server Error" ,level:"WARN"}
});

NewRelicCapacitorPlugin.logAttributes({attributes:{
  "userID": 12345,
  "sessionID": "abcde12345",
  "isLoggedIn": true,
  "message":"this is test",
  "level":"INFO"
}});

통사론

NewRelic.logInfo(message: string): void;

NewRelic.logDebug(message: string): void;

NewRelic.logVerbose(message: string): void;

NewRelic.logWarn(message: string): void;

NewRelic.logError(message: string): void;

NewRelic.log(level: string, message: string): void;

NewRelic.logAttributes(attributes: {[key: string]: boolean | number | string}): void;

예시 [#example]

NewRelic.logInfo("User logged in successfully");

NewRelic.logDebug("Debug message");

NewRelic.logVerbose("Verbose message detailing step-by-step execution");

NewRelic.logWarn("Warning message indicating a potential issue");

NewRelic.logError("Error message indicating a failure");

NewRelic.log("INFO", "User logged in successfully");

NewRelic.logAttributes({
  "userID": 12345,
  "sessionID": "abcde12345",
  "isLoggedIn": true,
  "message":"this is test",
  "level":"INFO"
});

통사론

CrossNewRelic.Current.LogInfo(String message) : void

CrossNewRelic.Current.LogError(String message) : void

CrossNewRelic.Current.LogVerbose(String message) : void

CrossNewRelic.Current.LogWarning(String message) : void

CrossNewRelic.Current.LogDebug(String message) : void

CrossNewRelic.Current.Log(LogLevel level, String message) : void

CrossNewRelic.Current.LogAttributes(Dictionary<string, object> attributes) : void

예시 [#example]

CrossNewRelic.Current.LogInfo("This is an informational message");

CrossNewRelic.Current.LogError("This is an error message");

CrossNewRelic.Current.LogVerbose("This is a verbose message");

CrossNewRelic.Current.LogWarning("This is a warning message");

CrossNewRelic.Current.LogDebug("This is a debug message");

CrossNewRelic.Current.Log(LogLevel.Info, "This is an informational message");

CrossNewRelic.Current.LogAttributes(new Dictionary<string, object>()
    {
        { "level","info"},
        { "BreadNumValue", 12.3 },
        { "BreadStrValue", "MAUIBread" },
        { "BreadBoolValue", true },
        { "message", "This is a message with attributes" }
    }
);

통사론

NewrelicMobile.instance.logInfo(String message) : void

NewrelicMobile.instance.logError(String message) : void

NewrelicMobile.instance.logVerbose(String message) : void

NewrelicMobile.instance.logWarning(String message) : void

NewrelicMobile.instance.logDebug(String message) : void

NewrelicMobile.instance.log(LogLevel level, String message) : void

NewrelicMobile.instance.logAll(Exception exception,Map<String, dynamic>? attributes) : void

NewrelicMobile.instance.logAttributes(Dictionary<string, object> attributes) : void

예시 [#example]

NewrelicMobile.instance.logInfo("This is an informational message");

NewrelicMobile.instance.logError("This is an error message");

NewrelicMobile.instance.logVerbose("This is a verbose message");

NewrelicMobile.instance.logWarning("This is a warning message");

NewrelicMobile.instance.logDebug("This is a debug message");

NewrelicMobile.instance.log(LogLevel.Info, "This is an informational message");

NewrelicMobile.instance.logAll(Exception("This is an exception"), {
  "BreadNumValue": 12.3,
  "BreadStrValue": "FlutterBread",
  "BreadBoolValue": true,
  "message": "This is a message with attributes",
   "level":"info"
});

NewrelicMobile.instance.logAttributes({
  "BreadNumValue": 12.3,
  "BreadStrValue": "FlutterBread",
  "BreadBoolValue": true,
  "message": "This is a message with attributes",
  "level":"info"
});

통사론

NewRelic.logInfo(String message) : void

NewRelic.logError(String message) : void

NewRelic.logVerbose(String message) : void

NewRelic.logWarning(String message) : void

NewRelic.logDebug(String message) : void

NewRelic.log(LogLevel level, String message) : void

NewRelic.logAll(Error error,attributes?: {[key: string]: any}) : void

NewRelic.logAttributes(attributes?: {[key: string]: any}) : void

예시 [#example]

NewRelic.logInfo();

NewRelic.logError("This is an error message");

NewRelic.logVerbose("This is a verbose message");

NewRelic.logWarning("This is a warning message");

NewRelic.logDebug("This is a debug message");

NewRelic.log(LogLevel.INFO, "This is an informational message");

Newrelic.logAll(new Error("This is an exception"), {
  BreadNumValue: 12.3,
  BreadStrValue: "FlutterBread",
  BreadBoolValue: true,
  message: "This is a message with attributes",
});

Newrelic.logAttributes({
  BreadNumValue: 12.3,
  BreadStrValue: "FlutterBread",
  BreadBoolValue: true,
  message: "This is a message with attributes",
  level: newRelic.LogLevel.INFO,
});

통사론

CrossNewRelicClient.Current.LogInfo(String message) : void

CrossNewRelicClient.Current.LogError(String message) : void

CrossNewRelicClient.Current.LogVerbose(String message) : void

CrossNewRelicClient.Current.LogWarning(String message) : void

CrossNewRelicClient.Current.LogDebug(String message) : void

CrossNewRelicClient.Current.Log(LogLevel level, String message) : void

CrossNewRelicClient.Current.LogAttributes(Dictionary<string, object> attributes) : void

예시 [#example]

CrossNewRelicClient.Current.LogInfo("This is an informational message");

CrossNewRelicClient.Current.LogError("This is an error message");

CrossNewRelicClient.Current.LogVerbose("This is a verbose message");

CrossNewRelicClient.Current.LogWarning("This is a warning message");

CrossNewRelicClient.Current.LogDebug("This is a debug message");

CrossNewRelicClient.Current.Log(LogLevel.Info, "This is an informational message");

CrossNewRelicClient.Current.LogAttributes(new Dictionary<string, object>()
    {
        {"level", "info"},
        { "BreadNumValue", 12.3 },
        { "BreadStrValue", "XamBread" },
        { "BreadBoolValue", true },
        { "message", "This is a message with attributes" }
    }
);

통사론

NewRelicAgent.LogInfo(String message) : void

NewRelicAgent.LogError(String message) : void

NewRelicAgent.LogVerbose(String message) : void

NewRelicAgent.LogWarning(String message) : void

NewRelicAgent.LogDebug(String message) : void

NewRelicAgent.Log(LogLevel level, String message) : void

NewRelicAgent.LogAttributes(Dictionary<string, object> attributes) : void

예시 [#example]

NewRelicAgent.LogInfo("This is an informational message");

NewRelicAgent.LogError("This is an error message");

NewRelicAgent.LogVerbose("This is a verbose message");

NewRelicAgent.LogWarning("This is a warning message");

NewRelicAgent.LogDebug("This is a debug message");

NewRelicAgent.Log(LogLevel.Info, "This is an informational message");

NewRelicAgent.LogAttributes(new Dictionary<string, object>()
        {
            {"level", "info"},
            {"BreadNumValue", 12.3 },
            {"BreadStrValue", "UnityBread" },
            {"BreadBoolValue", true },
            {"message", "This is a message with attributes" }
        }
    );

통사론

UNewRelicBPLibrary::logInfo(FString message) : void

UNewRelicBPLibrary::logError(FString message) : void

UNewRelicBPLibrary::logVerbose(FString message) : void

UNewRelicBPLibrary::logWarning(FString message) : void

UNewRelicBPLibrary::logDebug(FString message) : void

UNewRelicBPLibrary::log(AgentLogLevel level, FString message) : void

UNewRelicBPLibrary::logAttributes(TMap <FString, FString> attributes) : void

예시 [#example]

#include "NewRelicBPLibrary.h"

UNewRelicBPLibrary::logInfo("This is an informational message");

UNewRelicBPLibrary::logError("This is an error message");

UNewRelicBPLibrary::logVerbose("This is a verbose message");

UNewRelicBPLibrary::logDebug("This is a debug message");

UNewRelicBPLibrary::logWarning("This is a warning message");

UNewRelicBPLibrary::log(AgentLogLevel::Debug, "This is a debug message");

TMap<FString, FString> attributes;
attributes.Add("place", TEXT("Robots"));
attributes.Add("user", TEXT("user1"));
attributes.Add("level", TEXT("DEBUG"));
attributes.Add("message", TEXT("This is a debug message"));

UNewRelicBPLibrary::logAttributes(attributes);

사용자의 편의를 위해 제공되는 기계 번역입니다.