blob: 854a7da3f84cb52113a7508dbab5fe82040c8a83 [file]
// Copyright 2021 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <lib/syslog/cpp/macros.h>
#include <zircon/types.h>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include "log_decoder.h"
#include "log_decoder_api.h"
namespace log_decoder {
namespace {
struct ScopedLogMessages {
LogMessages messages;
explicit ScopedLogMessages(LogMessages m) : messages(m) {}
ScopedLogMessages(const ScopedLogMessages&) = delete;
ScopedLogMessages& operator=(const ScopedLogMessages&) = delete;
~ScopedLogMessages() { fuchsia_free_log_messages(messages); }
};
fuchsia_logger::LogMessage DecodeBuffer(fuchsia_logging::LogBuffer& buffer) {
std::span<const uint8_t> span = buffer.EndRecord();
ZX_ASSERT(!span.empty() && span.data() != nullptr);
ScopedLogMessages decoded(fuchsia_decode_log_messages_to_struct(
span.data(), span.size(), /*expect_extended_attribution=*/false, nullptr));
EXPECT_EQ(decoded.messages.error_str, nullptr);
EXPECT_EQ(decoded.messages.messages.len, 1u);
auto fidl_res = ToFidlLogMessage(*decoded.messages.messages.ptr[0]);
EXPECT_TRUE(fidl_res.is_ok());
return fidl_res.take_value();
}
TEST(LogDecoder, DecodesCorrectly) {
fuchsia_logging::LogBufferBuilder builder(fuchsia_logging::LogSeverity::Info);
auto buffer = builder.WithMsg("test message").WithFile(__FILE__, __LINE__).Build();
buffer.WriteKeyValue("tag", "some tag");
buffer.WriteKeyValue("tag", "some other tag");
buffer.WriteKeyValue("user property", 5.2);
std::span<const uint8_t> span = buffer.EndRecord();
ASSERT_FALSE(span.empty());
ASSERT_NE(span.data(), nullptr);
ScopedLogMessages decoded(fuchsia_decode_log_messages_to_struct(
span.data(), span.size(), /*expect_extended_attribution=*/false, nullptr));
ASSERT_EQ(decoded.messages.error_str, nullptr);
ASSERT_EQ(decoded.messages.messages.len, 1u);
const LogMessage* raw_msg = decoded.messages.messages.ptr[0];
ASSERT_EQ(raw_msg->tags.len, 2u);
EXPECT_EQ(std::string_view(reinterpret_cast<const char*>(raw_msg->tags.ptr[0].ptr),
raw_msg->tags.ptr[0].len),
"some tag");
EXPECT_EQ(std::string_view(reinterpret_cast<const char*>(raw_msg->tags.ptr[1].ptr),
raw_msg->tags.ptr[1].len),
"some other tag");
ASSERT_EQ(raw_msg->kvps.len, 1u);
EXPECT_EQ(std::string_view(reinterpret_cast<const char*>(raw_msg->kvps.ptr[0].key.ptr),
raw_msg->kvps.ptr[0].key.len),
"user property");
EXPECT_EQ(raw_msg->kvps.ptr[0].value.tag, CppValue::Tag::CPP_VALUE_FLOATING);
EXPECT_DOUBLE_EQ(raw_msg->kvps.ptr[0].value.FLOATING._0, 5.2);
EXPECT_EQ(
std::string_view(reinterpret_cast<const char*>(raw_msg->message.ptr), raw_msg->message.len),
"test message");
}
TEST(LogDecoder, DecodeInvalidBytesReturnsError) {
const uint8_t invalid_bytes[] = {0x01, 0x02, 0x03, 0x04};
ScopedLogMessages decoded(fuchsia_decode_log_messages_to_struct(
invalid_bytes, sizeof(invalid_bytes), /*expect_extended_attribution=*/false, nullptr));
EXPECT_NE(decoded.messages.error_str, nullptr);
EXPECT_EQ(decoded.messages.messages.len, 0u);
}
TEST(LogDecoder, DecodesArchivistArguments) {
constexpr char kTestMoniker[] = "some_moniker";
constexpr char kTestUrl[] = "fuchsia-pkg://fuchsia.com/test#test.cm";
fuchsia_logging::LogBufferBuilder builder(fuchsia_logging::LogSeverity::Info);
auto buffer = builder.WithMsg("test message").WithFile("test_file", 42).Build();
std::span<const uint8_t> span = buffer.EndRecord();
std::vector<uint8_t> new_buffer(span.size() + 4 + 4 + 8 + ((sizeof(kTestMoniker) - 1 + 7) & ~7) +
((sizeof(kTestUrl) - 1 + 7) & ~7));
memcpy(new_buffer.data(), span.data(), span.size());
size_t current_offset = span.size();
uint32_t moniker_len = sizeof(kTestMoniker) - 1;
uint32_t url_len = sizeof(kTestUrl) - 1;
uint64_t rolled_out_logs = 1;
memcpy(new_buffer.data() + current_offset, &moniker_len, 4);
current_offset += 4;
memcpy(new_buffer.data() + current_offset, &url_len, 4);
current_offset += 4;
memcpy(new_buffer.data() + current_offset, &rolled_out_logs, 8);
current_offset += 8;
memcpy(new_buffer.data() + current_offset, kTestMoniker, moniker_len);
current_offset += (moniker_len + 7) & ~7;
memcpy(new_buffer.data() + current_offset, kTestUrl, url_len);
current_offset += (url_len + 7) & ~7;
auto messages =
fuchsia_decode_log_messages_to_struct(new_buffer.data(), current_offset, true, nullptr);
ASSERT_EQ(messages.messages.len, static_cast<size_t>(1));
ASSERT_EQ(messages.messages.ptr[0]->tags.len, static_cast<size_t>(0));
auto fidl_res = ToFidlLogMessage(*messages.messages.ptr[0]);
ASSERT_TRUE(fidl_res.is_ok());
auto fidl_msg = fidl_res.take_value();
ASSERT_EQ(fidl_msg.tags().size(), 1u);
EXPECT_EQ(fidl_msg.tags()[0], kTestMoniker);
EXPECT_EQ(fidl_msg.msg(), "[test_file(42)] test message");
fuchsia_free_log_messages(messages);
}
TEST(LogDecoderApi, ToFidlLogMessageMonikerTag) {
constexpr char kTestMoniker[] = "core/network/netstack";
constexpr char kTestUrl[] = "fuchsia-pkg://fuchsia.com/netstack#meta/netstack.cm";
fuchsia_logging::LogBufferBuilder builder(fuchsia_logging::LogSeverity::Info);
auto buffer = builder.WithMsg("hello network").WithFile("net.cc", 100).Build();
buffer.WriteKeyValue("tag", "custom_tag");
std::span<const uint8_t> span = buffer.EndRecord();
std::vector<uint8_t> new_buffer(span.size() + 4 + 4 + 8 + ((sizeof(kTestMoniker) - 1 + 7) & ~7) +
((sizeof(kTestUrl) - 1 + 7) & ~7));
memcpy(new_buffer.data(), span.data(), span.size());
size_t current_offset = span.size();
uint32_t moniker_len = sizeof(kTestMoniker) - 1;
uint32_t url_len = sizeof(kTestUrl) - 1;
uint64_t rolled_out_logs = 0;
memcpy(new_buffer.data() + current_offset, &moniker_len, 4);
current_offset += 4;
memcpy(new_buffer.data() + current_offset, &url_len, 4);
current_offset += 4;
memcpy(new_buffer.data() + current_offset, &rolled_out_logs, 8);
current_offset += 8;
memcpy(new_buffer.data() + current_offset, kTestMoniker, moniker_len);
current_offset += (moniker_len + 7) & ~7;
memcpy(new_buffer.data() + current_offset, kTestUrl, url_len);
current_offset += (url_len + 7) & ~7;
auto messages =
fuchsia_decode_log_messages_to_struct(new_buffer.data(), current_offset, true, nullptr);
ASSERT_EQ(messages.messages.len, 1u);
const LogMessage* raw_msg = messages.messages.ptr[0];
EXPECT_EQ(raw_msg->tags.len, 1u);
auto fidl_res = ToFidlLogMessage(*raw_msg);
ASSERT_TRUE(fidl_res.is_ok());
auto fidl_msg = fidl_res.take_value();
ASSERT_EQ(fidl_msg.tags().size(), 2u);
EXPECT_EQ(fidl_msg.tags()[0], "netstack");
EXPECT_EQ(fidl_msg.tags()[1], "custom_tag");
EXPECT_EQ(fidl_msg.msg(), "[net.cc(100)] hello network");
fuchsia_free_log_messages(messages);
}
TEST(LogDecoderApi, ToFidlLogMessageRootMonikerOmitsDotTag) {
constexpr char kTestMoniker[] = ".";
constexpr char kTestUrl[] = "fuchsia-pkg://fuchsia.com/root#meta/root.cm";
fuchsia_logging::LogBufferBuilder builder(fuchsia_logging::LogSeverity::Info);
auto buffer = builder.WithMsg("hello root").WithFile("root.cc", 10).Build();
buffer.WriteKeyValue("tag", "integration_test");
std::span<const uint8_t> span = buffer.EndRecord();
// Allocate a buffer large enough for the FXT log record followed by the extended attribution
// metadata appended by Archivist: a 16-byte header (4-byte moniker length, 4-byte component URL
// length, and 8-byte rolled-out logs count) plus the 8-byte aligned moniker and URL strings.
std::vector<uint8_t> new_buffer(span.size() + 4 + 4 + 8 + ((sizeof(kTestMoniker) - 1 + 7) & ~7) +
((sizeof(kTestUrl) - 1 + 7) & ~7));
// Copy the encoded FXT log record into the start of the buffer.
memcpy(new_buffer.data(), span.data(), span.size());
size_t current_offset = span.size();
uint32_t moniker_len = sizeof(kTestMoniker) - 1;
uint32_t url_len = sizeof(kTestUrl) - 1;
uint64_t rolled_out_logs = 0;
// Append the 16-byte extended metadata header: moniker_len, url_len, and rolled_out_logs.
memcpy(new_buffer.data() + current_offset, &moniker_len, 4);
current_offset += 4;
memcpy(new_buffer.data() + current_offset, &url_len, 4);
current_offset += 4;
memcpy(new_buffer.data() + current_offset, &rolled_out_logs, 8);
current_offset += 8;
// Append the moniker and component URL strings, each padded to an 8-byte boundary.
memcpy(new_buffer.data() + current_offset, kTestMoniker, moniker_len);
current_offset += (moniker_len + 7) & ~7;
memcpy(new_buffer.data() + current_offset, kTestUrl, url_len);
current_offset += (url_len + 7) & ~7;
auto messages =
fuchsia_decode_log_messages_to_struct(new_buffer.data(), current_offset, true, nullptr);
ASSERT_EQ(messages.messages.len, 1u);
const LogMessage* raw_msg = messages.messages.ptr[0];
auto fidl_res = ToFidlLogMessage(*raw_msg);
ASSERT_TRUE(fidl_res.is_ok());
auto fidl_msg = fidl_res.take_value();
ASSERT_EQ(fidl_msg.tags().size(), 1u);
EXPECT_EQ(fidl_msg.tags()[0], "integration_test");
EXPECT_EQ(fidl_msg.msg(), "[root.cc(10)] hello root");
fuchsia_free_log_messages(messages);
}
TEST(LogDecoder, HandlesInvalidInput) {
// A simple invalid byte sequence. A valid log message would have a different structure.
const uint8_t invalid_data[] = {0xDE, 0xAD, 0xBE, 0xEF};
ScopedLogMessages decoded(fuchsia_decode_log_messages_to_struct(
invalid_data, sizeof(invalid_data), /*expect_extended_attribution=*/true, nullptr));
ASSERT_NE(decoded.messages.error_str, nullptr);
ASSERT_EQ(std::string(decoded.messages.error_str),
std::string("couldn't parse message: InvalidHeader"));
}
TEST(LogDecoderApi, ToFidlLogMessageMultipleArguments) {
fuchsia_logging::LogBufferBuilder builder(fuchsia_logging::LogSeverity::Info);
auto buffer = builder.WithMsg("test message").WithFile("test_file", 42).Build();
buffer.WriteKeyValue("tag", "my_tag");
buffer.WriteKeyValue("int_key", int64_t{-123});
buffer.WriteKeyValue("uint_key", uint64_t{456});
buffer.WriteKeyValue("double_key", 3.14);
buffer.WriteKeyValue("neg_double", -2.5);
buffer.WriteKeyValue("zero_double", 0.0);
buffer.WriteKeyValue("bool_key", true);
buffer.WriteKeyValue("bool_false", false);
buffer.WriteKeyValue("text_key", "hello \"world\" \\ test");
buffer.WriteKeyValue("empty_text", "");
auto fidl_msg = DecodeBuffer(buffer);
EXPECT_EQ(fidl_msg.severity(), static_cast<int32_t>(fuchsia_logging::LogSeverity::Info));
ASSERT_EQ(fidl_msg.tags().size(), 1u);
EXPECT_EQ(fidl_msg.tags()[0], "my_tag");
EXPECT_EQ(fidl_msg.msg(),
"[test_file(42)] test message int_key=-123 uint_key=456 double_key=3.140000 "
"neg_double=-2.500000 zero_double=0.000000 bool_key=true bool_false=false "
"text_key=\"hello \\\"world\\\" \\\\ test\" empty_text=\"\"");
}
TEST(LogDecoderApi, ToFidlLogMessageMessageNoFile) {
fuchsia_logging::LogBufferBuilder builder(fuchsia_logging::LogSeverity::Info);
auto buffer = builder.WithMsg("test message").Build();
buffer.WriteKeyValue("foo", "bar");
buffer.WriteKeyValue("num", int64_t{10});
auto fidl_msg = DecodeBuffer(buffer);
EXPECT_EQ(fidl_msg.msg(), "test message foo=\"bar\" num=10");
}
TEST(LogDecoderApi, ToFidlLogMessageNoArguments) {
fuchsia_logging::LogBufferBuilder builder(fuchsia_logging::LogSeverity::Info);
auto buffer = builder.WithMsg("test message").WithFile("test_file", 42).Build();
auto fidl_msg = DecodeBuffer(buffer);
EXPECT_EQ(fidl_msg.msg(), "[test_file(42)] test message");
}
TEST(LogDecoderApi, ToFidlLogMessageOneArgument) {
fuchsia_logging::LogBufferBuilder builder(fuchsia_logging::LogSeverity::Info);
auto buffer = builder.WithMsg("test message").WithFile("test_file", 42).Build();
buffer.WriteKeyValue("foo", "bar");
auto fidl_msg = DecodeBuffer(buffer);
EXPECT_EQ(fidl_msg.msg(), "[test_file(42)] test message foo=\"bar\"");
}
TEST(LogDecoderApi, ToFidlLogMessageNoMessage) {
fuchsia_logging::LogBufferBuilder builder0(fuchsia_logging::LogSeverity::Info);
auto buffer0 = builder0.WithMsg("").WithFile("test_file", 42).Build();
EXPECT_EQ(DecodeBuffer(buffer0).msg(), "[test_file(42)]");
fuchsia_logging::LogBufferBuilder builder1(fuchsia_logging::LogSeverity::Info);
auto buffer1 = builder1.WithMsg("").WithFile("test_file", 42).Build();
buffer1.WriteKeyValue("key", int64_t{100});
EXPECT_EQ(DecodeBuffer(buffer1).msg(), "[test_file(42)] key=100");
fuchsia_logging::LogBufferBuilder builder2(fuchsia_logging::LogSeverity::Info);
auto buffer2 = builder2.WithMsg("").WithFile("test_file", 42).Build();
buffer2.WriteKeyValue("k1", int64_t{1});
buffer2.WriteKeyValue("k2", int64_t{2});
EXPECT_EQ(DecodeBuffer(buffer2).msg(), "[test_file(42)] k1=1 k2=2");
}
TEST(LogDecoderApi, ToFidlLogMessageNoMessageNoFile) {
fuchsia_logging::LogBufferBuilder builder0(fuchsia_logging::LogSeverity::Info);
auto buffer0 = builder0.WithMsg("").Build();
EXPECT_EQ(DecodeBuffer(buffer0).msg(), "");
fuchsia_logging::LogBufferBuilder builder1(fuchsia_logging::LogSeverity::Info);
auto buffer1 = builder1.WithMsg("").Build();
buffer1.WriteKeyValue("only_key", "val");
EXPECT_EQ(DecodeBuffer(buffer1).msg(), "only_key=\"val\"");
fuchsia_logging::LogBufferBuilder builder2(fuchsia_logging::LogSeverity::Info);
auto buffer2 = builder2.WithMsg("").Build();
buffer2.WriteKeyValue("a", int64_t{10});
buffer2.WriteKeyValue("b", int64_t{20});
EXPECT_EQ(DecodeBuffer(buffer2).msg(), "a=10 b=20");
}
} // namespace
} // namespace log_decoder