Source code
Revision control
Copy as Markdown
Other Tools
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# Write out scalar information for C++. The scalars are defined
# in a file provided as a command-line argument.
import json
import sys
from collections import OrderedDict
from os import path
import buildconfig
from mozparsers import parse_scalars
from mozparsers.shared_telemetry_utils import ParserError, static_assert
COMPONENTS_PATH = path.abspath(
path.join(path.dirname(__file__), path.pardir, path.pardir)
)
sys.path.append(
path.join(COMPONENTS_PATH, "glean", "build_scripts", "glean_parser_ext")
)
from string_table import StringTable
# The banner/text at the top of the generated file.
banner = """/* This file is auto-generated, only for internal use in TelemetryScalar.h,
see gen_scalar_data.py. */
"""
file_header = """\
#ifndef mozilla_TelemetryScalarData_h
#define mozilla_TelemetryScalarData_h
#include "core/ScalarInfo.h"
#include "nsITelemetry.h"
namespace {
"""
file_footer = """\
} // namespace
#endif // mozilla_TelemetryScalarData_h
"""
def write_scalar_info(
scalar,
output,
name_index,
expiration_index,
store_index,
store_count,
key_count,
key_index,
):
"""Writes a scalar entry to the output file.
:param scalar: a ScalarType instance describing the scalar.
:param output: the output stream.
:param name_index: the index of the scalar name in the strings table.
:param expiration_index: the index of the expiration version in the strings table.
"""
if scalar.record_on_os(buildconfig.substs["OS_TARGET"]):
print(
" {{ {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {} }},".format(
scalar.nsITelemetry_kind,
name_index,
expiration_index,
scalar.dataset,
" | ".join(scalar.record_in_processes_enum),
"true" if scalar.keyed else "false",
key_count,
key_index,
" | ".join(scalar.products_enum),
store_count,
store_index,
),
file=output,
)
def write_scalar_tables(scalars, output):
"""Writes the scalar and strings tables to an header file.
:param scalars: a list of ScalarType instances describing the scalars.
:param output: the output stream.
"""
string_table = StringTable()
store_table = []
total_store_count = 0
keys_table = []
total_key_count = 0
print("const ScalarInfo gScalars[] = {", file=output)
for s in scalars:
# We add both the scalar label and the expiration string to the strings
# table.
name_index = string_table.stringIndex(s.label)
exp_index = string_table.stringIndex(s.expires)
stores = s.record_into_store
store_index = 0
if stores == ["main"]:
# if count == 1 && offset == UINT16_MAX -> only main store
store_index = "UINT16_MAX"
else:
store_index = total_store_count
store_table.append((s.label, string_table.stringIndexes(stores)))
total_store_count += len(stores)
keys = s.keys
key_index = 0
if len(keys) > 0:
key_index = total_key_count
keys_table.append((s.label, string_table.stringIndexes(keys)))
total_key_count += len(keys)
# Write the scalar info entry.
write_scalar_info(
s,
output,
name_index,
exp_index,
store_index,
len(stores),
len(keys),
key_index,
)
print("};", file=output)
string_table_name = "gScalarsStringTable"
string_table.writeDefinition(output, string_table_name)
static_assert(
output, "sizeof(%s) <= UINT32_MAX" % string_table_name, "index overflow"
)
print("\nconstexpr uint32_t gScalarKeysTable[] = {", file=output)
for name, indexes in keys_table:
print("/* %s */ %s," % (name, ", ".join(map(str, indexes))), file=output)
print("};", file=output)
store_table_name = "gScalarStoresTable"
print("\n#if defined(_MSC_VER) && !defined(__clang__)", file=output)
print("const uint32_t {}[] = {{".format(store_table_name), file=output)
print("#else", file=output)
print("constexpr uint32_t {}[] = {{".format(store_table_name), file=output)
print("#endif", file=output)
for name, indexes in store_table:
print("/* %s */ %s," % (name, ", ".join(map(str, indexes))), file=output)
print("};", file=output)
static_assert(
output, "sizeof(%s) <= UINT16_MAX" % store_table_name, "index overflow"
)
def parse_scalar_definitions(filenames):
scalars = []
for filename in filenames:
try:
batch = parse_scalars.load_scalars(filename)
scalars.extend(batch)
except ParserError as ex:
print("\nError processing %s:\n%s\n" % (filename, str(ex)), file=sys.stderr)
sys.exit(1)
return scalars
def generate_JSON_definitions(output, *filenames):
"""Write the scalar definitions to a JSON file.
:param output: the file to write the content to.
:param filenames: a list of filenames provided by the build system.
We only support a single file.
"""
scalars = parse_scalar_definitions(filenames)
scalar_definitions = OrderedDict()
for scalar in scalars:
category = scalar.category
if category not in scalar_definitions:
scalar_definitions[category] = OrderedDict()
scalar_definitions[category][scalar.name] = OrderedDict(
{
"kind": scalar.nsITelemetry_kind,
"keyed": scalar.keyed,
"keys": scalar.keys,
"record_on_release": True
if scalar.dataset_short == "opt-out"
else False,
# We don't expire dynamic-builtin scalars: they're only meant for
# use in local developer builds anyway. They will expire when rebuilding.
"expired": False,
"stores": scalar.record_into_store,
"expires": scalar.expires,
"products": scalar.products,
}
)
json.dump(scalar_definitions, output)
def main(output, *filenames):
# Load the scalars first.
scalars = parse_scalar_definitions(filenames)
# Write the scalar data file.
print(banner, file=output)
print(file_header, file=output)
write_scalar_tables(scalars, output)
print(file_footer, file=output)
if __name__ == "__main__":
main(sys.stdout, *sys.argv[1:])