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 "base/log/ace_trace.h"
17
18#ifndef WINDOWS_PLATFORM
19#include "securec.h"
20#endif
21
22namespace OHOS::Ace {
23namespace {
24const size_t MAX_STRING_SIZE = 512;
25}
26
27bool AceTraceBeginWithArgv(const char* format, va_list args)
28{
29    char name[MAX_STRING_SIZE] = { 0 };
30    if (vsnprintf_s(name, sizeof(name), sizeof(name) - 1, format, args) < 0) {
31        return false;
32    }
33    AceTraceBegin(name);
34    return true;
35}
36
37bool AceTraceBeginWithArgvCommercial(const char* format, va_list args)
38{
39    char name[MAX_STRING_SIZE] = { 0 };
40    if (vsnprintf_s(name, sizeof(name), sizeof(name) - 1, format, args) < 0) {
41        return false;
42    }
43    AceTraceBeginCommercial(name);
44    return true;
45}
46
47bool AceTraceBeginWithArgs(const char* format, ...)
48{
49    va_list args;
50    va_start(args, format);
51    bool retVal = AceTraceBeginWithArgv(format, args);
52    va_end(args);
53    return retVal;
54}
55
56void AceCountTraceWidthArgs(int32_t count, const char* format, ...)
57{
58    char name[MAX_STRING_SIZE] = { 0 };
59    va_list args;
60    va_start(args, format);
61    if (vsnprintf_s(name, sizeof(name), sizeof(name) - 1, format, args) < 0) {
62        return;
63    }
64    va_end(args);
65    AceCountTrace(name, count);
66}
67
68AceScopedTrace::AceScopedTrace(const char* format, ...)
69{
70    va_list args;
71    va_start(args, format);
72    strValid_ = AceTraceBeginWithArgv(format, args);
73    va_end(args);
74}
75
76AceScopedTrace::~AceScopedTrace()
77{
78    if (strValid_) {
79        AceTraceEnd();
80    }
81}
82
83AceScopedTraceCommercial::AceScopedTraceCommercial(const char* format, ...)
84{
85    va_list args;
86    va_start(args, format);
87    strValid_ = AceTraceBeginWithArgvCommercial(format, args);
88    va_end(args);
89}
90
91AceScopedTraceCommercial::~AceScopedTraceCommercial()
92{
93    if (strValid_) {
94        AceTraceEndCommercial();
95    }
96}
97
98AceScopedTraceFlag::AceScopedTraceFlag(bool flag, const char* format, ...)
99{
100    if (flag) {
101        va_list args;
102        va_start(args, format);
103        flagTraceEnabled_ = AceTraceBeginWithArgv(format, args);
104        va_end(args);
105    }
106}
107
108AceScopedTraceFlag::~AceScopedTraceFlag()
109{
110    if (flagTraceEnabled_) {
111        AceTraceEnd();
112    }
113}
114
115std::string ACE_EXPORT AceAsyncTraceBeginWithArgv(int32_t taskId, const char* format, va_list args)
116{
117    char name[MAX_STRING_SIZE] = { 0 };
118    if (vsnprintf_s(name, sizeof(name), sizeof(name) - 1, format, args) < 0) {
119        return "";
120    }
121    AceAsyncTraceBegin(taskId, name);
122    return name;
123}
124
125std::string ACE_EXPORT AceAsyncTraceBeginWithArgs(int32_t taskId, char* format, ...)
126{
127    va_list args;
128    va_start(args, format);
129    std::string name = AceAsyncTraceBeginWithArgv(taskId, format, args);
130    va_end(args);
131    return name;
132}
133
134std::atomic<std::int32_t> AceAsyncScopedTrace::id_ = 0;
135
136AceAsyncScopedTrace::AceAsyncScopedTrace(const char* format, ...)
137{
138    taskId_ = id_++;
139    va_list args;
140    va_start(args, format);
141    name_ = AceAsyncTraceBeginWithArgv(taskId_, format, args);
142    va_end(args);
143}
144
145AceAsyncScopedTrace::~AceAsyncScopedTrace()
146{
147    if (!name_.empty()) {
148        AceAsyncTraceEnd(taskId_, name_.c_str());
149    }
150}
151} // namespace OHOS::Ace
152