1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "trace_streamer_selector.h"
17 #include <algorithm>
18 #include <chrono>
19 #include <cstdlib>
20 #include <functional>
21 #include <regex>
22 #include "animation_filter.h"
23 #include "app_start_filter.h"
24 #include "args_filter.h"
25 #include "binder_filter.h"
26 #include "clock_filter_ex.h"
27 #include "cpu_filter.h"
28 #include "file.h"
29 #include "filter_filter.h"
30 #include "frame_filter.h"
31 #include "hi_sysevent_measure_filter.h"
32 #include "irq_filter.h"
33 #include "measure_filter.h"
34 #include "task_pool_filter.h"
35 #include "parser/bytrace_parser/bytrace_parser.h"
36 #include "parser/htrace_pbreader_parser/htrace_parser.h"
37 #include "parser/rawtrace_parser/rawtrace_parser.h"
38 #include "perf_data_filter.h"
39 #include "process_filter.h"
40 #include "slice_filter.h"
41 #include "stat_filter.h"
42 #include "string_help.h"
43 #include "system_event_measure_filter.h"
44
45 namespace {
46 const uint32_t CHUNK_SIZE = 1024 * 1024;
47 constexpr uint16_t RAW_TRACE_MAGIC_NUMBER = 57161;
48 } // namespace
49 using namespace SysTuning::base;
50 namespace SysTuning {
51 namespace TraceStreamer {
52 namespace {
IsHisysEventData(const std::string & bytraceMode)53 bool IsHisysEventData(const std::string& bytraceMode)
54 {
55 auto firstLine = std::find(bytraceMode.begin(), bytraceMode.end(), '}');
56 if (firstLine == bytraceMode.end()) {
57 return false;
58 }
59 std::string line(bytraceMode.begin(), ++firstLine);
60 json jMessage;
61 if (!jMessage.accept(line)) {
62 return false;
63 }
64 std::string startStr = R"({"domain_":)";
65 if (!StartWith(line, startStr)) {
66 return false;
67 }
68 return true;
69 }
GuessFileType(const uint8_t * data,size_t size)70 TraceFileType GuessFileType(const uint8_t* data, size_t size)
71 {
72 if (size == 0) {
73 return TRACE_FILETYPE_UN_KNOW;
74 }
75 std::string start(reinterpret_cast<const char*>(data), std::min<size_t>(size, 20));
76 if (start.find("# tracer") != std::string::npos) {
77 return TRACE_FILETYPE_BY_TRACE;
78 }
79 if (start.find("# TRACE") != std::string::npos) {
80 return TRACE_FILETYPE_BY_TRACE;
81 }
82 uint16_t magicNumber = INVALID_UINT16;
83 int ret = memcpy_s(&magicNumber, sizeof(uint16_t), data, sizeof(uint16_t));
84 TS_CHECK_TRUE(ret == EOK, TRACE_FILETYPE_UN_KNOW, "Memcpy FAILED!Error code is %d, data size is %zu.", ret, size);
85 if (magicNumber == RAW_TRACE_MAGIC_NUMBER) {
86 return TRACE_FILETYPE_RAW_TRACE;
87 }
88 std::string lowerStart(start);
89 transform(start.begin(), start.end(), lowerStart.begin(), ::tolower);
90 if ((lowerStart.compare(0, std::string("<!doctype html>").length(), "<!doctype html>") == 0) ||
91 (lowerStart.compare(0, std::string("<html>").length(), "<html>") == 0)) {
92 return TRACE_FILETYPE_BY_TRACE;
93 }
94 if (start.compare(0, std::string("\x0a").length(), "\x0a") == 0) {
95 return TRACE_FILETYPE_UN_KNOW;
96 }
97 if (start.compare(0, std::string("OHOSPROF").length(), "OHOSPROF") == 0) {
98 return TRACE_FILETYPE_H_TRACE;
99 }
100 if (start.compare(0, std::string("PERFILE2").length(), "PERFILE2") == 0) {
101 return TRACE_FILETYPE_PERF;
102 }
103 const std::regex bytraceMatcher = std::regex(R"(-(\d+)\s+\(?\s*(\d+|-+)?\)?\s?\[(\d+)\]\s*)"
104 R"([a-zA-Z0-9.]{0,5}\s+(\d+\.\d+):\s+(\S+):)");
105 std::smatch matcheLine;
106 std::string bytraceMode(reinterpret_cast<const char*>(data), size);
107 if (std::regex_search(bytraceMode, matcheLine, bytraceMatcher)) {
108 return TRACE_FILETYPE_BY_TRACE;
109 }
110
111 const std::regex hilogMatcher = std::regex(R"( *(\w+ )?([\-\d: ]+\.\d+) +(\d+) +(\d+) +([FEWID]) +(.+?): +(.+))");
112 if (std::regex_search(bytraceMode, matcheLine, hilogMatcher)) {
113 return TRACE_FILETYPE_HILOG;
114 }
115 // Identify hisysevent data
116 if (IsHisysEventData(bytraceMode)) {
117 return TRACE_FILETYPE_HI_SYSEVENT;
118 }
119 return TRACE_FILETYPE_UN_KNOW;
120 }
121 } // namespace
122
TraceStreamerSelector()123 TraceStreamerSelector::TraceStreamerSelector()
124 : fileType_(TRACE_FILETYPE_UN_KNOW), bytraceParser_(nullptr), htraceParser_(nullptr), rawTraceParser_(nullptr)
125 {
126 InitFilter();
127 }
~TraceStreamerSelector()128 TraceStreamerSelector::~TraceStreamerSelector() {}
129
InitFilter()130 void TraceStreamerSelector::InitFilter()
131 {
132 streamFilters_ = std::make_unique<TraceStreamerFilters>();
133 traceDataCache_ = std::make_unique<TraceDataCache>();
134 streamFilters_->animationFilter_ = std::make_unique<AnimationFilter>(traceDataCache_.get(), streamFilters_.get());
135 streamFilters_->cpuFilter_ = std::make_unique<CpuFilter>(traceDataCache_.get(), streamFilters_.get());
136 streamFilters_->sliceFilter_ = std::make_unique<SliceFilter>(traceDataCache_.get(), streamFilters_.get());
137
138 streamFilters_->processFilter_ = std::make_unique<ProcessFilter>(traceDataCache_.get(), streamFilters_.get());
139 streamFilters_->clockFilter_ = std::make_unique<ClockFilterEx>(traceDataCache_.get(), streamFilters_.get());
140 streamFilters_->filterFilter_ = std::make_unique<FilterFilter>(traceDataCache_.get(), streamFilters_.get());
141
142 streamFilters_->cpuMeasureFilter_ =
143 std::make_unique<MeasureFilter>(traceDataCache_.get(), streamFilters_.get(), E_CPU_MEASURE_FILTER);
144 streamFilters_->processMeasureFilter_ =
145 std::make_unique<MeasureFilter>(traceDataCache_.get(), streamFilters_.get(), E_PROCESS_MEASURE_FILTER);
146 streamFilters_->statFilter_ = std::make_unique<StatFilter>(traceDataCache_.get(), streamFilters_.get());
147 streamFilters_->binderFilter_ = std::make_unique<BinderFilter>(traceDataCache_.get(), streamFilters_.get());
148 streamFilters_->argsFilter_ = std::make_unique<ArgsFilter>(traceDataCache_.get(), streamFilters_.get());
149 streamFilters_->irqFilter_ = std::make_unique<IrqFilter>(traceDataCache_.get(), streamFilters_.get());
150 streamFilters_->frameFilter_ = std::make_unique<FrameFilter>(traceDataCache_.get(), streamFilters_.get());
151 streamFilters_->clockRateFilter_ =
152 std::make_unique<MeasureFilter>(traceDataCache_.get(), streamFilters_.get(), E_CLOCK_RATE_FILTER);
153 streamFilters_->clockEnableFilter_ =
154 std::make_unique<MeasureFilter>(traceDataCache_.get(), streamFilters_.get(), E_CLOCK_ENABLE_FILTER);
155 streamFilters_->clockDisableFilter_ =
156 std::make_unique<MeasureFilter>(traceDataCache_.get(), streamFilters_.get(), E_CLOCK_DISABLE_FILTER);
157 streamFilters_->clkRateFilter_ =
158 std::make_unique<MeasureFilter>(traceDataCache_.get(), streamFilters_.get(), E_CLK_RATE_FILTER);
159 streamFilters_->clkEnableFilter_ =
160 std::make_unique<MeasureFilter>(traceDataCache_.get(), streamFilters_.get(), E_CLK_ENABLE_FILTER);
161 streamFilters_->clkDisableFilter_ =
162 std::make_unique<MeasureFilter>(traceDataCache_.get(), streamFilters_.get(), E_CLK_DISABLE_FILTER);
163 streamFilters_->sysEventMemMeasureFilter_ =
164 std::make_unique<SystemEventMeasureFilter>(traceDataCache_.get(), streamFilters_.get(), E_SYS_MEMORY_FILTER);
165 streamFilters_->sysEventVMemMeasureFilter_ = std::make_unique<SystemEventMeasureFilter>(
166 traceDataCache_.get(), streamFilters_.get(), E_SYS_VIRTUAL_MEMORY_FILTER);
167 streamFilters_->appStartupFilter_ = std::make_unique<APPStartupFilter>(traceDataCache_.get(), streamFilters_.get());
168 streamFilters_->perfDataFilter_ = std::make_unique<PerfDataFilter>(traceDataCache_.get(), streamFilters_.get());
169 streamFilters_->sysEventSourceFilter_ = std::make_unique<SystemEventMeasureFilter>(
170 traceDataCache_.get(), streamFilters_.get(), E_SYS_EVENT_SOURCE_FILTER);
171 streamFilters_->hiSysEventMeasureFilter_ =
172 std::make_unique<HiSysEventMeasureFilter>(traceDataCache_.get(), streamFilters_.get());
173 streamFilters_->taskPoolFilter_ = std::make_unique<TaskPoolFilter>(traceDataCache_.get(), streamFilters_.get());
174 }
175
WaitForParserEnd()176 void TraceStreamerSelector::WaitForParserEnd()
177 {
178 if (fileType_ == TRACE_FILETYPE_H_TRACE) {
179 htraceParser_->WaitForParserEnd();
180 }
181 if (fileType_ == TRACE_FILETYPE_BY_TRACE || fileType_ == TRACE_FILETYPE_HILOG ||
182 fileType_ == TRACE_FILETYPE_HI_SYSEVENT) {
183 bytraceParser_->WaitForParserEnd();
184 }
185 if (fileType_ == TRACE_FILETYPE_PERF) {
186 htraceParser_->TraceDataSegmentEnd(false);
187 htraceParser_->WaitForParserEnd();
188 }
189 if (fileType_ == TRACE_FILETYPE_RAW_TRACE) {
190 rawTraceParser_->WaitForParserEnd();
191 }
192 traceDataCache_->UpdateTraceRange();
193 if (traceDataCache_->AnimationTraceEnabled()) {
194 streamFilters_->animationFilter_->UpdateFrameInfo();
195 streamFilters_->animationFilter_->UpdateDynamicFrameInfo();
196 }
197 }
198
GetMetaData()199 MetaData* TraceStreamerSelector::GetMetaData()
200 {
201 return traceDataCache_->GetMetaData();
202 }
203
SetDataType(TraceFileType type)204 void TraceStreamerSelector::SetDataType(TraceFileType type)
205 {
206 fileType_ = type;
207 if (fileType_ == TRACE_FILETYPE_H_TRACE) {
208 htraceParser_ = std::make_unique<HtraceParser>(traceDataCache_.get(), streamFilters_.get());
209 } else if (fileType_ == TRACE_FILETYPE_BY_TRACE) {
210 bytraceParser_ = std::make_unique<BytraceParser>(traceDataCache_.get(), streamFilters_.get());
211 } else if (fileType_ == TRACE_FILETYPE_RAW_TRACE) {
212 rawTraceParser_ = std::make_unique<RawTraceParser>(traceDataCache_.get(), streamFilters_.get());
213 }
214 }
215 // only support parse long trace profiler_data_xxxxxxxx_xxxxxx_x.htrace
BatchParseTraceDataSegment(std::unique_ptr<uint8_t[]> data,size_t size)216 bool TraceStreamerSelector::BatchParseTraceDataSegment(std::unique_ptr<uint8_t[]> data, size_t size)
217 {
218 if (size == 0) {
219 return true;
220 }
221 if (fileType_ == TRACE_FILETYPE_UN_KNOW) {
222 fileType_ = GuessFileType(data.get(), size);
223 if (fileType_ != TRACE_FILETYPE_H_TRACE) {
224 TS_LOGE("File type is not supported in this mode!");
225 return false;
226 }
227 htraceParser_ = std::make_unique<HtraceParser>(traceDataCache_.get(), streamFilters_.get());
228 }
229 htraceParser_->ParseTraceDataSegment(std::move(data), size);
230 return true;
231 }
ParseTraceDataSegment(std::unique_ptr<uint8_t[]> data,size_t size,bool isSplitFile,int32_t isFinish)232 bool TraceStreamerSelector::ParseTraceDataSegment(std::unique_ptr<uint8_t[]> data,
233 size_t size,
234 bool isSplitFile,
235 int32_t isFinish)
236 {
237 if (size == 0) {
238 return true;
239 }
240 if (fileType_ == TRACE_FILETYPE_UN_KNOW) {
241 fileType_ = GuessFileType(data.get(), size);
242 if (fileType_ == TRACE_FILETYPE_H_TRACE || fileType_ == TRACE_FILETYPE_PERF) {
243 htraceParser_ = std::make_unique<HtraceParser>(traceDataCache_.get(), streamFilters_.get());
244 htraceParser_->EnableFileSeparate(enableFileSeparate_);
245 } else if (fileType_ == TRACE_FILETYPE_BY_TRACE || fileType_ == TRACE_FILETYPE_HI_SYSEVENT ||
246 fileType_ == TRACE_FILETYPE_HILOG) {
247 bytraceParser_ = std::make_unique<BytraceParser>(traceDataCache_.get(), streamFilters_.get(), fileType_);
248 bytraceParser_->EnableBytrace(fileType_ == TRACE_FILETYPE_BY_TRACE);
249 } else if (fileType_ == TRACE_FILETYPE_RAW_TRACE) {
250 rawTraceParser_ = std::make_unique<RawTraceParser>(traceDataCache_.get(), streamFilters_.get());
251 }
252 if (fileType_ == TRACE_FILETYPE_UN_KNOW) {
253 SetAnalysisResult(TRACE_PARSER_FILE_TYPE_ERROR);
254 TS_LOGI(
255 "File type is not supported!,\nthe head content is:%s\n ---warning!!!---\n"
256 "File type is not supported!,\n",
257 data.get());
258 return false;
259 }
260 }
261 traceDataCache_->SetSplitFileMinTime(minTs_);
262 traceDataCache_->SetSplitFileMaxTime(maxTs_);
263 traceDataCache_->isSplitFile_ = isSplitFile;
264 if (fileType_ == TRACE_FILETYPE_H_TRACE) {
265 htraceParser_->ParseTraceDataSegment(std::move(data), size);
266 } else if (fileType_ == TRACE_FILETYPE_BY_TRACE || fileType_ == TRACE_FILETYPE_HI_SYSEVENT ||
267 fileType_ == TRACE_FILETYPE_HILOG) {
268 bytraceParser_->ParseTraceDataSegment(std::move(data), size, isFinish);
269 return true;
270 } else if (fileType_ == TRACE_FILETYPE_PERF) {
271 htraceParser_->StoreTraceDataSegment(std::move(data), size, isFinish);
272 } else if (fileType_ == TRACE_FILETYPE_RAW_TRACE) {
273 rawTraceParser_->ParseTraceDataSegment(std::move(data), size, isFinish);
274 }
275 SetAnalysisResult(TRACE_PARSER_NORMAL);
276 return true;
277 }
EnableMetaTable(bool enabled)278 void TraceStreamerSelector::EnableMetaTable(bool enabled)
279 {
280 traceDataCache_->EnableMetaTable(enabled);
281 }
282
EnableFileSave(bool enabled)283 void TraceStreamerSelector::EnableFileSave(bool enabled)
284 {
285 enableFileSeparate_ = enabled;
286 }
287
SetCleanMode(bool cleanMode)288 void TraceStreamerSelector::SetCleanMode(bool cleanMode)
289 {
290 g_curLogLevel = LOG_OFF;
291 }
292
ExportDatabase(const std::string & outputName,TraceDataDB::ResultCallBack resultCallBack)293 int32_t TraceStreamerSelector::ExportDatabase(const std::string& outputName, TraceDataDB::ResultCallBack resultCallBack)
294 {
295 traceDataCache_->UpdateTraceRange();
296 return traceDataCache_->ExportDatabase(outputName, resultCallBack);
297 }
CreatEmptyBatchDB(const std::string dbPath)298 int32_t TraceStreamerSelector::CreatEmptyBatchDB(const std::string dbPath)
299 {
300 return traceDataCache_->CreatEmptyBatchDB(dbPath);
301 }
BatchExportDatabase(const std::string & outputName)302 int32_t TraceStreamerSelector::BatchExportDatabase(const std::string& outputName)
303 {
304 traceDataCache_->UpdateTraceRange();
305 return traceDataCache_->BatchExportDatabase(outputName);
306 }
RevertTableName(const std::string & outputName)307 void TraceStreamerSelector::RevertTableName(const std::string& outputName)
308 {
309 return traceDataCache_->RevertTableName(outputName);
310 }
ExportPerfReadableText(const std::string & outputName,TraceDataDB::ResultCallBack resultCallBack)311 int32_t TraceStreamerSelector::ExportPerfReadableText(const std::string& outputName,
312 TraceDataDB::ResultCallBack resultCallBack)
313 {
314 traceDataCache_->UpdateTraceRange();
315 return traceDataCache_->ExportPerfReadableText(outputName, resultCallBack);
316 }
317
ExportHookReadableText(const std::string & outputName,TraceDataDB::ResultCallBack resultCallBack)318 int32_t TraceStreamerSelector::ExportHookReadableText(const std::string& outputName,
319 TraceDataDB::ResultCallBack resultCallBack)
320 {
321 traceDataCache_->UpdateTraceRange();
322 return traceDataCache_->ExportHookReadableText(outputName, resultCallBack);
323 }
324
ExportEbpfReadableText(const std::string & outputName,TraceDataDB::ResultCallBack resultCallBack)325 int32_t TraceStreamerSelector::ExportEbpfReadableText(const std::string& outputName,
326 TraceDataDB::ResultCallBack resultCallBack)
327 {
328 traceDataCache_->UpdateTraceRange();
329 return traceDataCache_->ExportEbpfReadableText(outputName, resultCallBack);
330 }
331
ReloadSymbolFiles(std::string & directory,std::vector<std::string> & symbolsPaths)332 bool TraceStreamerSelector::ReloadSymbolFiles(std::string& directory, std::vector<std::string>& symbolsPaths)
333 {
334 TS_LOGE("directory is %s", directory.c_str());
335 for (auto file : symbolsPaths) {
336 TS_LOGE("files is %s", file.c_str());
337 }
338 return htraceParser_->ReparseSymbolFilesAndResymbolization(directory, symbolsPaths);
339 }
Clear()340 void TraceStreamerSelector::Clear()
341 {
342 traceDataCache_->Prepare();
343 traceDataCache_->Clear();
344 }
SearchData()345 std::vector<std::string> TraceStreamerSelector::SearchData()
346 {
347 return traceDataCache_->SearchData();
348 }
OperateDatabase(const std::string & sql)349 int32_t TraceStreamerSelector::OperateDatabase(const std::string& sql)
350 {
351 return traceDataCache_->OperateDatabase(sql);
352 }
SearchDatabase(const std::string & sql,TraceDataDB::ResultCallBack resultCallBack)353 int32_t TraceStreamerSelector::SearchDatabase(const std::string& sql, TraceDataDB::ResultCallBack resultCallBack)
354 {
355 return traceDataCache_->SearchDatabase(sql, resultCallBack);
356 }
SearchDatabaseToProto(const std::string & data,SqllitePreparCacheData::TLVResultCallBack resultCallBack)357 int32_t TraceStreamerSelector::SearchDatabaseToProto(const std::string& data,
358 SqllitePreparCacheData::TLVResultCallBack resultCallBack)
359 {
360 return traceDataCache_->SearchDatabaseToProto(data, resultCallBack);
361 }
SearchDatabase(const std::string & sql,uint8_t * out,int32_t outLen)362 int32_t TraceStreamerSelector::SearchDatabase(const std::string& sql, uint8_t* out, int32_t outLen)
363 {
364 return traceDataCache_->SearchDatabase(sql, out, outLen);
365 }
SearchDatabase(std::string & sql,bool printf)366 int32_t TraceStreamerSelector::SearchDatabase(std::string& sql, bool printf)
367 {
368 return traceDataCache_->SearchDatabase(sql, printf);
369 }
SearchDatabase(const std::string & sql)370 std::string TraceStreamerSelector::SearchDatabase(const std::string& sql)
371 {
372 return traceDataCache_->SearchDatabase(sql);
373 }
InitMetricsMap(std::map<std::string,std::string> & metricsMap)374 void TraceStreamerSelector::InitMetricsMap(std::map<std::string, std::string>& metricsMap)
375 {
376 metricsMap.emplace(TRACE_MEM_UNAGG, MEM_UNAGG_QUERY);
377 metricsMap.emplace(TRACE_MEM, MEM_QUERY);
378 metricsMap.emplace(TRACE_MEM_TOP_TEN, MEM_TOP_QUERY);
379 metricsMap.emplace(TRACE_METADATA, META_DATA_QUERY);
380 metricsMap.emplace(SYS_CALLS, SYS_CALL_QUERY);
381 metricsMap.emplace(TRACE_STATS, TRACE_STATE_QUERY);
382 metricsMap.emplace(TRACE_TASK_NAMES, TRACE_TASK_NAME);
383 }
MetricsSqlQuery(const std::string & metrics)384 const std::string TraceStreamerSelector::MetricsSqlQuery(const std::string& metrics)
385 {
386 std::map<std::string, std::string> metricsMap;
387 InitMetricsMap(metricsMap);
388 auto itor = metricsMap.find(metrics);
389 if (itor == metricsMap.end()) {
390 TS_LOGE("metrics name error!!!");
391 return "";
392 }
393 return itor->second;
394 }
UpdateTraceRangeTime(uint8_t * data,int32_t len)395 int32_t TraceStreamerSelector::UpdateTraceRangeTime(uint8_t* data, int32_t len)
396 {
397 std::string traceRangeStr;
398 (void)memcpy_s(&traceRangeStr, len, data, len);
399 std::vector<string> vTraceRangeStr = SplitStringToVec(traceRangeStr, ";");
400 uint64_t minTs = std::stoull(vTraceRangeStr.at(0));
401 uint64_t maxTs = std::stoull(vTraceRangeStr.at(1));
402 traceDataCache_->UpdateTraceTime(minTs);
403 traceDataCache_->UpdateTraceTime(maxTs);
404 return 0;
405 }
SetCancel(bool cancel)406 void TraceStreamerSelector::SetCancel(bool cancel)
407 {
408 traceDataCache_->SetCancel(cancel);
409 }
UpdateBinderRunnableTraceStatus(bool status)410 void TraceStreamerSelector::UpdateBinderRunnableTraceStatus(bool status)
411 {
412 traceDataCache_->UpdateBinderRunnableTraceStatus(status);
413 }
UpdateAnimationTraceStatus(bool status)414 void TraceStreamerSelector::UpdateAnimationTraceStatus(bool status)
415 {
416 traceDataCache_->UpdateAnimationTraceStatus(status);
417 }
UpdateTaskPoolTraceStatus(bool status)418 void TraceStreamerSelector::UpdateTaskPoolTraceStatus(bool status)
419 {
420 traceDataCache_->UpdateTaskPoolTraceStatus(status);
421 }
UpdateAppStartTraceStatus(bool status)422 void TraceStreamerSelector::UpdateAppStartTraceStatus(bool status)
423 {
424 traceDataCache_->UpdateAppStartTraceStatus(status);
425 }
LoadQueryFile(const std::string & sqlOperator,std::vector<std::string> & sqlStrings)426 bool TraceStreamerSelector::LoadQueryFile(const std::string& sqlOperator, std::vector<std::string>& sqlStrings)
427 {
428 auto fd = fopen(sqlOperator.c_str(), "r");
429 if (!fd) {
430 TS_LOGE("open file failed!");
431 return false;
432 }
433 char buffer[CHUNK_SIZE];
434 while (!feof(fd)) {
435 std::string sqlString;
436 while (fgets(buffer, sizeof(buffer), fd)) {
437 std::string line = buffer;
438 if (line == "\n" || line == "\r\n") {
439 break;
440 }
441 sqlString.append(buffer);
442
443 if (EndWith(line, ";") || EndWith(line, ";\r\n")) {
444 break;
445 }
446 }
447
448 if (sqlString.empty()) {
449 continue;
450 }
451 sqlStrings.push_back(sqlString);
452 }
453 (void)fclose(fd);
454 fd = nullptr;
455 return true;
456 }
ReadSqlFileAndPrintResult(const std::string & sqlOperator)457 bool TraceStreamerSelector::ReadSqlFileAndPrintResult(const std::string& sqlOperator)
458 {
459 std::vector<std::string> sqlStrings;
460 if (!LoadQueryFile(sqlOperator, sqlStrings)) {
461 return false;
462 }
463 if (sqlStrings.empty()) {
464 TS_LOGE("%s is empty!", sqlOperator.c_str());
465 return false;
466 }
467 for (auto& str : sqlStrings) {
468 SearchDatabase(str, true);
469 }
470 return true;
471 }
ParserAndPrintMetrics(const std::string & metrics)472 bool TraceStreamerSelector::ParserAndPrintMetrics(const std::string& metrics)
473 {
474 auto metricsName = SplitStringToVec(metrics, ",");
475 for (const auto& itemName : metricsName) {
476 std::string result = SearchDatabase(MetricsSqlQuery(itemName));
477 if (result == "") {
478 return false;
479 }
480 Metrics metricsOperator;
481 metricsOperator.ParserJson(itemName, result);
482 for (auto item : metricsOperator.GetMetricsMap()) {
483 if (item.second == itemName) {
484 metricsOperator.PrintMetricsResult(item.first, nullptr);
485 continue;
486 }
487 }
488 }
489 return true;
490 }
491 } // namespace TraceStreamer
492 } // namespace SysTuning
493