Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 3aa89364 authored by Andreas Gampe's avatar Andreas Gampe
Browse files

Base: Add default tag manipulation 

Allow the default tag (the program name) to be overwritten.

(cherry picked from commit 1923e768)

Bug: 34867873
Test: m
Test: logging_test
Test: manual
Merged-In: I4ef32bad413a7cc82e46ce16a2f26212925964b1
Change-Id: I4ef32bad413a7cc82e46ce16a2f26212925964b1
parent fc8febc8

base/include/android-base/logging.h

+3 −0
Original line number Diff line number Diff line
@@ -105,6 +105,9 @@ void StderrLogger(LogId, LogSeverity, const char*, const char*, unsigned int, co 


void DefaultAborter(const char* abort_message);



std::string GetDefaultTag();

void SetDefaultTag(const std::string& tag);



#ifdef __ANDROID__

// We expose this even though it is the default because a user that wants to

// override the default log buffer will have to construct this themselves.

base/logging.cpp

+31 −7
Original line number Diff line number Diff line
@@ -139,9 +139,27 @@ static AbortFunction& Aborter() { 
  return aborter;

}



static std::string& ProgramInvocationName() {

  static auto& programInvocationName = *new std::string(getprogname());

  return programInvocationName;

static std::recursive_mutex& TagLock() {

  static auto& tag_lock = *new std::recursive_mutex();

  return tag_lock;

}

static std::string* gDefaultTag;

std::string GetDefaultTag() {

  std::lock_guard<std::recursive_mutex> lock(TagLock());

  if (gDefaultTag == nullptr) {

    return "";

  }

  return *gDefaultTag;

}

void SetDefaultTag(const std::string& tag) {

  std::lock_guard<std::recursive_mutex> lock(TagLock());

  if (gDefaultTag != nullptr) {

    delete gDefaultTag;

    gDefaultTag = nullptr;

  }

  if (!tag.empty()) {

    gDefaultTag = new std::string(tag);

  }

}



static bool gInitialized = false;
@@ -269,8 +287,7 @@ void InitLogging(char* argv[], LogFunction&& logger, AbortFunction&& aborter) { 
  // Linux to recover this, but we don't have that luxury on the Mac/Windows,

  // and there are a couple of argv[0] variants that are commonly used.

  if (argv != nullptr) {

    std::lock_guard<std::mutex> lock(LoggingLock());

    ProgramInvocationName() = basename(argv[0]);

    SetDefaultTag(basename(argv[0]));

  }



  const char* tags = getenv("ANDROID_LOG_TAGS");
@@ -448,9 +465,16 @@ std::ostream& LogMessage::stream() { 


void LogMessage::LogLine(const char* file, unsigned int line, LogId id, LogSeverity severity,

                         const char* tag, const char* message) {

  if (tag == nullptr) tag = ProgramInvocationName().c_str();

  if (tag == nullptr) {

    std::lock_guard<std::recursive_mutex> lock(TagLock());

    if (gDefaultTag == nullptr) {

      gDefaultTag = new std::string(getprogname());

    }

    Logger()(id, severity, gDefaultTag->c_str(), file, line, message);

  } else {

    Logger()(id, severity, tag, file, line, message);

  }

}



void LogMessage::LogLine(const char* file, unsigned int line, LogId id, LogSeverity severity,

                         const char* message) {

base/logging_test.cpp

+26 −3
Original line number Diff line number Diff line
@@ -206,8 +206,8 @@ static std::string make_log_pattern(android::base::LogSeverity severity, 
}

#endif



static void CheckMessage(const CapturedStderr& cap,

                         android::base::LogSeverity severity, const char* expected) {

static void CheckMessage(const CapturedStderr& cap, android::base::LogSeverity severity,

                         const char* expected, const char* expected_tag = nullptr) {

  std::string output;

  ASSERT_EQ(0, lseek(cap.fd(), 0, SEEK_SET));

  android::base::ReadFdToString(cap.fd(), &output);
@@ -217,9 +217,18 @@ static void CheckMessage(const CapturedStderr& cap, 
  // many characters are in the log message.

  ASSERT_GT(output.length(), strlen(expected));

  ASSERT_NE(nullptr, strstr(output.c_str(), expected)) << output;

  if (expected_tag != nullptr) {

    ASSERT_NE(nullptr, strstr(output.c_str(), expected_tag)) << output;

  }



#if !defined(_WIN32)

  std::regex message_regex(make_log_pattern(severity, expected));

  std::string regex_str;

  if (expected_tag != nullptr) {

    regex_str.append(expected_tag);

    regex_str.append(" ");

  }

  regex_str.append(make_log_pattern(severity, expected));

  std::regex message_regex(regex_str);

  ASSERT_TRUE(std::regex_search(output, message_regex)) << output;

#endif

}
@@ -600,3 +609,17 @@ TEST(logging, LOG_FATAL_ABORTER_MESSAGE) { 
__attribute__((constructor)) void TestLoggingInConstructor() {

  LOG(ERROR) << "foobar";

}



TEST(logging, SetDefaultTag) {

  constexpr const char* expected_tag = "test_tag";

  constexpr const char* expected_msg = "foobar";

  CapturedStderr cap;

  {

    std::string old_default_tag = android::base::GetDefaultTag();

    android::base::SetDefaultTag(expected_tag);

    android::base::ScopedLogSeverity sls(android::base::LogSeverity::INFO);

    LOG(INFO) << expected_msg;

    android::base::SetDefaultTag(old_default_tag);

  }

  CheckMessage(cap, android::base::LogSeverity::INFO, expected_msg, expected_tag);

}