Allow users to sort traces

backend/clickhouse/logs.go

@@ -3,11 +3,12 @@ package clickhouse
 import (
 	"context"
 	"fmt"
-	"github.com/openlyinc/pointy"
 	"math"
 	"strings"
 	"time"
 
+	"github.com/openlyinc/pointy"
+
 	"github.com/ClickHouse/clickhouse-go/v2/lib/driver"
 	e "github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
@@ -36,6 +37,7 @@ var logKeysToColumns = map[modelInputs.ReservedLogKey]string{
 	modelInputs.ReservedLogKeyServiceVersion:  "ServiceVersion",
 	modelInputs.ReservedLogKeyEnvironment:     "Environment",
 	modelInputs.ReservedLogKeyMessage:         "Body",
+	modelInputs.ReservedLogKeyTimestamp:       "Timestamp",
 }
 
 // These keys show up as recommendations, but with no recommended values due to high cardinality
@@ -198,9 +200,8 @@ func (client *Client) ReadSessionLogs(ctx context.Context, projectID int, params
 		selectCols,
 		[]int{projectID},
 		params,
-		Pagination{},
-		OrderBackwardInverted,
-		OrderForwardInverted)
+		Pagination{Direction: modelInputs.SortDirectionAsc},
+	)
 	if err != nil {
 		return nil, err
 	}
@@ -251,9 +252,7 @@ func (client *Client) ReadLogsTotalCount(ctx context.Context, projectID int, par
 		[]string{"COUNT(*)"},
 		[]int{projectID},
 		params,
-		Pagination{CountOnly: true},
-		OrderBackwardNatural,
-		OrderForwardNatural)
+		Pagination{CountOnly: true})
 	if err != nil {
 		return 0, err
 	}
@@ -340,8 +339,6 @@ func (client *Client) ReadLogsHistogram(ctx context.Context, projectID int, para
 			[]int{projectID},
 			params,
 			Pagination{CountOnly: true},
-			OrderBackwardNatural,
-			OrderForwardNatural,
 		)
 	} else {
 		fromSb, err = makeSelectBuilder(
@@ -350,8 +347,6 @@ func (client *Client) ReadLogsHistogram(ctx context.Context, projectID int, para
 			[]int{projectID},
 			params,
 			Pagination{CountOnly: true},
-			OrderBackwardNatural,
-			OrderForwardNatural,
 		)
 	}
 	if err != nil {

backend/clickhouse/logs_test.go

@@ -43,6 +43,9 @@ func setupTest(tb testing.TB) (*Client, func(tb testing.TB)) {
 
 		err = client.conn.Exec(context.Background(), fmt.Sprintf("TRUNCATE TABLE %s", TracesTable))
 		assert.NoError(tb, err)
+
+		err = client.conn.Exec(context.Background(), fmt.Sprintf("TRUNCATE TABLE %s", TracesSamplingTable))
+		assert.NoError(tb, err)
 	}
 }
 

backend/clickhouse/query.go

@@ -39,12 +39,7 @@ func readObjects[TObj interface{}, TReservedKey ~string](ctx context.Context, cl
 	var err error
 	var args []interface{}
 
-	orderForward := OrderForwardNatural
-	orderBackward := OrderBackwardNatural
-	if pagination.Direction == modelInputs.SortDirectionAsc {
-		orderForward = OrderForwardInverted
-		orderBackward = OrderBackwardInverted
-	}
+	orderForward, _ := getSortOrders[TReservedKey](sb, pagination.Direction, config, params)
 
 	outerSelect := strings.Join(config.SelectColumns, ", ")
 	innerSelect := []string{"Timestamp", "UUID"}
@@ -58,9 +53,7 @@ func readObjects[TObj interface{}, TReservedKey ~string](ctx context.Context, cl
 			params,
 			Pagination{
 				Before: pagination.At,
-			},
-			orderBackward,
-			orderForward)
+			})
 		if err != nil {
 			return nil, err
 		}
