glean-parser 17.2.0__tar.gz → 18.0.0__tar.gz

{glean_parser-17.2.0 → glean_parser-18.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: glean-parser
-Version: 17.2.0
+Version: 18.0.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
@@ -12,13 +12,12 @@ Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Natural Language :: English
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 Requires-Dist: click>=7
 Requires-Dist: diskcache>=4
 Requires-Dist: jinja2>=2.10.1
@@ -45,7 +44,7 @@ code for various integrations, linting and coverage testing.
 
 ## Requirements
 
-- Python 3.8 (or later)
+- Python 3.9 (or later)
 
 ## Usage
 

{glean_parser-17.2.0 → glean_parser-18.0.0}/README.md

@@ -16,7 +16,7 @@ code for various integrations, linting and coverage testing.
 
 ## Requirements
 
-- Python 3.8 (or later)
+- Python 3.9 (or later)
 
 ## Usage
 

{glean_parser-17.2.0 → glean_parser-18.0.0}/glean_parser/__main__.py

@@ -166,7 +166,13 @@ def check(schema):
     is_flag=True,
     help=("Require tags to be specified for metrics and pings."),
 )
-def glinter(input, allow_reserved, allow_missing_files, require_tags):
+@click.option(
+    "--expire-by-version",
+    help="Expire metrics by version, with the provided major version.",
+    type=click.INT,
+    required=False,
+)
+def glinter(input, allow_reserved, allow_missing_files, require_tags, expire_by_version):
     """
     Runs a linter over the metrics.
     """
@@ -177,6 +183,7 @@ def glinter(input, allow_reserved, allow_missing_files, require_tags):
                 "allow_reserved": allow_reserved,
                 "allow_missing_files": allow_missing_files,
                 "require_tags": require_tags,
+                "expire_by_version": expire_by_version,
             },
         )
     )

{glean_parser-17.2.0 → glean_parser-18.0.0}/glean_parser/go_server.py

@@ -147,8 +147,6 @@ 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
             )
         )

{glean_parser-17.2.0 → glean_parser-18.0.0}/glean_parser/lint.py

@@ -34,6 +34,12 @@ LintGenerator = Generator[str, None, None]
 NitGenerator = Generator["GlinterNit", None, None]
 
 
+def noop(*args):
+    """ A noop `LintGenerator`. Never yields a GlinterNit."""
+    return
+    yield
+
+
 class CheckType(enum.Enum):
     warning = 0
     error = 1
