stash

Author: jeremydvoss

instrumentation/opentelemetry-instrumentation-fastapi/pyproject.toml

@@ -36,6 +36,10 @@ dependencies = [
 instruments = [
     "fastapi ~= 0.92",
 ]
+instruments_either = [
+    "fastapi ~= 0.92",
+    "fastapi-slim ~= 0.92",
+]
 
 [project.entry-points.opentelemetry_instrumentor]
 fastapi = "opentelemetry.instrumentation.fastapi:FastAPIInstrumentor"

instrumentation/opentelemetry-instrumentation-kafka-python/pyproject.toml

@@ -31,7 +31,7 @@ dependencies = [
 ]
 
 [project.optional-dependencies]
-instruments = [
+instruments_either = [
   "kafka-python >= 2.0, < 3.0",
   "kafka-python-ng >= 2.0, < 3.0"
 ]

opentelemetry-instrumentation/src/opentelemetry/instrumentation/dependencies.py

@@ -20,24 +20,49 @@
 from packaging.requirements import InvalidRequirement, Requirement
 
 from opentelemetry.util._importlib_metadata import (
+    Distribution,
     PackageNotFoundError,
     version,
 )
 
 logger = getLogger(__name__)
 
+#TODO: consider replacing _either with _any or _or
 
 class DependencyConflict:
     required: str | None = None
     found: str | None = None
+    # The following fields are used when an instrumentation requires any of a set of dependencies rather than all.
+    required_either: Collection[str] = []
+    found_either: Collection[str] = []
 
-    def __init__(self, required: str | None, found: str | None = None):
+    # TODO: No longer requires required field
+    def __init__(self, required: str | None = None, found: str | None = None, required_either: Collection[str] = [], found_either: Collection[str] = []):
         self.required = required
         self.found = found
+        # The following fields are used when an instrumentation requires any of a set of dependencies rather than all.
+        self.required_either = required_either
+        self.found_either = found_either
 
     def __str__(self):
+        if not self.required and (self.required_either or self.found_either):
+            # TODO: make sure this formats correctly
+            return f'DependencyConflict: requested any of the following: "{self.required_either}" but found: "{self.found_either}"'
         return f'DependencyConflict: requested: "{self.required}" but found: "{self.found}"'
 
+# TODO: Figure out if this should be a subclass of DependencyConflict.
+# If now, change functions to return either and then ensure that all the dependents can handle the new value
+# class DependencyConflictEither(DependencyConflict):
+#     required: Collection[str] = []
+#     found: Collection[str] = []
+
+#     def __init__(self, required: Collection[str], found: Collection[str] = []):
+#         self.required = required
+#         self.found = found
+
+#     def __str__(self):
+#         return f'DependencyConflictEither: requested: "{self.required}" but found: "{self.found}"'
+
 
 class DependencyConflictError(Exception):
     conflict: DependencyConflict
@@ -49,10 +74,49 @@ def __str__(self):
         return str(self.conflict)
 
 
+def get_dist_dependency_conflicts(
+    dist: Distribution,
+) -> DependencyConflict | None:
+    instrumentation_deps = []
+    instrumentation_either_deps = []
+    extra = "extra"
+    instruments = "instruments"
+    instruments_marker = {extra: instruments}
+    instruments_either = "instruments_either"
+    instruments_either_marker = {extra: instruments_either}
+    print(f"dist: {dist}")
+    print(f"dist.requires: {dist.requires}")
+    if dist.requires:
+        for dep in dist.requires:
+            print(f"dep: {dep}")
+            if extra not in dep:
+                print(f"Skipping dep: {dep}")
+                continue
+            if instruments not in dep and instruments_either not in dep:
+                print(f"Skipping dep: {dep}")
+                continue
+
+            req = Requirement(dep)
+            print(f"req: {req}")
+            if req.marker.evaluate(instruments_marker): # type: ignore
+                print("Evaluated. Append")
+                instrumentation_deps.append(req) # type: ignore
+            if req.marker.evaluate(instruments_either_marker): # type: ignore
+                print("Evaluated. either. Append")
+                # Need someway to separate
+                instrumentation_either_deps.append(req) # type: ignore
+    dc = get_dependency_conflicts(instrumentation_deps, instrumentation_either_deps) # type: ignore
+    print(f"dep conf: {dc}")
+    return dc
+    # return get_dependency_conflicts(instrumentation_deps, instrumentation_either_deps) # type: ignore
+
+
 def get_dependency_conflicts(
-    deps: Collection[str | Requirement],
+    deps: Collection[str | Requirement], # Depedencies all of which are required
+    deps_either: Collection[str | Requirement] = [], # Dependencies any of which are required
 ) -> DependencyConflict | None:
     for dep in deps:
+        # TODO: what is this?
         if isinstance(dep, Requirement):
             req = dep
         else:
@@ -69,8 +133,55 @@ def get_dependency_conflicts(
         try:
             dist_version = version(req.name)
         except PackageNotFoundError:
+            # TODO: Technically this field should allow Requirements type. Tackle this in a separate PR.
             return DependencyConflict(dep)
 
         if not req.specifier.contains(dist_version):
+            # TODO: Technically this field should allow Requirements type
             return DependencyConflict(dep, f"{req.name} {dist_version}")
+    
+    # TODO: add eval of deps_either
+    if deps_either:
+        # TODO: change to using DependencyConflict
+        # is_dependency_conflict = True
+        required_either: Collection[str] = []
+        found_either: Collection[str] = []
+        for dep in deps_either:
+            # TODO: what is this?
+            if isinstance(dep, Requirement):
+                req = dep
+            else:
+                try:
+                    req = Requirement(dep)
+                except InvalidRequirement as exc:
+                    logger.warning(
+                        'error parsing dependency, reporting as a conflict: "%s" - %s',
+                        dep,
+                        exc,
+                    )
+                    return DependencyConflict(dep)
+
+            try:
+                dist_version = version(req.name)
+            except PackageNotFoundError:
+                print(f"PackageNotFoundError: {req.name}")
+                continue
+                # TODO: anything here?
+                # return DependencyConflict(dep)
+                required_either.append(dep)
+
+            if req.specifier.contains(dist_version):
+                # is_dependency_conflict = False
+                # Since only one of the instrumentation_either dependencies is required, there is no depdendency conflict.
+                break
+            else:
+                required_either.append(dep)
+                found_either.append(f"{req.name} {dist_version}")
+        
+        # return DependencyConflict(dep, f"{req.name} {dist_version}")
+        return DependencyConflict(
+            required_either=required_either,
+            found_either=found_either,
+        )
+
     return None