+agentsMetaHash [Required]
+ |
+
+string
+ |
+
+ this hash is used to determine the deployment of the agents.
+e.g. when the distro for container changes, or it's compatibility version,
+or something else that requires rollout, the hash change will indicate that.
+if the hash is empty, it means that no agent should be enabled in any pod container.
+ |
+
+
+
sdkConfigs [Required]
|
@@ -1353,9 +1367,9 @@ TODO: consider adding more granular control over the SDKs, such as community/ent
string
|
- The hash used to determine whether the associated workload needs to be rolled out.
-This hash is calculated based on the containers config array and takes into account the
-container name, Instrumented flag and the OTel distro name.
+ This hash is recorded only after the rollout took place.
+it allows us to determine if the workload needs to be rollout based on previous rollout and the current config.
+if this field is different than the spec.AgentsDeploymentHash it means rollout is needed or not yet updated.
|
diff --git a/frontend/graph/generated.go b/frontend/graph/generated.go
index fd4fd876d9..f975906525 100644
--- a/frontend/graph/generated.go
+++ b/frontend/graph/generated.go
@@ -138,10 +138,6 @@ type ComplexityRoot struct {
MaxPayloadLength func(childComplexity int) int
}
- DeleteAttribute struct {
- AttributeName func(childComplexity int) int
- }
-
DeleteAttributeAction struct {
Details func(childComplexity int) int
Disable func(childComplexity int) int
@@ -282,6 +278,34 @@ type ComplexityRoot struct {
Selected func(childComplexity int) int
}
+ K8sAnnotationAttribute struct {
+ AnnotationKey func(childComplexity int) int
+ AttributeKey func(childComplexity int) int
+ }
+
+ K8sAttributes struct {
+ AnnotationsAttributes func(childComplexity int) int
+ CollectClusterID func(childComplexity int) int
+ CollectContainerAttributes func(childComplexity int) int
+ CollectWorkloadID func(childComplexity int) int
+ LabelsAttributes func(childComplexity int) int
+ }
+
+ K8sAttributesAction struct {
+ Details func(childComplexity int) int
+ Disable func(childComplexity int) int
+ ID func(childComplexity int) int
+ Name func(childComplexity int) int
+ Notes func(childComplexity int) int
+ Signals func(childComplexity int) int
+ Type func(childComplexity int) int
+ }
+
+ K8sLabelAttribute struct {
+ AttributeKey func(childComplexity int) int
+ LabelKey func(childComplexity int) int
+ }
+
LatencySamplerAction struct {
Details func(childComplexity int) int
Disable func(childComplexity int) int
@@ -947,13 +971,6 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in
return e.complexity.DbQueryPayloadCollection.MaxPayloadLength(childComplexity), true
- case "DeleteAttribute.attributeName":
- if e.complexity.DeleteAttribute.AttributeName == nil {
- break
- }
-
- return e.complexity.DeleteAttribute.AttributeName(childComplexity), true
-
case "DeleteAttributeAction.details":
if e.complexity.DeleteAttributeAction.Details == nil {
break
@@ -1556,6 +1573,118 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in
return e.complexity.K8sActualSource.Selected(childComplexity), true
+ case "K8sAnnotationAttribute.annotationKey":
+ if e.complexity.K8sAnnotationAttribute.AnnotationKey == nil {
+ break
+ }
+
+ return e.complexity.K8sAnnotationAttribute.AnnotationKey(childComplexity), true
+
+ case "K8sAnnotationAttribute.attributeKey":
+ if e.complexity.K8sAnnotationAttribute.AttributeKey == nil {
+ break
+ }
+
+ return e.complexity.K8sAnnotationAttribute.AttributeKey(childComplexity), true
+
+ case "K8sAttributes.annotationsAttributes":
+ if e.complexity.K8sAttributes.AnnotationsAttributes == nil {
+ break
+ }
+
+ return e.complexity.K8sAttributes.AnnotationsAttributes(childComplexity), true
+
+ case "K8sAttributes.collectClusterId":
+ if e.complexity.K8sAttributes.CollectClusterID == nil {
+ break
+ }
+
+ return e.complexity.K8sAttributes.CollectClusterID(childComplexity), true
+
+ case "K8sAttributes.collectContainerAttributes":
+ if e.complexity.K8sAttributes.CollectContainerAttributes == nil {
+ break
+ }
+
+ return e.complexity.K8sAttributes.CollectContainerAttributes(childComplexity), true
+
+ case "K8sAttributes.collectWorkloadId":
+ if e.complexity.K8sAttributes.CollectWorkloadID == nil {
+ break
+ }
+
+ return e.complexity.K8sAttributes.CollectWorkloadID(childComplexity), true
+
+ case "K8sAttributes.labelsAttributes":
+ if e.complexity.K8sAttributes.LabelsAttributes == nil {
+ break
+ }
+
+ return e.complexity.K8sAttributes.LabelsAttributes(childComplexity), true
+
+ case "K8sAttributesAction.details":
+ if e.complexity.K8sAttributesAction.Details == nil {
+ break
+ }
+
+ return e.complexity.K8sAttributesAction.Details(childComplexity), true
+
+ case "K8sAttributesAction.disable":
+ if e.complexity.K8sAttributesAction.Disable == nil {
+ break
+ }
+
+ return e.complexity.K8sAttributesAction.Disable(childComplexity), true
+
+ case "K8sAttributesAction.id":
+ if e.complexity.K8sAttributesAction.ID == nil {
+ break
+ }
+
+ return e.complexity.K8sAttributesAction.ID(childComplexity), true
+
+ case "K8sAttributesAction.name":
+ if e.complexity.K8sAttributesAction.Name == nil {
+ break
+ }
+
+ return e.complexity.K8sAttributesAction.Name(childComplexity), true
+
+ case "K8sAttributesAction.notes":
+ if e.complexity.K8sAttributesAction.Notes == nil {
+ break
+ }
+
+ return e.complexity.K8sAttributesAction.Notes(childComplexity), true
+
+ case "K8sAttributesAction.signals":
+ if e.complexity.K8sAttributesAction.Signals == nil {
+ break
+ }
+
+ return e.complexity.K8sAttributesAction.Signals(childComplexity), true
+
+ case "K8sAttributesAction.type":
+ if e.complexity.K8sAttributesAction.Type == nil {
+ break
+ }
+
+ return e.complexity.K8sAttributesAction.Type(childComplexity), true
+
+ case "K8sLabelAttribute.attributeKey":
+ if e.complexity.K8sLabelAttribute.AttributeKey == nil {
+ break
+ }
+
+ return e.complexity.K8sLabelAttribute.AttributeKey(childComplexity), true
+
+ case "K8sLabelAttribute.labelKey":
+ if e.complexity.K8sLabelAttribute.LabelKey == nil {
+ break
+ }
+
+ return e.complexity.K8sLabelAttribute.LabelKey(childComplexity), true
+
case "LatencySamplerAction.details":
if e.complexity.LatencySamplerAction.Details == nil {
break
@@ -5751,50 +5880,6 @@ func (ec *executionContext) fieldContext_DbQueryPayloadCollection_dropPartialPay
return fc, nil
}
-func (ec *executionContext) _DeleteAttribute_attributeName(ctx context.Context, field graphql.CollectedField, obj *model.DeleteAttribute) (ret graphql.Marshaler) {
- fc, err := ec.fieldContext_DeleteAttribute_attributeName(ctx, field)
- if err != nil {
- return graphql.Null
- }
- ctx = graphql.WithFieldContext(ctx, fc)
- defer func() {
- if r := recover(); r != nil {
- ec.Error(ctx, ec.Recover(ctx, r))
- ret = graphql.Null
- }
- }()
- resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
- ctx = rctx // use context from middleware stack in children
- return obj.AttributeName, nil
- })
- if err != nil {
- ec.Error(ctx, err)
- return graphql.Null
- }
- if resTmp == nil {
- if !graphql.HasFieldError(ctx, fc) {
- ec.Errorf(ctx, "must not be null")
- }
- return graphql.Null
- }
- res := resTmp.(string)
- fc.Result = res
- return ec.marshalNString2string(ctx, field.Selections, res)
-}
-
-func (ec *executionContext) fieldContext_DeleteAttribute_attributeName(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
- fc = &graphql.FieldContext{
- Object: "DeleteAttribute",
- Field: field,
- IsMethod: false,
- IsResolver: false,
- Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
- return nil, errors.New("field of type String does not have child fields")
- },
- }
- return fc, nil
-}
-
func (ec *executionContext) _DeleteAttributeAction_id(ctx context.Context, field graphql.CollectedField, obj *model.DeleteAttributeAction) (ret graphql.Marshaler) {
fc, err := ec.fieldContext_DeleteAttributeAction_id(ctx, field)
if err != nil {
@@ -9741,8 +9826,8 @@ func (ec *executionContext) fieldContext_K8sActualSource_conditions(_ context.Co
return fc, nil
}
-func (ec *executionContext) _LatencySamplerAction_id(ctx context.Context, field graphql.CollectedField, obj *model.LatencySamplerAction) (ret graphql.Marshaler) {
- fc, err := ec.fieldContext_LatencySamplerAction_id(ctx, field)
+func (ec *executionContext) _K8sAnnotationAttribute_annotationKey(ctx context.Context, field graphql.CollectedField, obj *model.K8sAnnotationAttribute) (ret graphql.Marshaler) {
+ fc, err := ec.fieldContext_K8sAnnotationAttribute_annotationKey(ctx, field)
if err != nil {
return graphql.Null
}
@@ -9755,7 +9840,7 @@ func (ec *executionContext) _LatencySamplerAction_id(ctx context.Context, field
}()
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
- return obj.ID, nil
+ return obj.AnnotationKey, nil
})
if err != nil {
ec.Error(ctx, err)
@@ -9769,24 +9854,24 @@ func (ec *executionContext) _LatencySamplerAction_id(ctx context.Context, field
}
res := resTmp.(string)
fc.Result = res
- return ec.marshalNID2string(ctx, field.Selections, res)
+ return ec.marshalNString2string(ctx, field.Selections, res)
}
-func (ec *executionContext) fieldContext_LatencySamplerAction_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_K8sAnnotationAttribute_annotationKey(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
fc = &graphql.FieldContext{
- Object: "LatencySamplerAction",
+ Object: "K8sAnnotationAttribute",
Field: field,
IsMethod: false,
IsResolver: false,
Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
- return nil, errors.New("field of type ID does not have child fields")
+ return nil, errors.New("field of type String does not have child fields")
},
}
return fc, nil
}
-func (ec *executionContext) _LatencySamplerAction_type(ctx context.Context, field graphql.CollectedField, obj *model.LatencySamplerAction) (ret graphql.Marshaler) {
- fc, err := ec.fieldContext_LatencySamplerAction_type(ctx, field)
+func (ec *executionContext) _K8sAnnotationAttribute_attributeKey(ctx context.Context, field graphql.CollectedField, obj *model.K8sAnnotationAttribute) (ret graphql.Marshaler) {
+ fc, err := ec.fieldContext_K8sAnnotationAttribute_attributeKey(ctx, field)
if err != nil {
return graphql.Null
}
@@ -9799,7 +9884,7 @@ func (ec *executionContext) _LatencySamplerAction_type(ctx context.Context, fiel
}()
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
- return obj.Type, nil
+ return obj.AttributeKey, nil
})
if err != nil {
ec.Error(ctx, err)
@@ -9816,9 +9901,9 @@ func (ec *executionContext) _LatencySamplerAction_type(ctx context.Context, fiel
return ec.marshalNString2string(ctx, field.Selections, res)
}
-func (ec *executionContext) fieldContext_LatencySamplerAction_type(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_K8sAnnotationAttribute_attributeKey(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
fc = &graphql.FieldContext{
- Object: "LatencySamplerAction",
+ Object: "K8sAnnotationAttribute",
Field: field,
IsMethod: false,
IsResolver: false,
@@ -9829,8 +9914,8 @@ func (ec *executionContext) fieldContext_LatencySamplerAction_type(_ context.Con
return fc, nil
}
-func (ec *executionContext) _LatencySamplerAction_name(ctx context.Context, field graphql.CollectedField, obj *model.LatencySamplerAction) (ret graphql.Marshaler) {
- fc, err := ec.fieldContext_LatencySamplerAction_name(ctx, field)
+func (ec *executionContext) _K8sAttributes_collectContainerAttributes(ctx context.Context, field graphql.CollectedField, obj *model.K8sAttributes) (ret graphql.Marshaler) {
+ fc, err := ec.fieldContext_K8sAttributes_collectContainerAttributes(ctx, field)
if err != nil {
return graphql.Null
}
@@ -9843,35 +9928,38 @@ func (ec *executionContext) _LatencySamplerAction_name(ctx context.Context, fiel
}()
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
- return obj.Name, nil
+ return obj.CollectContainerAttributes, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
+ if !graphql.HasFieldError(ctx, fc) {
+ ec.Errorf(ctx, "must not be null")
+ }
return graphql.Null
}
- res := resTmp.(*string)
+ res := resTmp.(bool)
fc.Result = res
- return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
+ return ec.marshalNBoolean2bool(ctx, field.Selections, res)
}
-func (ec *executionContext) fieldContext_LatencySamplerAction_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_K8sAttributes_collectContainerAttributes(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
fc = &graphql.FieldContext{
- Object: "LatencySamplerAction",
+ Object: "K8sAttributes",
Field: field,
IsMethod: false,
IsResolver: false,
Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
- return nil, errors.New("field of type String does not have child fields")
+ return nil, errors.New("field of type Boolean does not have child fields")
},
}
return fc, nil
}
-func (ec *executionContext) _LatencySamplerAction_notes(ctx context.Context, field graphql.CollectedField, obj *model.LatencySamplerAction) (ret graphql.Marshaler) {
- fc, err := ec.fieldContext_LatencySamplerAction_notes(ctx, field)
+func (ec *executionContext) _K8sAttributes_collectWorkloadId(ctx context.Context, field graphql.CollectedField, obj *model.K8sAttributes) (ret graphql.Marshaler) {
+ fc, err := ec.fieldContext_K8sAttributes_collectWorkloadId(ctx, field)
if err != nil {
return graphql.Null
}
@@ -9884,35 +9972,38 @@ func (ec *executionContext) _LatencySamplerAction_notes(ctx context.Context, fie
}()
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
- return obj.Notes, nil
+ return obj.CollectWorkloadID, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
+ if !graphql.HasFieldError(ctx, fc) {
+ ec.Errorf(ctx, "must not be null")
+ }
return graphql.Null
}
- res := resTmp.(*string)
+ res := resTmp.(bool)
fc.Result = res
- return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
+ return ec.marshalNBoolean2bool(ctx, field.Selections, res)
}
-func (ec *executionContext) fieldContext_LatencySamplerAction_notes(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_K8sAttributes_collectWorkloadId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
fc = &graphql.FieldContext{
- Object: "LatencySamplerAction",
+ Object: "K8sAttributes",
Field: field,
IsMethod: false,
IsResolver: false,
Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
- return nil, errors.New("field of type String does not have child fields")
+ return nil, errors.New("field of type Boolean does not have child fields")
},
}
return fc, nil
}
-func (ec *executionContext) _LatencySamplerAction_disable(ctx context.Context, field graphql.CollectedField, obj *model.LatencySamplerAction) (ret graphql.Marshaler) {
- fc, err := ec.fieldContext_LatencySamplerAction_disable(ctx, field)
+func (ec *executionContext) _K8sAttributes_collectClusterId(ctx context.Context, field graphql.CollectedField, obj *model.K8sAttributes) (ret graphql.Marshaler) {
+ fc, err := ec.fieldContext_K8sAttributes_collectClusterId(ctx, field)
if err != nil {
return graphql.Null
}
@@ -9925,7 +10016,7 @@ func (ec *executionContext) _LatencySamplerAction_disable(ctx context.Context, f
}()
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
- return obj.Disable, nil
+ return obj.CollectClusterID, nil
})
if err != nil {
ec.Error(ctx, err)
@@ -9942,9 +10033,9 @@ func (ec *executionContext) _LatencySamplerAction_disable(ctx context.Context, f
return ec.marshalNBoolean2bool(ctx, field.Selections, res)
}
-func (ec *executionContext) fieldContext_LatencySamplerAction_disable(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_K8sAttributes_collectClusterId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
fc = &graphql.FieldContext{
- Object: "LatencySamplerAction",
+ Object: "K8sAttributes",
Field: field,
IsMethod: false,
IsResolver: false,
@@ -9955,8 +10046,8 @@ func (ec *executionContext) fieldContext_LatencySamplerAction_disable(_ context.
return fc, nil
}
-func (ec *executionContext) _LatencySamplerAction_signals(ctx context.Context, field graphql.CollectedField, obj *model.LatencySamplerAction) (ret graphql.Marshaler) {
- fc, err := ec.fieldContext_LatencySamplerAction_signals(ctx, field)
+func (ec *executionContext) _K8sAttributes_labelsAttributes(ctx context.Context, field graphql.CollectedField, obj *model.K8sAttributes) (ret graphql.Marshaler) {
+ fc, err := ec.fieldContext_K8sAttributes_labelsAttributes(ctx, field)
if err != nil {
return graphql.Null
}
@@ -9969,7 +10060,7 @@ func (ec *executionContext) _LatencySamplerAction_signals(ctx context.Context, f
}()
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
- return obj.Signals, nil
+ return obj.LabelsAttributes, nil
})
if err != nil {
ec.Error(ctx, err)
@@ -9981,26 +10072,32 @@ func (ec *executionContext) _LatencySamplerAction_signals(ctx context.Context, f
}
return graphql.Null
}
- res := resTmp.([]model.SignalType)
+ res := resTmp.([]*model.K8sLabelAttribute)
fc.Result = res
- return ec.marshalNSignalType2ᚕgithubᚗcomᚋodigosᚑioᚋodigosᚋfrontendᚋgraphᚋmodelᚐSignalTypeᚄ(ctx, field.Selections, res)
+ return ec.marshalNK8sLabelAttribute2ᚕᚖgithubᚗcomᚋodigosᚑioᚋodigosᚋfrontendᚋgraphᚋmodelᚐK8sLabelAttributeᚄ(ctx, field.Selections, res)
}
-func (ec *executionContext) fieldContext_LatencySamplerAction_signals(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_K8sAttributes_labelsAttributes(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
fc = &graphql.FieldContext{
- Object: "LatencySamplerAction",
+ Object: "K8sAttributes",
Field: field,
IsMethod: false,
IsResolver: false,
Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
- return nil, errors.New("field of type SignalType does not have child fields")
+ switch field.Name {
+ case "labelKey":
+ return ec.fieldContext_K8sLabelAttribute_labelKey(ctx, field)
+ case "attributeKey":
+ return ec.fieldContext_K8sLabelAttribute_attributeKey(ctx, field)
+ }
+ return nil, fmt.Errorf("no field named %q was found under type K8sLabelAttribute", field.Name)
},
}
return fc, nil
}
-func (ec *executionContext) _LatencySamplerAction_details(ctx context.Context, field graphql.CollectedField, obj *model.LatencySamplerAction) (ret graphql.Marshaler) {
- fc, err := ec.fieldContext_LatencySamplerAction_details(ctx, field)
+func (ec *executionContext) _K8sAttributes_annotationsAttributes(ctx context.Context, field graphql.CollectedField, obj *model.K8sAttributes) (ret graphql.Marshaler) {
+ fc, err := ec.fieldContext_K8sAttributes_annotationsAttributes(ctx, field)
if err != nil {
return graphql.Null
}
@@ -10013,7 +10110,7 @@ func (ec *executionContext) _LatencySamplerAction_details(ctx context.Context, f
}()
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
- return obj.Details, nil
+ return obj.AnnotationsAttributes, nil
})
if err != nil {
ec.Error(ctx, err)
@@ -10025,26 +10122,32 @@ func (ec *executionContext) _LatencySamplerAction_details(ctx context.Context, f
}
return graphql.Null
}
- res := resTmp.([]*string)
+ res := resTmp.([]*model.K8sAnnotationAttribute)
fc.Result = res
- return ec.marshalNString2ᚕᚖstring(ctx, field.Selections, res)
+ return ec.marshalNK8sAnnotationAttribute2ᚕᚖgithubᚗcomᚋodigosᚑioᚋodigosᚋfrontendᚋgraphᚋmodelᚐK8sAnnotationAttributeᚄ(ctx, field.Selections, res)
}
-func (ec *executionContext) fieldContext_LatencySamplerAction_details(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_K8sAttributes_annotationsAttributes(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
fc = &graphql.FieldContext{
- Object: "LatencySamplerAction",
+ Object: "K8sAttributes",
Field: field,
IsMethod: false,
IsResolver: false,
Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
- return nil, errors.New("field of type String does not have child fields")
+ switch field.Name {
+ case "annotationKey":
+ return ec.fieldContext_K8sAnnotationAttribute_annotationKey(ctx, field)
+ case "attributeKey":
+ return ec.fieldContext_K8sAnnotationAttribute_attributeKey(ctx, field)
+ }
+ return nil, fmt.Errorf("no field named %q was found under type K8sAnnotationAttribute", field.Name)
},
}
return fc, nil
}
-func (ec *executionContext) _MessagingPayloadCollection_maxPayloadLength(ctx context.Context, field graphql.CollectedField, obj *model.MessagingPayloadCollection) (ret graphql.Marshaler) {
- fc, err := ec.fieldContext_MessagingPayloadCollection_maxPayloadLength(ctx, field)
+func (ec *executionContext) _K8sAttributesAction_id(ctx context.Context, field graphql.CollectedField, obj *model.K8sAttributesAction) (ret graphql.Marshaler) {
+ fc, err := ec.fieldContext_K8sAttributesAction_id(ctx, field)
if err != nil {
return graphql.Null
}
@@ -10057,35 +10160,38 @@ func (ec *executionContext) _MessagingPayloadCollection_maxPayloadLength(ctx con
}()
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
- return obj.MaxPayloadLength, nil
+ return obj.ID, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
+ if !graphql.HasFieldError(ctx, fc) {
+ ec.Errorf(ctx, "must not be null")
+ }
return graphql.Null
}
- res := resTmp.(*int)
+ res := resTmp.(string)
fc.Result = res
- return ec.marshalOInt2ᚖint(ctx, field.Selections, res)
+ return ec.marshalNID2string(ctx, field.Selections, res)
}
-func (ec *executionContext) fieldContext_MessagingPayloadCollection_maxPayloadLength(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_K8sAttributesAction_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
fc = &graphql.FieldContext{
- Object: "MessagingPayloadCollection",
+ Object: "K8sAttributesAction",
Field: field,
IsMethod: false,
IsResolver: false,
Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
- return nil, errors.New("field of type Int does not have child fields")
+ return nil, errors.New("field of type ID does not have child fields")
},
}
return fc, nil
}
-func (ec *executionContext) _MessagingPayloadCollection_dropPartialPayloads(ctx context.Context, field graphql.CollectedField, obj *model.MessagingPayloadCollection) (ret graphql.Marshaler) {
- fc, err := ec.fieldContext_MessagingPayloadCollection_dropPartialPayloads(ctx, field)
+func (ec *executionContext) _K8sAttributesAction_type(ctx context.Context, field graphql.CollectedField, obj *model.K8sAttributesAction) (ret graphql.Marshaler) {
+ fc, err := ec.fieldContext_K8sAttributesAction_type(ctx, field)
if err != nil {
return graphql.Null
}
@@ -10098,35 +10204,38 @@ func (ec *executionContext) _MessagingPayloadCollection_dropPartialPayloads(ctx
}()
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
- return obj.DropPartialPayloads, nil
+ return obj.Type, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
+ if !graphql.HasFieldError(ctx, fc) {
+ ec.Errorf(ctx, "must not be null")
+ }
return graphql.Null
}
- res := resTmp.(*bool)
+ res := resTmp.(string)
fc.Result = res
- return ec.marshalOBoolean2ᚖbool(ctx, field.Selections, res)
+ return ec.marshalNString2string(ctx, field.Selections, res)
}
-func (ec *executionContext) fieldContext_MessagingPayloadCollection_dropPartialPayloads(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_K8sAttributesAction_type(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
fc = &graphql.FieldContext{
- Object: "MessagingPayloadCollection",
+ Object: "K8sAttributesAction",
Field: field,
IsMethod: false,
IsResolver: false,
Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
- return nil, errors.New("field of type Boolean does not have child fields")
+ return nil, errors.New("field of type String does not have child fields")
},
}
return fc, nil
}
-func (ec *executionContext) _Mutation_updateApiToken(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
- fc, err := ec.fieldContext_Mutation_updateApiToken(ctx, field)
+func (ec *executionContext) _K8sAttributesAction_name(ctx context.Context, field graphql.CollectedField, obj *model.K8sAttributesAction) (ret graphql.Marshaler) {
+ fc, err := ec.fieldContext_K8sAttributesAction_name(ctx, field)
if err != nil {
return graphql.Null
}
@@ -10139,49 +10248,35 @@ func (ec *executionContext) _Mutation_updateApiToken(ctx context.Context, field
}()
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
- return ec.resolvers.Mutation().UpdateAPIToken(rctx, fc.Args["token"].(string))
+ return obj.Name, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
- if !graphql.HasFieldError(ctx, fc) {
- ec.Errorf(ctx, "must not be null")
- }
return graphql.Null
}
- res := resTmp.(bool)
+ res := resTmp.(*string)
fc.Result = res
- return ec.marshalNBoolean2bool(ctx, field.Selections, res)
+ return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}
-func (ec *executionContext) fieldContext_Mutation_updateApiToken(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_K8sAttributesAction_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
fc = &graphql.FieldContext{
- Object: "Mutation",
+ Object: "K8sAttributesAction",
Field: field,
- IsMethod: true,
- IsResolver: true,
+ IsMethod: false,
+ IsResolver: false,
Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
- return nil, errors.New("field of type Boolean does not have child fields")
+ return nil, errors.New("field of type String does not have child fields")
},
}
- defer func() {
- if r := recover(); r != nil {
- err = ec.Recover(ctx, r)
- ec.Error(ctx, err)
- }
- }()
- ctx = graphql.WithFieldContext(ctx, fc)
- if fc.Args, err = ec.field_Mutation_updateApiToken_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
- ec.Error(ctx, err)
- return fc, err
- }
return fc, nil
}
-func (ec *executionContext) _Mutation_persistK8sNamespace(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
- fc, err := ec.fieldContext_Mutation_persistK8sNamespace(ctx, field)
+func (ec *executionContext) _K8sAttributesAction_notes(ctx context.Context, field graphql.CollectedField, obj *model.K8sAttributesAction) (ret graphql.Marshaler) {
+ fc, err := ec.fieldContext_K8sAttributesAction_notes(ctx, field)
if err != nil {
return graphql.Null
}
@@ -10194,7 +10289,719 @@ func (ec *executionContext) _Mutation_persistK8sNamespace(ctx context.Context, f
}()
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
- return ec.resolvers.Mutation().PersistK8sNamespace(rctx, fc.Args["namespace"].(model.PersistNamespaceItemInput))
+ return obj.Notes, nil
+ })
+ if err != nil {
+ ec.Error(ctx, err)
+ return graphql.Null
+ }
+ if resTmp == nil {
+ return graphql.Null
+ }
+ res := resTmp.(*string)
+ fc.Result = res
+ return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) fieldContext_K8sAttributesAction_notes(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ fc = &graphql.FieldContext{
+ Object: "K8sAttributesAction",
+ Field: field,
+ IsMethod: false,
+ IsResolver: false,
+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return nil, errors.New("field of type String does not have child fields")
+ },
+ }
+ return fc, nil
+}
+
+func (ec *executionContext) _K8sAttributesAction_disable(ctx context.Context, field graphql.CollectedField, obj *model.K8sAttributesAction) (ret graphql.Marshaler) {
+ fc, err := ec.fieldContext_K8sAttributesAction_disable(ctx, field)
+ if err != nil {
+ return graphql.Null
+ }
+ ctx = graphql.WithFieldContext(ctx, fc)
+ defer func() {
+ if r := recover(); r != nil {
+ ec.Error(ctx, ec.Recover(ctx, r))
+ ret = graphql.Null
+ }
+ }()
+ resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.Disable, nil
+ })
+ if err != nil {
+ ec.Error(ctx, err)
+ return graphql.Null
+ }
+ if resTmp == nil {
+ if !graphql.HasFieldError(ctx, fc) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(bool)
+ fc.Result = res
+ return ec.marshalNBoolean2bool(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) fieldContext_K8sAttributesAction_disable(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ fc = &graphql.FieldContext{
+ Object: "K8sAttributesAction",
+ Field: field,
+ IsMethod: false,
+ IsResolver: false,
+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return nil, errors.New("field of type Boolean does not have child fields")
+ },
+ }
+ return fc, nil
+}
+
+func (ec *executionContext) _K8sAttributesAction_signals(ctx context.Context, field graphql.CollectedField, obj *model.K8sAttributesAction) (ret graphql.Marshaler) {
+ fc, err := ec.fieldContext_K8sAttributesAction_signals(ctx, field)
+ if err != nil {
+ return graphql.Null
+ }
+ ctx = graphql.WithFieldContext(ctx, fc)
+ defer func() {
+ if r := recover(); r != nil {
+ ec.Error(ctx, ec.Recover(ctx, r))
+ ret = graphql.Null
+ }
+ }()
+ resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.Signals, nil
+ })
+ if err != nil {
+ ec.Error(ctx, err)
+ return graphql.Null
+ }
+ if resTmp == nil {
+ if !graphql.HasFieldError(ctx, fc) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.([]model.SignalType)
+ fc.Result = res
+ return ec.marshalNSignalType2ᚕgithubᚗcomᚋodigosᚑioᚋodigosᚋfrontendᚋgraphᚋmodelᚐSignalTypeᚄ(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) fieldContext_K8sAttributesAction_signals(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ fc = &graphql.FieldContext{
+ Object: "K8sAttributesAction",
+ Field: field,
+ IsMethod: false,
+ IsResolver: false,
+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return nil, errors.New("field of type SignalType does not have child fields")
+ },
+ }
+ return fc, nil
+}
+
+func (ec *executionContext) _K8sAttributesAction_details(ctx context.Context, field graphql.CollectedField, obj *model.K8sAttributesAction) (ret graphql.Marshaler) {
+ fc, err := ec.fieldContext_K8sAttributesAction_details(ctx, field)
+ if err != nil {
+ return graphql.Null
+ }
+ ctx = graphql.WithFieldContext(ctx, fc)
+ defer func() {
+ if r := recover(); r != nil {
+ ec.Error(ctx, ec.Recover(ctx, r))
+ ret = graphql.Null
+ }
+ }()
+ resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.Details, nil
+ })
+ if err != nil {
+ ec.Error(ctx, err)
+ return graphql.Null
+ }
+ if resTmp == nil {
+ if !graphql.HasFieldError(ctx, fc) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(*model.K8sAttributes)
+ fc.Result = res
+ return ec.marshalNK8sAttributes2ᚖgithubᚗcomᚋodigosᚑioᚋodigosᚋfrontendᚋgraphᚋmodelᚐK8sAttributes(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) fieldContext_K8sAttributesAction_details(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ fc = &graphql.FieldContext{
+ Object: "K8sAttributesAction",
+ Field: field,
+ IsMethod: false,
+ IsResolver: false,
+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ switch field.Name {
+ case "collectContainerAttributes":
+ return ec.fieldContext_K8sAttributes_collectContainerAttributes(ctx, field)
+ case "collectWorkloadId":
+ return ec.fieldContext_K8sAttributes_collectWorkloadId(ctx, field)
+ case "collectClusterId":
+ return ec.fieldContext_K8sAttributes_collectClusterId(ctx, field)
+ case "labelsAttributes":
+ return ec.fieldContext_K8sAttributes_labelsAttributes(ctx, field)
+ case "annotationsAttributes":
+ return ec.fieldContext_K8sAttributes_annotationsAttributes(ctx, field)
+ }
+ return nil, fmt.Errorf("no field named %q was found under type K8sAttributes", field.Name)
+ },
+ }
+ return fc, nil
+}
+
+func (ec *executionContext) _K8sLabelAttribute_labelKey(ctx context.Context, field graphql.CollectedField, obj *model.K8sLabelAttribute) (ret graphql.Marshaler) {
+ fc, err := ec.fieldContext_K8sLabelAttribute_labelKey(ctx, field)
+ if err != nil {
+ return graphql.Null
+ }
+ ctx = graphql.WithFieldContext(ctx, fc)
+ defer func() {
+ if r := recover(); r != nil {
+ ec.Error(ctx, ec.Recover(ctx, r))
+ ret = graphql.Null
+ }
+ }()
+ resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.LabelKey, nil
+ })
+ if err != nil {
+ ec.Error(ctx, err)
+ return graphql.Null
+ }
+ if resTmp == nil {
+ if !graphql.HasFieldError(ctx, fc) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(string)
+ fc.Result = res
+ return ec.marshalNString2string(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) fieldContext_K8sLabelAttribute_labelKey(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ fc = &graphql.FieldContext{
+ Object: "K8sLabelAttribute",
+ Field: field,
+ IsMethod: false,
+ IsResolver: false,
+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return nil, errors.New("field of type String does not have child fields")
+ },
+ }
+ return fc, nil
+}
+
+func (ec *executionContext) _K8sLabelAttribute_attributeKey(ctx context.Context, field graphql.CollectedField, obj *model.K8sLabelAttribute) (ret graphql.Marshaler) {
+ fc, err := ec.fieldContext_K8sLabelAttribute_attributeKey(ctx, field)
+ if err != nil {
+ return graphql.Null
+ }
+ ctx = graphql.WithFieldContext(ctx, fc)
+ defer func() {
+ if r := recover(); r != nil {
+ ec.Error(ctx, ec.Recover(ctx, r))
+ ret = graphql.Null
+ }
+ }()
+ resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.AttributeKey, nil
+ })
+ if err != nil {
+ ec.Error(ctx, err)
+ return graphql.Null
+ }
+ if resTmp == nil {
+ if !graphql.HasFieldError(ctx, fc) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(string)
+ fc.Result = res
+ return ec.marshalNString2string(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) fieldContext_K8sLabelAttribute_attributeKey(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ fc = &graphql.FieldContext{
+ Object: "K8sLabelAttribute",
+ Field: field,
+ IsMethod: false,
+ IsResolver: false,
+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return nil, errors.New("field of type String does not have child fields")
+ },
+ }
+ return fc, nil
+}
+
+func (ec *executionContext) _LatencySamplerAction_id(ctx context.Context, field graphql.CollectedField, obj *model.LatencySamplerAction) (ret graphql.Marshaler) {
+ fc, err := ec.fieldContext_LatencySamplerAction_id(ctx, field)
+ if err != nil {
+ return graphql.Null
+ }
+ ctx = graphql.WithFieldContext(ctx, fc)
+ defer func() {
+ if r := recover(); r != nil {
+ ec.Error(ctx, ec.Recover(ctx, r))
+ ret = graphql.Null
+ }
+ }()
+ resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.ID, nil
+ })
+ if err != nil {
+ ec.Error(ctx, err)
+ return graphql.Null
+ }
+ if resTmp == nil {
+ if !graphql.HasFieldError(ctx, fc) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(string)
+ fc.Result = res
+ return ec.marshalNID2string(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) fieldContext_LatencySamplerAction_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ fc = &graphql.FieldContext{
+ Object: "LatencySamplerAction",
+ Field: field,
+ IsMethod: false,
+ IsResolver: false,
+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return nil, errors.New("field of type ID does not have child fields")
+ },
+ }
+ return fc, nil
+}
+
+func (ec *executionContext) _LatencySamplerAction_type(ctx context.Context, field graphql.CollectedField, obj *model.LatencySamplerAction) (ret graphql.Marshaler) {
+ fc, err := ec.fieldContext_LatencySamplerAction_type(ctx, field)
+ if err != nil {
+ return graphql.Null
+ }
+ ctx = graphql.WithFieldContext(ctx, fc)
+ defer func() {
+ if r := recover(); r != nil {
+ ec.Error(ctx, ec.Recover(ctx, r))
+ ret = graphql.Null
+ }
+ }()
+ resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.Type, nil
+ })
+ if err != nil {
+ ec.Error(ctx, err)
+ return graphql.Null
+ }
+ if resTmp == nil {
+ if !graphql.HasFieldError(ctx, fc) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(string)
+ fc.Result = res
+ return ec.marshalNString2string(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) fieldContext_LatencySamplerAction_type(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ fc = &graphql.FieldContext{
+ Object: "LatencySamplerAction",
+ Field: field,
+ IsMethod: false,
+ IsResolver: false,
+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return nil, errors.New("field of type String does not have child fields")
+ },
+ }
+ return fc, nil
+}
+
+func (ec *executionContext) _LatencySamplerAction_name(ctx context.Context, field graphql.CollectedField, obj *model.LatencySamplerAction) (ret graphql.Marshaler) {
+ fc, err := ec.fieldContext_LatencySamplerAction_name(ctx, field)
+ if err != nil {
+ return graphql.Null
+ }
+ ctx = graphql.WithFieldContext(ctx, fc)
+ defer func() {
+ if r := recover(); r != nil {
+ ec.Error(ctx, ec.Recover(ctx, r))
+ ret = graphql.Null
+ }
+ }()
+ resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.Name, nil
+ })
+ if err != nil {
+ ec.Error(ctx, err)
+ return graphql.Null
+ }
+ if resTmp == nil {
+ return graphql.Null
+ }
+ res := resTmp.(*string)
+ fc.Result = res
+ return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) fieldContext_LatencySamplerAction_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ fc = &graphql.FieldContext{
+ Object: "LatencySamplerAction",
+ Field: field,
+ IsMethod: false,
+ IsResolver: false,
+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return nil, errors.New("field of type String does not have child fields")
+ },
+ }
+ return fc, nil
+}
+
+func (ec *executionContext) _LatencySamplerAction_notes(ctx context.Context, field graphql.CollectedField, obj *model.LatencySamplerAction) (ret graphql.Marshaler) {
+ fc, err := ec.fieldContext_LatencySamplerAction_notes(ctx, field)
+ if err != nil {
+ return graphql.Null
+ }
+ ctx = graphql.WithFieldContext(ctx, fc)
+ defer func() {
+ if r := recover(); r != nil {
+ ec.Error(ctx, ec.Recover(ctx, r))
+ ret = graphql.Null
+ }
+ }()
+ resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.Notes, nil
+ })
+ if err != nil {
+ ec.Error(ctx, err)
+ return graphql.Null
+ }
+ if resTmp == nil {
+ return graphql.Null
+ }
+ res := resTmp.(*string)
+ fc.Result = res
+ return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) fieldContext_LatencySamplerAction_notes(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ fc = &graphql.FieldContext{
+ Object: "LatencySamplerAction",
+ Field: field,
+ IsMethod: false,
+ IsResolver: false,
+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return nil, errors.New("field of type String does not have child fields")
+ },
+ }
+ return fc, nil
+}
+
+func (ec *executionContext) _LatencySamplerAction_disable(ctx context.Context, field graphql.CollectedField, obj *model.LatencySamplerAction) (ret graphql.Marshaler) {
+ fc, err := ec.fieldContext_LatencySamplerAction_disable(ctx, field)
+ if err != nil {
+ return graphql.Null
+ }
+ ctx = graphql.WithFieldContext(ctx, fc)
+ defer func() {
+ if r := recover(); r != nil {
+ ec.Error(ctx, ec.Recover(ctx, r))
+ ret = graphql.Null
+ }
+ }()
+ resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.Disable, nil
+ })
+ if err != nil {
+ ec.Error(ctx, err)
+ return graphql.Null
+ }
+ if resTmp == nil {
+ if !graphql.HasFieldError(ctx, fc) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(bool)
+ fc.Result = res
+ return ec.marshalNBoolean2bool(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) fieldContext_LatencySamplerAction_disable(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ fc = &graphql.FieldContext{
+ Object: "LatencySamplerAction",
+ Field: field,
+ IsMethod: false,
+ IsResolver: false,
+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return nil, errors.New("field of type Boolean does not have child fields")
+ },
+ }
+ return fc, nil
+}
+
+func (ec *executionContext) _LatencySamplerAction_signals(ctx context.Context, field graphql.CollectedField, obj *model.LatencySamplerAction) (ret graphql.Marshaler) {
+ fc, err := ec.fieldContext_LatencySamplerAction_signals(ctx, field)
+ if err != nil {
+ return graphql.Null
+ }
+ ctx = graphql.WithFieldContext(ctx, fc)
+ defer func() {
+ if r := recover(); r != nil {
+ ec.Error(ctx, ec.Recover(ctx, r))
+ ret = graphql.Null
+ }
+ }()
+ resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.Signals, nil
+ })
+ if err != nil {
+ ec.Error(ctx, err)
+ return graphql.Null
+ }
+ if resTmp == nil {
+ if !graphql.HasFieldError(ctx, fc) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.([]model.SignalType)
+ fc.Result = res
+ return ec.marshalNSignalType2ᚕgithubᚗcomᚋodigosᚑioᚋodigosᚋfrontendᚋgraphᚋmodelᚐSignalTypeᚄ(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) fieldContext_LatencySamplerAction_signals(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ fc = &graphql.FieldContext{
+ Object: "LatencySamplerAction",
+ Field: field,
+ IsMethod: false,
+ IsResolver: false,
+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return nil, errors.New("field of type SignalType does not have child fields")
+ },
+ }
+ return fc, nil
+}
+
+func (ec *executionContext) _LatencySamplerAction_details(ctx context.Context, field graphql.CollectedField, obj *model.LatencySamplerAction) (ret graphql.Marshaler) {
+ fc, err := ec.fieldContext_LatencySamplerAction_details(ctx, field)
+ if err != nil {
+ return graphql.Null
+ }
+ ctx = graphql.WithFieldContext(ctx, fc)
+ defer func() {
+ if r := recover(); r != nil {
+ ec.Error(ctx, ec.Recover(ctx, r))
+ ret = graphql.Null
+ }
+ }()
+ resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.Details, nil
+ })
+ if err != nil {
+ ec.Error(ctx, err)
+ return graphql.Null
+ }
+ if resTmp == nil {
+ if !graphql.HasFieldError(ctx, fc) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.([]*string)
+ fc.Result = res
+ return ec.marshalNString2ᚕᚖstring(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) fieldContext_LatencySamplerAction_details(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ fc = &graphql.FieldContext{
+ Object: "LatencySamplerAction",
+ Field: field,
+ IsMethod: false,
+ IsResolver: false,
+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return nil, errors.New("field of type String does not have child fields")
+ },
+ }
+ return fc, nil
+}
+
+func (ec *executionContext) _MessagingPayloadCollection_maxPayloadLength(ctx context.Context, field graphql.CollectedField, obj *model.MessagingPayloadCollection) (ret graphql.Marshaler) {
+ fc, err := ec.fieldContext_MessagingPayloadCollection_maxPayloadLength(ctx, field)
+ if err != nil {
+ return graphql.Null
+ }
+ ctx = graphql.WithFieldContext(ctx, fc)
+ defer func() {
+ if r := recover(); r != nil {
+ ec.Error(ctx, ec.Recover(ctx, r))
+ ret = graphql.Null
+ }
+ }()
+ resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.MaxPayloadLength, nil
+ })
+ if err != nil {
+ ec.Error(ctx, err)
+ return graphql.Null
+ }
+ if resTmp == nil {
+ return graphql.Null
+ }
+ res := resTmp.(*int)
+ fc.Result = res
+ return ec.marshalOInt2ᚖint(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) fieldContext_MessagingPayloadCollection_maxPayloadLength(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ fc = &graphql.FieldContext{
+ Object: "MessagingPayloadCollection",
+ Field: field,
+ IsMethod: false,
+ IsResolver: false,
+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return nil, errors.New("field of type Int does not have child fields")
+ },
+ }
+ return fc, nil
+}
+
+func (ec *executionContext) _MessagingPayloadCollection_dropPartialPayloads(ctx context.Context, field graphql.CollectedField, obj *model.MessagingPayloadCollection) (ret graphql.Marshaler) {
+ fc, err := ec.fieldContext_MessagingPayloadCollection_dropPartialPayloads(ctx, field)
+ if err != nil {
+ return graphql.Null
+ }
+ ctx = graphql.WithFieldContext(ctx, fc)
+ defer func() {
+ if r := recover(); r != nil {
+ ec.Error(ctx, ec.Recover(ctx, r))
+ ret = graphql.Null
+ }
+ }()
+ resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.DropPartialPayloads, nil
+ })
+ if err != nil {
+ ec.Error(ctx, err)
+ return graphql.Null
+ }
+ if resTmp == nil {
+ return graphql.Null
+ }
+ res := resTmp.(*bool)
+ fc.Result = res
+ return ec.marshalOBoolean2ᚖbool(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) fieldContext_MessagingPayloadCollection_dropPartialPayloads(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ fc = &graphql.FieldContext{
+ Object: "MessagingPayloadCollection",
+ Field: field,
+ IsMethod: false,
+ IsResolver: false,
+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return nil, errors.New("field of type Boolean does not have child fields")
+ },
+ }
+ return fc, nil
+}
+
+func (ec *executionContext) _Mutation_updateApiToken(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
+ fc, err := ec.fieldContext_Mutation_updateApiToken(ctx, field)
+ if err != nil {
+ return graphql.Null
+ }
+ ctx = graphql.WithFieldContext(ctx, fc)
+ defer func() {
+ if r := recover(); r != nil {
+ ec.Error(ctx, ec.Recover(ctx, r))
+ ret = graphql.Null
+ }
+ }()
+ resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return ec.resolvers.Mutation().UpdateAPIToken(rctx, fc.Args["token"].(string))
+ })
+ if err != nil {
+ ec.Error(ctx, err)
+ return graphql.Null
+ }
+ if resTmp == nil {
+ if !graphql.HasFieldError(ctx, fc) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(bool)
+ fc.Result = res
+ return ec.marshalNBoolean2bool(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) fieldContext_Mutation_updateApiToken(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ fc = &graphql.FieldContext{
+ Object: "Mutation",
+ Field: field,
+ IsMethod: true,
+ IsResolver: true,
+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return nil, errors.New("field of type Boolean does not have child fields")
+ },
+ }
+ defer func() {
+ if r := recover(); r != nil {
+ err = ec.Recover(ctx, r)
+ ec.Error(ctx, err)
+ }
+ }()
+ ctx = graphql.WithFieldContext(ctx, fc)
+ if fc.Args, err = ec.field_Mutation_updateApiToken_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
+ ec.Error(ctx, err)
+ return fc, err
+ }
+ return fc, nil
+}
+
+func (ec *executionContext) _Mutation_persistK8sNamespace(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
+ fc, err := ec.fieldContext_Mutation_persistK8sNamespace(ctx, field)
+ if err != nil {
+ return graphql.Null
+ }
+ ctx = graphql.WithFieldContext(ctx, fc)
+ defer func() {
+ if r := recover(); r != nil {
+ ec.Error(ctx, ec.Recover(ctx, r))
+ ret = graphql.Null
+ }
+ }()
+ resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return ec.resolvers.Mutation().PersistK8sNamespace(rctx, fc.Args["namespace"].(model.PersistNamespaceItemInput))
})
if err != nil {
ec.Error(ctx, err)
@@ -18857,6 +19664,13 @@ func (ec *executionContext) _Action(ctx context.Context, sel ast.SelectionSet, o
switch obj := (obj).(type) {
case nil:
return graphql.Null
+ case model.K8sAttributesAction:
+ return ec._K8sAttributesAction(ctx, sel, &obj)
+ case *model.K8sAttributesAction:
+ if obj == nil {
+ return graphql.Null
+ }
+ return ec._K8sAttributesAction(ctx, sel, obj)
case model.AddClusterInfoAction:
return ec._AddClusterInfoAction(ctx, sel, &obj)
case *model.AddClusterInfoAction:
@@ -19647,47 +20461,9 @@ func (ec *executionContext) _CustomReadDataLabel(ctx context.Context, sel ast.Se
}
case "value":
out.Values[i] = ec._CustomReadDataLabel_value(ctx, field, obj)
- if out.Values[i] == graphql.Null {
- out.Invalids++
- }
- default:
- panic("unknown field " + strconv.Quote(field.Name))
- }
- }
- out.Dispatch(ctx)
- if out.Invalids > 0 {
- return graphql.Null
- }
-
- atomic.AddInt32(&ec.deferred, int32(len(deferred)))
-
- for label, dfs := range deferred {
- ec.processDeferredGroup(graphql.DeferredGroup{
- Label: label,
- Path: graphql.GetPath(ctx),
- FieldSet: dfs,
- Context: ctx,
- })
- }
-
- return out
-}
-
-var dbQueryPayloadCollectionImplementors = []string{"DbQueryPayloadCollection"}
-
-func (ec *executionContext) _DbQueryPayloadCollection(ctx context.Context, sel ast.SelectionSet, obj *model.DbQueryPayloadCollection) graphql.Marshaler {
- fields := graphql.CollectFields(ec.OperationContext, sel, dbQueryPayloadCollectionImplementors)
-
- out := graphql.NewFieldSet(fields)
- deferred := make(map[string]*graphql.FieldSet)
- for i, field := range fields {
- switch field.Name {
- case "__typename":
- out.Values[i] = graphql.MarshalString("DbQueryPayloadCollection")
- case "maxPayloadLength":
- out.Values[i] = ec._DbQueryPayloadCollection_maxPayloadLength(ctx, field, obj)
- case "dropPartialPayloads":
- out.Values[i] = ec._DbQueryPayloadCollection_dropPartialPayloads(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
default:
panic("unknown field " + strconv.Quote(field.Name))
}
@@ -19711,22 +20487,21 @@ func (ec *executionContext) _DbQueryPayloadCollection(ctx context.Context, sel a
return out
}
-var deleteAttributeImplementors = []string{"DeleteAttribute"}
+var dbQueryPayloadCollectionImplementors = []string{"DbQueryPayloadCollection"}
-func (ec *executionContext) _DeleteAttribute(ctx context.Context, sel ast.SelectionSet, obj *model.DeleteAttribute) graphql.Marshaler {
- fields := graphql.CollectFields(ec.OperationContext, sel, deleteAttributeImplementors)
+func (ec *executionContext) _DbQueryPayloadCollection(ctx context.Context, sel ast.SelectionSet, obj *model.DbQueryPayloadCollection) graphql.Marshaler {
+ fields := graphql.CollectFields(ec.OperationContext, sel, dbQueryPayloadCollectionImplementors)
out := graphql.NewFieldSet(fields)
deferred := make(map[string]*graphql.FieldSet)
for i, field := range fields {
switch field.Name {
case "__typename":
- out.Values[i] = graphql.MarshalString("DeleteAttribute")
- case "attributeName":
- out.Values[i] = ec._DeleteAttribute_attributeName(ctx, field, obj)
- if out.Values[i] == graphql.Null {
- out.Invalids++
- }
+ out.Values[i] = graphql.MarshalString("DbQueryPayloadCollection")
+ case "maxPayloadLength":
+ out.Values[i] = ec._DbQueryPayloadCollection_maxPayloadLength(ctx, field, obj)
+ case "dropPartialPayloads":
+ out.Values[i] = ec._DbQueryPayloadCollection_dropPartialPayloads(ctx, field, obj)
default:
panic("unknown field " + strconv.Quote(field.Name))
}
@@ -20465,10 +21240,257 @@ func (ec *executionContext) _InstrumentationLibraryGlobalId(ctx context.Context,
if out.Values[i] == graphql.Null {
out.Invalids++
}
- case "spanKind":
- out.Values[i] = ec._InstrumentationLibraryGlobalId_spanKind(ctx, field, obj)
- case "language":
- out.Values[i] = ec._InstrumentationLibraryGlobalId_language(ctx, field, obj)
+ case "spanKind":
+ out.Values[i] = ec._InstrumentationLibraryGlobalId_spanKind(ctx, field, obj)
+ case "language":
+ out.Values[i] = ec._InstrumentationLibraryGlobalId_language(ctx, field, obj)
+ default:
+ panic("unknown field " + strconv.Quote(field.Name))
+ }
+ }
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
+ return graphql.Null
+ }
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
+ return out
+}
+
+var instrumentationRuleImplementors = []string{"InstrumentationRule"}
+
+func (ec *executionContext) _InstrumentationRule(ctx context.Context, sel ast.SelectionSet, obj *model.InstrumentationRule) graphql.Marshaler {
+ fields := graphql.CollectFields(ec.OperationContext, sel, instrumentationRuleImplementors)
+
+ out := graphql.NewFieldSet(fields)
+ deferred := make(map[string]*graphql.FieldSet)
+ for i, field := range fields {
+ switch field.Name {
+ case "__typename":
+ out.Values[i] = graphql.MarshalString("InstrumentationRule")
+ case "ruleId":
+ out.Values[i] = ec._InstrumentationRule_ruleId(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ case "ruleName":
+ out.Values[i] = ec._InstrumentationRule_ruleName(ctx, field, obj)
+ case "notes":
+ out.Values[i] = ec._InstrumentationRule_notes(ctx, field, obj)
+ case "disabled":
+ out.Values[i] = ec._InstrumentationRule_disabled(ctx, field, obj)
+ case "mutable":
+ out.Values[i] = ec._InstrumentationRule_mutable(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ case "profileName":
+ out.Values[i] = ec._InstrumentationRule_profileName(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ case "workloads":
+ out.Values[i] = ec._InstrumentationRule_workloads(ctx, field, obj)
+ case "instrumentationLibraries":
+ out.Values[i] = ec._InstrumentationRule_instrumentationLibraries(ctx, field, obj)
+ case "payloadCollection":
+ out.Values[i] = ec._InstrumentationRule_payloadCollection(ctx, field, obj)
+ case "codeAttributes":
+ out.Values[i] = ec._InstrumentationRule_codeAttributes(ctx, field, obj)
+ default:
+ panic("unknown field " + strconv.Quote(field.Name))
+ }
+ }
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
+ return graphql.Null
+ }
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
+ return out
+}
+
+var instrumentationSourcesAnalyzeImplementors = []string{"InstrumentationSourcesAnalyze"}
+
+func (ec *executionContext) _InstrumentationSourcesAnalyze(ctx context.Context, sel ast.SelectionSet, obj *model.InstrumentationSourcesAnalyze) graphql.Marshaler {
+ fields := graphql.CollectFields(ec.OperationContext, sel, instrumentationSourcesAnalyzeImplementors)
+
+ out := graphql.NewFieldSet(fields)
+ deferred := make(map[string]*graphql.FieldSet)
+ for i, field := range fields {
+ switch field.Name {
+ case "__typename":
+ out.Values[i] = graphql.MarshalString("InstrumentationSourcesAnalyze")
+ case "instrumented":
+ out.Values[i] = ec._InstrumentationSourcesAnalyze_instrumented(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ case "workload":
+ out.Values[i] = ec._InstrumentationSourcesAnalyze_workload(ctx, field, obj)
+ case "namespace":
+ out.Values[i] = ec._InstrumentationSourcesAnalyze_namespace(ctx, field, obj)
+ case "instrumentedText":
+ out.Values[i] = ec._InstrumentationSourcesAnalyze_instrumentedText(ctx, field, obj)
+ default:
+ panic("unknown field " + strconv.Quote(field.Name))
+ }
+ }
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
+ return graphql.Null
+ }
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
+ return out
+}
+
+var k8sActualNamespaceImplementors = []string{"K8sActualNamespace"}
+
+func (ec *executionContext) _K8sActualNamespace(ctx context.Context, sel ast.SelectionSet, obj *model.K8sActualNamespace) graphql.Marshaler {
+ fields := graphql.CollectFields(ec.OperationContext, sel, k8sActualNamespaceImplementors)
+
+ out := graphql.NewFieldSet(fields)
+ deferred := make(map[string]*graphql.FieldSet)
+ for i, field := range fields {
+ switch field.Name {
+ case "__typename":
+ out.Values[i] = graphql.MarshalString("K8sActualNamespace")
+ case "name":
+ out.Values[i] = ec._K8sActualNamespace_name(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ atomic.AddUint32(&out.Invalids, 1)
+ }
+ case "selected":
+ out.Values[i] = ec._K8sActualNamespace_selected(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ atomic.AddUint32(&out.Invalids, 1)
+ }
+ case "k8sActualSources":
+ field := field
+
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
+ defer func() {
+ if r := recover(); r != nil {
+ ec.Error(ctx, ec.Recover(ctx, r))
+ }
+ }()
+ res = ec._K8sActualNamespace_k8sActualSources(ctx, field, obj)
+ if res == graphql.Null {
+ atomic.AddUint32(&fs.Invalids, 1)
+ }
+ return res
+ }
+
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
+
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
+
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
+ default:
+ panic("unknown field " + strconv.Quote(field.Name))
+ }
+ }
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
+ return graphql.Null
+ }
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
+ return out
+}
+
+var k8sActualSourceImplementors = []string{"K8sActualSource"}
+
+func (ec *executionContext) _K8sActualSource(ctx context.Context, sel ast.SelectionSet, obj *model.K8sActualSource) graphql.Marshaler {
+ fields := graphql.CollectFields(ec.OperationContext, sel, k8sActualSourceImplementors)
+
+ out := graphql.NewFieldSet(fields)
+ deferred := make(map[string]*graphql.FieldSet)
+ for i, field := range fields {
+ switch field.Name {
+ case "__typename":
+ out.Values[i] = graphql.MarshalString("K8sActualSource")
+ case "namespace":
+ out.Values[i] = ec._K8sActualSource_namespace(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ case "name":
+ out.Values[i] = ec._K8sActualSource_name(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ case "kind":
+ out.Values[i] = ec._K8sActualSource_kind(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ case "numberOfInstances":
+ out.Values[i] = ec._K8sActualSource_numberOfInstances(ctx, field, obj)
+ case "selected":
+ out.Values[i] = ec._K8sActualSource_selected(ctx, field, obj)
+ case "otelServiceName":
+ out.Values[i] = ec._K8sActualSource_otelServiceName(ctx, field, obj)
+ case "containers":
+ out.Values[i] = ec._K8sActualSource_containers(ctx, field, obj)
+ case "conditions":
+ out.Values[i] = ec._K8sActualSource_conditions(ctx, field, obj)
default:
panic("unknown field " + strconv.Quote(field.Name))
}
@@ -20492,46 +21514,27 @@ func (ec *executionContext) _InstrumentationLibraryGlobalId(ctx context.Context,
return out
}
-var instrumentationRuleImplementors = []string{"InstrumentationRule"}
+var k8sAnnotationAttributeImplementors = []string{"K8sAnnotationAttribute"}
-func (ec *executionContext) _InstrumentationRule(ctx context.Context, sel ast.SelectionSet, obj *model.InstrumentationRule) graphql.Marshaler {
- fields := graphql.CollectFields(ec.OperationContext, sel, instrumentationRuleImplementors)
+func (ec *executionContext) _K8sAnnotationAttribute(ctx context.Context, sel ast.SelectionSet, obj *model.K8sAnnotationAttribute) graphql.Marshaler {
+ fields := graphql.CollectFields(ec.OperationContext, sel, k8sAnnotationAttributeImplementors)
out := graphql.NewFieldSet(fields)
deferred := make(map[string]*graphql.FieldSet)
for i, field := range fields {
switch field.Name {
case "__typename":
- out.Values[i] = graphql.MarshalString("InstrumentationRule")
- case "ruleId":
- out.Values[i] = ec._InstrumentationRule_ruleId(ctx, field, obj)
- if out.Values[i] == graphql.Null {
- out.Invalids++
- }
- case "ruleName":
- out.Values[i] = ec._InstrumentationRule_ruleName(ctx, field, obj)
- case "notes":
- out.Values[i] = ec._InstrumentationRule_notes(ctx, field, obj)
- case "disabled":
- out.Values[i] = ec._InstrumentationRule_disabled(ctx, field, obj)
- case "mutable":
- out.Values[i] = ec._InstrumentationRule_mutable(ctx, field, obj)
+ out.Values[i] = graphql.MarshalString("K8sAnnotationAttribute")
+ case "annotationKey":
+ out.Values[i] = ec._K8sAnnotationAttribute_annotationKey(ctx, field, obj)
if out.Values[i] == graphql.Null {
out.Invalids++
}
- case "profileName":
- out.Values[i] = ec._InstrumentationRule_profileName(ctx, field, obj)
+ case "attributeKey":
+ out.Values[i] = ec._K8sAnnotationAttribute_attributeKey(ctx, field, obj)
if out.Values[i] == graphql.Null {
out.Invalids++
}
- case "workloads":
- out.Values[i] = ec._InstrumentationRule_workloads(ctx, field, obj)
- case "instrumentationLibraries":
- out.Values[i] = ec._InstrumentationRule_instrumentationLibraries(ctx, field, obj)
- case "payloadCollection":
- out.Values[i] = ec._InstrumentationRule_payloadCollection(ctx, field, obj)
- case "codeAttributes":
- out.Values[i] = ec._InstrumentationRule_codeAttributes(ctx, field, obj)
default:
panic("unknown field " + strconv.Quote(field.Name))
}
@@ -20555,28 +21558,42 @@ func (ec *executionContext) _InstrumentationRule(ctx context.Context, sel ast.Se
return out
}
-var instrumentationSourcesAnalyzeImplementors = []string{"InstrumentationSourcesAnalyze"}
+var k8sAttributesImplementors = []string{"K8sAttributes"}
-func (ec *executionContext) _InstrumentationSourcesAnalyze(ctx context.Context, sel ast.SelectionSet, obj *model.InstrumentationSourcesAnalyze) graphql.Marshaler {
- fields := graphql.CollectFields(ec.OperationContext, sel, instrumentationSourcesAnalyzeImplementors)
+func (ec *executionContext) _K8sAttributes(ctx context.Context, sel ast.SelectionSet, obj *model.K8sAttributes) graphql.Marshaler {
+ fields := graphql.CollectFields(ec.OperationContext, sel, k8sAttributesImplementors)
out := graphql.NewFieldSet(fields)
deferred := make(map[string]*graphql.FieldSet)
for i, field := range fields {
switch field.Name {
case "__typename":
- out.Values[i] = graphql.MarshalString("InstrumentationSourcesAnalyze")
- case "instrumented":
- out.Values[i] = ec._InstrumentationSourcesAnalyze_instrumented(ctx, field, obj)
+ out.Values[i] = graphql.MarshalString("K8sAttributes")
+ case "collectContainerAttributes":
+ out.Values[i] = ec._K8sAttributes_collectContainerAttributes(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ case "collectWorkloadId":
+ out.Values[i] = ec._K8sAttributes_collectWorkloadId(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ case "collectClusterId":
+ out.Values[i] = ec._K8sAttributes_collectClusterId(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ case "labelsAttributes":
+ out.Values[i] = ec._K8sAttributes_labelsAttributes(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ case "annotationsAttributes":
+ out.Values[i] = ec._K8sAttributes_annotationsAttributes(ctx, field, obj)
if out.Values[i] == graphql.Null {
out.Invalids++
}
- case "workload":
- out.Values[i] = ec._InstrumentationSourcesAnalyze_workload(ctx, field, obj)
- case "namespace":
- out.Values[i] = ec._InstrumentationSourcesAnalyze_namespace(ctx, field, obj)
- case "instrumentedText":
- out.Values[i] = ec._InstrumentationSourcesAnalyze_instrumentedText(ctx, field, obj)
default:
panic("unknown field " + strconv.Quote(field.Name))
}
@@ -20600,63 +21617,46 @@ func (ec *executionContext) _InstrumentationSourcesAnalyze(ctx context.Context,
return out
}
-var k8sActualNamespaceImplementors = []string{"K8sActualNamespace"}
+var k8sAttributesActionImplementors = []string{"K8sAttributesAction", "Action"}
-func (ec *executionContext) _K8sActualNamespace(ctx context.Context, sel ast.SelectionSet, obj *model.K8sActualNamespace) graphql.Marshaler {
- fields := graphql.CollectFields(ec.OperationContext, sel, k8sActualNamespaceImplementors)
+func (ec *executionContext) _K8sAttributesAction(ctx context.Context, sel ast.SelectionSet, obj *model.K8sAttributesAction) graphql.Marshaler {
+ fields := graphql.CollectFields(ec.OperationContext, sel, k8sAttributesActionImplementors)
out := graphql.NewFieldSet(fields)
deferred := make(map[string]*graphql.FieldSet)
for i, field := range fields {
switch field.Name {
case "__typename":
- out.Values[i] = graphql.MarshalString("K8sActualNamespace")
- case "name":
- out.Values[i] = ec._K8sActualNamespace_name(ctx, field, obj)
+ out.Values[i] = graphql.MarshalString("K8sAttributesAction")
+ case "id":
+ out.Values[i] = ec._K8sAttributesAction_id(ctx, field, obj)
if out.Values[i] == graphql.Null {
- atomic.AddUint32(&out.Invalids, 1)
+ out.Invalids++
}
- case "selected":
- out.Values[i] = ec._K8sActualNamespace_selected(ctx, field, obj)
+ case "type":
+ out.Values[i] = ec._K8sAttributesAction_type(ctx, field, obj)
if out.Values[i] == graphql.Null {
- atomic.AddUint32(&out.Invalids, 1)
+ out.Invalids++
}
- case "k8sActualSources":
- field := field
-
- innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
- defer func() {
- if r := recover(); r != nil {
- ec.Error(ctx, ec.Recover(ctx, r))
- }
- }()
- res = ec._K8sActualNamespace_k8sActualSources(ctx, field, obj)
- if res == graphql.Null {
- atomic.AddUint32(&fs.Invalids, 1)
- }
- return res
+ case "name":
+ out.Values[i] = ec._K8sAttributesAction_name(ctx, field, obj)
+ case "notes":
+ out.Values[i] = ec._K8sAttributesAction_notes(ctx, field, obj)
+ case "disable":
+ out.Values[i] = ec._K8sAttributesAction_disable(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
}
-
- if field.Deferrable != nil {
- dfs, ok := deferred[field.Deferrable.Label]
- di := 0
- if ok {
- dfs.AddField(field)
- di = len(dfs.Values) - 1
- } else {
- dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
- deferred[field.Deferrable.Label] = dfs
- }
- dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
- return innerFunc(ctx, dfs)
- })
-
- // don't run the out.Concurrently() call below
- out.Values[i] = graphql.Null
- continue
+ case "signals":
+ out.Values[i] = ec._K8sAttributesAction_signals(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ case "details":
+ out.Values[i] = ec._K8sAttributesAction_details(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
}
-
- out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
default:
panic("unknown field " + strconv.Quote(field.Name))
}
@@ -20680,42 +21680,27 @@ func (ec *executionContext) _K8sActualNamespace(ctx context.Context, sel ast.Sel
return out
}
-var k8sActualSourceImplementors = []string{"K8sActualSource"}
+var k8sLabelAttributeImplementors = []string{"K8sLabelAttribute"}
-func (ec *executionContext) _K8sActualSource(ctx context.Context, sel ast.SelectionSet, obj *model.K8sActualSource) graphql.Marshaler {
- fields := graphql.CollectFields(ec.OperationContext, sel, k8sActualSourceImplementors)
+func (ec *executionContext) _K8sLabelAttribute(ctx context.Context, sel ast.SelectionSet, obj *model.K8sLabelAttribute) graphql.Marshaler {
+ fields := graphql.CollectFields(ec.OperationContext, sel, k8sLabelAttributeImplementors)
out := graphql.NewFieldSet(fields)
deferred := make(map[string]*graphql.FieldSet)
for i, field := range fields {
switch field.Name {
case "__typename":
- out.Values[i] = graphql.MarshalString("K8sActualSource")
- case "namespace":
- out.Values[i] = ec._K8sActualSource_namespace(ctx, field, obj)
- if out.Values[i] == graphql.Null {
- out.Invalids++
- }
- case "name":
- out.Values[i] = ec._K8sActualSource_name(ctx, field, obj)
+ out.Values[i] = graphql.MarshalString("K8sLabelAttribute")
+ case "labelKey":
+ out.Values[i] = ec._K8sLabelAttribute_labelKey(ctx, field, obj)
if out.Values[i] == graphql.Null {
out.Invalids++
}
- case "kind":
- out.Values[i] = ec._K8sActualSource_kind(ctx, field, obj)
+ case "attributeKey":
+ out.Values[i] = ec._K8sLabelAttribute_attributeKey(ctx, field, obj)
if out.Values[i] == graphql.Null {
out.Invalids++
}
- case "numberOfInstances":
- out.Values[i] = ec._K8sActualSource_numberOfInstances(ctx, field, obj)
- case "selected":
- out.Values[i] = ec._K8sActualSource_selected(ctx, field, obj)
- case "otelServiceName":
- out.Values[i] = ec._K8sActualSource_otelServiceName(ctx, field, obj)
- case "containers":
- out.Values[i] = ec._K8sActualSource_containers(ctx, field, obj)
- case "conditions":
- out.Values[i] = ec._K8sActualSource_conditions(ctx, field, obj)
default:
panic("unknown field " + strconv.Quote(field.Name))
}
@@ -23595,6 +24580,124 @@ func (ec *executionContext) marshalNK8sActualSource2ᚕᚖgithubᚗcomᚋodigos
return ret
}
+func (ec *executionContext) marshalNK8sAnnotationAttribute2ᚕᚖgithubᚗcomᚋodigosᚑioᚋodigosᚋfrontendᚋgraphᚋmodelᚐK8sAnnotationAttributeᚄ(ctx context.Context, sel ast.SelectionSet, v []*model.K8sAnnotationAttribute) graphql.Marshaler {
+ ret := make(graphql.Array, len(v))
+ var wg sync.WaitGroup
+ isLen1 := len(v) == 1
+ if !isLen1 {
+ wg.Add(len(v))
+ }
+ for i := range v {
+ i := i
+ fc := &graphql.FieldContext{
+ Index: &i,
+ Result: &v[i],
+ }
+ ctx := graphql.WithFieldContext(ctx, fc)
+ f := func(i int) {
+ defer func() {
+ if r := recover(); r != nil {
+ ec.Error(ctx, ec.Recover(ctx, r))
+ ret = nil
+ }
+ }()
+ if !isLen1 {
+ defer wg.Done()
+ }
+ ret[i] = ec.marshalNK8sAnnotationAttribute2ᚖgithubᚗcomᚋodigosᚑioᚋodigosᚋfrontendᚋgraphᚋmodelᚐK8sAnnotationAttribute(ctx, sel, v[i])
+ }
+ if isLen1 {
+ f(i)
+ } else {
+ go f(i)
+ }
+
+ }
+ wg.Wait()
+
+ for _, e := range ret {
+ if e == graphql.Null {
+ return graphql.Null
+ }
+ }
+
+ return ret
+}
+
+func (ec *executionContext) marshalNK8sAnnotationAttribute2ᚖgithubᚗcomᚋodigosᚑioᚋodigosᚋfrontendᚋgraphᚋmodelᚐK8sAnnotationAttribute(ctx context.Context, sel ast.SelectionSet, v *model.K8sAnnotationAttribute) graphql.Marshaler {
+ if v == nil {
+ if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
+ ec.Errorf(ctx, "the requested element is null which the schema does not allow")
+ }
+ return graphql.Null
+ }
+ return ec._K8sAnnotationAttribute(ctx, sel, v)
+}
+
+func (ec *executionContext) marshalNK8sAttributes2ᚖgithubᚗcomᚋodigosᚑioᚋodigosᚋfrontendᚋgraphᚋmodelᚐK8sAttributes(ctx context.Context, sel ast.SelectionSet, v *model.K8sAttributes) graphql.Marshaler {
+ if v == nil {
+ if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
+ ec.Errorf(ctx, "the requested element is null which the schema does not allow")
+ }
+ return graphql.Null
+ }
+ return ec._K8sAttributes(ctx, sel, v)
+}
+
+func (ec *executionContext) marshalNK8sLabelAttribute2ᚕᚖgithubᚗcomᚋodigosᚑioᚋodigosᚋfrontendᚋgraphᚋmodelᚐK8sLabelAttributeᚄ(ctx context.Context, sel ast.SelectionSet, v []*model.K8sLabelAttribute) graphql.Marshaler {
+ ret := make(graphql.Array, len(v))
+ var wg sync.WaitGroup
+ isLen1 := len(v) == 1
+ if !isLen1 {
+ wg.Add(len(v))
+ }
+ for i := range v {
+ i := i
+ fc := &graphql.FieldContext{
+ Index: &i,
+ Result: &v[i],
+ }
+ ctx := graphql.WithFieldContext(ctx, fc)
+ f := func(i int) {
+ defer func() {
+ if r := recover(); r != nil {
+ ec.Error(ctx, ec.Recover(ctx, r))
+ ret = nil
+ }
+ }()
+ if !isLen1 {
+ defer wg.Done()
+ }
+ ret[i] = ec.marshalNK8sLabelAttribute2ᚖgithubᚗcomᚋodigosᚑioᚋodigosᚋfrontendᚋgraphᚋmodelᚐK8sLabelAttribute(ctx, sel, v[i])
+ }
+ if isLen1 {
+ f(i)
+ } else {
+ go f(i)
+ }
+
+ }
+ wg.Wait()
+
+ for _, e := range ret {
+ if e == graphql.Null {
+ return graphql.Null
+ }
+ }
+
+ return ret
+}
+
+func (ec *executionContext) marshalNK8sLabelAttribute2ᚖgithubᚗcomᚋodigosᚑioᚋodigosᚋfrontendᚋgraphᚋmodelᚐK8sLabelAttribute(ctx context.Context, sel ast.SelectionSet, v *model.K8sLabelAttribute) graphql.Marshaler {
+ if v == nil {
+ if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
+ ec.Errorf(ctx, "the requested element is null which the schema does not allow")
+ }
+ return graphql.Null
+ }
+ return ec._K8sLabelAttribute(ctx, sel, v)
+}
+
func (ec *executionContext) unmarshalNK8sResourceKind2githubᚗcomᚋodigosᚑioᚋodigosᚋfrontendᚋgraphᚋmodelᚐK8sResourceKind(ctx context.Context, v interface{}) (model.K8sResourceKind, error) {
var res model.K8sResourceKind
err := res.UnmarshalGQL(v)
diff --git a/frontend/graph/model/models_gen.go b/frontend/graph/model/models_gen.go
index 4c35d489ae..887f09abfb 100644
--- a/frontend/graph/model/models_gen.go
+++ b/frontend/graph/model/models_gen.go
@@ -147,10 +147,6 @@ type DbQueryPayloadCollectionInput struct {
DropPartialPayloads *bool `json:"dropPartialPayloads,omitempty"`
}
-type DeleteAttribute struct {
- AttributeName string `json:"attributeName"`
-}
-
type DeleteAttributeAction struct {
ID string `json:"id"`
Type string `json:"type"`
@@ -365,6 +361,46 @@ type K8sActualSource struct {
Conditions []*Condition `json:"conditions,omitempty"`
}
+type K8sAnnotationAttribute struct {
+ AnnotationKey string `json:"annotationKey"`
+ AttributeKey string `json:"attributeKey"`
+}
+
+type K8sAttributes struct {
+ CollectContainerAttributes bool `json:"collectContainerAttributes"`
+ CollectWorkloadID bool `json:"collectWorkloadId"`
+ CollectClusterID bool `json:"collectClusterId"`
+ LabelsAttributes []*K8sLabelAttribute `json:"labelsAttributes"`
+ AnnotationsAttributes []*K8sAnnotationAttribute `json:"annotationsAttributes"`
+}
+
+type K8sAttributesAction struct {
+ ID string `json:"id"`
+ Type string `json:"type"`
+ Name *string `json:"name,omitempty"`
+ Notes *string `json:"notes,omitempty"`
+ Disable bool `json:"disable"`
+ Signals []SignalType `json:"signals"`
+ Details *K8sAttributes `json:"details"`
+}
+
+func (K8sAttributesAction) IsAction() {}
+func (this K8sAttributesAction) GetID() string { return this.ID }
+func (this K8sAttributesAction) GetType() string { return this.Type }
+func (this K8sAttributesAction) GetName() *string { return this.Name }
+func (this K8sAttributesAction) GetNotes() *string { return this.Notes }
+func (this K8sAttributesAction) GetDisable() bool { return this.Disable }
+func (this K8sAttributesAction) GetSignals() []SignalType {
+ if this.Signals == nil {
+ return nil
+ }
+ interfaceSlice := make([]SignalType, 0, len(this.Signals))
+ for _, concrete := range this.Signals {
+ interfaceSlice = append(interfaceSlice, concrete)
+ }
+ return interfaceSlice
+}
+
type K8sDesiredNamespaceInput struct {
AutoInstrument *bool `json:"autoInstrument,omitempty"`
}
@@ -374,6 +410,11 @@ type K8sDesiredSourceInput struct {
AutoInstrument *bool `json:"autoInstrument,omitempty"`
}
+type K8sLabelAttribute struct {
+ LabelKey string `json:"labelKey"`
+ AttributeKey string `json:"attributeKey"`
+}
+
type K8sNamespaceID struct {
Name string `json:"name"`
}
diff --git a/frontend/graph/schema.graphqls b/frontend/graph/schema.graphqls
index 27bf4799b1..38ede1950e 100644
--- a/frontend/graph/schema.graphqls
+++ b/frontend/graph/schema.graphqls
@@ -362,6 +362,34 @@ interface Action {
signals: [SignalType!]!
}
+type K8sLabelAttribute {
+ labelKey: String!
+ attributeKey: String!
+}
+
+type K8sAnnotationAttribute {
+ annotationKey: String!
+ attributeKey: String!
+}
+
+type K8sAttributes {
+ collectContainerAttributes: Boolean!
+ collectWorkloadId: Boolean!
+ collectClusterId: Boolean!
+ labelsAttributes: [K8sLabelAttribute!]!
+ annotationsAttributes: [K8sAnnotationAttribute!]!
+}
+
+type K8sAttributesAction implements Action {
+ id: ID!
+ type: String!
+ name: String
+ notes: String
+ disable: Boolean!
+ signals: [SignalType!]!
+ details: K8sAttributes!
+}
+
type ClusterInfo {
attributeName: String!
attributeStringValue: String
@@ -377,10 +405,6 @@ type AddClusterInfoAction implements Action {
details: [ClusterInfo!]!
}
-type DeleteAttribute {
- attributeName: String!
-}
-
type DeleteAttributeAction implements Action {
id: ID!
type: String!
diff --git a/frontend/graph/schema.resolvers.go b/frontend/graph/schema.resolvers.go
index 32e4511c36..e30e964b61 100644
--- a/frontend/graph/schema.resolvers.go
+++ b/frontend/graph/schema.resolvers.go
@@ -179,6 +179,24 @@ func (r *computePlatformResolver) Actions(ctx context.Context, obj *model.Comput
var response []*model.PipelineAction
ns := env.GetCurrentNamespace()
+ // K8sAttributes actions
+ kaActions, err := kube.DefaultClient.ActionsClient.K8sAttributesResolvers(ns).List(ctx, metav1.ListOptions{})
+ if err != nil {
+ return nil, err
+ }
+ for _, action := range kaActions.Items {
+ specStr, err := json.Marshal(action.Spec)
+ if err != nil {
+ return nil, err
+ }
+ response = append(response, &model.PipelineAction{
+ ID: action.Name,
+ Type: action.Kind,
+ Spec: string(specStr),
+ Conditions: convertConditions(action.Status.Conditions),
+ })
+ }
+
// AddClusterInfos actions
icaActions, err := kube.DefaultClient.ActionsClient.AddClusterInfos(ns).List(ctx, metav1.ListOptions{})
if err != nil {
@@ -689,6 +707,8 @@ func (r *mutationResolver) CreateAction(ctx context.Context, action model.Action
}
switch action.Type {
+ case actionservices.ActionTypeK8sAttributes:
+ return actionservices.CreateK8sAttributes(ctx, action)
case actionservices.ActionTypeAddClusterInfo:
return actionservices.CreateAddClusterInfo(ctx, action)
case actionservices.ActionTypeDeleteAttribute:
@@ -716,6 +736,8 @@ func (r *mutationResolver) UpdateAction(ctx context.Context, id string, action m
}
switch action.Type {
+ case actionservices.ActionTypeK8sAttributes:
+ return actionservices.UpdateK8sAttributes(ctx, id, action)
case actionservices.ActionTypeAddClusterInfo:
return actionservices.UpdateAddClusterInfo(ctx, id, action)
case actionservices.ActionTypeDeleteAttribute:
@@ -743,6 +765,12 @@ func (r *mutationResolver) DeleteAction(ctx context.Context, id string, actionTy
}
switch actionType {
+ case actionservices.ActionTypeK8sAttributes:
+ err := actionservices.DeleteK8sAttributes(ctx, id)
+ if err != nil {
+ return false, fmt.Errorf("failed to delete K8sAttributes: %v", err)
+ }
+
case actionservices.ActionTypeAddClusterInfo:
err := actionservices.DeleteAddClusterInfo(ctx, id)
if err != nil {
diff --git a/frontend/services/actions/addclusterinfo.go b/frontend/services/actions/addclusterinfo.go
index 002168dfb4..773bf08ce6 100644
--- a/frontend/services/actions/addclusterinfo.go
+++ b/frontend/services/actions/addclusterinfo.go
@@ -15,7 +15,7 @@ import (
)
type AddClusterInfoDetails struct {
- ClusterAttributes []model.ClusterInfo `json:"clusterAttributes"`
+ ClusterAttributes []v1alpha1.OtelAttributeWithValue `json:"clusterAttributes"`
}
func CreateAddClusterInfo(ctx context.Context, action model.ActionInput) (model.Action, error) {
diff --git a/frontend/services/actions/constants.go b/frontend/services/actions/constants.go
index aed6dc0fa1..b4ca97fe5d 100644
--- a/frontend/services/actions/constants.go
+++ b/frontend/services/actions/constants.go
@@ -1,6 +1,7 @@
package services
const (
+ ActionTypeK8sAttributes = "K8sAttributesResolver"
ActionTypeAddClusterInfo = "AddClusterInfo"
ActionTypeDeleteAttribute = "DeleteAttribute"
ActionTypeRenameAttribute = "RenameAttribute"
diff --git a/frontend/services/actions/k8sattributes.go b/frontend/services/actions/k8sattributes.go
new file mode 100644
index 0000000000..a923093e95
--- /dev/null
+++ b/frontend/services/actions/k8sattributes.go
@@ -0,0 +1,184 @@
+package services
+
+import (
+ "context"
+ "encoding/json"
+ "fmt"
+
+ "github.com/odigos-io/odigos/api/actions/v1alpha1"
+ "github.com/odigos-io/odigos/frontend/graph/model"
+ "github.com/odigos-io/odigos/frontend/kube"
+ "github.com/odigos-io/odigos/frontend/services"
+ "github.com/odigos-io/odigos/k8sutils/pkg/env"
+ apierrors "k8s.io/apimachinery/pkg/api/errors"
+ metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+type K8sAttributesDetails struct {
+ CollectContainerAttributes bool `json:"collectContainerAttributes"`
+ CollectWorkloadUID bool `json:"collectWorkloadId"`
+ CollectClusterUID bool `json:"collectClusterId"`
+ LabelsAttributes []v1alpha1.K8sLabelAttribute `json:"labelsAttributes,omitempty"`
+ AnnotationsAttributes []v1alpha1.K8sAnnotationAttribute `json:"annotationsAttributes,omitempty"`
+}
+
+func CreateK8sAttributes(ctx context.Context, action model.ActionInput) (model.Action, error) {
+ var details K8sAttributesDetails
+ err := json.Unmarshal([]byte(action.Details), &details)
+ if err != nil {
+ return nil, fmt.Errorf("invalid details for K8sAttributes: %v", err)
+ }
+
+ signals, err := services.ConvertSignals(action.Signals)
+ if err != nil {
+ return nil, fmt.Errorf("failed to convert signals: %v", err)
+ }
+
+ k8sAttributesAction := &v1alpha1.K8sAttributesResolver{
+ ObjectMeta: metav1.ObjectMeta{
+ GenerateName: "ka-",
+ },
+ Spec: v1alpha1.K8sAttributesSpec{
+ ActionName: services.DerefString(action.Name),
+ Notes: services.DerefString(action.Notes),
+ Disabled: action.Disable,
+ Signals: signals,
+ CollectContainerAttributes: details.CollectContainerAttributes,
+ CollectWorkloadUID: details.CollectWorkloadUID,
+ CollectClusterUID: details.CollectClusterUID,
+ LabelsAttributes: details.LabelsAttributes,
+ AnnotationsAttributes: details.AnnotationsAttributes,
+ },
+ }
+
+ ns := env.GetCurrentNamespace()
+
+ generatedAction, err := kube.DefaultClient.ActionsClient.K8sAttributesResolvers(ns).Create(ctx, k8sAttributesAction, metav1.CreateOptions{})
+ if err != nil {
+ return nil, fmt.Errorf("failed to create K8sAttributes: %v", err)
+ }
+
+ labelAttrs := make([]*model.K8sLabelAttribute, len(details.LabelsAttributes))
+ for i, attr := range details.LabelsAttributes {
+ labelAttrs[i] = &model.K8sLabelAttribute{
+ LabelKey: attr.LabelKey,
+ AttributeKey: attr.AttributeKey,
+ }
+ }
+
+ annotAttrs := make([]*model.K8sAnnotationAttribute, len(details.AnnotationsAttributes))
+ for i, attr := range details.AnnotationsAttributes {
+ annotAttrs[i] = &model.K8sAnnotationAttribute{
+ AnnotationKey: attr.AnnotationKey,
+ AttributeKey: attr.AttributeKey,
+ }
+ }
+
+ response := &model.K8sAttributesAction{
+ ID: generatedAction.Name,
+ Type: ActionTypeAddClusterInfo,
+ Name: action.Name,
+ Notes: action.Notes,
+ Disable: action.Disable,
+ Signals: action.Signals,
+ Details: &model.K8sAttributes{
+ CollectContainerAttributes: details.CollectContainerAttributes,
+ CollectWorkloadID: details.CollectWorkloadUID,
+ CollectClusterID: details.CollectClusterUID,
+ LabelsAttributes: labelAttrs,
+ AnnotationsAttributes: annotAttrs,
+ },
+ }
+
+ return response, nil
+}
+
+func UpdateK8sAttributes(ctx context.Context, id string, action model.ActionInput) (model.Action, error) {
+ ns := env.GetCurrentNamespace()
+
+ // Fetch the existing action
+ existingAction, err := kube.DefaultClient.ActionsClient.K8sAttributesResolvers(ns).Get(ctx, id, metav1.GetOptions{})
+ if err != nil {
+ return nil, fmt.Errorf("failed to fetch K8sAttributes: %v", err)
+ }
+
+ // Parse the details from action.Details
+ var details K8sAttributesDetails
+ err = json.Unmarshal([]byte(action.Details), &details)
+ if err != nil {
+ return nil, fmt.Errorf("invalid details for K8sAttributes: %v", err)
+ }
+
+ // Convert signals from action input
+ signals, err := services.ConvertSignals(action.Signals)
+ if err != nil {
+ return nil, fmt.Errorf("failed to convert signals: %v", err)
+ }
+
+ // Update the existing action with new values
+ existingAction.Spec.ActionName = services.DerefString(action.Name)
+ existingAction.Spec.Notes = services.DerefString(action.Notes)
+ existingAction.Spec.Disabled = action.Disable
+ existingAction.Spec.Signals = signals
+ existingAction.Spec.CollectContainerAttributes = details.CollectContainerAttributes
+ existingAction.Spec.CollectWorkloadUID = details.CollectWorkloadUID
+ existingAction.Spec.CollectClusterUID = details.CollectClusterUID
+ existingAction.Spec.LabelsAttributes = details.LabelsAttributes
+ existingAction.Spec.AnnotationsAttributes = details.AnnotationsAttributes
+
+ // Update the action in Kubernetes
+ updatedAction, err := kube.DefaultClient.ActionsClient.K8sAttributesResolvers(ns).Update(ctx, existingAction, metav1.UpdateOptions{})
+ if err != nil {
+ return nil, fmt.Errorf("failed to update K8sAttributes: %v", err)
+ }
+
+ // Prepare the response model
+ labelAttrs := make([]*model.K8sLabelAttribute, len(details.LabelsAttributes))
+ for i, attr := range details.LabelsAttributes {
+ labelAttrs[i] = &model.K8sLabelAttribute{
+ LabelKey: attr.LabelKey,
+ AttributeKey: attr.AttributeKey,
+ }
+ }
+
+ annotAttrs := make([]*model.K8sAnnotationAttribute, len(details.AnnotationsAttributes))
+ for i, attr := range details.AnnotationsAttributes {
+ annotAttrs[i] = &model.K8sAnnotationAttribute{
+ AnnotationKey: attr.AnnotationKey,
+ AttributeKey: attr.AttributeKey,
+ }
+ }
+
+ response := &model.K8sAttributesAction{
+ ID: updatedAction.Name,
+ Type: ActionTypeAddClusterInfo,
+ Name: action.Name,
+ Notes: action.Notes,
+ Disable: action.Disable,
+ Signals: action.Signals,
+ Details: &model.K8sAttributes{
+ CollectContainerAttributes: details.CollectContainerAttributes,
+ CollectWorkloadID: details.CollectWorkloadUID,
+ CollectClusterID: details.CollectClusterUID,
+ LabelsAttributes: labelAttrs,
+ AnnotationsAttributes: annotAttrs,
+ },
+ }
+
+ return response, nil
+}
+
+func DeleteK8sAttributes(ctx context.Context, id string) error {
+ ns := env.GetCurrentNamespace()
+
+ // Delete the action by its ID from Kubernetes
+ err := kube.DefaultClient.ActionsClient.K8sAttributesResolvers(ns).Delete(ctx, id, metav1.DeleteOptions{})
+ if err != nil {
+ if apierrors.IsNotFound(err) {
+ return fmt.Errorf("K8sAttributes action with ID %s not found", id)
+ }
+ return fmt.Errorf("failed to delete K8sAttributes action: %v", err)
+ }
+
+ return nil
+}
diff --git a/frontend/webapp/@types/actions.ts b/frontend/webapp/@types/actions.ts
index 6b0bfd039e..446a4ecebd 100644
--- a/frontend/webapp/@types/actions.ts
+++ b/frontend/webapp/@types/actions.ts
@@ -14,10 +14,14 @@ export interface ParsedActionSpec {
signals: string[];
disabled?: boolean;
+ collectContainerAttributes?: boolean | null;
+ collectWorkloadUID?: boolean | null;
+ collectClusterUID?: boolean | null;
+ labelsAttributes?: { labelKey: string; attributeKey: string }[] | null;
+ annotationsAttributes?: { annotationKey: string; attributeKey: string }[] | null;
clusterAttributes?: { attributeName: string; attributeStringValue: string }[] | null;
attributeNamesToDelete?: string[] | null;
renames?: { [oldKey: string]: string } | null;
-
piiCategories?: string[] | null;
fallback_sampling_ratio?: number | null;
sampling_percentage?: string | null;
diff --git a/frontend/webapp/app/(setup)/choose-sources/page.tsx b/frontend/webapp/app/(setup)/choose-sources/page.tsx
index da312e3737..0644f03e33 100644
--- a/frontend/webapp/app/(setup)/choose-sources/page.tsx
+++ b/frontend/webapp/app/(setup)/choose-sources/page.tsx
@@ -6,7 +6,7 @@ import { ENTITY_TYPES } from '@odigos/ui-utils';
import { Stepper } from '@odigos/ui-components';
import { OnboardingStepperWrapper } from '@/components';
import SetupHeader from '@/components/lib-imports/setup-header';
-import { FormRef, SourceSelectionForm } from '@odigos/ui-containers';
+import { SourceSelectionForm, type SourceSelectionFormRef } from '@odigos/ui-containers';
export default function Page() {
// call important hooks that should run on page-mount
@@ -16,7 +16,7 @@ export default function Page() {
const onSelectNamespace = (ns: string) => setSelectedNamespace((prev) => (prev === ns ? '' : ns));
const { allNamespaces, data: namespace, loading: nsLoad } = useNamespace(selectedNamespace);
- const formRef = useRef