reserved opentelemetry.io namespace

Author: Horiodino

pkg/instrumentation/sdk.go

@@ -401,6 +401,91 @@ func chooseServiceVersion(pod corev1.Pod, index int) string {
 	return tag
 }
 
+
+/*
+	Desire for a Reserved Namespace:
+    There's a desire to reserve a specific namespace, in this case, .opentelemetry.io/, for special instructions or configurations related to OpenTelemetry.
+
+    User-Defined Values in the Namespace:
+        Users are expected to set values within this reserved namespace, such as 'resource.opentelemetry.io/service.name' or 'resource.opentelemetry.io/my.attribute: some-value' on a pod or deployment.
+
+    Recognition by OpenTelemetry Operator:
+        The OpenTelemetry Operator should be designed to recognize and understand these user-defined values within the reserved namespace.
+
+    Purpose of Recognition:
+        Upon recognizing these values, the OpenTelemetry Operator is expected to perform certain actions or configurations based on the provided instructions.
+        For example, if a user sets 'resource.opentelemetry.io/service.name' on a pod, the operator should understand that this is an instruction to set the service name for that specific pod.
+
+    Dynamic Configuration Based on Annotations:
+        Annotations on Kubernetes resources (e.g., pods or deployments) are used as a means of providing configuration instructions.
+        If an annotation like 'resource.opentelemetry.io/my.attribute: some-value' is set, the OpenTelemetry Operator should interpret this as an instruction to set a specific attribute (e.g., my.attribute) with a particular value (some-value) for the associated resource.
+
+
+
+	TODO
+	according to the issue the end result should be something like this:
+	for example, if I was to set 'resource.opentelemetry.io/service.name' on a pod, then use instrumentation CRDs to add instrumentation, the value of that annotation would be propagated to the instrumentation.
+
+	the above example is doing that in the following way: if a user sets 'resource.opentelemetry.io/service.name' on a pod, the operator should understand that this is an instruction to set the service name for that specific pod.
+	then the operator should interpret this as an instruction to set a specific attribute (e.g., my.attribute) with a particular value (some-value) for the associated resource.
+	and finally the operator should propagate the value of that annotation to the instrumentation.
+
+	in simple words the operator should understand that this is an instruction to set the service name for that specific pod and then propagate the value of that annotation to the instrumentation.
+	propogate means that the operator should interpret this as an instruction to set a specific attribute (e.g., my.attribute) with a particular value (some-value) for the associated resource.
+
+*/
+
+/*  
+	Add a new namespace as a reserved namespace (e.g., *.opentelemetry.io/*).
+	Add a new function to the operator to recognize and understand user-defined values within the reserved namespace.
+	Add a new function to the operator to perform certain actions or configurations based on the provided instructions.
+	Add a new function to the operator to set the service name for that specific pod.
+	Add a new function to the operator to set a specific attribute (e.g., my.attribute) with a particular value (some-value) for the associated resource.
+	Add a new function to the operator to interpret this as an instruction to set a specific attribute (e.g., my.attribute) with a particular value (some-value) for the associated resource.
+	In the createResourceMap function, add code to parse the reserved namespace and set the associated values as resource attributes.
+*/
+
+// create/reserve namespace 
+
+func (i *sdkInjector) createReservedNamespace(ctx context.Context) (corev1.Namespace, error) {
+	ns := corev1.Namespace{}
+	ns.Name = "opentelemetry.io"
+	err := i.client.Create(ctx, &ns)
+	if err != nil {
+		return ns, err
+	}
+	return ns, nil
+}
+
+// 	Add a new function to the operator to recognize and understand user-defined values within the reserved namespace.
+
+func (i *sdkInjector) recognizeUserDefinedValues(ctx context.Context, ns corev1.Namespace) (corev1.Namespace, error) {
+	// what we need to do here is to recognize and understand user-defined values within the reserved namespace.
+	// what kind of user-defined values? the ones that are set on a pod or deployment.
+	// how do we do that? we need to use annotations on Kubernetes resources (e.g., pods or deployments) as a means of providing configuration instructions.
+	// what kind of annotations? the ones that are set on a pod or deployment.
+	// we will use recognise if the user set the value as open-telemetry.io/attribute: some-value
+	// then we will use the value of that annotation to set a specific attribute (e.g., my.attribute) with a particular value (some-value) for the associated resource.
+
+	// check for the namespace is created or not if the namespace is not created then create it else throw an error
+
+	err := i.client.Get(ctx, types.NamespacedName{Name: ns.Name}, &ns)
+	if err != nil {
+		return ns, err
+	}
+
+	// Get the all pods in the givennamespace 
+
+
+	// TODO - use the annotations to recognize and understand user-defined values within the reserved namespace
+	// TODO - use the annotations to set the specific attribute with a particular value for the associated resource
+
+	return ns, nil
+	
+}
+
+
+
 // createResourceMap creates resource attribute map.
 // User defined attributes (in explicitly set env var) have higher precedence.
 func (i *sdkInjector) createResourceMap(ctx context.Context, otelinst v1alpha1.Instrumentation, ns corev1.Namespace, pod corev1.Pod, index int) map[string]string {