func BeginDatastoreSegment( txnID int64, parentID int64, table string, operation string, sql string, rollupName string, ) int64 { ctable := C.CString(table) defer C.free(unsafe.Pointer(ctable)) coperation := C.CString(operation) defer C.free(unsafe.Pointer(coperation)) csql := C.CString(sql) defer C.free(unsafe.Pointer(csql)) crollupName := C.CString(rollupName) defer C.free(unsafe.Pointer(crollupName)) id := C.newrelic_segment_datastore_begin( C.long(txnID), C.long(parentID), ctable, coperation, csql, crollupName, (*[0]byte)(C.newrelic_basic_literal_replacement_obfuscator), ) return int64(id) }
func StartDatastoreStatement(tId TTransactionId, sId SegmentId, table string, operation string) SegmentId { if operation != NR_DATASTORE_OPERATION_SELECT && operation != NR_DATASTORE_OPERATION_INSERT && operation != NR_DATASTORE_OPERATION_UPDATE && operation != NR_DATASTORE_OPERATION_DELETE { return SegmentId(0) } cTable := C.CString(table) defer C.free(unsafe.Pointer(cTable)) cOperation := C.CString(operation) defer C.free(unsafe.Pointer(cOperation)) cId := C.long(tId) cSeg := C.long(sId) result := C.newrelic_segment_datastore_begin(cId, cSeg, cTable, cOperation) return SegmentId(result) }
/* * Identify the beginning of a segment that performs a database operation. * * * SQL Obfuscation * =============== * If you supply the sql_obfuscator parameter with NULL, the supplied SQL string * will go through our basic literal replacement obfuscator that strips the SQL * string literals (values between single or double quotes) and numeric * sequences, replacing them with the ? character. For example: * * This SQL: * SELECT * FROM table WHERE ssn=‘000-00-0000’ * * obfuscates to: * SELECT * FROM table WHERE ssn=? * * Because our default obfuscator just replaces literals, there could be * cases that it does not handle well. For instance, it will not strip out * comments from your SQL string, it will not handle certain database-specific * language features, and it could fail for other complex cases. * * If this level of obfuscation is not sufficient, you can supply your own * custom obfuscator via the sql_obfuscator parameter. * * SQL Trace Rollup * ================ * The agent aggregates similar SQL statements together using the supplied * sql_trace_rollup_name. * * To make the most out of this feature, you should either (1) supply the * sql_trace_rollup_name parameter with a name that describes what the SQL is * doing, such as "get_user_account" or (2) pass it NULL, in which case * it will use the sql obfuscator to generate a name. * * @param transaction_id id of transaction * @param parent_segment_id id of parent segment * @param table name of the database table * @param operation name of the sql operation * @param sql the sql string * @param sql_trace_rollup_name the rollup name for the sql trace * @param sql_obfuscator a function pointer that takes sql and obfuscates it * @return segment id on success, else negative warning code or error code */ func SegmentDatastoreBegin(id, parent int64, table, operation, sql, sqlTraceRollupName string) (int64, error) { ctable := C.CString(table) defer C.free(unsafe.Pointer(ctable)) coperation := C.CString(operation) defer C.free(unsafe.Pointer(coperation)) csql := C.CString(sql) defer C.free(unsafe.Pointer(csql)) csqlTraceRollupName := C.CString(sqlTraceRollupName) defer C.free(unsafe.Pointer(csqlTraceRollupName)) return errNoLong(C.newrelic_segment_datastore_begin( C.long(id), C.long(parent), ctable, coperation, csql, csqlTraceRollupName, (*[0]byte)(C.newrelic_basic_literal_replacement_obfuscator), )) }