Implementing code

We are adding a `code` field to the profiling. Its meant to be a unique (per repo) string that can identify which profiling is being made on this system without needing to pass env, version or ids on the individual profiling uploads

Also adding a `needs_version_creation` in case the customer doesn't want that API call to be made on startup (they will need to do at least themselves once). The call itself is idempotent, so they should not need to worry about it unless they particularly need it to go

Author: ThiagoCodecov

codecovopentelem/__init__.py

@@ -85,13 +85,13 @@ def __init__(
         self,
         cov_storage: CodecovCoverageStorageManager,
         repository_token: str,
-        profiling_id: str,
+        code: str,
         codecov_endpoint: str,
         untracked_export_rate: float,
     ):
         self._cov_storage = cov_storage
         self._repository_token = repository_token
-        self._profiling_id = profiling_id
+        self._code = code
         self._codecov_endpoint = codecov_endpoint
         self._untracked_export_rate = untracked_export_rate
 
@@ -128,7 +128,7 @@ def export(self, spans):
             res = requests.post(
                 url,
                 headers={"Authorization": f"repotoken {self._repository_token}"},
-                json={"profiling": self._profiling_id},
+                json={"profiling": self._code},
             )
             res.raise_for_status()
         except requests.RequestException:
@@ -149,63 +149,54 @@ def get_codecov_opentelemetry_instances(
     repository_token: str,
     sample_rate: float,
     untracked_export_rate: float,
+    code: str,
     filters: Optional[Dict] = None,
-    profiling_identifier: Optional[str] = None,
+    version_identifier: Optional[str] = None,
     environment: Optional[str] = None,
-    profiling_id: Optional[str] = None,
+    needs_version_creation: bool = True,
     codecov_endpoint: str = None,
     writeable_folder: str = None,
 ) -> Tuple[CodecovCoverageGenerator, CoverageExporter]:
     """
     Entrypoint for getting a span processor/span exporter
         pair for getting profiling data into codecov
 
-    Notice that either `profiling_id` or `profiling_identifier` and `environment` need to be set.
-        If `profiling_id` is set, we just use it directly on the exporter. If not, we will use
-        `profiling_identifier` and `environment` to generate fetch a `profiling_id` from the
-        database
-
     Args:
         repository_token (str): The profiling-capable authentication token
         sample_rate (float): The sampling rate for codecov
         untracked_export_rate (float): Description
         filters (Optional[Dict], optional): A dictionary of filters for determining which
             spans should have its coverage tracked
-        profiling_identifier (Optional[str], optional): The identifier for what profiling one is doing
+        version_identifier (Optional[str], optional): The identifier for what
+            software version is being profiled
         environment (Optional[str], optional): Which environment this profiling is running on
-        profiling_id (Optional[str], optional): Description
+        code (str): The code of this profiling
         codecov_endpoint (str, optional): For configuring the endpoint in case
             the user is in enterprise (not supported yet). Default is "https://api.codecov.io/"
         writeable_folder (str, optional): A folder that is guaranteed to be write-able
             in the system. It's only used for temporary files, and nothing is expected
             to live very long in there.
     """
     codecov_endpoint = codecov_endpoint or "https://api.codecov.io"
-    if profiling_id is None:
-        if profiling_identifier is None or environment is None:
-            raise UnableToStartProcessorException(
-                "Codecov profiling needs either the id or identifier + environment"
-            )
+    if code is None:
+        raise UnableToStartProcessorException("Codecov profiling needs a code set")
+    if needs_version_creation and version_identifier and environment:
         response = requests.post(
             urllib.parse.urljoin(codecov_endpoint, "/profiling/versions"),
             json={
-                "version_identifier": profiling_identifier,
+                "version_identifier": version_identifier,
                 "environment": environment,
+                "code": code,
             },
             headers={"Authorization": f"repotoken {repository_token}"},
         )
         try:
             response.raise_for_status()
         except requests.HTTPError:
             raise UnableToStartProcessorException()
-        profiling_id = response.json()["external_id"]
     manager = CodecovCoverageStorageManager(writeable_folder, filters or {})
     generator = CodecovCoverageGenerator(manager, sample_rate)
     exporter = CoverageExporter(
-        manager,
-        repository_token,
-        profiling_id,
-        codecov_endpoint,
-        untracked_export_rate,
+        manager, repository_token, code, codecov_endpoint, untracked_export_rate,
     )
     return (generator, exporter)

tests/test_interface.py

@@ -1,16 +1,13 @@
-import json
 from uuid import uuid4
 
 import pytest
 import responses
-from coverage import Coverage
-from coverage.xmlreport import XmlReporter
 
 from codecovopentelem import (
     CodecovCoverageGenerator,
     CoverageExporter,
-    get_codecov_opentelemetry_instances,
     UnableToStartProcessorException,
+    get_codecov_opentelemetry_instances,
 )
 
 
@@ -26,15 +23,12 @@ def test_get_codecov_opentelemetry_instances_nothing_set(mocker, mocked_response
             repository_token="repository_token",
             sample_rate=0.1,
             untracked_export_rate=0.1,
+            code=None,
         )
-    assert exc.value.args == (
-        "Codecov profiling needs either the id or identifier + environment",
-    )
+    assert exc.value.args == ("Codecov profiling needs a code set",)
 
 
-def test_get_codecov_opentelemetry_instances_nothing_set_env_and_version(
-    mocker, mocked_responses
-):
+def test_get_codecov_opentelemetry_instances_with_call_made(mocker, mocked_responses):
     uuid = uuid4().hex
     mocked_responses.add(
         responses.POST,
@@ -45,8 +39,9 @@ def test_get_codecov_opentelemetry_instances_nothing_set_env_and_version(
         match=[
             responses.matchers.json_params_matcher(
                 {
-                    "version_identifier": "profiling_identifier",
+                    "version_identifier": "version_identifier",
                     "environment": "production",
+                    "code": "code",
                 }
             )
         ],
@@ -55,8 +50,27 @@ def test_get_codecov_opentelemetry_instances_nothing_set_env_and_version(
         repository_token="repository_token",
         sample_rate=0.1,
         untracked_export_rate=0.1,
-        profiling_identifier="profiling_identifier",
+        code="code",
+        version_identifier="version_identifier",
+        environment="production",
+    )
+    assert len(res) == 2
+    generator, exporter = res
+    assert isinstance(generator, CodecovCoverageGenerator)
+    assert isinstance(exporter, CoverageExporter)
+
+
+def test_get_codecov_opentelemetry_instances_with_call_not_made(
+    mocker, mocked_responses
+):
+    res = get_codecov_opentelemetry_instances(
+        repository_token="repository_token",
+        sample_rate=0.1,
+        untracked_export_rate=0.1,
+        code="code",
+        version_identifier="version_identifier",
         environment="production",
+        needs_version_creation=False,
     )
     assert len(res) == 2
     generator, exporter = res