Page MenuHomePhabricator
Differential D14043

[keyserver] Introduce metric for weekly active users
ClosedPublic
Actions

Authored by ashoat on Nov 25 2024, 12:02 PM.
Tags
None
Referenced Files
Unknown Object (File)
Thu, Mar 27, 5:02 PM
Unknown Object (File)
Thu, Mar 27, 8:52 AM
Unknown Object (File)
Wed, Mar 26, 9:31 PM
Unknown Object (File)
Wed, Mar 26, 5:37 AM
Unknown Object (File)
Wed, Mar 26, 3:17 AM
Unknown Object (File)
Thu, Mar 13, 4:46 AM
Unknown Object (File)
Mar 1 2025, 10:17 AM
Unknown Object (File)
Mar 1 2025, 1:17 AM
View All 55 Files
Subscribers
tomek

Details

Reviewers
varun
will
Commits
rCOMM502916913bc0: [keyserver] Introduce metric for weekly active users
Summary

We already have DAUs and MAUs, but it wouldn't hurt to track this on a weekly basis as well.

Depends on D14042

Test Plan

Ran it on my personal server and confirmed that a message appeared with the new metric

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Revision Contents
Changeset List

PathSize
keyserver/
src/
cron/
3 lines

Diff 46048

View Options

keyserver/src/cron/metrics.js

