Files
opencloud/services/graph/load_test.js
T
Pascal Bleser 5b72318493 chore(graph): add metrics for HTTP API and LDAP
Introducing gowrap as a build-time tool to generate interface delegate
structs from templates:

 * added as a 'make go-generate' target in services/graph,
 * added as a build-time dependency in .bingo/

Introduce an LDAP client abstraction interface to be able to wrap the
go-ldap client API with metrics transparently (and possibly hooks and
such in the future), in order to use delegation patterns to measure the
time LDAP (client) operations take to finish, as well as to track their
results (success, failure, not-found).

Has two implementations that are generated using gowrap:

* a go-ldap adapter implementation that directly delegates to a go-ldap
  connection
* a time measuring and metrics collecting implementation that delegates
  to another LdapClient

The metrics collecting one is disabled by default, can be enabled with
GRAPH_LDAP_METRICS_DISABLE=false

It collects durations of outbound LDAP client operations into a histogram, as
well as the number of concurrent outbound LDAP operations in a gauge (via an
atomic int and a gauge function, as that performs best).

Add an HTTP middleware that measures how long Graph HTTP API requests
take, storing taken time into a histogram along with labels for

 * method,
 * path pattern (from the chi routes),
 * Graph API version prefix,
 * Graph API resource name,
 * and the resulting status code.

It also tracks the number of concurrent inbound Graph API HTTP requests
using a gauge (also using an atomic int and a gauge function).

Disabled by default, can be enabled with
GRAPH_HTTP_METRICS_DISABLE=false

Add Backend and EducationBackend delegate implementations that measure
execution time on the level of the higher API call operations there
(CreateUser, DeleteUser, ..., CreateSchool, ...), generated using
gowrap.

Disabled by default, can be enabled with
GRAPH_IDENTITY_BACKEND_METRICS_DISABLE=false

Also added a small k6 script to produce some read-only load on the Graph
API, for a casual test of the metrics, as well as k6 in mise.toml.

Make an internal changes to how singular LDAP entry searches work in the LDAP
identity backends:

 * check whether searches for a singular entry returns more than one
   result, in which case a new error TooManyResults is returned, instead
   of leaving that undetected, blindly taking the first result, and
   potentially risking data inconsistencies

Improve the loggers in identity backends by adding attributes for their
request targets (Reva gateway address or LDAP URI, respectively).

Also add a "backend" attribute for all Graph API logs (set to "ldap" or
"cs3"), to help debug potential issues, and remove them from all the logger
debug calls at the beginning of each LDAP-related function as those should
really be part of the logger and set beforehand.

The LDAP identity backend logger also has two new attributes to help
debugging with logs:

 * write (bool): whether write operations are enabled
 * refint (bool): whether refint is enabled or not

Also adds a dedicated counter metric for user password change operations.

Minor campfire improvements:

 * add a constructor func for the CS3 backend

 * add a constructor func for the LDAP backend

 * in the LDAP identity backend, in searchLDAPEntryByFilter (used by all
   search/get public functions), errors that occur when performing LDAP
   SEARCH operations were blindly mapped to a ItemNotFound error,
   instead of being analyzed as it could be caused by a technical error

 * in the requireadmin middleware, add debug logging to explain why a
   request is denied

 * when an LDAP password change fails because the user entry was not
   found in LDAP, we now have a log message that tracks that
2026-09-01 10:57:47 +02:00

81 lines
2.6 KiB
JavaScript

// Small k6 script to generate some load on read-only endpoints of
// the Graph API, for showcasing the metrics.
import http from 'k6/http';
import { check, sleep } from 'k6';
import encoding from 'k6/encoding';
// Configuration via environment variables with defaults
const BASE_URL = __ENV.BASE_URL || 'https://localhost:9200';
const USERNAME = __ENV.USERNAME || 'alan';
const PASSWORD = __ENV.PASSWORD || 'demo';
export const options = {
insecureSkipTLSVerify: true,
vus: 10,
thresholds: {
http_req_failed: ['rate<0.01'],
http_req_duration: ['p(95)<500'],
},
};
const credentials = `${USERNAME}:${PASSWORD}`;
const encodedCredentials = encoding.b64encode(credentials);
const params = {
headers: {
'Authorization': `Basic ${encodedCredentials}`,
'Accept': 'application/json',
},
};
export default function () {
// Fetch current user profile, including the list of groups the user is part of
let resMe = http.get(`${BASE_URL}/graph/v1.0/me?$expand=memberOf`, params);
const meOk = check(resMe, { 'GET /me status is 200': (r) => r.status === 200 });
sleep(0.1);
// extract the names of the groups the user is part of, because the user is allowed
// to retrieve information about those
let groupNames = [];
if (meOk && resMe.json() && resMe.json().memberOf) {
groupNames = (resMe.json().memberOf || []).map((group) => group.displayName);
}
// Fetch oneself using the users search API:
let resUsers = http.get(`${BASE_URL}/graph/v1.0/users?$search="${USERNAME}"`, params);
check(resUsers, { 'GET /users status is 200': (r) => r.status === 200 });
sleep(0.1);
// Fetch storage drives
let resDrives = http.get(`${BASE_URL}/graph/v1.0/drives`, params);
const drivesOk = check(resDrives, {
'GET /drives status is 200': (r) => r.status === 200,
});
sleep(0.1);
// For each of those drives, retrieve deeper information about each
if (drivesOk && resDrives.json() && resDrives.json().value) {
const drives = resDrives.json().value;
if (drives.length > 0) {
const driveId = drives[0].id;
let resDrive = http.get(`${BASE_URL}/graph/v1.0/drives/${driveId}`, params);
check(resDrive, {
'GET /drives/{id} status is 200': (r) => r.status === 200,
});
}
}
// For each of the groups the user is part of, retrieve information about each of them
// using the group searching endpoint
for (const group of groupNames) {
let resGroups = http.get(`${BASE_URL}/graph/v1.0/groups?$search="${group}"`, params);
const groupsOk = check(resGroups, {
'GET /groups status is 200': (r) => r.status === 200,
});
}
sleep(0.2);
}