17th-Ranger-Battalion-ORG/RangerMetrics
7
1
Fork 0
Code Issues 4 Pull Requests Packages Projects Releases Wiki Activity

working version w JSON-based settings configuration

Browse Source
This commit is contained in:
IndigoFox
2023-04-17 20:40:45 -07:00
parent e907eeecfd
commit 20400a0929
22 changed files with 526 additions and 478 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
@RangerMetrics/addons/RangerMetrics/config.cpp
View File

@@ -72,6 +72,7 @@ class CfgFunctions {
class sendClientPoll {};
class startServerPoll {};
class classHandlers {};
class initCapture {};
};
class helpers {
file = "\RangerMetrics\functions\helpers";

17
@RangerMetrics/addons/RangerMetrics/functions/callbackHandlers/fn_callbackHandler.sqf
View File

@@ -15,8 +15,12 @@ if (_data isEqualTo "") exitWith {
// Parse response from string array
private "_response";
try {
diag_log format ["Raw callback: %1: %2", _function, _data];
_response = parseSimpleArray _data;
// diag_log format ["Raw callback: %1: %2", _function, _data];
if (_function find "JSON" > -1) then {
_response = [_data, 2] call CBA_fnc_parseJSON;
} else {
_response = parseSimpleArray _data;
};
} catch {
[
format ["Callback invalid data: %1: %2", _function, _data],
@@ -35,11 +39,14 @@ switch (_function) do {
_response call RangerMetrics_fnc_log;
};
};
case "loadSettingsJSON": {
[_function, _response] call RangerMetrics_callback_fnc_loadSettings;
};
case "loadSettings": {
// Load settings
_response call RangerMetrics_callback_fnc_loadSettings;
[_function, _response] call RangerMetrics_callback_fnc_loadSettings;
};
default {
_response call RangerMetrics_fnc_log;
}
}
};
};

39
@RangerMetrics/addons/RangerMetrics/functions/callbackHandlers/fn_loadSettings.sqf
View File

