1 /*
2 * Copyright (C) 2023 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <cstdint>
18 #include <memory>
19 #include <vector>
20
21 #include "src/trace_processor/importers/proto/network_trace_module.h"
22
23 #include "perfetto/base/status.h"
24 #include "perfetto/ext/base/string_view.h"
25 #include "perfetto/protozero/packed_repeated_fields.h"
26 #include "perfetto/protozero/scattered_heap_buffer.h"
27 #include "perfetto/trace_processor/trace_blob.h"
28 #include "perfetto/trace_processor/trace_blob_view.h"
29 #include "protos/perfetto/trace/android/network_trace.pbzero.h"
30 #include "protos/perfetto/trace/trace.pbzero.h"
31 #include "src/trace_processor/db/column/types.h"
32 #include "src/trace_processor/importers/common/args_tracker.h"
33 #include "src/trace_processor/importers/common/args_translation_table.h"
34 #include "src/trace_processor/importers/common/async_track_set_tracker.h"
35 #include "src/trace_processor/importers/common/global_args_tracker.h"
36 #include "src/trace_processor/importers/common/process_track_translation_table.h"
37 #include "src/trace_processor/importers/common/slice_tracker.h"
38 #include "src/trace_processor/importers/common/slice_translation_table.h"
39 #include "src/trace_processor/importers/common/track_tracker.h"
40 #include "src/trace_processor/importers/proto/proto_trace_parser_impl.h"
41 #include "src/trace_processor/importers/proto/proto_trace_reader.h"
42 #include "src/trace_processor/sorter/trace_sorter.h"
43 #include "src/trace_processor/storage/trace_storage.h"
44 #include "src/trace_processor/types/trace_processor_context.h"
45 #include "src/trace_processor/types/variadic.h"
46 #include "test/gtest_and_gmock.h"
47
48 namespace perfetto::trace_processor {
49 namespace {
50
51 using ::perfetto::protos::pbzero::TrafficDirection;
52
53 class NetworkTraceModuleTest : public testing::Test {
54 public:
NetworkTraceModuleTest()55 NetworkTraceModuleTest() {
56 context_.storage = std::make_shared<TraceStorage>();
57 storage_ = context_.storage.get();
58
59 context_.track_tracker = std::make_unique<TrackTracker>(&context_);
60 context_.slice_tracker = std::make_unique<SliceTracker>(&context_);
61 context_.args_tracker = std::make_unique<ArgsTracker>(&context_);
62 context_.global_args_tracker =
63 std::make_unique<GlobalArgsTracker>(storage_);
64 context_.slice_translation_table =
65 std::make_unique<SliceTranslationTable>(storage_);
66 context_.process_track_translation_table =
67 std::make_unique<ProcessTrackTranslationTable>(storage_);
68 context_.args_translation_table =
69 std::make_unique<ArgsTranslationTable>(storage_);
70 context_.async_track_set_tracker =
71 std::make_unique<AsyncTrackSetTracker>(&context_);
72 context_.proto_trace_parser =
73 std::make_unique<ProtoTraceParserImpl>(&context_);
74 context_.sorter = std::make_shared<TraceSorter>(
75 &context_, TraceSorter::SortingMode::kFullSort);
76 }
77
TokenizeAndParse()78 base::Status TokenizeAndParse() {
79 context_.chunk_readers.push_back(
80 std::make_unique<ProtoTraceReader>(&context_));
81
82 trace_->Finalize();
83 std::vector<uint8_t> v = trace_.SerializeAsArray();
84 trace_.Reset();
85
86 auto status = context_.chunk_readers.back()->Parse(
87 TraceBlobView(TraceBlob::CopyFrom(v.data(), v.size())));
88 context_.sorter->ExtractEventsForced();
89 context_.slice_tracker->FlushPendingSlices();
90 context_.args_tracker->Flush();
91 return status;
92 }
93
HasArg(ArgSetId sid,base::StringView key,Variadic value)94 bool HasArg(ArgSetId sid, base::StringView key, Variadic value) {
95 StringId key_id = storage_->InternString(key);
96 const auto& a = storage_->arg_table();
97 Query q;
98 q.constraints = {a.arg_set_id().eq(sid)};
99 for (auto it = a.FilterToIterator(q); it; ++it) {
100 if (it.key() == key_id) {
101 EXPECT_EQ(it.flat_key(), key_id);
102 if (storage_->GetArgValue(it.row_number().row_number()) == value) {
103 return true;
104 }
105 }
106 }
107 return false;
108 }
109
110 protected:
111 protozero::HeapBuffered<protos::pbzero::Trace> trace_;
112 TraceProcessorContext context_;
113 TraceStorage* storage_;
114 };
115
TEST_F(NetworkTraceModuleTest,ParseAndFormatPacket)116 TEST_F(NetworkTraceModuleTest, ParseAndFormatPacket) {
117 NetworkTraceModule module(&context_);
118
119 auto* packet = trace_->add_packet();
120 packet->set_timestamp(123);
121
122 auto* event = packet->set_network_packet();
123 event->set_direction(TrafficDirection::DIR_EGRESS);
124 event->set_length(72);
125 event->set_uid(1010);
126 event->set_tag(0x407);
127 event->set_local_port(5100);
128 event->set_remote_port(443);
129 event->set_tcp_flags(0b10010);
130 event->set_ip_proto(6);
131 event->set_interface("wlan");
132
133 ASSERT_TRUE(TokenizeAndParse().ok());
134
135 const auto& slices = storage_->slice_table();
136 ASSERT_EQ(slices.row_count(), 1u);
137 EXPECT_EQ(slices[0].ts(), 123);
138
139 EXPECT_TRUE(HasArg(2u, "packet_length", Variadic::Integer(72)));
140 EXPECT_TRUE(HasArg(2u, "socket_uid", Variadic::Integer(1010)));
141 EXPECT_TRUE(HasArg(2u, "local_port", Variadic::Integer(5100)));
142 EXPECT_TRUE(HasArg(2u, "remote_port", Variadic::Integer(443)));
143 EXPECT_TRUE(HasArg(2u, "packet_transport",
144 Variadic::String(storage_->InternString("IPPROTO_TCP"))));
145 EXPECT_TRUE(HasArg(2u, "socket_tag",
146 Variadic::String(storage_->InternString("0x407"))));
147 EXPECT_TRUE(HasArg(2u, "packet_tcp_flags",
148 Variadic::String(storage_->InternString(".s..a..."))));
149 }
150
TEST_F(NetworkTraceModuleTest,TokenizeAndParsePerPacketBundle)151 TEST_F(NetworkTraceModuleTest, TokenizeAndParsePerPacketBundle) {
152 NetworkTraceModule module(&context_);
153
154 auto* packet = trace_->add_packet();
155 packet->set_timestamp(123);
156
157 protozero::PackedVarInt timestamps;
158 timestamps.Append(0);
159 timestamps.Append(10);
160
161 protozero::PackedVarInt lengths;
162 lengths.Append(72);
163 lengths.Append(100);
164
165 auto* event = packet->set_network_packet_bundle();
166 event->set_packet_timestamps(timestamps);
167 event->set_packet_lengths(lengths);
168
169 auto* ctx = event->set_ctx();
170 ctx->set_uid(456);
171
172 ASSERT_TRUE(TokenizeAndParse().ok());
173
174 const auto& slices = storage_->slice_table();
175 ASSERT_EQ(slices.row_count(), 2u);
176 EXPECT_EQ(slices[0].ts(), 123);
177 EXPECT_EQ(slices[1].ts(), 133);
178
179 EXPECT_TRUE(HasArg(2u, "packet_length", Variadic::Integer(72)));
180 EXPECT_TRUE(HasArg(3u, "packet_length", Variadic::Integer(100)));
181 }
182
TEST_F(NetworkTraceModuleTest,TokenizeAndParseAggregateBundle)183 TEST_F(NetworkTraceModuleTest, TokenizeAndParseAggregateBundle) {
184 NetworkTraceModule module(&context_);
185
186 auto* packet = trace_->add_packet();
187 packet->set_timestamp(123);
188
189 auto* event = packet->set_network_packet_bundle();
190 event->set_total_packets(2);
191 event->set_total_duration(10);
192 event->set_total_length(172);
193
194 auto* ctx = event->set_ctx();
195 ctx->set_uid(456);
196
197 ASSERT_TRUE(TokenizeAndParse().ok());
198
199 const auto& slices = storage_->slice_table();
200 ASSERT_EQ(slices.row_count(), 1u);
201 EXPECT_EQ(slices[0].ts(), 123);
202 EXPECT_EQ(slices[0].dur(), 10);
203
204 EXPECT_TRUE(HasArg(2u, "packet_length", Variadic::Integer(172)));
205 EXPECT_TRUE(HasArg(2u, "packet_count", Variadic::Integer(2)));
206 }
207
208 } // namespace
209 } // namespace perfetto::trace_processor
210