Skip to content

SigNoz is an open-source, OpenTelemetry-native observability platform for your team and their AI agents. Get logs, metrics, and traces in one tool with features like APM, distributed tracing, log management, infra monitoring, etc. Combined with SigNoz MCP and a native AI teammate (in SigNoz Cloud) it helps you build more resilient apps.

feat(promote): authorize promoted paths per signal (#13029)

Nikhil Soni86ade5973efd
diff --git a/.github/workflows/integrationci.yaml b/.github/workflows/integrationci.yaml
index ca18a30958..68bfa72c50 100644
--- a/.github/workflows/integrationci.yaml
+++ b/.github/workflows/integrationci.yaml
@@ -60,6 +60,7 @@ jobs:
- rawexportdata
- promqlconformance
- promapiconformance
+ - promote
- querierauthz
- role
- rootuser
diff --git a/docs/api/openapi.yml b/docs/api/openapi.yml
index e64a2412eb..39c9aa19e4 100644
--- a/docs/api/openapi.yml
+++ b/docs/api/openapi.yml
@@ -13681,9 +13681,11 @@ paths:
description: Internal Server Error
security:
- api_key:
- - VIEWER
+ - logs-field:list
+ - traces-field:list
- tokenizer:
- - VIEWER
+ - logs-field:list
+ - traces-field:list
summary: List promoted paths
tags:
- promote
@@ -13750,9 +13752,11 @@ paths:
description: Internal Server Error
security:
- api_key:
- - EDITOR
+ - logs-field:update
+ - traces-field:update
- tokenizer:
- - EDITOR
+ - logs-field:update
+ - traces-field:update
summary: Promote paths
tags:
- promote
diff --git a/pkg/apiserver/signozapiserver/promote.go b/pkg/apiserver/signozapiserver/promote.go
index 9e6b1a9099..32e653070b 100644
--- a/pkg/apiserver/signozapiserver/promote.go
+++ b/pkg/apiserver/signozapiserver/promote.go
@@ -3,14 +3,16 @@ package signozapiserver
import (
"net/http"
+ "github.com/gorilla/mux"
+
"github.com/SigNoz/signoz/pkg/http/handler"
- "github.com/SigNoz/signoz/pkg/types"
+ "github.com/SigNoz/signoz/pkg/types/authtypes"
+ "github.com/SigNoz/signoz/pkg/types/coretypes"
"github.com/SigNoz/signoz/pkg/types/promotetypes"
- "github.com/gorilla/mux"
)
func (provider *provider) addPromoteRoutes(router *mux.Router) error {
- if err := router.Handle("/api/v1/promoted_paths", handler.New(provider.authzMiddleware.EditAccess(provider.promoteHandler.PromotePaths), handler.OpenAPIDef{
+ if err := router.Handle("/api/v1/promoted_paths", handler.New(provider.authzMiddleware.CheckResources(provider.promoteHandler.PromotePaths, authtypes.SigNozAdminRoleName, authtypes.SigNozEditorRoleName), handler.OpenAPIDef{
ID: "PromotePaths",
Tags: []string{"promote"},
Summary: "Promote paths",
@@ -50,12 +52,17 @@ func (provider *provider) addPromoteRoutes(router *mux.Router) error {
ResponseContentType: "",
SuccessStatusCode: http.StatusCreated,
ErrorStatusCodes: []int{http.StatusBadRequest},
- SecuritySchemes: newSecuritySchemes(types.RoleEditor),
- })).Methods(http.MethodPost).GetError(); err != nil {
+ SecuritySchemes: newScopedSecuritySchemes([]string{coretypes.ResourceMetaResourceLogsField.Scope(coretypes.VerbUpdate), coretypes.ResourceMetaResourceTracesField.Scope(coretypes.VerbUpdate)}),
+ }, handler.WithResourceDefs(handler.TelemetryResourceDef{
+ Verb: coretypes.VerbUpdate,
+ Category: coretypes.ActionCategoryConfigurationChange,
+ Selector: coretypes.WildcardSelector,
+ Resources: promotetypes.PromotePathsResources,
+ }))).Methods(http.MethodPost).GetError(); err != nil {
return err
}
- if err := router.Handle("/api/v1/promoted_paths", handler.New(provider.authzMiddleware.ViewAccess(provider.promoteHandler.ListPromotedPaths), handler.OpenAPIDef{
+ if err := router.Handle("/api/v1/promoted_paths", handler.New(provider.authzMiddleware.CheckResources(provider.promoteHandler.ListPromotedPaths, authtypes.SigNozAdminRoleName, authtypes.SigNozEditorRoleName, authtypes.SigNozViewerRoleName), handler.OpenAPIDef{
ID: "ListPromotedPaths",
Tags: []string{"promote"},
Summary: "List promoted paths",
@@ -67,8 +74,13 @@ func (provider *provider) addPromoteRoutes(router *mux.Router) error {
ResponseContentType: "",
SuccessStatusCode: http.StatusOK,
ErrorStatusCodes: []int{http.StatusBadRequest},
- SecuritySchemes: newSecuritySchemes(types.RoleViewer),
- })).Methods(http.MethodGet).GetError(); err != nil {
+ SecuritySchemes: newScopedSecuritySchemes([]string{coretypes.ResourceMetaResourceLogsField.Scope(coretypes.VerbList), coretypes.ResourceMetaResourceTracesField.Scope(coretypes.VerbList)}),
+ }, handler.WithResourceDefs(handler.TelemetryResourceDef{
+ Verb: coretypes.VerbList,
+ Category: coretypes.ActionCategoryDataAccess,
+ Selector: coretypes.WildcardSelector,
+ Resources: promotetypes.ListPromotedPathsResources,
+ }))).Methods(http.MethodGet).GetError(); err != nil {
return err
}
diff --git a/pkg/signoz/provider.go b/pkg/signoz/provider.go
index 014e83cbb6..8ce7daca61 100644
--- a/pkg/signoz/provider.go
+++ b/pkg/signoz/provider.go
@@ -260,6 +260,7 @@ func NewSQLMigrationProviderFactories(
sqlmigration.NewAddChannelSpecFactory(sqlschema),
sqlmigration.NewAddUserTuplesFactory(sqlstore),
sqlmigration.NewAddRuleViewFactory(sqlstore, sqlschema),
+ sqlmigration.NewAddFieldTuplesFactory(sqlstore),
)
}
diff --git a/pkg/sqlmigration/134_add_field_tuples.go b/pkg/sqlmigration/134_add_field_tuples.go
new file mode 100644
index 0000000000..4a51a7ca0a
--- /dev/null
+++ b/pkg/sqlmigration/134_add_field_tuples.go
@@ -0,0 +1,144 @@
+package sqlmigration
+
+import (
+ "context"
+ "database/sql"
+ "time"
+
+ "github.com/oklog/ulid/v2"
+ "github.com/uptrace/bun"
+ "github.com/uptrace/bun/dialect"
+ "github.com/uptrace/bun/migrate"
+
+ "github.com/SigNoz/signoz/pkg/factory"
+ "github.com/SigNoz/signoz/pkg/sqlstore"
+)
+
+type addFieldTuples struct {
+ sqlstore sqlstore.SQLStore
+}
+
+func NewAddFieldTuplesFactory(sqlstore sqlstore.SQLStore) factory.ProviderFactory[SQLMigration, Config] {
+ return factory.NewProviderFactory(factory.MustNewName("add_field_tuples"), func(ctx context.Context, ps factory.ProviderSettings, c Config) (SQLMigration, error) {
+ return &addFieldTuples{sqlstore: sqlstore}, nil
+ })
+}
+
+func (migration *addFieldTuples) Register(migrations *migrate.Migrations) error {
+ return migrations.Register(migration.Up, migration.Down)
+}
+
+func (migration *addFieldTuples) Up(ctx context.Context, db *bun.DB) error {
+ tx, err := db.BeginTx(ctx, nil)
+ if err != nil {
+ return err
+ }
+ defer func() { _ = tx.Rollback() }()
+
+ var storeID string
+ err = tx.QueryRowContext(ctx, `SELECT id FROM store WHERE name = ? LIMIT 1`, "signoz").Scan(&storeID)
+ if err != nil {
+ return err
+ }
+
+ var orgIDs []string
+ err = tx.NewSelect().
+ Table("organizations").
+ Column("id").
+ Scan(ctx, &orgIDs)
+ if err != nil && err != sql.ErrNoRows {
+ return err
+ }
+
+ isPG := migration.sqlstore.BunDB().Dialect().Name() == dialect.PG
+
+ tuples := []migrationTuple{
+ {"signoz-admin", "metaresource", "logs-field", "read"},
+ {"signoz-admin", "metaresource", "logs-field", "update"},
+ {"signoz-admin", "metaresource", "logs-field", "list"},
+ {"signoz-editor", "metaresource", "logs-field", "read"},
+ {"signoz-editor", "metaresource", "logs-field", "update"},
+ {"signoz-editor", "metaresource", "logs-field", "list"},
+ {"signoz-viewer", "metaresource", "logs-field", "read"},
+ {"signoz-viewer", "metaresource", "logs-field", "list"},
+ {"signoz-admin", "metaresource", "traces-field", "read"},
+ {"signoz-admin", "metaresource", "traces-field", "update"},
+ {"signoz-admin", "metaresource", "traces-field", "list"},
+ {"signoz-editor", "metaresource", "traces-field", "read"},
+ {"signoz-editor", "metaresource", "traces-field", "update"},
+ {"signoz-editor", "metaresource", "traces-field", "list"},
+ {"signoz-viewer", "metaresource", "traces-field", "read"},
+ {"signoz-viewer", "metaresource", "traces-field", "list"},
+ }
+
+ for _, orgID := range orgIDs {
+ for _, tuple := range tuples {
+ entropy := ulid.DefaultEntropy()
+ now := time.Now().UTC()
+ tupleID := ulid.MustNew(ulid.Timestamp(now), entropy).String()
+
+ objectID := "organization/" + orgID + "/" + tuple.objectName + "/*"
+ roleSubject := "organization/" + orgID + "/role/" + tuple.roleName
+
+ if isPG {
+ user := "role:" + roleSubject + "#assignee"
+ result, err := tx.ExecContext(ctx, `
+ INSERT INTO tuple (store, object_type, object_id, relation, _user, user_type, ulid, inserted_at)
+ VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+ ON CONFLICT (store, object_type, object_id, relation, _user) DO NOTHING`,
+ storeID, tuple.objectType, objectID, tuple.relation, user, "userset", tupleID, now,
+ )
+ if err != nil {
+ return err
+ }
+ rowsAffected, err := result.RowsAffected()
+ if err != nil {
+ return err
+ }
+ if rowsAffected == 0 {
+ continue
+ }
+ _, err = tx.ExecContext(ctx, `
+ INSERT INTO changelog (store, object_type, object_id, relation, _user, operation, ulid, inserted_at)
+ VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+ ON CONFLICT (store, ulid, object_type) DO NOTHING`,
+ storeID, tuple.objectType, objectID, tuple.relation, user, 0, tupleID, now,
+ )
+ if err != nil {
+ return err
+ }
+ } else {
+ result, err := tx.ExecContext(ctx, `
+ INSERT INTO tuple (store, object_type, object_id, relation, user_object_type, user_object_id, user_relation, user_type, ulid, inserted_at)
+ VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+ ON CONFLICT (store, object_type, object_id, relation, user_object_type, user_object_id, user_relation) DO NOTHING`,
+ storeID, tuple.objectType, objectID, tuple.relation, "role", roleSubject, "assignee", "userset", tupleID, now,
+ )
+ if err != nil {
+ return err
+ }
+ rowsAffected, err := result.RowsAffected()
+ if err != nil {
+ return err
+ }
+ if rowsAffected == 0 {
+ continue
+ }
+ _, err = tx.ExecContext(ctx, `
+ INSERT INTO changelog (store, object_type, object_id, relation, user_object_type, user_object_id, user_relation, operation, ulid, inserted_at)
+ VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+ ON CONFLICT (store, ulid, object_type) DO NOTHING`,
+ storeID, tuple.objectType, objectID, tuple.relation, "role", roleSubject, "assignee", 0, tupleID, now,
+ )
+ if err != nil {
+ return err
+ }
+ }
+ }
+ }
+ return tx.Commit()
+}
+
+func (migration *addFieldTuples) Down(context.Context, *bun.DB) error {
+ return nil
+}
diff --git a/pkg/types/promotetypes/resource.go b/pkg/types/promotetypes/resource.go
new file mode 100644
index 0000000000..2de34a4bad
--- /dev/null
+++ b/pkg/types/promotetypes/resource.go
@@ -0,0 +1,76 @@
+package promotetypes
+
+import (
+ "github.com/tidwall/gjson"
+
+ "github.com/SigNoz/signoz/pkg/errors"
+ "github.com/SigNoz/signoz/pkg/types/coretypes"
+ "github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+)
+
+// PromotePathsResources resolves the field resources of the signals in a promote request body.
+func PromotePathsResources(ec coretypes.ExtractorContext) ([]coretypes.ResourceWithID, error) {
+ values := gjson.GetBytes(ec.RequestBody, "#.signal").Array()
+ signals := make([]telemetrytypes.Signal, 0, len(values))
+ for _, value := range values {
+ signal, ok := telemetrytypes.SignalFromText(value.String())
+ if !ok {
+ return nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "invalid signal: %s", value.String())
+ }
+ signals = append(signals, signal)
+ }
+
+ return fieldResources(signals)
+}
+
+// ListPromotedPathsResources resolves the field resources of the filtered signals, or of all when none match.
+func ListPromotedPathsResources(ec coretypes.ExtractorContext) ([]coretypes.ResourceWithID, error) {
+ filters := ListPromotedPathsFilters{}
+ if ec.Request != nil {
+ filters.Signal = ec.Request.URL.Query().Get("signal")
+ filters.Context = ec.Request.URL.Query().Get("context")
+ }
+
+ signals := make([]telemetrytypes.Signal, 0)
+ for _, target := range Targets() {
+ if filters.MatchesTarget(target) {
+ signals = append(signals, target.Entry.Signal)
+ }
+ }
+ if len(signals) == 0 {
+ for _, target := range Targets() {
+ signals = append(signals, target.Entry.Signal)
+ }
+ }
+
+ return fieldResources(signals)
+}
+
+func fieldResources(signals []telemetrytypes.Signal) ([]coretypes.ResourceWithID, error) {
+ resources := make([]coretypes.ResourceWithID, 0, len(signals))
+ seen := make(map[string]struct{})
+ for _, signal := range signals {
+ resource, ok := fieldResource(signal)
+ if !ok {
+ return nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "promotion is not supported for signal %s", signal.StringValue())
+ }
+ if _, ok := seen[resource.Kind().String()]; ok {
+ continue
+ }
+ seen[resource.Kind().String()] = struct{}{}
+ resources = append(resources, coretypes.ResourceWithID{Resource: resource})
+ }
+
+ return resources, nil
+}
+
+func fieldResource(signal telemetrytypes.Signal) (coretypes.Resource, bool) {
+ switch signal {
+ case telemetrytypes.SignalLogs:
+ return coretypes.ResourceMetaResourceLogsField, true
+ case telemetrytypes.SignalTraces:
+ return coretypes.ResourceMetaResourceTracesField, true
+ default:
+ return nil, false
+ }
+}
diff --git a/pkg/types/promotetypes/resource_test.go b/pkg/types/promotetypes/resource_test.go
new file mode 100644
index 0000000000..93a7ad37af
--- /dev/null
+++ b/pkg/types/promotetypes/resource_test.go
@@ -0,0 +1,114 @@
+package promotetypes
+
+import (
+ "net/http/httptest"
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+
+ "github.com/SigNoz/signoz/pkg/types/coretypes"
+)
+
+func resourceKinds(resources []coretypes.ResourceWithID) []string {
+ kinds := make([]string, 0, len(resources))
+ for _, resource := range resources {
+ kinds = append(kinds, resource.Resource.Kind().String())
+ }
+ return kinds
+}
+
+func TestPromotePathsResources(t *testing.T) {
+ testCases := []struct {
+ name string
+ body string
+ want []string
+ wantErr bool
+ }{
+ {
+ name: "Traces_TracesField",
+ body: `[{"signal":"traces","context":"attribute","path":"http.method"}]`,
+ want: []string{"traces-field"},
+ },
+ {
+ name: "LogsAndTraces_BothFieldsOnce",
+ body: `[{"signal":"logs","context":"body","path":"a"},{"signal":"traces","context":"attribute","path":"b"},{"signal":"logs","context":"body","path":"c"}]`,
+ want: []string{"logs-field", "traces-field"},
+ },
+ {
+ name: "Empty_NoResources",
+ body: `[]`,
+ want: []string{},
+ },
+ {
+ name: "InvalidSignal_Rejected",
+ body: `[{"signal":"events","context":"attribute","path":"a"}]`,
+ wantErr: true,
+ },
+ {
+ name: "UnsupportedSignal_Rejected",
+ body: `[{"signal":"metrics","context":"attribute","path":"a"}]`,
+ wantErr: true,
+ },
+ {
+ name: "MalformedBody_NoResources",
+ body: `{"signal":"traces"}`,
+ want: []string{},
+ },
+ }
+
+ for _, testCase := range testCases {
+ t.Run(testCase.name, func(t *testing.T) {
+ resources, err := PromotePathsResources(coretypes.ExtractorContext{RequestBody: []byte(testCase.body)})
+ if testCase.wantErr {
+ assert.Error(t, err)
+ return
+ }
+ require.NoError(t, err)
+ assert.Equal(t, testCase.want, resourceKinds(resources))
+ })
+ }
+}
+
+func TestListPromotedPathsResources(t *testing.T) {
+ testCases := []struct {
+ name string
+ query string
+ want []string
+ }{
+ {
+ name: "NoFilters_EveryField",
+ query: "",
+ want: []string{"logs-field", "traces-field"},
+ },
+ {
+ name: "TracesSignal_TracesField",
+ query: "?signal=traces",
+ want: []string{"traces-field"},
+ },
+ {
+ name: "BodyContext_LogsField",
+ query: "?context=body",
+ want: []string{"logs-field"},
+ },
+ {
+ name: "NoMatchingDomain_EveryField",
+ query: "?signal=metrics",
+ want: []string{"logs-field", "traces-field"},
+ },
+ {
+ name: "InvalidSignal_EveryField",
+ query: "?signal=events",
+ want: []string{"logs-field", "traces-field"},
+ },
+ }
+
+ for _, testCase := range testCases {
+ t.Run(testCase.name, func(t *testing.T) {
+ request := httptest.NewRequest("GET", "/api/v1/promoted_paths"+testCase.query, nil)
+ resources, err := ListPromotedPathsResources(coretypes.ExtractorContext{Request: request})
+ require.NoError(t, err)
+ assert.Equal(t, testCase.want, resourceKinds(resources))
+ })
+ }
+}
diff --git a/tests/integration/tests/promote/01_authz.py b/tests/integration/tests/promote/01_authz.py
new file mode 100644
index 0000000000..4f94dfce8f
--- /dev/null
+++ b/tests/integration/tests/promote/01_authz.py
@@ -0,0 +1,164 @@
+from collections.abc import Callable
+from http import HTTPStatus
+
+import requests
+from wiremock.resources.mappings import Mapping
+
+from fixtures import types
+from fixtures.auth import (
+ USER_ADMIN_EMAIL,
+ USER_ADMIN_PASSWORD,
+ add_license,
+ change_user_role,
+ create_active_user,
+)
+from fixtures.role import find_role_by_name, transaction_group
+
+PROMOTED_PATH_BASE = "/api/v1/promoted_paths"
+
+_EDITOR_EMAIL = "[email protected]"
+_VIEWER_EMAIL = "[email protected]"
+_TRACES_ONLY_ROLE_NAME = "promote-traces-only"
+_TRACES_ONLY_EMAIL = "[email protected]"
+_PASSWORD = "password123Z$"
+
+_TRACES_PATH = {"signal": "traces", "context": "attribute", "path": "authz.probe", "promote": True}
+_LOGS_PATH = {"signal": "logs", "context": "body", "path": "authz.probe", "promote": True}
+
+
+def test_apply_license(
+ signoz: types.SigNoz,
+ create_user_admin: types.Operation, # pylint: disable=unused-argument
+ make_http_mocks: Callable[[types.TestContainerDocker, list[Mapping]], None],
+ get_token: Callable[[str, str], str],
+) -> None:
+ add_license(signoz, make_http_mocks, get_token)
+
+
+def test_setup_users(
+ signoz: types.SigNoz,
+ create_user_admin: types.Operation, # pylint: disable=unused-argument
+ get_token: Callable[[str, str], str],
+ create_role: Callable[..., str],
+) -> None:
+ admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+
+ create_active_user(signoz, admin_token, email=_EDITOR_EMAIL, role="signoz-editor", password=_PASSWORD, name="promote editor")
+ create_active_user(signoz, admin_token, email=_VIEWER_EMAIL, role="signoz-viewer", password=_PASSWORD, name="promote viewer")
+
+ create_role(
+ admin_token,
+ _TRACES_ONLY_ROLE_NAME,
+ [
+ transaction_group("update", "metaresource", "traces-field", ["*"]),
+ transaction_group("list", "metaresource", "traces-field", ["*"]),
+ ],
+ )
+ user_id = create_active_user(signoz, admin_token, email=_TRACES_ONLY_EMAIL, role="signoz-viewer", password=_PASSWORD, name="promote traces only")
+ change_user_role(signoz, admin_token, user_id, "signoz-viewer", _TRACES_ONLY_ROLE_NAME)
+
+
+def test_managed_roles(
+ signoz: types.SigNoz,
+ create_user_admin: types.Operation, # pylint: disable=unused-argument
+ get_token: Callable[[str, str], str],
+) -> None:
+ cases = [
+ (USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD, HTTPStatus.CREATED),
+ (_EDITOR_EMAIL, _PASSWORD, HTTPStatus.CREATED),
+ (_VIEWER_EMAIL, _PASSWORD, HTTPStatus.FORBIDDEN),
+ ]
+ for email, password, promote_status in cases:
+ token = get_token(email, password)
+
+ resp = requests.post(
+ signoz.self.host_configs["8080"].get(PROMOTED_PATH_BASE),
+ json=[_TRACES_PATH, _LOGS_PATH],
+ headers={"Authorization": f"Bearer {token}"},
+ timeout=5,
+ )
+ assert resp.status_code == promote_status, f"{email} promote: expected {promote_status}, got {resp.status_code}: {resp.text}"
+
+ resp = requests.get(
+ signoz.self.host_configs["8080"].get(PROMOTED_PATH_BASE),
+ headers={"Authorization": f"Bearer {token}"},
+ timeout=5,
+ )
+ assert resp.status_code == HTTPStatus.OK, f"{email} list: {resp.text}"
+
+
+def test_promote_scoped_to_granted_signal(
+ signoz: types.SigNoz,
+ create_user_admin: types.Operation, # pylint: disable=unused-argument
+ get_token: Callable[[str, str], str],
+) -> None:
+ token = get_token(_TRACES_ONLY_EMAIL, _PASSWORD)
+
+ resp = requests.post(
+ signoz.self.host_configs["8080"].get(PROMOTED_PATH_BASE),
+ json=[_TRACES_PATH],
+ headers={"Authorization": f"Bearer {token}"},
+ timeout=5,
+ )
+ assert resp.status_code == HTTPStatus.CREATED, f"promote traces: {resp.text}"
+
+ for body in ([_LOGS_PATH], [_TRACES_PATH, _LOGS_PATH]):
+ resp = requests.post(
+ signoz.self.host_configs["8080"].get(PROMOTED_PATH_BASE),
+ json=body,
+ headers={"Authorization": f"Bearer {token}"},
+ timeout=5,
+ )
+ assert resp.status_code == HTTPStatus.FORBIDDEN, f"promote {body}: expected 403, got {resp.status_code}: {resp.text}"
+
+
+def test_list_scoped_to_granted_signal(
+ signoz: types.SigNoz,
+ create_user_admin: types.Operation, # pylint: disable=unused-argument
+ get_token: Callable[[str, str], str],
+) -> None:
+ token = get_token(_TRACES_ONLY_EMAIL, _PASSWORD)
+
+ resp = requests.get(
+ signoz.self.host_configs["8080"].get(PROMOTED_PATH_BASE),
+ params={"signal": "traces"},
+ headers={"Authorization": f"Bearer {token}"},
+ timeout=5,
+ )
+ assert resp.status_code == HTTPStatus.OK, f"list traces: {resp.text}"
+ assert {(path["signal"], path["path"]) for path in resp.json()["data"]} >= {("traces", "authz.probe")}
+
+ for params in ({"signal": "logs"}, {}):
+ resp = requests.get(
+ signoz.self.host_configs["8080"].get(PROMOTED_PATH_BASE),
+ params=params,
+ headers={"Authorization": f"Bearer {token}"},
+ timeout=5,
+ )
+ assert resp.status_code == HTTPStatus.FORBIDDEN, f"list {params}: expected 403, got {resp.status_code}: {resp.text}"
+
+
+def test_revoke_update(
+ signoz: types.SigNoz,
+ create_user_admin: types.Operation, # pylint: disable=unused-argument
+ get_token: Callable[[str, str], str],
+) -> None:
+ admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+ role_id = find_role_by_name(signoz, admin_token, _TRACES_ONLY_ROLE_NAME)
+
+ resp = requests.put(
+ signoz.self.host_configs["8080"].get(f"/api/v1/roles/{role_id}"),
+ json={"description": "", "transactionGroups": [transaction_group("list", "metaresource", "traces-field", ["*"])]},
+ headers={"Authorization": f"Bearer {admin_token}"},
+ timeout=5,
+ )
+ assert resp.status_code == HTTPStatus.NO_CONTENT, resp.text
+
+ token = get_token(_TRACES_ONLY_EMAIL, _PASSWORD)
+ resp = requests.post(
+ signoz.self.host_configs["8080"].get(PROMOTED_PATH_BASE),
+ json=[_TRACES_PATH],
+ headers={"Authorization": f"Bearer {token}"},
+ timeout=5,
+ )
+ assert resp.status_code == HTTPStatus.FORBIDDEN, f"promote after revoke: expected 403, got {resp.status_code}: {resp.text}"