@@ -1,4 +1,26 @@
private _data = _this;
params ["_function", "_data"];
if (_function isEqualTo "loadSettingsJSON") exitWith {
RangerMetrics_settings = _data;
RangerMetrics_recordingSettings = _data get "recordingSettings";
RangerMetrics_debug = RangerMetrics_settings get "arma3" get "debug";
[
format [
"Settings loaded: %1",
_data
],
"INFO"
] call RangerMetrics_fnc_log;
if (isServer) then {
["RangerMetrics_serverProfileName", profileName] remoteExecCall ["setVariable", 0, true];
RangerMetrics_serverProfileName = profileName;
};
call RangerMetrics_fnc_initCapture;
};
switch (_data select 0) do {
case "CREATED SETTINGS": {
@@ -7,27 +29,22 @@ switch (_data select 0) do {
"ERROR"
] call RangerMetrics_fnc_log;
};
case "SETTINGS LOADED": {
RangerMetrics_settings = createHashMapFromArray (_data # 1);
case "loadSettings": {
[
format [
"Settings loaded successfully from JSON. %1",
RangerMetrics_settings
"Setting loaded: %1",
_data
],
"INFO"
] call RangerMetrics_fnc_log;
// send server profile name to all clients with JIP, so HC or player reporting knows what server it's connected to
if (isServer) then {
["RangerMetrics_serverProfileName", profileName] remoteExecCall ["setVariable", 0, true];
RangerMetrics_serverProfileName = profileName;
};
};
default {
[
_data select 0,
"INFO"
] call RangerMetrics_fnc_log;
};
};
};

6
@RangerMetrics/addons/RangerMetrics/functions/capture/EHOnly/fn_milsim_serverEfficiency.sqf
View File

@@ -6,9 +6,11 @@ params ["_fields", []];
// ["float", "milsim_cps", "1"]
// ]
private _settings = RangerMetrics_recordingSettings get "CBAEventHandlers" get "milsimServerEfficiency";
[
"server_state",
"server_efficiency",
_settings get "bucket",
_settings get "measurement",
nil,
_fields,
["server"]

153
@RangerMetrics/addons/RangerMetrics/functions/capture/fn_entity_count.sqf
View File

@@ -1,5 +1,8 @@
if (!RangerMetrics_run) exitWith {};
private _settings = RangerMetrics_recordingSettings get "entityCount";
private _allUnits = allUnits;
private _allDeadMen = allDeadMen;
private _allGroups = allGroups;
@@ -9,92 +12,104 @@ private _allPlayers = call BIS_fnc_listPlayers;
private _thisSide = _x;
private _thisSideStr = _thisSide call BIS_fnc_sideNameUnlocalized;
// Number of remote units
["server_state", "entities_remote", [
["string", "side", _thisSideStr]
], [
["int", "units_alive", {
side _x isEqualTo _thisSide &&
not (local _x)
} count _allUnits],
["int", "units_dead", {
side _x isEqualTo _thisSide &&
not (local _x)
} count _allDeadMen],
["int", "groups_total", {
side _x isEqualTo _thisSide &&
not (local _x)
} count _allGroups],
["int", "vehicles_total", {
side _x isEqualTo _thisSide &&
not (local _x) &&
!(_x isKindOf "WeaponHolderSimulated")
} count _vehicles],
["int", "vehicles_weaponholder", {
side _x isEqualTo _thisSide &&
not (local _x) &&
(_x isKindOf "WeaponHolderSimulated")
} count _vehicles]
]] call RangerMetrics_fnc_queue;
// Number of local units
["server_state", "entities_local", [
["string", "side", _thisSideStr]
], [
["int", "units_alive", {
side _x isEqualTo _thisSide &&
local _x
} count _allUnits],
["int", "units_dead", {
side _x isEqualTo _thisSide &&
local _x
} count _allDeadMen],
["int", "groups_total", {
side _x isEqualTo _thisSide &&
local _x
} count _allGroups],
["int", "vehicles_total", {
side _x isEqualTo _thisSide &&
local _x &&
!(_x isKindOf "WeaponHolderSimulated")
} count _vehicles],
["int", "vehicles_weaponholder", {
side _x isEqualTo _thisSide &&
local _x &&
(_x isKindOf "WeaponHolderSimulated")
} count _vehicles]
]] call RangerMetrics_fnc_queue;
// Number of global units - only track on server
if (isServer) then {
["server_state", "entities_global", [
[
_settings get "bucket",
"entities_remote",
[
["string", "side", _thisSideStr]
], [
["int", "units_alive", {
side _x isEqualTo _thisSide
side _x isEqualTo _thisSide &&
not (local _x)
} count _allUnits],
["int", "units_dead", {
side _x isEqualTo _thisSide
side _x isEqualTo _thisSide &&
not (local _x)
} count _allDeadMen],
["int", "groups_total", {
side _x isEqualTo _thisSide
side _x isEqualTo _thisSide &&
not (local _x)
} count _allGroups],
["int", "vehicles_total", {
side _x isEqualTo _thisSide &&
not (local _x) &&
!(_x isKindOf "WeaponHolderSimulated")
} count _vehicles],
["int", "vehicles_weaponholder", {
side _x isEqualTo _thisSide &&
not (local _x) &&
(_x isKindOf "WeaponHolderSimulated")
} count _vehicles]
]
] call RangerMetrics_fnc_queue;
// Number of local units
[
_settings get "bucket",
"entities_local",
[
["string", "side", _thisSideStr]
], [
["int", "units_alive", {
side _x isEqualTo _thisSide &&
local _x
} count _allUnits],
["int", "units_dead", {
side _x isEqualTo _thisSide &&
local _x
} count _allDeadMen],
["int", "groups_total", {
side _x isEqualTo _thisSide &&
local _x
} count _allGroups],
["int", "vehicles_total", {
side _x isEqualTo _thisSide &&
local _x &&
!(_x isKindOf "WeaponHolderSimulated")
} count _vehicles],
["int", "players_alive", {
["int", "vehicles_weaponholder", {
side _x isEqualTo _thisSide &&
alive _x
} count _allPlayers],
["int", "players_dead", {
side _x isEqualTo _thisSide &&
!alive _x
} count _allPlayers]
]] call RangerMetrics_fnc_queue;
local _x &&
(_x isKindOf "WeaponHolderSimulated")
} count _vehicles]
]
] call RangerMetrics_fnc_queue;
// Number of global units - only track on server
if (isServer) then {
[
_settings get "bucket",
"entities_global",
[
["string", "side", _thisSideStr]
], [
["int", "units_alive", {
side _x isEqualTo _thisSide
} count _allUnits],
["int", "units_dead", {
side _x isEqualTo _thisSide
} count _allDeadMen],
["int", "groups_total", {
side _x isEqualTo _thisSide
} count _allGroups],
["int", "vehicles_total", {
side _x isEqualTo _thisSide &&
!(_x isKindOf "WeaponHolderSimulated")
} count _vehicles],
["int", "vehicles_weaponholder", {
side _x isEqualTo _thisSide &&
(_x isKindOf "WeaponHolderSimulated")
} count _vehicles],
["int", "players_alive", {
side _x isEqualTo _thisSide &&
alive _x
} count _allPlayers],
["int", "players_dead", {
side _x isEqualTo _thisSide &&
!alive _x
} count _allPlayers]
]
] call RangerMetrics_fnc_queue;
};
} forEach [east, west, independent, civilian];

7
@RangerMetrics/addons/RangerMetrics/functions/capture/fn_player_identity.sqf
View File

@@ -3,6 +3,7 @@ if (!RangerMetrics_run) exitWith {};
params ["_playerID", "_ownerId", "_playerUID", "_profileName", "_displayName", "_steamName", "_clientState", "_isHC", "_adminState", "_networkInfo", "_unit", ["_jip", false]];
// _networkInfo params ["_avgPing", "_avgBandwidth", "_desync"];
private _settings = RangerMetrics_recordingSettings get "playerIdentity";
private _fields = [
@@ -43,7 +44,7 @@ try {
];
} forEach _squadInfoDataFormat;
_unitInfoDataFormat =[
_unitInfoDataFormat = [
"unitUid",
"unitName",
"unitFullName",
@@ -72,8 +73,8 @@ if (_roleDescription isNotEqualTo "") then {
};
[
"player_state",
"player_identity",
_settings get "bucket",
_settings get "measurement",
[
["string", "playerUID", _playerUID]
],

9
@RangerMetrics/addons/RangerMetrics/functions/capture/fn_player_performance.sqf
View File

@@ -1,16 +1,13 @@
if (!RangerMetrics_run) exitWith {};
private _settings = "recordingSettings.serverPolling.userPerformance" call RangerMetrics_fnc_getSetting;
if (!_settings) exitWith {
[format["Error in settings lookup: %1", _settingsPath]] call RangerMetrics_fnc_log;
};
if !(_settings get "enabled") exitWith {false};
private _settings = RangerMetrics_recordingSettings get "playerPerformance";
{
_x params ["_playerID", "_ownerId", "_playerUID", "_profileName", "_displayName", "_steamName", "_clientState", "_isHC", "_adminState", "_networkInfo", "_unit"];
_networkInfo params ["_avgPing", "_avgBandwidth", "_desync"];
if (_unit == objNull || _isHC) exitWith {};
[
_settings get "bucket",
_settings get "measurement",

6
@RangerMetrics/addons/RangerMetrics/functions/capture/fn_player_status.sqf
View File

@@ -3,7 +3,11 @@ if (!RangerMetrics_run) exitWith {};
params ["_playerID", "_ownerId", "_playerUID", "_profileName", "_displayName", "_steamName", "_clientState", "_isHC", "_adminState", "_networkInfo", "_unit"];
// _networkInfo params ["_avgPing", "_avgBandwidth", "_desync"];
["player_state", "player_status",
private _settings = RangerMetrics_recordingSettings get "playerStatus";
[
_settings get "bucket",
_settings get "measurement",
[["string", "playerUID", _playerUID]],
[
["int", "clientStateNumber", _clientState],

17
@RangerMetrics/addons/RangerMetrics/functions/capture/fn_running_mission.sqf
View File

@@ -1,19 +1,22 @@
if (!RangerMetrics_run) exitWith {};
// Mission name
private _settings = RangerMetrics_recordingSettings get "runningMission";
[
"server_state", // bucket to store the data
"running_mission", // measurement classifier inside of bucket
_settings get "bucket",
_settings get "measurement",
nil, // tags
[ // fields
["string","briefing_name", briefingName],
["string","mission_name", missionName],
["string","mission_name_source", missionNameSource],
[
"string",
"onLoadName",
"on_load_name",
getMissionConfigValue ["onLoadName", ""]
],
["string","briefingName", briefingName],
["string","missionName", missionName],
["string","missionNameSource", missionNameSource]
["string","author", getMissionConfigValue ["author", ""]],
["string","server_name",serverName]
],
["profile", "server", "world"] // context
] call RangerMetrics_fnc_queue;

25
@RangerMetrics/addons/RangerMetrics/functions/capture/fn_running_scripts.sqf
View File

@@ -1,9 +1,20 @@
if (!RangerMetrics_run) exitWith {};
["server_state", "running_scripts", nil, [
["int", "spawn", diag_activeScripts select 0],
["int", "execVM", diag_activeScripts select 1],
["int", "exec", diag_activeScripts select 2],
["int", "execFSM", diag_activeScripts select 3],
["int", "pfh", if (RangerMetrics_cbaPresent) then {count CBA_common_perFrameHandlerArray} else {0}]
]] call RangerMetrics_fnc_queue;
private _settings = RangerMetrics_recordingSettings get "runningScripts";
[
_settings get "bucket",
_settings get "measurement",
nil,
[
["int", "spawn", diag_activeScripts select 0],
["int", "execVM", diag_activeScripts select 1],
["int", "exec", diag_activeScripts select 2],
["int", "execFSM", diag_activeScripts select 3],
["int", "pfh",
if (RangerMetrics_cbaPresent) then {
count CBA_common_perFrameHandlerArray
} else {0}
]
]
] call RangerMetrics_fnc_queue;

7
@RangerMetrics/addons/RangerMetrics/functions/capture/fn_server_performance.sqf
View File

@@ -1,6 +1,11 @@
if (!RangerMetrics_run) exitWith {};
["server_state", "server_performance", nil, [
private _settings = RangerMetrics_recordingSettings get "serverPerformance";
[
_settings get "bucket",
_settings get "measurement",
nil, [
["float", "fps_avg", diag_fps toFixed 2],
["float", "fps_min", diag_fpsMin toFixed 2]
]] call RangerMetrics_fnc_queue;

19
@RangerMetrics/addons/RangerMetrics/functions/capture/fn_server_time.sqf
View File

@@ -1,8 +1,15 @@
if (!RangerMetrics_run) exitWith {};
["server_state", "server_time", nil, [
["float", "diag_tickTime", diag_tickTime toFixed 2],
["float", "serverTime", time toFixed 2],
["float", "timeMultiplier", timeMultiplier toFixed 2],
["float", "accTime", accTime toFixed 2]
]] call RangerMetrics_fnc_queue;
private _settings = RangerMetrics_recordingSettings get "serverTime";
[
_settings get "bucket",
_settings get "measurement",
nil,
[
["float", "diag_tickTime", diag_tickTime toFixed 2],
["float", "serverTime", time toFixed 2],
["float", "timeMultiplier", timeMultiplier toFixed 2],
["float", "accTime", accTime toFixed 2]
]
] call RangerMetrics_fnc_queue;

6
@RangerMetrics/addons/RangerMetrics/functions/capture/fn_view_distance.sqf
View File

@@ -1,8 +1,10 @@
if (!RangerMetrics_run) exitWith {};
private _settings = RangerMetrics_recordingSettings get "viewDistance";
[
"server_state",
"view_distance",
_settings get "bucket",
_settings get "measurement",
nil,
[
["float", "objectViewDistance", getObjectViewDistance # 0],

6
@RangerMetrics/addons/RangerMetrics/functions/capture/fn_weather.sqf
View File

@@ -1,8 +1,10 @@
if (!RangerMetrics_run) exitWith {};
private _settings = RangerMetrics_recordingSettings get "weather";
[
"server_state", // bucket to store the data
"weather", // measurement classifier inside of bucket
_settings get "bucket",
_settings get "measurement",
nil, // tags
[ // fields
["float", "fog", fog],

8
@RangerMetrics/addons/RangerMetrics/functions/captureDefinitions/fn_server_CBA.sqf
View File

@@ -1,4 +1,8 @@
[
["ace_unconscious", RangerMetrics_event_fnc_ace_unconscious],
["milsim_serverEfficiency", RangerMetrics_event_fnc_milsim_serverEfficiency]
// ["ace_unconscious", RangerMetrics_event_fnc_ace_unconscious],
[
"milsimServerEfficiency",
"milsim_serverEfficiency",
RangerMetrics_event_fnc_milsim_serverEfficiency
]
]

68
@RangerMetrics/addons/RangerMetrics/functions/captureDefinitions/fn_server_missionEH.sqf
View File

@@ -32,7 +32,7 @@
private _userInfo = (getUserInfo _networkId);
_userInfo call RangerMetrics_capture_fnc_player_identity;
_userInfo call RangerMetrics_capture_fnc_player_status;
[_entity] call RangerMetrics_capture_fnc_unit_inventory;
// [_entity] call RangerMetrics_capture_fnc_unit_inventory;
["server_events", "PlayerConnected", [
["string", "playerUID", _userInfo#2]
], [
@@ -136,16 +136,16 @@
) exitWith {};
_this call RangerMetrics_event_fnc_EntityKilled;
call RangerMetrics_capture_fnc_entity_count;
[_entity] call RangerMetrics_capture_fnc_unit_inventory;
[_entity] call RangerMetrics_capture_fnc_unit_state;
// [_entity] call RangerMetrics_capture_fnc_unit_inventory;
// [_entity] call RangerMetrics_capture_fnc_unit_state;
[format["(EventHandler) EntityKilled fired: %1", _this], "DEBUG"] call RangerMetrics_fnc_log;
}],
["EntityRespawned", {
params ["_newEntity", "_oldEntity"];
call RangerMetrics_capture_fnc_entity_count;
[_entity] call RangerMetrics_capture_fnc_unit_inventory;
[_entity] call RangerMetrics_capture_fnc_unit_state;
// [_entity] call RangerMetrics_capture_fnc_unit_inventory;
// [_entity] call RangerMetrics_capture_fnc_unit_state;
[format["(EventHandler) EntityRespawned fired: %1", _this], "DEBUG"] call RangerMetrics_fnc_log;
}],
["GroupCreated", {
@@ -157,38 +157,38 @@
params ["_group"];
call RangerMetrics_capture_fnc_entity_count;
[format["(EventHandler) GroupDeleted fired: %1", _this], "DEBUG"] call RangerMetrics_fnc_log;
}],
["MarkerCreated", {
params ["_marker", "_channelNumber", "_owner", "_local"];
if (markerType _marker isEqualTo "") exitWith {};
_this call RangerMetrics_event_fnc_MarkerCreated;
[format["(EventHandler) MarkerCreated fired: %1", _this], "DEBUG"] call RangerMetrics_fnc_log;
}],
["MarkerDeleted", {
params ["_marker", "_channelNumber", "_owner", "_local"];
if (markerType _marker isEqualTo "") exitWith {};
_this call RangerMetrics_event_fnc_MarkerDeleted;
[format["(EventHandler) MarkerDeleted fired: %1", _this], "DEBUG"] call RangerMetrics_fnc_log;
}],
}]
// ["MarkerCreated", {
// params ["_marker", "_channelNumber", "_owner", "_local"];
// if (markerType _marker isEqualTo "") exitWith {};
// _this call RangerMetrics_event_fnc_MarkerCreated;
// [format["(EventHandler) MarkerCreated fired: %1", _this], "DEBUG"] call RangerMetrics_fnc_log;
// }],
// ["MarkerDeleted", {
// params ["_marker", "_channelNumber", "_owner", "_local"];
// if (markerType _marker isEqualTo "") exitWith {};
// _this call RangerMetrics_event_fnc_MarkerDeleted;
// [format["(EventHandler) MarkerDeleted fired: %1", _this], "DEBUG"] call RangerMetrics_fnc_log;
// }],
// ["MarkerUpdated", {
// params ["_marker", "_local"];
// if (markerType _marker isEqualTo "") exitWith {};
// _this call RangerMetrics_event_fnc_MarkerUpdated;
// }],
["Service", {
params ["_serviceVehicle", "_servicedVehicle", "_serviceType", "_needsService", "_autoSupply"];
[
"server_events",
"Service",
[
["string", "serviceVehicle", typeOf _serviceVehicle],
["string", "servicedVehicle", typeOf _servicedVehicle],
["int", "serviceType", _serviceType],
["bool", "needsService", _needsService],
["bool", "autoSupply", _autoSupply]
],
nil
] call RangerMetrics_fnc_queue;
[format["(EventHandler) Service fired: %1", _this], "DEBUG"] call RangerMetrics_fnc_log;
}]
// ["Service", {
// params ["_serviceVehicle", "_servicedVehicle", "_serviceType", "_needsService", "_autoSupply"];
// [
// "server_events",
// "Service",
// [
// ["string", "serviceVehicle", typeOf _serviceVehicle],
// ["string", "servicedVehicle", typeOf _servicedVehicle],
// ["int", "serviceType", _serviceType],
// ["bool", "needsService", _needsService],
// ["bool", "autoSupply", _autoSupply]
// ],
// nil
// ] call RangerMetrics_fnc_queue;
// [format["(EventHandler) Service fired: %1", _this], "DEBUG"] call RangerMetrics_fnc_log;
// }]
]

85
@RangerMetrics/addons/RangerMetrics/functions/captureDefinitions/fn_server_poll.sqf
View File

@@ -1,67 +1,42 @@
[
[
1, // interval
[ // functions to run
[
["server", "hc"],
RangerMetrics_capture_fnc_server_performance
]
]
"serverPerformance",
RangerMetrics_capture_fnc_server_performance
],
[
3,
[
[
["server", "hc"],
RangerMetrics_capture_fnc_running_scripts
],
[
["server", "hc"],
RangerMetrics_capture_fnc_player_performance
]
]
"runningScripts",
RangerMetrics_capture_fnc_running_scripts
],
[
15,
[
[
["server", "hc"],
RangerMetrics_capture_fnc_server_time
],
[
["hc"],
RangerMetrics_capture_fnc_entity_count
]
]
"entityCount",
RangerMetrics_capture_fnc_entity_count
],
[
120,
[
[
["server"],
{
{
[_x] call RangerMetrics_capture_fnc_unit_inventory;
} count (call BIS_fnc_listPlayers);
}
]
]
"playerPerformance",
RangerMetrics_capture_fnc_player_performance
],
[
300,
[
[
["server"],
RangerMetrics_capture_fnc_weather
],
[
["server"],
RangerMetrics_capture_fnc_view_distance
],
[
["server"],
RangerMetrics_capture_fnc_running_mission
]
]
"runningMission",
RangerMetrics_capture_fnc_running_mission
],
[
"serverTime",
RangerMetrics_capture_fnc_server_time
],
[
"weather",
RangerMetrics_capture_fnc_weather
],
[
"viewDistance",
RangerMetrics_capture_fnc_view_distance
]
// [
// "playerInventory",
// {
// {
// [_x] call RangerMetrics_capture_fnc_unit_inventory;
// } count (call BIS_fnc_listPlayers);
// }
// ],
]

111
@RangerMetrics/addons/RangerMetrics/functions/core/fn_initCapture.sqf Normal file
View File

@@ -0,0 +1,111 @@
// MISSION EH
{
if (!isServer) exitWith {};
_x params ["_ehName", "_code"];
_handle = (addMissionEventHandler [_ehName, _code]);
if (isNil "_handle") then {
[format["Failed to add Mission event handler: %1", _x], "ERROR"] call RangerMetrics_fnc_log;
false;
} else {
missionNamespace setVariable [
("RangerMetrics" + "_MEH_" + _ehName),
_handle
];
true;
};
} forEach (call RangerMetrics_cDefinitions_fnc_server_missionEH);
// SERVER POLLS
{
// for each definition in SQF, pair it to the settings imported from settings.json
// and then call the function to create the metric
// get the definition
_x params ["_name", "_code"];
// get the settings
private _settings = RangerMetrics_recordingSettings get _name;
if (isNil "_settings") exitWith {};
if (count (keys _settings) == 0) exitWith {};
if (
(_settings get "enabled") isNotEqualTo true ||
(
!isServer &&
(_settings get "serverOnly") isNotEqualTo false
) ||
(hasInterface && !isServer)
) exitWith {};
// set up pfh
_x call RangerMetrics_fnc_startServerPoll;
} forEach (call RangerMetrics_cDefinitions_fnc_server_poll);
// CBA EVENTS
{
private "_handle";
_x params ["_settingName", "_handleName", "_code"];
private _settings = RangerMetrics_recordingSettings get "CBAEventHandlers" get _settingName;
if (isNil "_settings") exitWith {};
if (count (keys _settings) == 0) exitWith {};
if (
(_settings get "enabled") isNotEqualTo true ||
(
!isServer &&
(_settings get "serverOnly") isNotEqualTo false
) ||
(hasInterface && !isServer)
) exitWith {};
_handle = ([_handleName, _code] call CBA_fnc_addEventHandlerArgs);
if (isNil "_handle") then {
[format["Failed to add CBA event handler: %1", _x], "ERROR"] call RangerMetrics_fnc_log;
false;
} else {
missionNamespace setVariable [
("RangerMetrics" + "_CBAEH_" + _settingName),
_handle
];
true;
};
} forEach (call RangerMetrics_cDefinitions_fnc_server_CBA);
private _meh = allVariables missionNamespace select {
_x find (toLower "RangerMetrics_MEH_") == 0
};
private _cba = allVariables missionNamespace select {
_x find (toLower "RangerMetrics_CBAEH_") == 0
};
private _serverPoll = allVariables missionNamespace select {
_x find (toLower "RangerMetrics_serverPoll_") == 0
};
[format ["Mission event handlers: %1", _meh]] call RangerMetrics_fnc_log;
[format ["CBA event handlers: %1", _cba]] call RangerMetrics_fnc_log;
[format ["Server poll handles: %1", _serverPoll]] call RangerMetrics_fnc_log;
RangerMetrics_initialized = true;
RangerMetrics_run = true;
["RangerMetrics_run", true] remoteExecCall ["setVariable", 0];
// start sending
[{
params ["_args", "_idPFH"];
if (scriptDone RangerMetrics_sendBatchHandle) then {
RangerMetrics_sendBatchHandle = [] spawn RangerMetrics_fnc_send;
};
// call RangerMetrics_fnc_send;
}, 2, []] call CBA_fnc_addPerFrameHandler;

120
@RangerMetrics/addons/RangerMetrics/functions/core/fn_postInit.sqf
View File

@@ -15,6 +15,9 @@ RangerMetrics_messageQueue = createHashMap;
// RangerMetrics_messageQueue apply {[_x, count _y]};
RangerMetrics_sendBatchHandle = scriptNull;
RangerMetrics_settings = createHashMap;
RangerMetrics_recordingSettings = createHashMap;
[format ["Instance name: %1", profileName]] call RangerMetrics_fnc_log;
[format ["CBA detected: %1", RangerMetrics_cbaPresent]] call RangerMetrics_fnc_log;
["Initializing v0.1"] call RangerMetrics_fnc_log;
@@ -33,97 +36,6 @@ addMissionEventHandler [
if (true) exitWith {};
// define the metrics to capture by sideloading definition files
// this keeps the main file clean and easy to read
// the definition files are in the format of a hashmap, where the key is the category and the value is an array of arrays, where each sub-array is a capture definition
RangerMetrics_captureDefinitions = createHashMapFromArray [
[
"ServerEvent",
createHashMapFromArray [
[
"MissionEventHandlers",
call RangerMetrics_cDefinitions_fnc_server_missionEH
]
]],
["ClientEvent", []],
[
"ServerPoll",
call RangerMetrics_cDefinitions_fnc_server_poll
],
[
"ClientPoll",
call RangerMetrics_cDefinitions_fnc_client_poll
],
[
"CBAEvent",
call RangerMetrics_cDefinitions_fnc_server_CBA
]
];
// add missionEventHandlers on server only
{_x params ["_handleName", "_code"];
if (!isServer) exitWith {};
// try {
_handle = (addMissionEventHandler [_handleName, _code]);
// } catch {
// _handle = nil;
// };
if (isNil "_handle") then {
[format["Failed to add Mission event handler: %1", [_handleName]], "ERROR"] call RangerMetrics_fnc_log;
} else {
missionNamespace setVariable [
("RangerMetrics" + "_MEH_" + _handleName),
_handle
];
true;
};
} forEach ((RangerMetrics_captureDefinitions get "ServerEvent") get "MissionEventHandlers");
// begin server polling
{
_x call RangerMetrics_fnc_startServerPoll;
} forEach (RangerMetrics_captureDefinitions get "ServerPoll");
// remoteExec client polling - send data to start handles
{
_x call RangerMetrics_fnc_sendClientPoll;
} forEach (RangerMetrics_captureDefinitions get "ClientPoll");
// {
// } forEach (call RangerMetrics_captureDefinitions_fnc_clientEvent);
// begin client polling
// set up CBA event listeners
{_x params ["_handleName", "_code"];
private "_handle";
// try {
_handle = ([_handleName, _code] call CBA_fnc_addEventHandlerArgs);
// } catch {
// _handle = nil;
// };
if (isNil "_handle") then {
[format["Failed to add CBA event handler: %1", [_handleName, _code]], "ERROR"] call RangerMetrics_fnc_log;
} else {
missionNamespace setVariable [
("RangerMetrics" + "_CBAEH_" + _handleName),
_handle
];
true;
};
} forEach (RangerMetrics_captureDefinitions get "CBAEvent");
[] spawn {
sleep 1;
isNil {
@@ -132,33 +44,9 @@ RangerMetrics_captureDefinitions = createHashMapFromArray [
// set up CBA class inits if CBA loaded
call RangerMetrics_fnc_classHandlers;
private _meh = allVariables missionNamespace select {
_x find (toLower "RangerMetrics_MEH_") == 0
};
private _cba = allVariables missionNamespace select {
_x find (toLower "RangerMetrics_CBAEH_") == 0
};
private _serverPoll = allVariables missionNamespace select {
_x find (toLower "RangerMetrics_captureBatchHandle_") == 0
};
[format ["Mission event handlers: %1", _meh]] call RangerMetrics_fnc_log;
[format ["CBA event handlers: %1", _cba]] call RangerMetrics_fnc_log;
[format ["Server poll handles: %1", _serverPoll]] call RangerMetrics_fnc_log;
RangerMetrics_initialized = true;
RangerMetrics_run = true;
["RangerMetrics_run", true] remoteExecCall ["setVariable", 0];
// start sending
[{
params ["_args", "_idPFH"];
if (scriptDone RangerMetrics_sendBatchHandle) then {
RangerMetrics_sendBatchHandle = [] spawn RangerMetrics_fnc_send;
};
// call RangerMetrics_fnc_send;
}, 2, []] call CBA_fnc_addPerFrameHandler;
};
};

107
@RangerMetrics/addons/RangerMetrics/functions/core/fn_startServerPoll.sqf
View File

@@ -1,84 +1,27 @@
params [
["_interval", 5, [0]],
["_functions", [], [[]]]
];
params ["_refName", "_code"];
private _captureHandleName = format ["RangerMetrics_captureBatchHandle_%1", _interval];
if (RangerMetrics_cbaPresent) then { // CBA is running, use PFH
/*
This capture method is dynamic.
Every 5 seconds, two script handles are checked. One is for capturing, one is for sending.
The capturing script will go through and capture data, getting nanosecond precision timestamps from the extension to go alongside each data point, then saving it to a queue. It will go through all assigned interval-based checks then exit, and on the next interval of this parent PFH, the capturing script will be spawned again.
The queue is a hashmap where keys are buckets and values are arrays of data points in [string] line protocol format.
The sending script will go through and send data, sending it in batches per bucket and per 2000 data points, as the max extension call with args is 2048 elements.
The sending script will also check if the queue is empty, and if it is, it will exit. This means scriptDone will be true, and on the next interval of this parent PFH, the sending script will be spawned again.
This system means that capture and sending are occurring in the scheduled environment, not blocking the server, while maintaining the timestamps of when each point was captured. The cycles of each will only occur at most once per 2 seconds, leaving plenty of time, and there will never be more than one call for each at a time.
*/
private _handle = [{
params ["_args", "_idPFH"];
_args params ["_captureHandleName", "_functions"];
if (!RangerMetrics_run) exitWith {};
// use spawn
// if (scriptDone _captureHandleName) then {
// missionNamespace setVariable [
// _captureHandleName,
// [_functions] spawn {
// {
// call _x;
// } forEach _this;
// }
// ];
// };
// call direct
[format["Running %1 functions for %2", count _functions, _captureHandleName], "DEBUG"] call RangerMetrics_fnc_log;
{
_x params ["_whereToRun", "_scriptBlock"];
if (
_whereToRun find "server" == -1 &&
!isServer
) exitWith {false};
if (
_whereToRun find "hc" == -1 &&
(!hasInterface && !isDedicated)
) exitWith {false};
[] spawn _scriptBlock;
} forEach _functions;
}, _interval, [_captureHandleName, _functions]] call CBA_fnc_addPerFrameHandler;
missionNamespace setVariable [_captureHandleName, _handle];
} else { // CBA isn't running, use sleep
[_interval, _functions] spawn {
params ["_interval", "_functions"];
while {true} do {
if (!RangerMetrics_run) exitWith {};
{
_x params ["_whereToRun", "_scriptBlock"];
if (
_whereToRun find "server" == -1 &&
!isServer
) exitWith {false};
if (
_whereToRun find "hc" == -1 &&
(!hasInterface && !isDedicated)
) exitWith {false};
[] spawn _scriptBlock;
} forEach _functions;
sleep (_interval * 2);
};
};
private _intervalMs = RangerMetrics_recordingSettings get _refName get "intervalMs";
if (isNil "_intervalMs") exitWith {
[format["No intervalMs found for serverPoll %1", _name]] call RangerMetrics_fnc_log;
};
private _interval = _intervalMs / 1000; // convert to seconds
// if interval is 0, just run once now at init
if (_interval == 0) exitWith {
[_code] call CBA_fnc_execNextFrame;
};
private _handle = [{
params ["_args", "_idPFH"];
_args params ["_refName", "_code"];
[_code] call CBA_fnc_execNextFrame;
}, _interval, _this] call CBA_fnc_addPerFrameHandler;
missionNamespace setVariable [
"RangerMetrics" + "_serverPoll_" + _refName,
_handle
];

120
@RangerMetrics/settings.example.json Normal file
View File

@@ -0,0 +1,120 @@
{
"influxdb": {
"enabled": true,
"host": "http://INFLUX_URL:8086",
"token": "XXXXXXXXXXXXXXXXXXXXXXXXXXXX_AUTH_TOKEN_XXXXXXXXXXXXXXXXXXXXXXXXXXX",
"org": "ORG_NAME"
},
"arma3": {
"refreshRateMs": 1000,
"debug": false
},
"timescaledb": {
"enabled": false,
"connectionUrl": "postgresql://user:pass@host.com:5432",
"databaseName": "ranger_metrics",
"description": "TimescaleDB is an open-source time-series database built on Postgres. The extension will connect to the maintenance database (postgres) first and create the database it will control with desired name, then shift connections to the newly created database to create the schema and conduct write operations."
},
"recordingSettings": {
"serverPerformance": {
"name": "serverPerformance",
"enabled": true,
"serverOnly": false,
"intervalMs": 1000,
"bucket": "server_performance",
"measurement": "fps",
"description": "SERVER/HC POLL. Tracks average and minimum FPS. Polled on server (and HC) at specified interval."
},
"runningScripts": {
"name": "runningScripts",
"enabled": true,
"serverOnly": false,
"intervalMs": 1000,
"bucket": "server_performance",
"measurement": "running_scripts",
"description": "SERVER/HC POLL. Tracks the number of scripts running on the server (and HC). Polled on specified interval."
},
"entityCount": {
"name": "entityCount",
"enabled": true,
"serverOnly": false,
"intervalMs": 20000,
"bucket": "server_performance",
"measurement": "n/a",
"description": "SERVER/HC POLL. Tracks the number of entities on the server. Polled on server (and HC) at specified interval as well as on EntityCreated/EntityRespawned/EntityKilled events. Measurement is static, [entities_local, entities_remote, entities_global]."
},
"playerPerformance": {
"name": "playerPerformance",
"enabled": true,
"serverOnly": true,
"intervalMs": 3000,
"bucket": "player_performance",
"measurement": "network",
"description": "SERVER POLL. User network performance. Tracks average ping, average bandwidth, and desync. Polled by the server at specified interval. Not tracked from headless client."
},
"serverTime": {
"name": "serverTime",
"enabled": true,
"serverOnly": true,
"intervalMs": 10000,
"bucket": "mission_data",
"measurement": "server_time",
"description": "SERVER POLL. Tracks the server time. Always server-only. Runs at specified interval."
},
"weather": {
"name": "weather",
"enabled": true,
"serverOnly": true,
"intervalMs": 300000,
"bucket": "mission_data",
"measurement": "weather",
"description": "SERVER POLL. Tracks the weather on the server. Always server-only. Runs at specified interval."
},
"viewDistance": {
"name": "viewDistance",
"enabled": true,
"serverOnly": true,
"intervalMs": 300000,
"bucket": "mission_data",
"measurement": "view_distance",
"description": "SERVER POSTINIT, MPEnded. Tracks the view distance on the server. Always server-only. Runs at specified interval."
},
"runningMission": {
"name": "runningMission",
"enabled": true,
"serverOnly": true,
"intervalMs": 0,
"bucket": "mission_data",
"measurement": "running_mission",
"description": "SERVER POSTINIT, MPEnded. Tracks the name of the mission running on the server. Always server-only. Runs at the start (and tries at end) of the mission."
},
"playerStatus": {
"name": "playerStatus",
"enabled": true,
"serverOnly": true,
"intervalMs": 0,
"bucket": "player_data",
"measurement": "client_state",
"description": "EH. Tracks players' clientstateNumber, adminState, and profileName on connect/disconnect to server and to mission, as well as when these values change."
},
"playerIdentity": {
"name": "playerIdentity",
"enabled": true,
"serverOnly": true,
"intervalMs": 0,
"bucket": "player_data",
"measurement": "player_identity",
"description": "EH. Tracks players' identity on connect/disconnect to server and to mission, as well as when these values change."
},
"CBAEventHandlers": {
"milsimServerEfficiency": {
"name": "milsimServerEfficiency",
"enabled": true,
"serverOnly": true,
"bucket": "server_performance",
"measurement": "milsim_server_efficiency",
"description": "EVENTHANDLER. Tracks the efficiency of the server."
}
}
}
}

67
@RangerMetrics/settings.json.example
View File

@@ -1,67 +0,0 @@
{
"influxdb": {
"host": "http://INFLUX_URL:8086",
"token": "XXXXXXXXXXXXXXXXXXXXXXXXXXXX_AUTH_TOKEN_XXXXXXXXXXXXXXXXXXXXXXXXXXX",
"org": "ORG_NAME"
},
"arma3": {
"refreshRateMs": 1000,
"debug": true
},
"recordingSettings": {
"serverPolling": {
"serverPerformance": {
"enabled": true,
"useWith": [
"server",
"headlessClient"
],
"runOnServer": true,
"runOnHeadlessClient": true,
"monitorIntervalInSeconds": 1,
"bucket": "performance",
"measurement": "server_performance",
"description": "Host or Headless Client performance. Tracks average and minimum FPS.",
"filePath": "functions/capture/server_performance.sqf"
},
"userPerformance": {
"enabled": true,
"useWith": [
"server"
],
"runOnServer": true,
"monitorIntervalInSeconds": 3,
"bucket": "network",
"measurement": "user_network",
"description": "User network performance. Tracks average ping, average bandwidth, and desync.",
"filePath": "functions/capture/player_performance.sqf"
},
"runningScripts": {
"enabled": true,
"useWith": [
"server",
"headlessClient"
],
"runOnServer": true,
"runOnHeadlessClient": true,
"monitorIntervalInSeconds": 3,
"bucket": "performance",
"measurement": "running_scripts",
"description": "Count of running scripts obtained via . Tracks the number of scripts running on the server and headless client.",
"filePath": "functions/capture/running_scripts.sqf"
},
"runningMission": {
"enabled": true,
"useWith": [
"server"
],
"runOnServer": true,
"monitorIntervalInSeconds": 300,
"bucket": "mission_data",
"measurement": "mission_name",
"description": "Tracks the name of the mission running on the server.",
"filePath": "functions/capture/running_mission.sqf"
}
}
}
}