11892994547

Committed 18 Nov 2024 01:01PM CUT coverage: 89.405%. First build

Build # 11892994547

Build Type

Pull #1883

github

Committed by

web-flow

Commit Message

Merge 8956dd0e9 into 84fe14e2e

Pull Request Pull Request #1883: build(deps): bump mozrunner from 8.3.1 to 8.3.2

Run Details

2523 of 2822 relevant lines covered (89.4%)

13.53 hits per line

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

52.94

/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	17✔
2	from collections import namedtuple	17✔
3	from multiprocessing import Process	17✔
4	from pathlib import Path	17✔
5
6	import distro	17✔
7	import importlib_resources	17✔
8	import mozinfo	17✔
9	from glean import Configuration, Glean, load_metrics, load_pings	17✔
10	from mozlog import get_proxy_logger	17✔
11
12	from mozregression import __version__	17✔
13	from mozregression.dates import is_date_or_datetime, to_datetime	17✔
14
15	LOG = get_proxy_logger("telemetry")	17✔
16
17	PINGS = load_pings(importlib_resources.files(__name__) / "pings.yaml")	17✔
18	METRICS = load_metrics(importlib_resources.files(__name__) / "metrics.yaml")	17✔
19
20	UsageMetrics = namedtuple(	17✔
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():	17✔
39	"""Return a dictionary with various information about the system."""
40	UNKNOWN = "unknown"	17✔
41	info = {	17✔
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":	17✔
50	try:	1✔
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]	1✔
54	except (AttributeError, IndexError):	×
55	info["mac_version"] = UNKNOWN	×
56	elif mozinfo.os == "win":	16✔
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":	16✔
64	distro_info = distro.info()	16✔
65	try:	16✔
66	info["linux_version"] = distro_info["version"]	16✔
67	info["linux_distro"] = distro_info["id"]	16✔
68	except KeyError:	×
69	info["linux_version"] = UNKNOWN	×
70	info["linux_distro"] = UNKNOWN	×
71	info["python_version"] = platform.python_version()	17✔
72	return info	17✔
73
74
75	def initialize_telemetry(upload_enabled, allow_multiprocessing=False):	17✔
76	mozregression_path = Path.home() / ".mozilla" / "mozregression"	3✔
77	Glean.initialize(	3✔
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):	17✔
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):	17✔
107	LOG.debug("Sending usage ping")	×
108	_send_telemetry_ping(metrics)	×
109
110
111	def _send_telemetry_ping_oop(metrics, upload_enabled):	17✔
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):	17✔
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 / 11892994547

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