10832265171

Committed 12 Sep 2024 01:52PM CUT coverage: 89.37%. First build

Build # 10832265171

Build Type

Pull #1813

github

Committed by

web-flow

Commit Message

Merge 113a4c43b into c39e24675

Pull Request Pull Request #1813: pyproject: fully migrate to pyproject.toml from setup.py (bug 1917431)

Run Details

2497 of 2794 relevant lines covered (89.37%)

0.89 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

47.06

/mozregression/telemetry.py

import platform
from collections import namedtuple
from multiprocessing import Process
from pathlib import Path

import distro
import importlib_resources
import mozinfo
from glean import Configuration, Glean, load_metrics, load_pings
from mozlog import get_proxy_logger

from mozregression import __version__
from mozregression.dates import is_date_or_datetime, to_datetime

LOG = get_proxy_logger("telemetry")

PINGS = load_pings(importlib_resources.files(__name__) / "pings.yaml")
METRICS = load_metrics(importlib_resources.files(__name__) / "metrics.yaml")

UsageMetrics = namedtuple(
    "UsageMetrics",
    [
        "variant",
        "appname",
        "build_type",
        "good",
        "bad",
        "launch",
        "windows_version",
        "mac_version",
        "linux_version",
        "linux_distro",
        "python_version",
    ],
)


def get_system_info():
    """Return a dictionary with various information about the system."""
    UNKNOWN = "unknown"
    info = {
        "windows_version": None,
        "mac_version": None,
        "linux_version": None,
        "linux_distro": None,
        "python_version": None,
    }

    if mozinfo.os == "mac":
        try:
            # Fetch the "release" from tuple containing macOS version information.
            # See https://docs.python.org/3/library/platform.html#macos-platform.
            info["mac_version"] = platform.mac_ver()[0]
        except (AttributeError, IndexError):
            info["mac_version"] = UNKNOWN
    elif mozinfo.os == "win":
        try:
            # Fetch "version" from tuple containing Windows version information.
            # See https://docs.python.org/3/library/platform.html#windows-platform.
            info["windows_version"] = platform.win32_ver()[1]
        except (AttributeError, IndexError):
            info["windows_version"] = UNKNOWN
    elif mozinfo.os == "linux":
        distro_info = distro.info()
        try:
            info["linux_version"] = distro_info["version"]
            info["linux_distro"] = distro_info["id"]
        except KeyError:
            info["linux_version"] = UNKNOWN
            info["linux_distro"] = UNKNOWN
    info["python_version"] = platform.python_version()
    return info


def initialize_telemetry(upload_enabled, allow_multiprocessing=False):
    mozregression_path = Path.home() / ".mozilla" / "mozregression"
    Glean.initialize(
        application_id="org.mozilla.mozregression",
        application_version=__version__,
        upload_enabled=upload_enabled,
        configuration=Configuration(allow_multiprocessing=allow_multiprocessing),
        data_dir=mozregression_path / "data",
    )


def _send_telemetry_ping(metrics):
    METRICS.usage.variant.set(metrics.variant)
    METRICS.usage.app.set(metrics.appname)
    METRICS.usage.build_type.set(metrics.build_type)
    if is_date_or_datetime(metrics.good):
        METRICS.usage.good_date.set(to_datetime(metrics.good))
    if is_date_or_datetime(metrics.bad):
        METRICS.usage.bad_date.set(to_datetime(metrics.bad))
    if is_date_or_datetime(metrics.launch):
        METRICS.usage.launch_date.set(to_datetime(metrics.launch))

    # System information metrics.
    METRICS.usage.mac_version.set(metrics.mac_version)
    METRICS.usage.linux_version.set(metrics.linux_version)
    METRICS.usage.linux_distro.set(metrics.linux_distro)
    METRICS.usage.windows_version.set(metrics.windows_version)
    METRICS.usage.python_version.set(metrics.python_version)
    PINGS.usage.submit()


def send_telemetry_ping(metrics):
    LOG.debug("Sending usage ping")
    _send_telemetry_ping(metrics)


def _send_telemetry_ping_oop(metrics, upload_enabled):
    initialize_telemetry(upload_enabled, allow_multiprocessing=True)
    if upload_enabled:
        _send_telemetry_ping(metrics)


def send_telemetry_ping_oop(metrics, upload_enabled):
    """
    This somewhat convoluted function forks off a process (using
    Python's multiprocessing module) and sends a glean ping --
    this is to get around the fact that we sometimes might
    call mozregression inside a process which is itself using
    Glean for other purposes (e.g. mach)
    """
    LOG.debug("Sending usage ping (OOP)")
    p = Process(target=_send_telemetry_ping_oop, args=(metrics, upload_enabled))
    p.start()

