mirror of
https://github.com/hanzoai/o11y.git
synced 2026-10-15 12:58:33 +00:00
zeekay
b9f9cdf918
Re-sync the entire SigNoz-derived Go tree to a clean fork of latest SigNoz main (upstream 3e6339019), eliminating the version-skew that broke `go build ./...` (mixed-era packages, ~14 imported-but-absent packages, partial signoz->o11y / clickhouse->datastore rebrands, self-import cycle, duplicate package decls). - pkg/ + cmd/ wholesale replaced with latest SigNoz; imports rewritten github.com/SigNoz/signoz/ -> github.com/hanzoai/o11y/. - Adopt SigNoz's CURRENT structure (resourcefilter->telemetryresourcefilter, integrationtypes->cloudintegrationtypes, roletypes/grammar/times folded in upstream); old paths dropped. - Fork deps repathed to hanzoai + bumped: signoz-otel-collector v0.144.6, clickhouse-go-mock v0.14.1, govaluate v0.1.0; expr-lang/expr => hanzoai/expr v1.17.8 (replace). go.mod reconciled from latest SigNoz; go.sum re-tidied. - ee/ + cmd/enterprise stripped — o11y stays MIT-only; community edition imports no ee packages. - Preserved o11y additions: module path github.com/hanzoai/o11y, mount.go (cloud.Register/zip mount adapter, HIP-0106), NOTICE + LICENSE (SigNoz §4c attribution retained; upstream pkg files are headerless per SigNoz convention). - Reverted o11y cosmetic renames (o11y*/datastore*) and experimental originals (authz/iamauthz, billing, zapreceiver, zapmetricreceiver) to SigNoz canonical to kill the skew; snapshots retained in git history for re-layering. go build ./... = exit 0. go vet clean except benign "unreachable code" in generated ANTLR parser files (inherited from upstream).
253 lines
7.7 KiB
Go
253 lines
7.7 KiB
Go
package impldashboard
|
|
|
|
import (
|
|
"context"
|
|
|
|
"github.com/hanzoai/o11y/pkg/errors"
|
|
"github.com/hanzoai/o11y/pkg/types/coretypes"
|
|
"github.com/hanzoai/o11y/pkg/types/dashboardtypes"
|
|
"github.com/hanzoai/o11y/pkg/types/tagtypes"
|
|
"github.com/hanzoai/o11y/pkg/valuer"
|
|
)
|
|
|
|
func (m *module) CreateV2(ctx context.Context, orgID valuer.UUID, createdBy string, creator valuer.UUID, source dashboardtypes.Source, postable dashboardtypes.PostableDashboardV2) (*dashboardtypes.DashboardV2, error) {
|
|
if !source.IsValid() {
|
|
return nil, errors.Newf(errors.TypeInvalidInput, dashboardtypes.ErrCodeDashboardInvalidSource, "invalid dashboard source %q, must be one of user, system, integration", source.StringValue())
|
|
}
|
|
if err := postable.Validate(); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
dashboard := postable.NewDashboardV2(orgID, createdBy, source)
|
|
var storableDashboard *dashboardtypes.StorableDashboard
|
|
|
|
err := m.store.RunInTx(ctx, func(ctx context.Context) error {
|
|
resolvedTags, err := m.tagModule.SyncTags(ctx, orgID, coretypes.KindDashboard, dashboard.ID, postable.Tags)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
dashboard.Tags = resolvedTags
|
|
|
|
storable, err := dashboard.ToStorableDashboard()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
storableDashboard = storable
|
|
return m.store.Create(ctx, storable)
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
m.analytics.TrackUser(ctx, orgID.String(), creator.String(), "Dashboard Created", dashboardtypes.NewStatsFromStorableDashboards([]*dashboardtypes.StorableDashboard{storableDashboard}))
|
|
return dashboard, nil
|
|
}
|
|
|
|
func (m *module) CloneV2(ctx context.Context, orgID valuer.UUID, createdBy string, creator valuer.UUID, id valuer.UUID) (*dashboardtypes.DashboardV2, error) {
|
|
existing, err := m.GetV2(ctx, orgID, id)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if err := existing.ErrIfNotClonable(); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return m.CreateV2(ctx, orgID, createdBy, creator, dashboardtypes.SourceUser, existing.ToPostableForCloning())
|
|
}
|
|
|
|
func (module *module) ListV2(ctx context.Context, orgID valuer.UUID, params *dashboardtypes.ListDashboardsV2Params) (*dashboardtypes.ListableDashboardV2, error) {
|
|
dashboards, total, err := module.store.ListV2(ctx, orgID, params)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
dashboardIDs := make([]valuer.UUID, len(dashboards))
|
|
for i, d := range dashboards {
|
|
dashboardIDs[i] = d.ID
|
|
}
|
|
|
|
tagsByDashboard, allTags, err := module.fetchDashboardTags(ctx, orgID, dashboardIDs)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return dashboardtypes.NewListableDashboardV2(dashboards, total, tagsByDashboard, allTags)
|
|
}
|
|
|
|
func (module *module) ListForUserV2(ctx context.Context, orgID valuer.UUID, userID valuer.UUID, params *dashboardtypes.ListDashboardsV2Params) (*dashboardtypes.ListableDashboardForUserV2, error) {
|
|
rows, total, err := module.store.ListForUser(ctx, orgID, userID, params)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
dashboardIDs := make([]valuer.UUID, len(rows))
|
|
for i, r := range rows {
|
|
dashboardIDs[i] = r.Dashboard.ID
|
|
}
|
|
|
|
tagsByDashboard, allTags, err := module.fetchDashboardTags(ctx, orgID, dashboardIDs)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return dashboardtypes.NewListableDashboardForUserV2(rows, total, tagsByDashboard, allTags)
|
|
}
|
|
|
|
func (module *module) fetchDashboardTags(ctx context.Context, orgID valuer.UUID, dashboardIDs []valuer.UUID) (map[valuer.UUID][]*tagtypes.Tag, []*tagtypes.Tag, error) {
|
|
tagsByDashboard, err := module.tagModule.ListForResources(ctx, orgID, coretypes.KindDashboard, dashboardIDs)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
|
|
allTags, err := module.tagModule.List(ctx, orgID, coretypes.KindDashboard)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
|
|
return tagsByDashboard, allTags, nil
|
|
}
|
|
|
|
func (module *module) GetV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID) (*dashboardtypes.DashboardV2, error) {
|
|
storable, err := module.store.Get(ctx, orgID, id)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
tags, err := module.tagModule.ListForResource(ctx, orgID, coretypes.KindDashboard, id)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return storable.ToDashboardV2(tags)
|
|
}
|
|
|
|
func (module *module) UpdateV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, updatable dashboardtypes.UpdatableDashboardV2) (*dashboardtypes.DashboardV2, error) {
|
|
if err := updatable.Validate(); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
existing, err := module.GetV2(ctx, orgID, id)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
// Locked-dashboard / state gate — independent of tags, so run it before the tx.
|
|
if err := existing.ErrIfNotUpdatable(); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
err = module.store.RunInTx(ctx, func(ctx context.Context) error {
|
|
resolvedTags, err := module.tagModule.SyncTags(ctx, orgID, coretypes.KindDashboard, id, updatable.Tags)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
err = existing.Update(updatable, updatedBy, resolvedTags)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
storable, err := existing.ToStorableDashboard()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return module.store.Update(ctx, orgID, storable)
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return existing, nil
|
|
}
|
|
|
|
func (module *module) PatchV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, patch dashboardtypes.PatchableDashboardV2) (*dashboardtypes.DashboardV2, error) {
|
|
existing, err := module.GetV2(ctx, orgID, id)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
// Locked-dashboard / state gate — independent of tags, so run it before the tx.
|
|
if err := existing.ErrIfNotUpdatable(); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
updateable, err := patch.Apply(existing)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
err = module.store.RunInTx(ctx, func(ctx context.Context) error {
|
|
resolvedTags, err := module.tagModule.SyncTags(ctx, orgID, coretypes.KindDashboard, id, updateable.Tags)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
err = existing.Update(*updateable, updatedBy, resolvedTags)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
storable, err := existing.ToStorableDashboard()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return module.store.Update(ctx, orgID, storable)
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return existing, nil
|
|
}
|
|
|
|
func (module *module) DeleteV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID) error {
|
|
existing, err := module.GetV2(ctx, orgID, id)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err := existing.ErrIfNotDeletable(); err != nil {
|
|
return err
|
|
}
|
|
|
|
return module.store.RunInTx(ctx, func(ctx context.Context) error {
|
|
// Syncing to an empty tag set drops every tag link for the dashboard.
|
|
if _, err := module.tagModule.SyncTags(ctx, orgID, coretypes.KindDashboard, id, nil); err != nil {
|
|
return err
|
|
}
|
|
if err := module.store.DeletePreferencesForDashboard(ctx, orgID, id); err != nil {
|
|
return err
|
|
}
|
|
return module.store.Delete(ctx, orgID, id)
|
|
})
|
|
}
|
|
|
|
func (module *module) LockUnlockV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, isAdmin bool, lock bool) error {
|
|
existing, err := module.GetV2(ctx, orgID, id)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err := existing.LockUnlock(lock, isAdmin, updatedBy); err != nil {
|
|
return err
|
|
}
|
|
storable, err := existing.ToStorableDashboard()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return module.store.Update(ctx, orgID, storable)
|
|
}
|
|
|
|
func (module *module) PinV2(ctx context.Context, orgID valuer.UUID, userID valuer.UUID, id valuer.UUID) error {
|
|
if _, err := module.GetV2(ctx, orgID, id); err != nil {
|
|
return err
|
|
}
|
|
return module.store.PinForUser(ctx, dashboardtypes.NewUserDashboardPreference(userID, id))
|
|
}
|
|
|
|
func (module *module) UnpinV2(ctx context.Context, orgID valuer.UUID, userID valuer.UUID, id valuer.UUID) error {
|
|
return module.store.UnpinForUser(ctx, orgID, userID, id)
|
|
}
|
|
|
|
func (module *module) DeletePreferencesForUser(ctx context.Context, orgID valuer.UUID, userID valuer.UUID) error {
|
|
return module.store.DeletePreferencesForUser(ctx, orgID, userID)
|
|
}
|