Show All 16 Lines
import type { CurrentUserInfo } from '../types/user-types.js'; import type { CurrentUserInfo } from '../types/user-types.js';
import type { import type {
CallServerEndpoint, CallServerEndpoint,
CallServerEndpointOptions, CallServerEndpointOptions,
} from '../utils/call-server-endpoint.js'; } from '../utils/call-server-endpoint.js';
import callServerEndpoint from '../utils/call-server-endpoint.js'; import callServerEndpoint from '../utils/call-server-endpoint.js';
export type ActionFunc<F> = (callServerEndpoint: CallServerEndpoint) => F; export type ActionFunc<F> = (callServerEndpoint: CallServerEndpoint) => F;
type CreateBoundServerCallsSelectorType = ( type CreateCallSingleKeyserverEndpointSelector = (
keyserverID: string, keyserverID: string,
) => <F>(ActionFunc<F>) => ServerCallSelectorParams => F; ) => ServerCallSelectorParams => CallServerEndpoint;
type CallKeyserverEndpointContextType = { type CallKeyserverEndpointContextType = {
+bindCookieAndUtilsIntoCallServerEndpoint: ( +bindCookieAndUtilsIntoCallServerEndpoint: (
params: BindServerCallsParams, params: BindServerCallsParams,
) => CallServerEndpoint, ) => CallServerEndpoint,
+createBoundServerCallsSelector: CreateBoundServerCallsSelectorType, +createCallSingleKeyserverEndpointSelector: CreateCallSingleKeyserverEndpointSelector,
}; };
const CallKeyserverEndpointContext: React.Context<?CallKeyserverEndpointContextType> = const CallKeyserverEndpointContext: React.Context<?CallKeyserverEndpointContextType> =
React.createContext(); React.createContext();
type OngoingRecoveryAttempt = { type OngoingRecoveryAttempt = {
+waitingCalls: Array<(callServerEndpoint: ?CallServerEndpoint) => mixed>, +waitingCalls: Array<(callServerEndpoint: ?CallServerEndpoint) => mixed>,
}; };
▲ Show 20 Lines • Show All 145 Lines • ▼ Show 20 Lines ) =>
data, data,
dispatch, dispatch,
options, options,
loggedIn, loggedIn,
keyserverID, keyserverID,
); );
}, []); }, []);
// All server calls needs to include some information from the Redux state // For each keyserver, we have a set of params that configure our connection
// (namely, the cookie). This information is used deep in the server call, // to it. These params get bound into callServerEndpoint before it's passed to
// at the point where callServerEndpoint is called. We don't want to bother // an ActionFunc. This helper function lets us create a selector for a given
// propagating the cookie (and any future config info that callServerEndpoint // keyserverID that will regenerate the bound callServerEndpoint function only
// needs) through to the server calls so they can pass it to // if one of the params changes. This lets us skip some React render cycles.
// callServerEndpoint. Instead, we "curry" the cookie onto callServerEndpoint const createCallSingleKeyserverEndpointSelector = React.useCallback(
// within react-redux's connect's mapStateToProps function, and then pass that (keyserverID: string): (ServerCallSelectorParams => CallServerEndpoint) =>
// "bound" callServerEndpoint that no longer needs the cookie as a parameter
// on to the server call.
const createBoundServerCallsSelector = React.useCallback(
(
keyserverID: string,
): (<F>(actionFunc: ActionFunc<F>) => ServerCallSelectorParams => F) =>
actionFunc =>
createSelector( createSelector(
(state: ServerCallSelectorParams) => state.dispatch, (params: ServerCallSelectorParams) => params.dispatch,
(state: ServerCallSelectorParams) => state.cookie, (params: ServerCallSelectorParams) => params.cookie,
(state: ServerCallSelectorParams) => state.urlPrefix, (params: ServerCallSelectorParams) => params.urlPrefix,
(state: ServerCallSelectorParams) => state.sessionID, (params: ServerCallSelectorParams) => params.sessionID,
(state: ServerCallSelectorParams) => state.currentUserInfo, (params: ServerCallSelectorParams) => params.currentUserInfo,
(state: ServerCallSelectorParams) => state.isSocketConnected, (params: ServerCallSelectorParams) => params.isSocketConnected,
(state: ServerCallSelectorParams) => (params: ServerCallSelectorParams) =>
state.lastCommunicatedPlatformDetails, params.lastCommunicatedPlatformDetails,
( (
dispatch: Dispatch, dispatch: Dispatch,
cookie: ?string, cookie: ?string,
urlPrefix: string, urlPrefix: string,
sessionID: ?string, sessionID: ?string,
currentUserInfo: ?CurrentUserInfo, currentUserInfo: ?CurrentUserInfo,
isSocketConnected: boolean, isSocketConnected: boolean,
lastCommunicatedPlatformDetails: ?PlatformDetails, lastCommunicatedPlatformDetails: ?PlatformDetails,
) => { ) =>
const boundCallServerEndpoint =
bindCookieAndUtilsIntoCallServerEndpoint({ bindCookieAndUtilsIntoCallServerEndpoint({
dispatch, dispatch,
cookie, cookie,
urlPrefix, urlPrefix,
sessionID, sessionID,
currentUserInfo, currentUserInfo,
isSocketConnected, isSocketConnected,
lastCommunicatedPlatformDetails, lastCommunicatedPlatformDetails,
keyserverID, keyserverID,
}); }),
return actionFunc(boundCallServerEndpoint);
},
), ),
[bindCookieAndUtilsIntoCallServerEndpoint], [bindCookieAndUtilsIntoCallServerEndpoint],
); );
const value = React.useMemo( const value = React.useMemo(
() => ({ () => ({
bindCookieAndUtilsIntoCallServerEndpoint, bindCookieAndUtilsIntoCallServerEndpoint,
createBoundServerCallsSelector, createCallSingleKeyserverEndpointSelector,
}), }),
[bindCookieAndUtilsIntoCallServerEndpoint, createBoundServerCallsSelector], [
bindCookieAndUtilsIntoCallServerEndpoint,
createCallSingleKeyserverEndpointSelector,
],
); );
return ( return (
<CallKeyserverEndpointContext.Provider value={value}> <CallKeyserverEndpointContext.Provider value={value}>
{props.children} {props.children}
</CallKeyserverEndpointContext.Provider> </CallKeyserverEndpointContext.Provider>
); );
} }
Show All 22 Lines