1	import platform	1✔
2	from collections import namedtuple	1✔
3	from multiprocessing import Process	1✔
4	from pathlib import Path	1✔
5
6	import distro	1✔
7	import importlib_resources	1✔
8	import mozinfo	1✔
9	from glean import Configuration, Glean, load_metrics, load_pings	1✔
10	from mozlog import get_proxy_logger	1✔
11
12	from mozregression import __version__	1✔
13	from mozregression.dates import is_date_or_datetime, to_datetime	1✔
14
15	LOG = get_proxy_logger("telemetry")	1✔
16
17	PINGS = load_pings(importlib_resources.files(__name__) / "pings.yaml")	1✔
18	METRICS = load_metrics(importlib_resources.files(__name__) / "metrics.yaml")	1✔
19
20	UsageMetrics = namedtuple(	1✔
21	"UsageMetrics",
22	[
23	"variant",
24	"appname",
25	"build_type",
26	"good",
27	"bad",
28	"launch",
29	"windows_version",
30	"mac_version",
31	"linux_version",
32	"linux_distro",
33	"python_version",
34	],
35	)
36
37
38	def get_system_info():	1✔
39	"""Return a dictionary with various information about the system."""
40	UNKNOWN = "unknown"	1✔
41	info = {	1✔
42	"windows_version": None,
43	"mac_version": None,
44	"linux_version": None,
45	"linux_distro": None,
46	"python_version": None,
47	}
48
49	if mozinfo.os == "mac":	1✔
50	try:	×
51	# Fetch the "release" from tuple containing macOS version information.
52	# See https://docs.python.org/3/library/platform.html#macos-platform.
53	info["mac_version"] = platform.mac_ver()[0]	×
54	except (AttributeError, IndexError):	×
55	info["mac_version"] = UNKNOWN	×
56	elif mozinfo.os == "win":	1✔
57	try:	×
58	# Fetch "version" from tuple containing Windows version information.
59	# See https://docs.python.org/3/library/platform.html#windows-platform.
60	info["windows_version"] = platform.win32_ver()[1]	×
61	except (AttributeError, IndexError):	×
62	info["windows_version"] = UNKNOWN	×
63	elif mozinfo.os == "linux":	1✔
64	distro_info = distro.info()	1✔
65	try:	1✔
66	info["linux_version"] = distro_info["version"]	1✔
67	info["linux_distro"] = distro_info["id"]	1✔
68	except KeyError:	×
69	info["linux_version"] = UNKNOWN	×
70	info["linux_distro"] = UNKNOWN	×
71	info["python_version"] = platform.python_version()	1✔
72	return info	1✔
73
74
75	def initialize_telemetry(upload_enabled, allow_multiprocessing=False):	1✔
76	mozregression_path = Path.home() / ".mozilla" / "mozregression"	×
77	Glean.initialize(	×
78	application_id="org.mozilla.mozregression",
79	application_version=__version__,
80	upload_enabled=upload_enabled,
81	configuration=Configuration(allow_multiprocessing=allow_multiprocessing),
82	data_dir=mozregression_path / "data",
83	)
84
85
86	def _send_telemetry_ping(metrics):	1✔
87	METRICS.usage.variant.set(metrics.variant)	×
88	METRICS.usage.app.set(metrics.appname)	×
89	METRICS.usage.build_type.set(metrics.build_type)	×
90	if is_date_or_datetime(metrics.good):	×
91	METRICS.usage.good_date.set(to_datetime(metrics.good))	×
92	if is_date_or_datetime(metrics.bad):	×
93	METRICS.usage.bad_date.set(to_datetime(metrics.bad))	×
94	if is_date_or_datetime(metrics.launch):	×
95	METRICS.usage.launch_date.set(to_datetime(metrics.launch))	×
96
97	# System information metrics.
98	METRICS.usage.mac_version.set(metrics.mac_version)	×
99	METRICS.usage.linux_version.set(metrics.linux_version)	×
100	METRICS.usage.linux_distro.set(metrics.linux_distro)	×
101	METRICS.usage.windows_version.set(metrics.windows_version)	×
102	METRICS.usage.python_version.set(metrics.python_version)	×
103	PINGS.usage.submit()	×
104
105
106	def send_telemetry_ping(metrics):	1✔
107	LOG.debug("Sending usage ping")	×
108	_send_telemetry_ping(metrics)	×
109
110
111	def _send_telemetry_ping_oop(metrics, upload_enabled):	1✔
112	initialize_telemetry(upload_enabled, allow_multiprocessing=True)	×
113	if upload_enabled:	×
114	_send_telemetry_ping(metrics)	×
115
116
117	def send_telemetry_ping_oop(metrics, upload_enabled):	1✔
118	"""
119	This somewhat convoluted function forks off a process (using
120	Python's multiprocessing module) and sends a glean ping --
121	this is to get around the fact that we sometimes might
122	call mozregression inside a process which is itself using
123	Glean for other purposes (e.g. mach)
124	"""
125	LOG.debug("Sending usage ping (OOP)")	×
126	p = Process(target=_send_telemetry_ping_oop, args=(metrics, upload_enabled))	×
127	p.start()	×

mozilla / mozregression / 10832265171

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous