glean-parser 18.2.0__tar.gz → 19.1.0__tar.gz

{glean_parser-18.2.0 → glean_parser-19.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: glean-parser
-Version: 18.2.0
+Version: 19.1.0
 Summary: Parser tools for Mozilla's Glean telemetry
 Project-URL: Homepage, https://mozilla.github.io/glean
 Project-URL: Repository, https://github.com/mozilla/glean_parser
@@ -34,7 +34,7 @@ Parser tools for Mozilla's Glean telemetry.
 
 Contains various utilities for handling `metrics.yaml` and `pings.yaml` for [the
 Glean SDKs](https://mozilla.github.io/glean). This includes producing generated
-code for various integrations, linting and coverage testing.
+code for various integrations and linting.
 
 ## Documentation
 

{glean_parser-18.2.0 → glean_parser-19.1.0}/README.md

@@ -6,7 +6,7 @@ Parser tools for Mozilla's Glean telemetry.
 
 Contains various utilities for handling `metrics.yaml` and `pings.yaml` for [the
 Glean SDKs](https://mozilla.github.io/glean). This includes producing generated
-code for various integrations, linting and coverage testing.
+code for various integrations and linting.
 
 ## Documentation
 

{glean_parser-18.2.0 → glean_parser-19.1.0}/glean_parser/__main__.py

@@ -18,7 +18,6 @@ import json
 import glean_parser
 
 
-from . import coverage as mod_coverage
 from . import data_review as mod_data_review
 from . import lint
 from . import translate as mod_translate
@@ -172,7 +171,9 @@ def check(schema):
     type=click.INT,
     required=False,
 )
-def glinter(input, allow_reserved, allow_missing_files, require_tags, expire_by_version):
+def glinter(
+    input, allow_reserved, allow_missing_files, require_tags, expire_by_version
+):
     """
     Runs a linter over the metrics.
     """
@@ -250,57 +251,6 @@ def dump(input, allow_reserved, allow_missing_files, require_tags):
     )
 
 
-@click.command()
-@click.option(
-    "-c",
-    "--coverage_file",
-    type=click.Path(exists=True, dir_okay=False, file_okay=True, readable=True),
-    required=True,
-    multiple=True,
-)
-@click.argument(
-    "metrics_files",
-    type=click.Path(exists=True, dir_okay=False, file_okay=True, readable=True),
-    nargs=-1,
-)
-@click.option(
-    "-o",
-    "--output",
-    type=click.Path(exists=False, dir_okay=False, file_okay=True, writable=True),
-    required=True,
-)
-@click.option(
-    "--format",
-    "-f",
-    type=click.Choice(list(mod_coverage.OUTPUTTERS.keys())),
-    required=True,
-)
-@click.option(
-    "--allow-reserved",
-    is_flag=True,
-    help=(
-        "If provided, allow the use of reserved fields. "
-        "Should only be set when building the Glean library itself."
-    ),
-)
-def coverage(coverage_file, metrics_files, format, output, allow_reserved):
-    """
-    Produce a coverage analysis file given raw coverage output and a set of
-    metrics.yaml files.
-    """
-    sys.exit(
-        mod_coverage.coverage(
-            [Path(x) for x in coverage_file],
-            [Path(x) for x in metrics_files],
-            format,
-            Path(output),
-            {
-                "allow_reserved": allow_reserved,
-            },
-        )
-    )
-
-
 @click.command()
 @click.argument("bug", type=str)
 @click.argument(
@@ -334,7 +284,6 @@ main.add_command(translate)
 main.add_command(check)
 main.add_command(glinter)
 main.add_command(dump)
-main.add_command(coverage)
 main.add_command(data_review_request, "data-review")
 
 

{glean_parser-18.2.0 → glean_parser-19.1.0}/glean_parser/go_server.py

@@ -32,7 +32,15 @@ from . import util
 
 # Adding a metric here will require updating the `generate_metric_type` function
 # and require adjustments to `metrics` variables the the template.
-SUPPORTED_METRIC_TYPES = ["string", "quantity", "event", "datetime", "boolean", "string_list"]
+SUPPORTED_METRIC_TYPES = [
+    "string",
+    "quantity",
+    "event",
+    "datetime",
+    "boolean",
+    "labeled_boolean",  # static labels only; dynamic labels are not supported
+    "string_list",
+]
 
 
 def generate_ping_type_name(ping_name: str) -> str:
@@ -80,6 +88,28 @@ def clean_string(s: str) -> str:
     return s.replace("\n", " ").rstrip()
 
 
+def validate_labeled_boolean(metric: metrics.Metric) -> bool:
+    """
+    Validate that a labeled_boolean metric has static labels defined.
+
+    The Go server outputter requires labels to be listed in metrics.yaml
+    because it generates a Go struct with a field per label at build time.
+    Dynamic labels are not supported.
+
+    Returns:
+        bool: True if valid, False otherwise
+    """
+    if not getattr(metric, "ordered_labels", None):
+        print(
+            "❌ Ignoring labeled_boolean metric without static labels: "
+            + f"{metric.name}."
+            + " Define labels in metrics.yaml to use this metric type."
+        )
+        return False
+
+    return True
+
+
 def output_go(
     objs: metrics.ObjectTree, output_dir: Path, options: Optional[Dict[str, Any]]
 ) -> None:
@@ -111,6 +141,9 @@ def output_go(
     # unique list of event metrics used in any ping
     event_metrics: List[metrics.Metric] = []
 
+    # unique list of labeled_boolean metrics used in any ping
+    labeled_boolean_metrics: List[metrics.Metric] = []
+
     # Go through all metrics in objs and build a map of
     # ping->list of metric categories->list of metrics
     # for easier processing in the template.
@@ -127,10 +160,22 @@ def output_go(
                     )
                     continue
 
+                # Validate labeled_boolean metrics
+                if metric.type == "labeled_boolean" and not validate_labeled_boolean(
+                    metric
+                ):
+                    continue
+
                 for ping in metric.send_in_pings:
                     if metric.type == "event" and metric not in event_metrics:
                         event_metrics.append(metric)
 
+                    if (
+                        metric.type == "labeled_boolean"
+                        and metric not in labeled_boolean_metrics
+                    ):
+                        labeled_boolean_metrics.append(metric)
+
                     metrics_by_type = ping_to_metrics[ping]
                     metrics_list = metrics_by_type.setdefault(metric.type, [])
                     metrics_list.append(metric)
@@ -149,6 +194,9 @@ def output_go(
     with filepath.open("w", encoding="utf-8") as fd:
         fd.write(
             template.render(
-                parser_version=__version__, pings=ping_to_metrics, events=event_metrics
+                parser_version=__version__,
+                pings=ping_to_metrics,
+                events=event_metrics,
+                labeled_booleans=labeled_boolean_metrics,
             )
         )

{glean_parser-18.2.0 → glean_parser-19.1.0}/glean_parser/lint.py

@@ -35,7 +35,7 @@ NitGenerator = Generator["GlinterNit", None, None]
 
 
 def noop(*args):
-    """ A noop `LintGenerator`. Never yields a GlinterNit."""
+    """A noop `LintGenerator`. Never yields a GlinterNit."""
     return
     yield
 
@@ -307,8 +307,12 @@ def check_event_on_non_events_ping(
     An event metric should usually go on the `events` ping or a custom ping,
     not on a builtin ping.
     """
-    disallowed_pings = set(pings.RESERVED_PING_NAMES) - {"default", "events"} | {"health"}
-    if metric.type == "event" and any([ping in disallowed_pings for ping in metric.send_in_pings]):
+    disallowed_pings = set(pings.RESERVED_PING_NAMES) - {"default", "events"} | {
+        "health"
+    }
+    if metric.type == "event" and any(
+        [ping in disallowed_pings for ping in metric.send_in_pings]
+    ):
         yield (
             "An event metric should usually go on the `events` ping or a custom ping, "
             + "not on a builtin ping."
@@ -709,7 +713,11 @@ def lint_metrics(
 
             for check_name, (check_func, check_type) in METRIC_CHECKS.items():
                 new_nits = list(check_func(metric, parser_config))
-                if check_unused_lints and check_name in metric.no_lint and not len(new_nits):
+                if (
+                    check_unused_lints
+                    and check_name in metric.no_lint
+                    and not len(new_nits)
+                ):
                     nits.append(
                         GlinterNit(
                             "UNUSED_NO_LINT",

glean_parser-19.1.0/glean_parser/rust_sym.py

@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*-
+
+# 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
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+"""
+Outputter to generate Rust code for metrics.
+"""
+
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from . import __version__
+from . import metrics
+from . import pings
+from . import util
+from .rust import (
+    rust_datatypes_filter,
+    ctor,
+    type_name,
+    extra_type_name,
+    structure_type_name,
+    extra_keys,
+    Category,
+)
+
+
+def output_rust(
+    objs: metrics.ObjectTree, output_dir: Path, options: Optional[Dict[str, Any]] = None
+) -> None:
+    """
+    Given a tree of objects, output Rust code to `output_dir`.
+
+    :param objs: A tree of objects (metrics and pings) as returned from
+        `parser.parse_objects`.
+    :param output_dir: Path to an output directory to write to.
+    :param options: options dictionary, not currently used for Rust
+    """
+
+    if options is None:
+        options = {}
+
+    template = util.get_jinja2_template(
+        "rust_sym.jinja2",
+        filters=(
+            ("rust", rust_datatypes_filter),
+            ("snake_case", util.snake_case),
+            ("camelize", util.camelize),
+            ("type_name", type_name),
+            ("extra_type_name", extra_type_name),
+            ("structure_type_name", structure_type_name),
+            ("ctor", ctor),
+            ("extra_keys", extra_keys),
+        ),
+    )
+
+    filename = "glean_metrics.rs"
+    filepath = output_dir / filename
+    categories = []
+
+    for category_key, category_val in objs.items():
+        contains_pings = any(
+            isinstance(obj, pings.Ping) for obj in category_val.values()
+        )
+
+        cat = Category(category_key, category_val, contains_pings)
+        categories.append(cat)
+
+    with filepath.open("w", encoding="utf-8") as fd:
+        fd.write(
+            template.render(
+                parser_version=__version__,
+                categories=categories,
+                extra_metric_args=util.extra_metric_args,
+                common_metric_args=util.common_metric_args,
+            )
+        )

{glean_parser-18.2.0 → glean_parser-19.1.0}/glean_parser/schemas/metrics.2-0-0.schema.yaml

@@ -254,7 +254,7 @@ definitions:
 
           A list of bug URLs (e.g. Bugzilla and Github) that are relevant to
           this metric, e.g., tracking its original implementation or later
-          changes to it.
+          changes to it, including renewals.
 
           Prior to version 2.0.0 of the schema, bugs could also be integers.
         type: array
@@ -268,7 +268,8 @@ definitions:
         description: |
           **Required.**
 
-          A list of URIs to any data collection reviews relevant to the metric.
+          A list of URLs to any data collection reviews relevant to the metric.
+          This should also include links to data reviews for renewals.
         type: array
         items:
           type: string

{glean_parser-18.2.0 → glean_parser-19.1.0}/glean_parser/schemas/pings.2-0-0.schema.yaml

@@ -168,7 +168,7 @@ additionalProperties:
         ping, e.g., tracking its original implementation or later changes to
         it.
 
-        It must be a URI to a bug page in a tracker.
+        It must be a URL to a bug page in a tracker.
 
         Prior to version 2.0.0 of the schema, bugs could also be integers.
       type: array
@@ -182,7 +182,7 @@ additionalProperties:
       description: |
         **Required.**
 
-        A list of URIs to any data collection reviews relevant to the ping.
+        A list of URLs to any data collection reviews relevant to the ping.
       type: array
       items:
         type: string

{glean_parser-18.2.0 → glean_parser-19.1.0}/glean_parser/templates/go_server.jinja2

@@ -73,7 +73,7 @@ type ping struct {
     Payload           string `json:"payload"`
 }
 
-type metrics map[string]map[string]interface{}
+type metrics map[string]map[string]any
 
 type pingPayload struct {
     ClientInfo clientInfo   `json:"client_info"`
@@ -187,7 +187,7 @@ func newGleanEvent(category, name string, extra map[string]string) gleanEvent {
     return gleanEvent{
         Category:  category,
         Name:      name,
-        Timestamp: time.Now().UnixMilli(),
+        Timestamp: 0,
         Extra: extra,
     }
 }
@@ -220,6 +220,18 @@ func (e {{ event|event_type_name }}) gleanEvent() gleanEvent {
 }
 {% endfor %}
 {% endif %}
+{# Generate struct types for labeled_boolean metrics #}
+{% if labeled_booleans %}
+{% for metric in labeled_booleans %}
+
+// {{ metric.description|clean_string }}
+type {{ metric|metric_argument_name }} struct {
+    {% for label in metric.ordered_labels %}
+    {{ label|event_extra_name }} *bool `json:"{{ label }},omitempty"`
+    {% endfor %}
+}
+{% endfor %}
+{% endif %}
 {# struct & methods for submitting pings #}
 {% for ping, metrics_by_type in pings.items() %}
 {% if metrics_by_type['event'] %}
@@ -240,7 +252,11 @@ type {{ ping|ping_type_name }} struct {
     {% for metric_type, metrics in metrics_by_type.items() %}
     {% if metric_type != 'event' %}
     {% for metric in metrics %}
+    {% if metric_type == 'labeled_boolean' %}
+    {{ metric|metric_argument_name }} {{ metric|metric_argument_name }} // {{ metric.description|clean_string }}
+    {% else %}
     {{ metric|metric_argument_name }} {{ metric_type|go_metric_type}} // {{ metric.description|clean_string }}
+    {% endif %}
     {% endfor %}
     {% endif %}
     {% endfor %}
@@ -254,6 +270,14 @@ func (g GleanEventsLogger) Record{{ ping|ping_type_name }}(
     requestInfo RequestInfo,
     params {{ ping|ping_type_name }},
 ) error {
+    {% if metrics_by_type['string_list'] %}
+    {% for metric in metrics_by_type['string_list'] %}
+    // Ensure nil string_list metrics serialize as empty arrays, not null
+    if params.{{ metric|metric_argument_name }} == nil {
+        params.{{ metric|metric_argument_name }} = []string{}
+    }
+    {% endfor %}
+    {% endif %}
     metrics := metrics{
     {% for metric_type, metrics in metrics_by_type.items() %}
     {% if metric_type != 'event' %}

{glean_parser-18.2.0 → glean_parser-19.1.0}/glean_parser/templates/javascript_server.jinja2

@@ -126,7 +126,7 @@ class {{ ping|event_class_name(metrics_by_type) }} {
     const now = new Date();
     const timestamp = now.toISOString();
     {% if 'event' in metrics_by_type %}
-    event.timestamp = now.getTime();
+    event.timestamp = 0;
     {% endif %}
     const eventPayload = {
       metrics: {

{glean_parser-18.2.0 → glean_parser-19.1.0}/glean_parser/templates/python_server.jinja2

@@ -35,29 +35,34 @@ class {{ ping|camelize }}ServerEventLogger:
 
     def record(
         self,
-        user_agent: str,
-        ip_address: str,
+        user_agent: str | None = None,
+        ip_address: str | None = None,
         {% for metric_type, metrics in metrics_by_type.items() %}
         {% if metric_type != 'event' %}
         {% for metric in metrics %}
-        {{ metric.category }}_{{ metric.name }}: {{ metric.type|py_metric_type }},
+        {{ metric.category }}_{{ metric.name }}: {{ metric.type|py_metric_type }} | None = None,
         {% endfor %}
         {% endif %}
         {% endfor %}
-        events: list[dict[str, Any]]
+        events: list[dict[str, Any]] | None = None,
     ) -> None:
         now = datetime.now(timezone.utc)
         timestamp = now.isoformat()
+        events = [] if events is None else events
         for event in events:
-            event["timestamp"] = int(1000.0 * now.timestamp())  # Milliseconds since epoch
+            event["timestamp"] = 0
         event_payload = {
             "metrics": {
                 {% for metric_type, metrics in metrics_by_type.items() %}
                 {% if metric_type != 'event' %}
                 "{{ metric_type }}": {
-                    {% for metric in metrics %}
-                    "{{ metric.category }}.{{ metric.name }}": {{ metric.category }}_{{ metric.name }},
-                    {% endfor %}
+                    key: value
+                    for key, value in [
+                        {% for metric in metrics %}
+                        ("{{ metric.category }}.{{ metric.name }}", {{ metric.category }}_{{ metric.name }}),
+                        {% endfor %}
+                    ]
+                    if value is not None
                 },
                 {% endif %}
                 {% endfor %}
@@ -117,17 +122,17 @@ class {{ ping|camelize }}ServerEventLogger:
     {% for event in metrics_by_type["event"] %}
     def {{ event|record_event_function_name }}(
         self,
-        user_agent: str,
-        ip_address: str,
+        user_agent: str | None = None,
+        ip_address: str | None = None,
         {% for metric_type, metrics in metrics_by_type.items() %}
         {% if metric_type != 'event' %}
         {% for metric in metrics %}
-        {{ metric.category }}_{{ metric.name }}: {{ metric.type|py_metric_type }},
+        {{ metric.category }}_{{ metric.name }}: {{ metric.type|py_metric_type }} | None = None,
         {% endfor %}
         {% endif %}
         {% endfor %}
         {% for extra, metadata in event.extra_keys.items() %}
-        {{ extra }}: {{ metadata.type|py_metric_type }},
+        {{ extra }}: {{ metadata.type|py_metric_type }} | None = None,
         {% endfor %}
     ) -> None:
         """
@@ -156,9 +161,13 @@ class {{ ping|camelize }}ServerEventLogger:
             "name": "{{ event.name }}",
             {% if event.extra_keys %}
             "extra": {
-                {% for extra, metadata in event.extra_keys.items() %}
-                "{{ extra }}": str({{ extra }}){% if 'bool' == metadata.type|py_metric_type %}.lower(){% endif %},
-                {% endfor %}
+                key: value
+                for key, value in [
+                    {% for extra, metadata in event.extra_keys.items() %}
+                    ("{{ extra }}", str({{ extra }}){% if 'bool' == metadata.type|py_metric_type %}.lower(){% endif %}),
+                    {% endfor %}
+                ]
+                if value is not None
             },
             {% endif %}
         }

{glean_parser-18.2.0 → glean_parser-19.1.0}/glean_parser/templates/ruby_server.jinja2

@@ -152,7 +152,7 @@ module Glean
         {
           'category' => '{{ event.category }}',
           'name' => '{{ event.name }}',
-          'timestamp' => (Time.now.utc.to_f * 1000).to_i,
+          'timestamp' => 0,
           'extra' => [
             {% for extra, metadata in event.extra_keys.items() %}
             ['{{ extra }}', {{ extra }}.to_s],

{glean_parser-18.2.0 → glean_parser-19.1.0}/glean_parser/templates/rust_server.jinja2

@@ -108,7 +108,7 @@ pub fn new_glean_event(
     GleanEvent {
         category: category.to_owned(),
         name: name.to_owned(),
-        timestamp: Utc::now().timestamp_millis(),
+        timestamp: 0,
         extra,
     }
 }
@@ -227,7 +227,7 @@ impl {{ ping|ping_events_type_name }} for {{ event|event_type_name }} {
     /// Create a GleanEvent for the above-defined Event struct ({{ event|event_type_name }}).
     /// Any metadata `extra` values are passed into the extra HashMap.
     fn glean_event(&self) -> GleanEvent {
-        // Any `extra_keys` will be output below to be inserted into `extra`. 
+        // Any `extra_keys` will be output below to be inserted into `extra`.
         // If there are none, an empty, immutable HashMap is created.
         {% if event.extra_keys.items()|length == 0 %}
         let extra: HashMap<String, String> = HashMap::new();
@@ -323,7 +323,7 @@ impl GleanEventsLogger {
         if let Some(event) = &params.event {
             events.push(event.glean_event());
         }
-        
+
         {% else %}
         let events: Vec<GleanEvent> = Vec::new();
         {% endif %}