mirror of
https://github.com/microsoft/vcpkg.git
synced 2024-12-15 06:51:37 +08:00
426 lines
13 KiB
C++
426 lines
13 KiB
C++
#include "metrics.h"
|
|
#include <utility>
|
|
#include <array>
|
|
#include <string>
|
|
#include <iostream>
|
|
#include <vector>
|
|
#include <sys/timeb.h>
|
|
#include <time.h>
|
|
#define WIN32_LEAN_AND_MEAN
|
|
#include <Windows.h>
|
|
#include <winhttp.h>
|
|
#include <fstream>
|
|
#include <filesystem>
|
|
#include "vcpkg_Strings.h"
|
|
#include "vcpkg_System.h"
|
|
|
|
namespace fs = std::tr2::sys;
|
|
|
|
namespace vcpkg
|
|
{
|
|
static std::string GetCurrentDateTime()
|
|
{
|
|
struct tm newtime;
|
|
time_t now;
|
|
int milli;
|
|
std::array<char, 80> date;
|
|
date.fill(0);
|
|
|
|
struct _timeb timebuffer;
|
|
|
|
_ftime_s(&timebuffer);
|
|
now = timebuffer.time;
|
|
milli = timebuffer.millitm;
|
|
|
|
errno_t err = gmtime_s(&newtime, &now);
|
|
if (err)
|
|
{
|
|
return "";
|
|
}
|
|
|
|
strftime(&date[0], date.size(), "%Y-%m-%dT%H:%M:%S", &newtime);
|
|
return std::string(&date[0]) + "." + std::to_string(milli) + "Z";
|
|
}
|
|
|
|
static std::string GenerateRandomUUID()
|
|
{
|
|
int partSizes[] = {8, 4, 4, 4, 12};
|
|
char uuid[37];
|
|
memset(uuid, 0, sizeof(uuid));
|
|
int num;
|
|
srand(static_cast<int>(time(nullptr)));
|
|
int index = 0;
|
|
for (int part = 0; part < 5; part++)
|
|
{
|
|
if (part > 0)
|
|
{
|
|
uuid[index] = '-';
|
|
index++;
|
|
}
|
|
|
|
// Generating UUID format version 4
|
|
// http://en.wikipedia.org/wiki/Universally_unique_identifier
|
|
for (int i = 0; i < partSizes[part]; i++ , index++)
|
|
{
|
|
if (part == 2 && i == 0)
|
|
{
|
|
num = 4;
|
|
}
|
|
else if (part == 4 && i == 0)
|
|
{
|
|
num = (rand() % 4) + 8;
|
|
}
|
|
else
|
|
{
|
|
num = rand() % 16;
|
|
}
|
|
|
|
if (num < 10)
|
|
{
|
|
uuid[index] = static_cast<char>('0' + num);
|
|
}
|
|
else
|
|
{
|
|
uuid[index] = static_cast<char>('a' + (num - 10));
|
|
}
|
|
}
|
|
}
|
|
|
|
return uuid;
|
|
}
|
|
|
|
static const std::string& get_session_id()
|
|
{
|
|
static const std::string id = GenerateRandomUUID();
|
|
return id;
|
|
}
|
|
|
|
static std::string to_json_string(const std::string& str)
|
|
{
|
|
std::string encoded = "\"";
|
|
for (auto&& ch : str)
|
|
{
|
|
if (ch == '\\')
|
|
{
|
|
encoded.append("\\\\");
|
|
}
|
|
else if (ch == '"')
|
|
{
|
|
encoded.append("\\\"");
|
|
}
|
|
else if (ch < 0x20 || ch >= 0x80)
|
|
{
|
|
// Note: this treats incoming Strings as Latin-1
|
|
static constexpr const char hex[16] = {
|
|
'0', '1', '2', '3', '4', '5', '6', '7',
|
|
'8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
|
|
encoded.append("\\u00");
|
|
encoded.push_back(hex[ch / 16]);
|
|
encoded.push_back(hex[ch % 16]);
|
|
}
|
|
else
|
|
{
|
|
encoded.push_back(ch);
|
|
}
|
|
}
|
|
encoded.push_back('"');
|
|
return encoded;
|
|
}
|
|
|
|
static std::string get_os_version_string()
|
|
{
|
|
std::wstring path;
|
|
path.resize(MAX_PATH);
|
|
auto n = GetSystemDirectoryW(&path[0], static_cast<UINT>(path.size()));
|
|
path.resize(n);
|
|
path += L"\\kernel32.dll";
|
|
|
|
auto versz = GetFileVersionInfoSizeW(path.c_str(), nullptr);
|
|
if (versz == 0)
|
|
return "";
|
|
|
|
std::vector<char> verbuf;
|
|
verbuf.resize(versz);
|
|
|
|
if (!GetFileVersionInfoW(path.c_str(), 0, static_cast<DWORD>(verbuf.size()), &verbuf[0]))
|
|
return "";
|
|
|
|
void* rootblock;
|
|
UINT rootblocksize;
|
|
if (!VerQueryValueW(&verbuf[0], L"\\", &rootblock, &rootblocksize))
|
|
return "";
|
|
|
|
auto rootblock_ffi = static_cast<VS_FIXEDFILEINFO *>(rootblock);
|
|
|
|
return Strings::format("%d.%d.%d",
|
|
static_cast<int>(HIWORD(rootblock_ffi->dwProductVersionMS)),
|
|
static_cast<int>(LOWORD(rootblock_ffi->dwProductVersionMS)),
|
|
static_cast<int>(HIWORD(rootblock_ffi->dwProductVersionLS)));
|
|
}
|
|
|
|
struct MetricMessage
|
|
{
|
|
std::string user_id = GenerateRandomUUID();
|
|
std::string user_timestamp;
|
|
std::string timestamp = GetCurrentDateTime();
|
|
std::string properties;
|
|
std::string measurements;
|
|
|
|
void TrackProperty(const std::string& name, const std::string& value)
|
|
{
|
|
if (properties.size() != 0)
|
|
properties.push_back(',');
|
|
properties.append(to_json_string(name));
|
|
properties.push_back(':');
|
|
properties.append(to_json_string(value));
|
|
}
|
|
|
|
void TrackMetric(const std::string& name, double value)
|
|
{
|
|
if (measurements.size() != 0)
|
|
measurements.push_back(',');
|
|
measurements.append(to_json_string(name));
|
|
measurements.push_back(':');
|
|
measurements.append(std::to_string(value));
|
|
}
|
|
|
|
std::string format_event_data_template() const
|
|
{
|
|
const std::string& session_id = get_session_id();
|
|
return Strings::format(R"([{
|
|
"ver": 1,
|
|
"name": "Microsoft.ApplicationInsights.Event",
|
|
"time": "%s",
|
|
"sampleRate": 100.000000,
|
|
"seq": "0:0",
|
|
"iKey": "b4e88960-4393-4dd9-ab8e-97e8fe6d7603",
|
|
"flags": 0.000000,
|
|
"tags": {
|
|
"ai.device.os": "Windows",
|
|
"ai.device.osVersion": "%s",
|
|
"ai.session.id": "%s",
|
|
"ai.user.id": "%s",
|
|
"ai.user.accountAcquisitionDate": "%s"
|
|
},
|
|
"data": {
|
|
"baseType": "EventData",
|
|
"baseData": {
|
|
"ver": 2,
|
|
"name": "commandline_test7",
|
|
"properties": { %s },
|
|
"measurements": { %s }
|
|
}
|
|
}
|
|
}])",
|
|
timestamp,
|
|
get_os_version_string(),
|
|
session_id,
|
|
user_id,
|
|
user_timestamp,
|
|
properties,
|
|
measurements);
|
|
}
|
|
};
|
|
|
|
static MetricMessage g_metricmessage;
|
|
static bool g_should_send_metrics =
|
|
#if defined(NDEBUG) && (DISABLE_METRICS == 0)
|
|
true
|
|
#else
|
|
false
|
|
#endif
|
|
;
|
|
static bool g_should_print_metrics = false;
|
|
|
|
bool GetCompiledMetricsEnabled()
|
|
{
|
|
return DISABLE_METRICS == 0;
|
|
}
|
|
|
|
void SetUserInformation(const std::string& user_id, const std::string& first_use_time)
|
|
{
|
|
g_metricmessage.user_id = user_id;
|
|
g_metricmessage.user_timestamp = first_use_time;
|
|
}
|
|
|
|
void InitUserInformation(std::string& user_id, std::string& first_use_time)
|
|
{
|
|
user_id = GenerateRandomUUID();
|
|
first_use_time = GetCurrentDateTime();
|
|
}
|
|
|
|
void SetSendMetrics(bool should_send_metrics)
|
|
{
|
|
g_should_send_metrics = should_send_metrics;
|
|
}
|
|
|
|
void SetPrintMetrics(bool should_print_metrics)
|
|
{
|
|
g_should_print_metrics = should_print_metrics;
|
|
}
|
|
|
|
void TrackMetric(const std::string& name, double value)
|
|
{
|
|
g_metricmessage.TrackMetric(name, value);
|
|
}
|
|
|
|
void TrackProperty(const std::string& name, const std::wstring& value)
|
|
{
|
|
// Note: this is not valid UTF-16 -> UTF-8, it just yields a close enough approximation for our purposes.
|
|
std::string converted_value;
|
|
converted_value.resize(value.size());
|
|
std::transform(
|
|
value.begin(), value.end(),
|
|
converted_value.begin(),
|
|
[](wchar_t ch)
|
|
{
|
|
return static_cast<char>(ch);
|
|
});
|
|
|
|
g_metricmessage.TrackProperty(name, converted_value);
|
|
}
|
|
|
|
void TrackProperty(const std::string& name, const std::string& value)
|
|
{
|
|
g_metricmessage.TrackProperty(name, value);
|
|
}
|
|
|
|
void Upload(const std::string& payload)
|
|
{
|
|
HINTERNET hSession = nullptr, hConnect = nullptr, hRequest = nullptr;
|
|
BOOL bResults = FALSE;
|
|
|
|
hSession = WinHttpOpen(L"vcpkg/1.0",
|
|
WINHTTP_ACCESS_TYPE_DEFAULT_PROXY,
|
|
WINHTTP_NO_PROXY_NAME,
|
|
WINHTTP_NO_PROXY_BYPASS,
|
|
0);
|
|
if (hSession)
|
|
hConnect = WinHttpConnect(hSession, L"dc.services.visualstudio.com", INTERNET_DEFAULT_HTTPS_PORT, 0);
|
|
|
|
if (hConnect)
|
|
hRequest = WinHttpOpenRequest(hConnect,
|
|
L"POST",
|
|
L"/v2/track",
|
|
nullptr,
|
|
WINHTTP_NO_REFERER,
|
|
WINHTTP_DEFAULT_ACCEPT_TYPES,
|
|
WINHTTP_FLAG_SECURE);
|
|
|
|
if (hRequest)
|
|
{
|
|
if (MAXDWORD <= payload.size())
|
|
abort();
|
|
std::wstring hdrs = L"Content-Type: application/json\r\n";
|
|
bResults = WinHttpSendRequest(hRequest,
|
|
hdrs.c_str(), static_cast<DWORD>(hdrs.size()),
|
|
(void*)&payload[0], static_cast<DWORD>(payload.size()), static_cast<DWORD>(payload.size()),
|
|
0);
|
|
}
|
|
|
|
if (bResults)
|
|
{
|
|
bResults = WinHttpReceiveResponse(hRequest, nullptr);
|
|
}
|
|
|
|
DWORD http_code = 0, junk = sizeof(DWORD);
|
|
|
|
if (bResults)
|
|
{
|
|
bResults = WinHttpQueryHeaders(hRequest, WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER, nullptr, &http_code, &junk, WINHTTP_NO_HEADER_INDEX);
|
|
}
|
|
|
|
std::vector<char> responseBuffer;
|
|
if (bResults)
|
|
{
|
|
DWORD availableData = 0, readData = 0, totalData = 0;
|
|
|
|
while ((bResults = WinHttpQueryDataAvailable(hRequest, &availableData)) && availableData > 0)
|
|
{
|
|
responseBuffer.resize(responseBuffer.size() + availableData);
|
|
|
|
bResults = WinHttpReadData(hRequest, &responseBuffer.data()[totalData], availableData, &readData);
|
|
|
|
if (!bResults)
|
|
{
|
|
break;
|
|
}
|
|
|
|
totalData += readData;
|
|
|
|
responseBuffer.resize(totalData);
|
|
}
|
|
}
|
|
|
|
if (!bResults)
|
|
{
|
|
#ifndef NDEBUG
|
|
__debugbreak();
|
|
auto err = GetLastError();
|
|
std::cerr << "[DEBUG] failed to connect to server: " << err << "\n";
|
|
#endif
|
|
}
|
|
|
|
if (hRequest)
|
|
WinHttpCloseHandle(hRequest);
|
|
if (hConnect)
|
|
WinHttpCloseHandle(hConnect);
|
|
if (hSession)
|
|
WinHttpCloseHandle(hSession);
|
|
}
|
|
|
|
static fs::path get_bindir()
|
|
{
|
|
wchar_t buf[_MAX_PATH ];
|
|
int bytes = GetModuleFileNameW(nullptr, buf, _MAX_PATH);
|
|
if (bytes == 0)
|
|
std::abort();
|
|
return fs::path(buf, buf + bytes);
|
|
}
|
|
|
|
void Flush()
|
|
{
|
|
std::string payload = g_metricmessage.format_event_data_template();
|
|
if (g_should_print_metrics)
|
|
std::cerr << payload << "\n";
|
|
if (!g_should_send_metrics)
|
|
return;
|
|
|
|
// Upload(payload);
|
|
|
|
wchar_t temp_folder[MAX_PATH];
|
|
GetTempPathW(MAX_PATH, temp_folder);
|
|
|
|
const fs::path temp_folder_path = temp_folder;
|
|
const fs::path temp_folder_path_exe = temp_folder_path / "vcpkgmetricsuploader.exe";
|
|
|
|
if (true)
|
|
{
|
|
const fs::path exe_path = []() -> fs::path
|
|
{
|
|
auto vcpkgdir = get_bindir().parent_path();
|
|
auto path = vcpkgdir / "vcpkgmetricsuploader.exe";
|
|
if (fs::exists(path))
|
|
return path;
|
|
|
|
path = vcpkgdir / "scripts" / "vcpkgmetricsuploader.exe";
|
|
if (fs::exists(path))
|
|
return path;
|
|
|
|
return L"";
|
|
}();
|
|
|
|
std::error_code ec;
|
|
fs::copy_file(exe_path, temp_folder_path_exe, fs::copy_options::skip_existing, ec);
|
|
if (ec)
|
|
return;
|
|
}
|
|
|
|
const fs::path vcpkg_metrics_txt_path = temp_folder_path / ("vcpkg" + GenerateRandomUUID() + ".txt");
|
|
std::ofstream(vcpkg_metrics_txt_path) << payload;
|
|
|
|
const std::wstring cmdLine = Strings::wformat(L"start %s %s", temp_folder_path_exe.native(), vcpkg_metrics_txt_path.native());
|
|
System::cmd_execute(cmdLine);
|
|
}
|
|
}
|