@@ -73,9 +66,7 @@ func readObjects[TObj interface{}, TReservedKey ~string](ctx context.Context, cl
 			params,
 			Pagination{
 				At: pagination.At,
-			},
-			orderBackward,
-			orderForward)
+			})
 		if err != nil {
 			return nil, err
 		}
@@ -88,9 +79,7 @@ func readObjects[TObj interface{}, TReservedKey ~string](ctx context.Context, cl
 			params,
 			Pagination{
 				After: pagination.At,
-			},
-			orderBackward,
-			orderForward)
+			})
 		if err != nil {
 			return nil, err
 		}
@@ -109,9 +98,7 @@ func readObjects[TObj interface{}, TReservedKey ~string](ctx context.Context, cl
 			innerSelect,
 			[]int{projectID},
 			params,
-			pagination,
-			orderBackward,
-			orderForward)
+			pagination)
 		if err != nil {
 			return nil, err
 		}
@@ -163,11 +150,11 @@ func makeSelectBuilder[T ~string](
 	projectIDs []int,
 	params modelInputs.QueryInput,
 	pagination Pagination,
-	orderBackward string,
-	orderForward string,
 ) (*sqlbuilder.SelectBuilder, error) {
 	sb := sqlbuilder.NewSelectBuilder()
 
+	orderForward, orderBackward := getSortOrders[T](sb, pagination.Direction, config, params)
+
 	sb.Select(selectCols...)
 	sb.From(config.TableName)
 	sb.Where(sb.In("ProjectId", projectIDs))
@@ -612,8 +599,6 @@ func readWorkspaceMetrics[T ~string](ctx context.Context, client *Client, sample
 		projectIDs,
 		params,
 		Pagination{CountOnly: true},
-		OrderBackwardNatural,
-		OrderForwardNatural,
 	)
 
 	var col string
@@ -897,8 +882,6 @@ func logLines[T ~string](ctx context.Context, client *Client, tableConfig model.
 		[]int{projectID},
 		params,
 		Pagination{CountOnly: true},
-		OrderBackwardNatural,
-		OrderForwardNatural,
 	)
 	if err != nil {
 		return nil, err
@@ -961,3 +944,36 @@ func repr(val reflect.Value) string {
 		return val.String()
 	}
 }
+
+func getSortOrders[TReservedKey ~string](
+	sb *sqlbuilder.SelectBuilder,
+	paginationDirection modelInputs.SortDirection,
+	config model.TableConfig[TReservedKey],
+	params modelInputs.QueryInput,
+) (string, string) {
+	sortColumn := "timestamp"
+	sortDirection := modelInputs.SortDirectionDesc
+	if params.Sort != nil {
+		sortColumn = params.Sort.Column
+		sortDirection = params.Sort.Direction
+	}
+
+	if col, found := config.KeysToColumns[TReservedKey(sortColumn)]; found {
+		sortColumn = col
+	} else {
+		sortColumn = fmt.Sprintf("%s[%s]", config.AttributesColumn, sb.Var(sortColumn))
+	}
+
+	forwardDirection := "DESC"
+	backwardDirection := "ASC"
+	if paginationDirection == modelInputs.SortDirectionAsc || sortDirection == modelInputs.SortDirectionAsc {
+		forwardDirection = "ASC"
+	} else {
+		backwardDirection = "DESC"
+	}
+
+	orderForward := fmt.Sprintf("%s %s, UUID %s", sortColumn, forwardDirection, forwardDirection)
+	orderBackward := fmt.Sprintf("%s %s, UUID %s", sortColumn, backwardDirection, backwardDirection)
+
+	return orderForward, orderBackward
+}

backend/clickhouse/trace_row.go

@@ -97,8 +97,8 @@ func (t *TraceRow) WithSpanKind(spanKind string) *TraceRow {
 	return t
 }
 
-func (t *TraceRow) WithDuration(startTime time.Time, endTime time.Time) *TraceRow {
-	t.Duration = int64(endTime.Sub(startTime).Nanoseconds())
+func (t *TraceRow) WithDuration(duration time.Duration) *TraceRow {
+	t.Duration = duration.Nanoseconds()
 	return t
 }
 

backend/clickhouse/traces.go

@@ -46,6 +46,7 @@ var traceKeysToColumns = map[modelInputs.ReservedTraceKey]string{
 	modelInputs.ReservedTraceKeyMetric:          "Events.Attributes[1]['metric.name']",
 	modelInputs.ReservedTraceKeyEnvironment:     "Environment",
 	modelInputs.ReservedTraceKeyHasErrors:       "HasErrors",
+	modelInputs.ReservedTraceKeyTimestamp:       "Timestamp",
 }
 
 var traceColumns = []string{
@@ -268,7 +269,12 @@ func (client *Client) ReadTraces(ctx context.Context, projectID int, params mode
 		}, nil
 	}
 
-	conn, err := readObjects(ctx, client, TracesTableConfig, projectID, params, pagination, scanTrace)
+	tableConfig := TracesTableConfig
+	if params.Sort != nil {
+		tableConfig = tracesSamplingTableConfig
+	}
+
+	conn, err := readObjects(ctx, client, tableConfig, projectID, params, pagination, scanTrace)
 	if err != nil {
 		return nil, err
 	}

backend/clickhouse/traces_test.go

@@ -2,6 +2,7 @@ package clickhouse
 
 import (
 	"context"
+	"fmt"
 	"testing"
 	"time"
 
@@ -191,3 +192,51 @@ func TestReadTracesWithEnvironmentFilter(t *testing.T) {
 	assert.NoError(t, err)
 	assert.Len(t, payload.Edges, 2)
 }
+
+func TestReadTracesWithSorting(t *testing.T) {
+	ctx := context.Background()
+	client, teardown := setupTest(t)
+	defer teardown(t)
+
+	now := time.Now()
+	rows := []*ClickhouseTraceRow{
+		NewTraceRow(now, 1).WithSpanName("Span A").WithDuration(100).WithTraceAttributes(map[string]string{"host.name": "b"}).AsClickhouseTraceRow(),
+		NewTraceRow(now, 1).WithSpanName("Span B").WithDuration(300).WithTraceAttributes(map[string]string{"host.name": "c"}).AsClickhouseTraceRow(),
+		NewTraceRow(now, 1).WithSpanName("Span C").WithDuration(200).WithTraceAttributes(map[string]string{"host.name": "a"}).AsClickhouseTraceRow(),
+	}
+
+	assert.NoError(t, client.BatchWriteTraceRows(ctx, rows))
+
+	payload, err := client.ReadTraces(ctx, 1, modelInputs.QueryInput{
+		DateRange: makeDateWithinRange(now),
+		Query:     "",
+		Sort: &modelInputs.SortInput{
+			Column:    "duration",
+			Direction: "DESC",
+		},
+	}, Pagination{})
+	assert.NoError(t, err)
+	assert.Len(t, payload.Edges, 3)
+
+	assert.Equal(t, "Span B", payload.Edges[0].Node.SpanName)
+	assert.Equal(t, "Span C", payload.Edges[1].Node.SpanName)
+	assert.Equal(t, "Span A", payload.Edges[2].Node.SpanName)
+
+	payload, err = client.ReadTraces(ctx, 1, modelInputs.QueryInput{
+		DateRange: makeDateWithinRange(now),
+		Query:     "",
+		Sort: &modelInputs.SortInput{
+			Column:    "host.name",
+			Direction: "DESC",
+		},
+	}, Pagination{})
+	assert.NoError(t, err)
+	assert.Len(t, payload.Edges, 3)
+
+	for i, edge := range payload.Edges {
+		fmt.Printf("Edge %d: %v\n", i, edge.Node)
+	}
+	assert.Equal(t, "Span B", payload.Edges[0].Node.SpanName)
+	assert.Equal(t, "Span A", payload.Edges[1].Node.SpanName)
+	assert.Equal(t, "Span C", payload.Edges[2].Node.SpanName)
+}