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.
TypeScript apmapplication-monitoringdistributed-tracinggogood-first-issuejaegerloglogsmetricsmonitoringnextjsobservabilityopen-sourceopentelemetryprometheusreactreactjsself-hostedtracingtypescript
package postprocess
import (
"fmt"
"math"
"sort"
"strings"
"github.com/SigNoz/signoz/pkg/query-service/constants"
v3 "github.com/SigNoz/signoz/pkg/query-service/model/v3"
)
func roundToTwoDecimal(number float64) float64 {
// Handle very small numbers
if math.Abs(number) < 0.000001 {
return 0
}
// Determine the number of decimal places to round to
decimalPlaces := 2
if math.Abs(number) < 0.01 {
decimalPlaces = int(math.Ceil(-math.Log10(math.Abs(number)))) + 1
}
// Round to the determined number of decimal places
scale := math.Pow(10, float64(decimalPlaces))
return math.Round(number*scale) / scale
}
func TransformToTableForBuilderQueries(results []*v3.Result, params *v3.QueryRangeParamsV3) []*v3.Result {
if len(results) == 0 {
return []*v3.Result{}
}
// Sort results by QueryName
sort.Slice(results, func(i, j int) bool {
return results[i].QueryName < results[j].QueryName
})
// Create a map to store all unique labels
seen := make(map[string]struct{})
labelKeys := []string{}
for _, result := range results {
for _, series := range result.Series {
for _, labels := range series.LabelsArray {
for key := range labels {
if _, ok := seen[key]; !ok {
seen[key] = struct{}{}
labelKeys = append(labelKeys, key)
}
}
}
}
}
// Create columns
// There will be one column for each label key and one column for each query name
columns := make([]*v3.TableColumn, 0, len(labelKeys)+len(results))
for _, key := range labelKeys {
columns = append(columns, &v3.TableColumn{Name: key, IsValueColumn: false})
}
for _, result := range results {
columns = append(columns, &v3.TableColumn{Name: result.QueryName, QueryName: result.QueryName, IsValueColumn: true})
}
// Create a map to store unique rows
rowMap := make(map[string]*v3.TableRow)
for _, result := range results {
for _, series := range result.Series {
if len(series.Points) == 0 {
continue
}
// Create a key for the row based on labels
var keyParts []string
rowData := make(map[string]interface{}, len(columns))
for _, key := range labelKeys {
value := "n/a"
for _, labels := range series.LabelsArray {
if v, ok := labels[key]; ok {
value = v
break
}
}
keyParts = append(keyParts, fmt.Sprintf("%s=%s", key, value))
rowData[key] = value
}
rowKey := strings.Join(keyParts, ",")
// Get or create the row
row, ok := rowMap[rowKey]
if !ok {
row = &v3.TableRow{Data: rowData, QueryName: result.QueryName}
rowMap[rowKey] = row
}
// Add the value for this query
for _, col := range columns {
if col.Name == result.QueryName {
row.Data[col.Name] = roundToTwoDecimal(series.Points[0].Value)
break
}
}
}
}
// Convert rowMap to a slice of TableRows
rows := make([]*v3.TableRow, 0, len(rowMap))
for _, row := range rowMap {
rows = append(rows, row)
}
// Get sorted query names
queryNames := make([]string, 0, len(params.CompositeQuery.BuilderQueries))
for queryName := range params.CompositeQuery.BuilderQueries {
queryNames = append(queryNames, queryName)
}
sort.Strings(queryNames)
// Sort rows based on OrderBy from BuilderQueries
sortRows(rows, params.CompositeQuery.BuilderQueries, queryNames)
for _, row := range rows {
for _, col := range columns {
if col.IsValueColumn {
if row.Data[col.Name] == nil {
row.Data[col.Name] = "n/a"
}
}
}
}
// Create the final result
tableResult := v3.Result{
Table: &v3.Table{
Columns: columns,
Rows: rows,
},
}
return []*v3.Result{&tableResult}
}
func sortRows(rows []*v3.TableRow, builderQueries map[string]*v3.BuilderQuery, queryNames []string) {
// use reverse order of queryNames
for i := len(queryNames) - 1; i >= 0; i-- {
queryName := queryNames[i]
sort.SliceStable(rows, func(i, j int) bool {
query := builderQueries[queryName]
orderByList := query.OrderBy
if len(orderByList) == 0 {
// If no orderBy is specified, sort by value in descending order
orderByList = []v3.OrderBy{{ColumnName: constants.SigNozOrderByValue, Order: "desc"}}
}
for _, orderBy := range orderByList {
name := orderBy.ColumnName
if name == constants.SigNozOrderByValue {
name = queryName
}
valI := rows[i].Data[name]
valJ := rows[j].Data[name]
if valI == nil || valJ == nil {
return rows[i].QueryName < rows[j].QueryName
}
// Compare based on the data type
switch v := valI.(type) {
case float64:
switch w := valJ.(type) {
case float64:
if v != w {
return (v < w) == (orderBy.Order == "asc")
}
default:
// For any other type, sort float64 first
return orderBy.Order == "asc"
}
case string:
switch w := valJ.(type) {
case float64:
// If types are different, sort numbers before strings
return orderBy.Order != "asc"
case string:
if v != w {
return (v < w) == (orderBy.Order == "asc")
}
default:
// For any other type, sort strings before bools
return orderBy.Order == "asc"
}
case bool:
switch w := valJ.(type) {
case float64, string:
// If types are different, sort bools after numbers and strings
return orderBy.Order != "asc"
case bool:
if v != w {
return (!v && w) == (orderBy.Order == "asc")
}
}
}
}
return false
})
}
}
func TransformToTableForClickHouseQueries(results []*v3.Result) []*v3.Result {
if len(results) == 0 {
return []*v3.Result{}
}
// Sort results by QueryName
sort.Slice(results, func(i, j int) bool {
return results[i].QueryName < results[j].QueryName
})
// Create a map to store all unique labels
seen := make(map[string]struct{})
labelKeys := []string{}
for _, result := range results {
for _, series := range result.Series {
for _, labels := range series.LabelsArray {
for key := range labels {
if _, ok := seen[key]; !ok {
seen[key] = struct{}{}
labelKeys = append(labelKeys, key)
}
}
}
}
}
// Create columns
// Why don't we have a column for each query name?
// Because we don't know if the query is an aggregation query or a non-aggregation query
// So we create a column for each query name that has at least one point
columns := make([]*v3.TableColumn, 0)
for _, key := range labelKeys {
columns = append(columns, &v3.TableColumn{Name: key, IsValueColumn: false})
}
for _, result := range results {
if len(result.Series) > 0 && len(result.Series[0].Points) > 0 {
columns = append(columns, &v3.TableColumn{Name: result.QueryName, QueryName: result.QueryName, IsValueColumn: true})
}
}
rows := make([]*v3.TableRow, 0)
for _, result := range results {
for _, series := range result.Series {
// Create a key for the row based on labels
rowData := make(map[string]interface{}, len(columns))
for _, key := range labelKeys {
value := "n/a"
for _, labels := range series.LabelsArray {
if v, ok := labels[key]; ok {
value = v
break
}
}
rowData[key] = value
}
// Get or create the row
row := &v3.TableRow{Data: rowData, QueryName: result.QueryName}
// Add the value for this query
for _, col := range columns {
if col.Name == result.QueryName && len(series.Points) > 0 {
row.Data[col.Name] = roundToTwoDecimal(series.Points[0].Value)
break
}
}
rows = append(rows, row)
}
}
for _, row := range rows {
for _, col := range columns {
if col.IsValueColumn {
if row.Data[col.Name] == nil {
row.Data[col.Name] = "n/a"
}
}
}
}
// Create the final result
tableResult := v3.Result{
Table: &v3.Table{
Columns: columns,
Rows: rows,
},
}
return []*v3.Result{&tableResult}
}