@@ -100,7 +106,7 @@ def check_common_prefix(
         common_prefix = "_".join(first[:i])
         yield (
             f"Within category '{category_name}', all metrics begin with "
-            f"prefix '{common_prefix}'."
+            f"prefix '{common_prefix}'. "
             "Remove the prefixes on the metric names and (possibly) "
             "rename the category."
         )
@@ -313,13 +319,43 @@ def check_unexpected_unit(
 def check_empty_datareview(
     metric: metrics.Metric, parser_config: Dict[str, Any]
 ) -> LintGenerator:
-    disallowed_datareview = ["", "todo"]
+    disallowed_datareview = ["", "todo", "tbd"]
     data_reviews = [dr.lower() in disallowed_datareview for dr in metric.data_reviews]
 
     if any(data_reviews):
         yield "List of data reviews should not contain empty strings or TODO markers."
 
 
+def check_event_extras_potential_data_sensitivity_required(
+    metric: metrics.Metric, parser_config: Dict[str, Any]
+) -> LintGenerator:
+    # Only looking at event metrics
+    if not isinstance(metric, metrics.Event):
+        return
+
+    # TODO(bug 1890648): Not all metrics have `data_sensitivity` defined.
+    has_data_sensitivity = hasattr(metric, "data_sensitivity")
+    # If already marked as "highly sensitive" no need for further checks
+    if has_data_sensitivity and any(
+        [
+            sensitivity == metrics.DataSensitivity.highly_sensitive
+            for sensitivity in metric.data_sensitivity
+        ]
+    ):
+        return
+
+    # List of potentially sensitive extra key names we want to flag.
+    potential_sensitive_names = ["url", "uri"]
+    name_list = ", ".join(potential_sensitive_names)
+
+    for extra_key in metric.extra_keys.keys():
+        if extra_key in potential_sensitive_names:
+            yield (
+                f"`{extra_key}` could potentially be used to collect sensitive data. Increase the metric's data sensitivity or disable the lint."
+                + f" (This lint applies for the following extra key names: {name_list})"
+            )
+
+
 def check_redundant_ping(
     pings: pings.Ping, parser_config: Dict[str, Any]
 ) -> LintGenerator:
@@ -432,6 +468,12 @@ METRIC_CHECKS: Dict[
     "METRIC_ON_EVENTS_LIFETIME": (check_metric_on_events_lifetime, CheckType.error),
     "UNEXPECTED_UNIT": (check_unexpected_unit, CheckType.warning),
     "EMPTY_DATAREVIEW": (check_empty_datareview, CheckType.warning),
+    "HIGHER_DATA_SENSITIVITY_REQUIRED": (
+        check_event_extras_potential_data_sensitivity_required,
+        CheckType.warning,
+    ),
+    # Implemented inline, listed here so that `UNKNOWN_LINT` knows about it.
+    "UNUSED_NO_LINT": (noop, CheckType.warning),
 }
 
 
@@ -627,8 +669,40 @@ def lint_metrics(
             )
 
         for _metric_name, metric in sorted(list(category_metrics.items())):
+            check_unused_lints = "UNUSED_NO_LINT" not in metric.no_lint
+            check_unknown_lint = "UNKNOWN_LINT" not in metric.no_lint
+
+            if check_unknown_lint and metric.no_lint:
+                known_lint_names = (
+                    set(METRIC_CHECKS.keys())
+                    | set(ALL_OBJECT_CHECKS.keys())
+                    | set(CATEGORY_CHECKS.keys())
+                )
+                unknown_lints = [
+                    lint for lint in metric.no_lint if lint not in known_lint_names
+                ]
+                if unknown_lints:
+                    nits.append(
+                        GlinterNit(
+                            "UNKNOWN_LINT",
+                            ".".join([metric.category, metric.name]),
+                            f"Metric contains unknown no_lints: {unknown_lints}. Please remove the `no_lint` entry.",
+                            CheckType.warning,
+                        )
+                    )
+
             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):
+                    nits.append(
+                        GlinterNit(
+                            "UNUSED_NO_LINT",
+                            ".".join([metric.category, metric.name]),
+                            f"Metric contains a no_lint: {check_name}, but {check_name} does not apply. Please remove the `no_lint` entry.",
+                            CheckType.warning,
+                        )
+                    )
+
                 if len(new_nits):
                     if check_name not in metric.no_lint:
                         nits.extend(

{glean_parser-17.2.0 → glean_parser-18.0.0}/glean_parser/markdown.py

@@ -52,9 +52,9 @@ def ping_desc(
 
     if ping_name in pings.RESERVED_PING_NAMES:
         desc = (
-            "This is a built-in ping that is assembled out of the "
-            "box by the Glean SDK."
+            "This is a built-in ping that is assembled out of the box by the Glean SDK."
         )
+
     elif ping_name == "all-pings":
         desc = "These metrics are sent in every ping."
     elif custom_pings_cache is not None and ping_name in custom_pings_cache:

{glean_parser-17.2.0 → glean_parser-18.0.0}/glean_parser/metrics.py

@@ -462,8 +462,10 @@ class Object(Metric):
         self._generate_structure = self.validate_structure(structure)
         super().__init__(*args, **kwargs)
 
-    ALLOWED_TOPLEVEL = {"type", "properties", "items"}
+    ALLOWED_TOPLEVEL = {"type", "properties", "items", "description", "oneOf"}
     ALLOWED_TYPES = ["object", "array", "number", "string", "boolean"]
+    ALLOWED_SUBTYPES = ["number", "string", "boolean"]
+    ALLOWED_ONEOF_FIELDS = {"description", "type"}
 
     @staticmethod
     def _validate_substructure(structure):
@@ -475,6 +477,34 @@ class Object(Metric):
                 f"Found additional fields: {extra}. Only allowed: {allowed}"
             )
 
+        if "oneOf" in structure:
+            subtypes = structure.pop("oneOf")
+            structure["type"] = "oneof"
+            structure["subtypes"] = []
+            if not subtypes:
+                raise ValueError("List of types required.")
+
+            for typ in subtypes:
+                extra = set(typ.keys()) - Object.ALLOWED_ONEOF_FIELDS
+                if extra:
+                    extra = ", ".join(extra)
+                    allowed = ", ".join(Object.ALLOWED_ONEOF_FIELDS)
+                    raise ValueError(
+                        f"Found additional fields: {extra}. Only allowed: {allowed}"
+                    )
+
+                ty = typ.get("type")
+                if not ty:
+                    raise ValueError("element of `oneOf` list must contain a type")
+
+                if ty not in Object.ALLOWED_SUBTYPES:
+                    raise ValueError(
+                        f"invalid `type` in `oneOf` list. found: {ty}, only allowed: {Object.ALLOWED_SUBTYPES}"
+                    )
+
+                structure["subtypes"].append(ty)
+            return structure
+
         if "type" not in structure:
             raise ValueError(
                 f"missing `type` in object structure. Allowed: {Object.ALLOWED_TYPES}"
@@ -579,7 +609,6 @@ class DualLabeledCounter(Metric):
         d["categories"] = self.ordered_categories
         del d["ordered_keys"]
         del d["ordered_categories"]
-        del d["dual_labeled"]
         return d
 
 

{glean_parser-17.2.0 → glean_parser-18.0.0}/glean_parser/pings.py

@@ -48,7 +48,9 @@ class Ping:
         self.metadata = metadata
         self.precise_timestamps = self.metadata.get("precise_timestamps", True)
         self.include_info_sections = self.metadata.get("include_info_sections", True)
-        self.follows_collection_enabled = self.metadata.get("follows_collection_enabled", True)
+        self.follows_collection_enabled = self.metadata.get(
+            "follows_collection_enabled", True
+        )
         if enabled is None:
             enabled = True
         self.enabled = enabled

{glean_parser-17.2.0 → glean_parser-18.0.0}/glean_parser/schemas/metrics.2-0-0.schema.yaml

@@ -15,10 +15,6 @@ description: |
 $id: moz://mozilla.org/schemas/glean/metrics/2-0-0
 
 definitions:
-  token:
-    type: string
-    pattern: "^[A-Za-z_][A-Za-z0-9_\\.]*$"
-
   snake_case:
     type: string
     pattern: "^[a-z_][a-z0-9_]*$"
@@ -39,11 +35,6 @@ definitions:
     type: string
     pattern: "^[a-z][a-z0-9-]{0,29}$"
 
-  long_id:
-    allOf:
-      - $ref: "#/definitions/snake_case"
-      - maxLength: 40
-
   short_id:
     allOf:
       - $ref: "#/definitions/snake_case"

{glean_parser-17.2.0 → glean_parser-18.0.0}/glean_parser/schemas/pings.2-0-0.schema.yaml

@@ -15,10 +15,6 @@ description: |
 $id: moz://mozilla.org/schemas/glean/pings/2-0-0
 
 definitions:
-  dotted_snake_case:
-    type: string
-    pattern: "^[a-z_][a-z0-9_]{0,29}(\\.[a-z_][a-z0-9_]{0,29})*$"
-    maxLength: 40
   # Prior to version 2.0.0 of the schema, special ping names with underscores
   # were also supported.
   kebab_case:

{glean_parser-17.2.0 → glean_parser-18.0.0}/glean_parser/templates/kotlin.jinja2

@@ -67,8 +67,17 @@ data class {{ obj.name|Camelize }}{{ suffix }}(
 {%- endmacro -%}
 
 {%- macro generate_structure(name, struct) %}
-{%- if struct.type == "array" -%}
-    @Serializable(with = {{name}}.Serializer::class)
+{%- if struct.type == "oneof" -%}
+    sealed class {{ name }}(): ObjectSerialize {
+    {% for ty in struct.subtypes %}
+        class {{ty|Camelize}}(val inner: kotlin.{{ty|structure_type_name}}? = null) : {{ name }}() {
+            override fun intoSerializedObject(): kotlin.String {
+                return this.inner?.intoSerializedObject() ?: "null"
+            }
+        }
+    {% endfor %}
+    }
+{%- elif struct.type == "array" -%}
     data class {{ name }}(var items: MutableList<{{ name }}Item> = mutableListOf()) : ObjectSerialize {
         fun add(elem: {{ name }}Item) = items.add(elem)
 
@@ -83,41 +92,54 @@ data class {{ obj.name|Camelize }}{{ suffix }}(
         fun set(index: Int, element: {{ name }}Item) = items.set(index, element)
 
         override fun intoSerializedObject(): String {
-            return Json.encodeToString(items)
-        }
-
-        internal object Serializer : KSerializer<{{name}}> {
-            @OptIn(kotlinx.serialization.ExperimentalSerializationApi::class)
-            override val descriptor = listSerialDescriptor<String>()
-
-            override fun deserialize(decoder: Decoder): {{ name }} {
-                val list = decoder.decodeSerializableValue(ListSerializer(serializer<{{name}}Item>()))
-                return {{name}}(items = list.toMutableList())
-            }
-
-            override fun serialize(encoder: Encoder, value: {{name}}) {
-                encoder.encodeSerializableValue(ListSerializer(serializer<{{name}}Item>()), value.items)
+            var json = buildString {
+                append("[")
+                var first = true
+                for (item in items) {
+                    if (!first) {
+                        append(",")
+                    }
+                    first = false
+                    append(item.intoSerializedObject())
+                }
+                append("]")
             }
+            return json
         }
     }
 
     {{ generate_structure(name ~ "Item", struct["items"]) }}
 
 {%- elif struct.type == "object" -%}
-    @Serializable
     data class {{ name }}(
         {% for itemname, val in struct.properties.items() %}
           {% if val.type == "array" %}
           var {{itemname|camelize}}: {{ name ~ itemname|Camelize }} = {{ name ~ itemname|Camelize }}(),
           {% elif val.type == "object" %}
           var {{itemname|camelize}}: {{ name ~ "Item" ~ itemname|Camelize ~ "Object" }}? = null,
+          {% elif val.type == "oneof" %}
+          var {{itemname|camelize}}: {{ name ~ itemname|Camelize ~ "Enum" }}? = null,
           {% else %}
           var {{itemname|camelize}}: {{val.type|structure_type_name}}? = null,
           {% endif %}
         {% endfor %}
     ): ObjectSerialize {
         override fun intoSerializedObject(): String {
-            return Json.encodeToString(this)
+            var data: MutableList<String> = mutableListOf()
+            {% for itemname, val in struct.properties.items() %}
+            this.{{itemname|camelize}}?.let { {{itemname|camelize}} ->
+                val elem = buildString {
+                    append("\"{{itemname}}\":")
+                    append({{itemname|camelize}}.intoSerializedObject())
+                }
+                data.add(elem)
+            }
+            {% endfor %}
+            return buildString {
+                append("{")
+                append(data.joinToString(","))
+                append("}")
+            }
         }
     }
 
@@ -128,6 +150,9 @@ data class {{ obj.name|Camelize }}{{ suffix }}(
         {% elif val.type == "object" %}
         {% set nested_name = name ~ "Item" ~ itemname|Camelize ~ "Object" %}
         {{ generate_structure(nested_name, val) }}
+        {% elif val.type == "oneof" %}
+        {% set nested_name = name ~ itemname|Camelize ~ "Enum" %}
+        {{ generate_structure(nested_name, val) }}
         {% endif %}
     {% endfor %}
 
@@ -174,15 +199,7 @@ import {{ glean_namespace }}.private.{{ obj_type }} // ktlint-disable import-ord
 import {{ glean_namespace }}.private.LabeledMetricType // ktlint-disable import-ordering
 {% endif %}
 {% if has_object_metrics %}
-import kotlinx.serialization.KSerializer
-import kotlinx.serialization.Serializable
-import kotlinx.serialization.builtins.ListSerializer
-import kotlinx.serialization.descriptors.listSerialDescriptor
-import kotlinx.serialization.encodeToString
-import kotlinx.serialization.encoding.Decoder
-import kotlinx.serialization.encoding.Encoder
-import kotlinx.serialization.json.Json
-import kotlinx.serialization.serializer
+import {{ glean_namespace }}.private.intoSerializedObject
 {% endif %}
 
 {# HACK HACK HACK -- typealiases MUST BE top-level #}

{glean_parser-17.2.0 → glean_parser-18.0.0}/glean_parser/templates/rust.jinja2

@@ -9,7 +9,16 @@ Jinja2 template is not. Please file bugs! #}
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 {%- macro generate_structure(name, struct) %}
-{% if struct.type == "array" %}
+{%- if struct.type == "oneof" -%}
+    #[derive(Debug, Hash, Eq, PartialEq, Clone, ::glean::traits::__serde::Serialize, ::glean::traits::__serde::Deserialize)]
+    #[serde(crate = "::glean::traits::__serde")]
+    #[serde(untagged)]
+    pub enum {{ name }} {
+        {% for ty in struct.subtypes %}
+          {{ty|Camelize}}({{ty|structure_type_name}}),
+        {% endfor %}
+    }
+{% elif struct.type == "array" %}
     pub type {{ name }} = Vec<{{ name }}Item>;
 
     {{ generate_structure(name ~ "Item", struct["items"]) }}
@@ -26,6 +35,9 @@ Jinja2 template is not. Please file bugs! #}
           {% elif val.type == "object" %}
           #[serde(skip_serializing_if = "Option::is_none")]
           pub {{itemname|snake_case}}: Option<{{ name ~ "Item" ~ itemname|Camelize ~ "Object" }}>,
+          {% elif val.type == "oneof" %}
+          #[serde(skip_serializing_if = "Option::is_none")]
+          pub {{itemname|snake_case}}: Option<{{ name ~ itemname|Camelize ~ "Enum" }}>,
           {% else %}
           #[serde(skip_serializing_if = "Option::is_none")]
           pub {{itemname|snake_case}}: Option<{{val.type|structure_type_name}}>,
@@ -40,6 +52,9 @@ Jinja2 template is not. Please file bugs! #}
         {% elif val.type == "object" %}
         {% set nested_name = name ~ "Item" ~ itemname|Camelize ~ "Object" %}
         {{ generate_structure(nested_name, val) }}
+        {% elif val.type == "oneof" %}
+        {% set nested_name = name ~ itemname|Camelize ~ "Enum" %}
+        {{ generate_structure(nested_name, val) }}
         {% endif %}
     {% endfor %}
 

{glean_parser-17.2.0 → glean_parser-18.0.0}/glean_parser/templates/swift.jinja2

@@ -45,7 +45,23 @@ struct {{ obj.name|Camelize }}{{ suffix }}: EventExtras {
 {% endmacro %}
 
 {%- macro generate_structure(name, struct) %}
-{%- if struct.type == "array" -%}
+{%- if struct.type == "oneof" -%}
+    enum {{ name }}: Codable, Equatable, ObjectSerialize {
+        {% for ty in struct.subtypes %}
+          case {{ty}}({{ty|structure_type_name}})
+        {% endfor %}
+
+          func intoSerializedObject() -> String {
+              switch self {
+              {% for ty in struct.subtypes %}
+                case .{{ty}}(let val):
+                    return val.intoSerializedObject()
+              {% endfor %}
+              }
+          }
+    }
+
+{%- elif struct.type == "array" -%}
     typealias {{ name }} = [{{ name }}Item]
 
     {{ generate_structure(name ~ "Item", struct["items"]) }}
@@ -57,15 +73,30 @@ struct {{ obj.name|Camelize }}{{ suffix }}: EventExtras {
           var {{itemname|camelize|variable_name}}: {{ name ~ itemname|Camelize }} = []
           {% elif val.type == "object" %}
           var {{itemname|camelize|variable_name}}: {{ name ~ "Item" ~ itemname|Camelize ~ "Object" }}?
+          {% elif val.type == "oneof" %}
+          var {{itemname|camelize|variable_name}}: {{ name ~ itemname|Camelize ~ "Enum" }}?
           {% else %}
           var {{itemname|camelize|variable_name}}: {{val.type|structure_type_name}}?
           {% endif %}
         {% endfor %}
 
         func intoSerializedObject() -> String {
-            let jsonEncoder = JSONEncoder()
-            let jsonData = try! jsonEncoder.encode(self)
-            let json = String(data: jsonData, encoding: String.Encoding.utf8)!
+            var data = [String]()
+            {% for itemname, val in struct.properties.items() %}
+                {% if val.type == "array" %}
+                if {{itemname|camelize|variable_name}}.count > 0 {
+                    let {{itemname|camelize|variable_name}} = self.{{itemname|camelize|variable_name}}
+                {% else %}
+                if let {{itemname}} = self.{{itemname}} {
+                {% endif %}
+                    var elem = "\"{{itemname}}\":"
+                    elem.append({{itemname|camelize|variable_name}}.intoSerializedObject())
+                    data.append(elem)
+                }
+            {% endfor %}
+            var json = "{"
+            json.append(data.joined(separator: ","))
+            json.append("}")
             return json
         }
     }
@@ -77,6 +108,9 @@ struct {{ obj.name|Camelize }}{{ suffix }}: EventExtras {
         {% elif val.type == "object" %}
         {% set nested_name = name ~ "Item" ~ itemname|Camelize ~ "Object" %}
         {{ generate_structure(nested_name, val) }}
+        {% elif val.type == "oneof" %}
+        {% set nested_name = name ~ itemname|Camelize ~ "Enum" %}
+        {{ generate_structure(nested_name, val) }}
         {% endif %}
     {% endfor %}
 
@@ -111,7 +145,7 @@ extension {{ namespace }} {
 
     {% for category in categories %}
     {% if category.contains_pings %}
-    class {{ category.name|Camelize }} {
+    final class {{ category.name|Camelize }}: Sendable {
         public static let shared = {{ category.name|Camelize }}()
         private init() {
             // Intentionally left private, no external user can instantiate a new global object.
@@ -121,7 +155,7 @@ extension {{ namespace }} {
         {% if obj|attr("_generate_enums") %}
         {% for name, suffix in obj["_generate_enums"] %}
         {% if obj|attr(name)|length %}
-        enum {{ obj.name|Camelize }}{{ suffix }}: Int, ReasonCodes {
+        enum {{ obj.name|Camelize }}{{ suffix }}: Int, ReasonCodes, Sendable {
             {% for key in obj|attr(name) %}
             case {{ key|camelize|variable_name }} = {{ loop.index-1 }}
             {% endfor %}

{glean_parser-17.2.0 → glean_parser-18.0.0}/pyproject.toml

@@ -11,14 +11,13 @@ classifiers = [
     "Intended Audience :: Developers",
     "Natural Language :: English",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.8",
     "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
 ]
-requires-python = ">=3.8"
+requires-python = ">=3.9"
 dependencies = [
     "Click>=7",
     "diskcache>=4",

glean_parser-18.0.0/tests/data/events_data_sensitivity.yaml

@@ -0,0 +1,78 @@
+# Any copyright is dedicated to the Public Domain.
+# https://creativecommons.org/publicdomain/zero/1.0/
+
+---
+$schema: moz://mozilla.org/schemas/glean/metrics/2-0-0
+
+event:
+  low_sensitivity:
+    type: event
+    description: |
+      Just testing events
+    bugs:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1973017
+    data_reviews:
+      - http://example.com/reviews
+    notification_emails:
+      - CHANGE-ME@example.com
+    extra_keys:
+      url:
+        type: string
+        description: "This is key one"
+    expires: never
+    data_sensitivity:
+      - technical
+
+  no_data_sensitivity:
+    type: event
+    description: |
+      Just testing events
+    bugs:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1973017
+    data_reviews:
+      - http://example.com/reviews
+    notification_emails:
+      - CHANGE-ME@example.com
+    extra_keys:
+      url:
+        type: string
+        description: "This is key one"
+    expires: never
+
+  correct_sensitivity:
+    type: event
+    description: |
+      Just testing events
+    bugs:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1973017
+    data_reviews:
+      - http://example.com/reviews
+    notification_emails:
+      - CHANGE-ME@example.com
+    extra_keys:
+      url:
+        type: string
+        description: "This is key one"
+    expires: never
+    data_sensitivity:
+      - highly_sensitive
+
+  exempt:
+    type: event
+    description: |
+      Just testing events
+    bugs:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1973017
+    data_reviews:
+      - http://example.com/reviews
+    notification_emails:
+      - CHANGE-ME@example.com
+    extra_keys:
+      url:
+        type: string
+        description: "This is key one"
+    expires: never
+    data_sensitivity:
+      - technical
+    no_lint:
+      - HIGHER_DATA_SENSITIVITY_REQUIRED