274 lines
7.2 KiB
Go
274 lines
7.2 KiB
Go
package postgres
|
|
|
|
import (
|
|
"math"
|
|
|
|
"openreplay/backend/pkg/hashid"
|
|
. "openreplay/backend/pkg/messages"
|
|
"openreplay/backend/pkg/url"
|
|
)
|
|
|
|
// TODO: change messages and replace everywhere to e.Index
|
|
func getSqIdx(messageID uint64) uint {
|
|
return uint(messageID % math.MaxInt32)
|
|
}
|
|
|
|
func (conn *Conn) InsertWebCustomEvent(sessionID uint64, e *CustomEvent) error {
|
|
err := conn.InsertCustomEvent(sessionID, e.Timestamp,
|
|
e.MessageID,
|
|
e.Name, e.Payload)
|
|
if err == nil {
|
|
conn.insertAutocompleteValue(sessionID, "CUSTOM", e.Name)
|
|
}
|
|
return err
|
|
}
|
|
|
|
func (conn *Conn) InsertWebUserID(sessionID uint64, userID *UserID) error {
|
|
err := conn.InsertUserID(sessionID, userID.ID)
|
|
if err == nil {
|
|
conn.insertAutocompleteValue(sessionID, "USERID", userID.ID)
|
|
}
|
|
return err
|
|
}
|
|
|
|
func (conn *Conn) InsertWebUserAnonymousID(sessionID uint64, userAnonymousID *UserAnonymousID) error {
|
|
err := conn.InsertUserAnonymousID(sessionID, userAnonymousID.ID)
|
|
if err == nil {
|
|
conn.insertAutocompleteValue(sessionID, "USERANONYMOUSID", userAnonymousID.ID)
|
|
}
|
|
return err
|
|
}
|
|
|
|
// func (conn *Conn) InsertWebResourceEvent(sessionID uint64, e *ResourceEvent) error {
|
|
// if e.Type != "fetch" {
|
|
// return nil
|
|
// }
|
|
// err := conn.InsertRequest(sessionID, e.Timestamp,
|
|
// e.MessageID,
|
|
// e.URL, e.Duration, e.Success,
|
|
// )
|
|
// if err == nil {
|
|
// conn.insertAutocompleteValue(sessionID, "REQUEST", url.DiscardURLQuery(e.URL))
|
|
// }
|
|
// return err
|
|
// }
|
|
|
|
// TODO: fix column "dom_content_loaded_event_end" of relation "pages"
|
|
func (conn *Conn) InsertWebPageEvent(sessionID uint64, e *PageEvent) error {
|
|
host, path, query, err := url.GetURLParts(e.URL)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
tx, err := conn.begin()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer tx.rollback()
|
|
// base_path is depricated
|
|
if err := tx.exec(`
|
|
INSERT INTO events.pages (
|
|
session_id, message_id, timestamp, referrer, base_referrer, host, path, query,
|
|
dom_content_loaded_time, load_time, response_end, first_paint_time, first_contentful_paint_time,
|
|
speed_index, visually_complete, time_to_interactive,
|
|
response_time, dom_building_time
|
|
) VALUES (
|
|
$1, $2, $3,
|
|
$4, $5,
|
|
$6, $7, $8,
|
|
NULLIF($9, 0), NULLIF($10, 0), NULLIF($11, 0), NULLIF($12, 0), NULLIF($13, 0),
|
|
NULLIF($14, 0), NULLIF($15, 0), NULLIF($16, 0),
|
|
NULLIF($17, 0), NULLIF($18, 0)
|
|
)
|
|
`,
|
|
sessionID, e.MessageID, e.Timestamp,
|
|
e.Referrer, url.DiscardURLQuery(e.Referrer),
|
|
host, path, query,
|
|
e.DomContentLoadedEventEnd, e.LoadEventEnd, e.ResponseEnd, e.FirstPaint, e.FirstContentfulPaint,
|
|
e.SpeedIndex, e.VisuallyComplete, e.TimeToInteractive,
|
|
calcResponseTime(e), calcDomBuildingTime(e),
|
|
); err != nil {
|
|
return err
|
|
}
|
|
if err = tx.exec(`
|
|
UPDATE sessions SET (pages_count, events_count) = (pages_count + 1, events_count + 1)
|
|
WHERE session_id = $1`,
|
|
sessionID,
|
|
); err != nil {
|
|
return err
|
|
}
|
|
if err = tx.commit(); err != nil {
|
|
return err
|
|
}
|
|
conn.insertAutocompleteValue(sessionID, "LOCATION", url.DiscardURLQuery(path))
|
|
conn.insertAutocompleteValue(sessionID, "REFERRER", url.DiscardURLQuery(e.Referrer))
|
|
return nil
|
|
}
|
|
|
|
func (conn *Conn) InsertWebClickEvent(sessionID uint64, e *ClickEvent) error {
|
|
tx, err := conn.begin()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer tx.rollback()
|
|
if err = tx.exec(`
|
|
INSERT INTO events.clicks
|
|
(session_id, message_id, timestamp, label, selector, url)
|
|
(SELECT
|
|
$1, $2, $3, NULLIF($4, ''), $5, host || path
|
|
FROM events.pages
|
|
WHERE session_id = $1 AND timestamp <= $3 ORDER BY timestamp DESC LIMIT 1
|
|
)
|
|
`,
|
|
sessionID, e.MessageID, e.Timestamp, e.Label, e.Selector,
|
|
); err != nil {
|
|
return err
|
|
}
|
|
if err = tx.exec(`
|
|
UPDATE sessions SET events_count = events_count + 1
|
|
WHERE session_id = $1`,
|
|
sessionID,
|
|
); err != nil {
|
|
return err
|
|
}
|
|
if err = tx.commit(); err != nil {
|
|
return err
|
|
}
|
|
conn.insertAutocompleteValue(sessionID, "CLICK", e.Label)
|
|
return nil
|
|
}
|
|
|
|
func (conn *Conn) InsertWebInputEvent(sessionID uint64, e *InputEvent) error {
|
|
tx, err := conn.begin()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer tx.rollback()
|
|
value := &e.Value
|
|
if e.ValueMasked {
|
|
value = nil
|
|
}
|
|
if err = tx.exec(`
|
|
INSERT INTO events.inputs
|
|
(session_id, message_id, timestamp, value, label)
|
|
VALUES
|
|
($1, $2, $3, $4, NULLIF($5,''))
|
|
`,
|
|
sessionID, e.MessageID, e.Timestamp, value, e.Label,
|
|
); err != nil {
|
|
return err
|
|
}
|
|
if err = tx.exec(`
|
|
UPDATE sessions SET events_count = events_count + 1
|
|
WHERE session_id = $1`,
|
|
sessionID,
|
|
); err != nil {
|
|
return err
|
|
}
|
|
if err = tx.commit(); err != nil {
|
|
return err
|
|
}
|
|
conn.insertAutocompleteValue(sessionID, "INPUT", e.Label)
|
|
return nil
|
|
}
|
|
|
|
func (conn *Conn) InsertWebErrorEvent(sessionID uint64, projectID uint32, e *ErrorEvent) error {
|
|
tx, err := conn.begin()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer tx.rollback()
|
|
errorID := hashid.WebErrorID(projectID, e)
|
|
|
|
if err = tx.exec(`
|
|
INSERT INTO errors
|
|
(error_id, project_id, source, name, message, payload)
|
|
VALUES
|
|
($1, $2, $3, $4, $5, $6::jsonb)
|
|
ON CONFLICT DO NOTHING`,
|
|
errorID, projectID, e.Source, e.Name, e.Message, e.Payload,
|
|
); err != nil {
|
|
return err
|
|
}
|
|
if err = tx.exec(`
|
|
INSERT INTO events.errors
|
|
(session_id, message_id, timestamp, error_id)
|
|
VALUES
|
|
($1, $2, $3, $4)
|
|
`,
|
|
sessionID, e.MessageID, e.Timestamp, errorID,
|
|
); err != nil {
|
|
return err
|
|
}
|
|
if err = tx.exec(`
|
|
UPDATE sessions SET errors_count = errors_count + 1, issue_score = issue_score + 1000
|
|
WHERE session_id = $1`,
|
|
sessionID,
|
|
); err != nil {
|
|
return err
|
|
}
|
|
return tx.commit()
|
|
}
|
|
|
|
func (conn *Conn) InsertWebFetchEvent(sessionID uint64, savePayload bool, e *FetchEvent) error {
|
|
var request, response *string
|
|
if savePayload {
|
|
request = &e.Request
|
|
response = &e.Response
|
|
}
|
|
host, path, query, err := url.GetURLParts(e.URL)
|
|
conn.insertAutocompleteValue(sessionID, "REQUEST", path)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
sqlRequest := `
|
|
INSERT INTO events_common.requests (
|
|
session_id, timestamp, seq_index,
|
|
url, host, path, query,
|
|
request_body, response_body, status_code, method,
|
|
duration, success
|
|
) VALUES (
|
|
$1, $2, $3,
|
|
left($4, 2700), $5, $6, $7,
|
|
$8, $9, $10::smallint, NULLIF($11, '')::http_method,
|
|
$12, $13
|
|
) ON CONFLICT DO NOTHING`
|
|
conn.batchQueue(sessionID, sqlRequest,
|
|
sessionID, e.Timestamp, getSqIdx(e.MessageID),
|
|
e.URL, host, path, query,
|
|
request, response, e.Status, url.EnsureMethod(e.Method),
|
|
e.Duration, e.Status < 400,
|
|
)
|
|
|
|
// Record approximate message size
|
|
conn.updateBatchSize(sessionID, len(sqlRequest)+len(e.URL)+len(host)+len(path)+len(query)+
|
|
len(e.Request)+len(e.Response)+len(url.EnsureMethod(e.Method))+8*5+1)
|
|
return nil
|
|
}
|
|
|
|
func (conn *Conn) InsertWebGraphQLEvent(sessionID uint64, savePayload bool, e *GraphQLEvent) error {
|
|
var request, response *string
|
|
if savePayload {
|
|
request = &e.Variables
|
|
response = &e.Response
|
|
}
|
|
conn.insertAutocompleteValue(sessionID, "GRAPHQL", e.OperationName)
|
|
|
|
sqlRequest := `
|
|
INSERT INTO events.graphql (
|
|
session_id, timestamp, message_id,
|
|
name,
|
|
request_body, response_body
|
|
) VALUES (
|
|
$1, $2, $3,
|
|
left($4, 2700),
|
|
$5, $6
|
|
) ON CONFLICT DO NOTHING`
|
|
conn.batchQueue(sessionID, sqlRequest, sessionID, e.Timestamp, e.MessageID,
|
|
e.OperationName, request, response,
|
|
)
|
|
|
|
// Record approximate message size
|
|
conn.updateBatchSize(sessionID, len(sqlRequest)+len(e.OperationName)+len(e.Variables)+len(e.Response)+8*3)
|
|
return nil
|
|
}
|