Allow choosing fields to fetch for sentry events

pkg/handlers/handlers.go

@@ -48,6 +48,7 @@ func HandleEvents(client sentry.SentryClient, query query.SentryQuery, backendQu
 		ProjectIds:       query.ProjectIds,
 		Environments:     query.Environments,
 		Query:            query.EventsQuery,
+		Fields:           query.EventsFields,
 		Sort:             query.EventsSort,
 		Limit:            query.EventsLimit,
 		From:             backendQuery.TimeRange.From,

pkg/handlers/handlers_test.go

@@ -168,6 +168,7 @@ func TestSentryDatasource_Events(t *testing.T) {
 			"projectIds" : ["project_id"],
 			"environments" : ["dev"],
 			"eventsQuery" : "event_query",
+			"eventsFields" : ["id","title","message","project.name","release"],
 			"eventsSort" : "event_sort",
 			"eventsLimit" : 10
 		}`
@@ -185,10 +186,11 @@ func TestSentryDatasource_Events(t *testing.T) {
 		// Assert the content of the data frame
 		frame := res.Responses["A"].Frames[0]
 		require.NotNil(t, frame.Fields)
-		require.Equal(t, 11, len(frame.Fields))
+		require.Equal(t, 4, len(frame.Fields))
 		assert.Equal(t, 3, frame.Fields[0].Len())
-		require.Equal(t, "ID", frame.Fields[0].Name)
-		require.Equal(t, "Title", frame.Fields[1].Name)
+		require.Equal(t, "id", frame.Fields[0].Name)
+		require.Equal(t, "message", frame.Fields[1].Name)
+		require.Contains(t, frame.Meta.ExecutedQueryString, "release")
 	})
 
 	t.Run("valid events stats query should produce correct result", func(t *testing.T) {

pkg/query/model.go

@@ -8,6 +8,7 @@ type SentryQuery struct {
 	IssuesSort        string   `json:"issuesSort,omitempty"`
 	IssuesLimit       int64    `json:"issuesLimit,omitempty"`
 	EventsQuery       string   `json:"eventsQuery,omitempty"`
+	EventsFields      []string `json:"eventsFields,omitempty"`
 	EventsSort        string   `json:"eventsSort,omitempty"`
 	EventsLimit       int64    `json:"eventsLimit,omitempty"`
 	EventsStatsQuery  string   `json:"eventsStatsQuery,omitempty"`

pkg/sentry/events.go

@@ -7,54 +7,18 @@ import (
 	"time"
 )
 
-type SentryEvents struct {
-	Data []SentryEvent          `json:"data"`
-	Meta map[string]interface{} `json:"meta"`
-}
-
-type SentryEvent struct {
-	ID              string    `json:"id"`
-	Title           string    `json:"title"`
-	Project         string    `json:"project"`
-	ProjectId       int64     `json:"project.id"`
-	Release         string    `json:"release"`
-	Count           int64     `json:"count()"`
-	EventsPerMinute float64   `json:"epm()"`
-	LastSeen        time.Time `json:"last_seen()"`
-	Level           string    `json:"level"`
-	EventType       string    `json:"event.type"`
-	Platform        string    `json:"platform"`
-}
-
 type GetEventsInput struct {
 	OrganizationSlug string
 	ProjectIds       []string
 	Environments     []string
+	Fields           []string
 	Query            string
 	From             time.Time
 	To               time.Time
 	Sort             string
 	Limit            int64
 }
 
-// getRequiredFields returns the list of fields that are required to be fetched
-// from the sentry API. This is used to build the query string.
-func getRequiredFields() []string {
-	return []string{
-		"id",
-		"title",
-		"project",
-		"project.id",
-		"release",
-		"count()",
-		"epm()",
-		"last_seen()",
-		"level",
-		"event.type",
-		"platform",
-	}
-}
-
 func (gei *GetEventsInput) ToQuery() string {
 	urlPath := fmt.Sprintf("/api/0/organizations/%s/events/?", gei.OrganizationSlug)
 	if gei.Limit < 1 || gei.Limit > 100 {
@@ -68,7 +32,7 @@ func (gei *GetEventsInput) ToQuery() string {
 		params.Set("sort", gei.Sort)
 	}
 	params.Set("per_page", strconv.FormatInt(gei.Limit, 10))
-	for _, field := range getRequiredFields() {
+	for _, field := range gei.Fields {
 		params.Add("field", field)
 	}
 	for _, projectId := range gei.ProjectIds {
@@ -80,8 +44,10 @@ func (gei *GetEventsInput) ToQuery() string {
 	return urlPath + params.Encode()
 }
 
-func (sc *SentryClient) GetEvents(gei GetEventsInput) ([]SentryEvent, string, error) {
-	var out SentryEvents
+func (sc *SentryClient) GetEvents(gei GetEventsInput) ([]map[string]interface{}, string, error) {
+	var out struct {
+		Data []map[string]interface{} `json:"data"`
+	}
 	executedQueryString := gei.ToQuery()
 	err := sc.Fetch(executedQueryString, &out)
 	return out.Data, sc.BaseURL + executedQueryString, err

src/components/query-editor/EventsEditor.tsx

@@ -11,10 +11,44 @@ interface EventsEditorProps {
   onRunQuery: () => void;
 }
 
+// A list of fields that are to be fetched from the sentry API. 
+// This is used to build the default query string.
+const DEFAULT_FIELDS = [
+  'id',
+  'title',
+  'project',
+  'project.id',
+  'release',
+  'count()',
+  'epm()',
+  'last_seen()',
+  'level',
+  'event.type',
+  'platform'
+];
+
+const fieldOptions = DEFAULT_FIELDS.map(field => ({
+  label: field,
+  value: field
+}));
+
 export const EventsEditor = ({ query, onChange, onRunQuery }: EventsEditorProps) => {
+  const [customOptions, setCustomOptions] = React.useState<Array<{ label: string, value: string }>>([]);
+  if (!query.eventsFields) {
+    onChange({
+      ...query,
+      eventsFields: DEFAULT_FIELDS
+    });
+    onRunQuery();
+  }
+
   const onEventsQueryChange = (eventsQuery: string) => {
     onChange({ ...query, eventsQuery });
   };
+  const onEventsFieldsChange = (eventsFields: string[]) => {
+    onChange({ ...query, eventsFields: eventsFields });
+    onRunQuery();
+  };
   const onEventsSortChange = (eventsSort: SentryEventSort) => {
     onChange({ ...query, eventsSort: eventsSort });
     onRunQuery();
@@ -39,6 +73,36 @@ export const EventsEditor = ({ query, onChange, onRunQuery }: EventsEditorProps)
           />
         </EditorField>
       </EditorRow>
+      <EditorRow>
+        <EditorField
+          tooltip={selectors.components.QueryEditor.Events.Fields.tooltip}
+          label={selectors.components.QueryEditor.Events.Fields.label}
+          width={'100%'}
+        >
+          <Select
+            isMulti={true}
+            options={[...fieldOptions, ...customOptions]}
+            value={query.eventsFields?.map(field => ({ label: field, value: field })) || []}
+            onChange={(values) => onEventsFieldsChange(
+              (values || []).map((v: { value: string }) => v.value)
+                .filter(Boolean)
+            )}
+            allowCustomValue={true}
+            onCreateOption={(v) => {
+              const customValue = { label: v, value: v };
+              setCustomOptions([...customOptions, customValue]);
+              onEventsFieldsChange([
+                ...(query.eventsFields || []),
+                v
+              ]);
+            }}
+            placeholder={selectors.components.QueryEditor.Events.Fields.placeholder}
+            width={'auto'}
+            maxVisibleValues={20}
+            showAllSelectedWhenOpen={true}
+          />
+        </EditorField>
+      </EditorRow>
       <EditorRow>
         <EditorFieldGroup>
           <EditorField

src/selectors.ts

@@ -69,6 +69,11 @@ export const Components = {
       },
     },
     Events: {
+      Fields: {
+        label: 'Fields',
+        tooltip: 'Sentry field names to fetch',
+        placeholder: 'Enter a Sentry field name',
+      },
       Query: {
         label: 'Query',
         tooltip: 'Sentry query to filter the results',

src/types.ts

@@ -65,6 +65,7 @@ export type SentryEventsQuery = {
   projectIds: string[];
   environments: string[];
   eventsQuery: string;
+  eventsFields?: string[];
   eventsSort?: SentryEventSort;
   eventsLimit?: number;
 } & SentryQueryBase<'events'>;