@epicgames-ps/lib-pixelstreamingsignalling-ue5.8 0.1.0

package/docs/pixelstreamingsignalling/README.md

@@ -0,0 +1,145 @@
+[**@epicgames-ps/lib-pixelstreamingsignalling-ue5.5**](../README.md)
+
+***
+
+[@epicgames-ps/lib-pixelstreamingsignalling-ue5.5](../README.md) / pixelstreamingsignalling
+
+# pixelstreamingsignalling
+
+## References
+
+### createHandlerListener
+
+Re-exports [createHandlerListener](../LoggingUtils/functions/createHandlerListener.md)
+
+***
+
+### IConfig
+
+Re-exports [IConfig](../Logger/interfaces/IConfig.md)
+
+***
+
+### IMessageLogger
+
+Re-exports [IMessageLogger](../LoggingUtils/interfaces/IMessageLogger.md)
+
+***
+
+### InitLogging
+
+Re-exports [InitLogging](../Logger/functions/InitLogging.md)
+
+***
+
+### IPlayer
+
+Re-exports [IPlayer](../PlayerRegistry/interfaces/IPlayer.md)
+
+***
+
+### IPlayerInfo
+
+Re-exports [IPlayerInfo](../PlayerRegistry/interfaces/IPlayerInfo.md)
+
+***
+
+### IProtoLogObj
+
+Re-exports [IProtoLogObj](../LoggingUtils/interfaces/IProtoLogObj.md)
+
+***
+
+### IServerConfig
+
+Re-exports [IServerConfig](../SignallingServer/interfaces/IServerConfig.md)
+
+***
+
+### IStreamer
+
+Re-exports [IStreamer](../StreamerRegistry/interfaces/IStreamer.md)
+
+***
+
+### IStreamerInfo
+
+Re-exports [IStreamerInfo](../StreamerRegistry/interfaces/IStreamerInfo.md)
+
+***
+
+### IWebServerConfig
+
+Re-exports [IWebServerConfig](../WebServer/interfaces/IWebServerConfig.md)
+
+***
+
+### logForward
+
+Re-exports [logForward](../LoggingUtils/functions/logForward.md)
+
+***
+
+### Logger
+
+Re-exports [Logger](../Logger/variables/Logger.md)
+
+***
+
+### logIncoming
+
+Re-exports [logIncoming](../LoggingUtils/functions/logIncoming.md)
+
+***
+
+### logOutgoing
+
+Re-exports [logOutgoing](../LoggingUtils/functions/logOutgoing.md)
+
+***
+
+### PlayerConnection
+
+Re-exports [PlayerConnection](../PlayerConnection/classes/PlayerConnection.md)
+
+***
+
+### PlayerRegistry
+
+Re-exports [PlayerRegistry](../PlayerRegistry/classes/PlayerRegistry.md)
+
+***
+
+### ProtocolConfig
+
+Re-exports [ProtocolConfig](../SignallingServer/type-aliases/ProtocolConfig.md)
+
+***
+
+### SFUConnection
+
+Re-exports [SFUConnection](../SFUConnection/classes/SFUConnection.md)
+
+***
+
+### SignallingServer
+
+Re-exports [SignallingServer](../SignallingServer/classes/SignallingServer.md)
+
+***
+
+### StreamerConnection
+
+Re-exports [StreamerConnection](../StreamerConnection/classes/StreamerConnection.md)
+
+***
+
+### StreamerRegistry
+
+Re-exports [StreamerRegistry](../StreamerRegistry/classes/StreamerRegistry.md)
+
+***
+
+### WebServer
+
+Re-exports [WebServer](../WebServer/classes/WebServer.md)

package/eslint.config.mjs

@@ -0,0 +1,39 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+import tseslint from 'typescript-eslint';
+import tsdocPlugin from 'eslint-plugin-tsdoc';
+import baseConfig from '../eslint.config.mjs'
+
+export default tseslint.config(
+    baseConfig,
+    {
+        ignores: [],
+    },
+    {
+        languageOptions: {
+            parser: tseslint.parser,
+            parserOptions: {
+                project: 'tsconfig.cjs.json',
+                tsconfigRootDir: import.meta.dirname,
+            },
+        },
+        files: ["src/**/*.ts"],
+        plugins: {
+            'tsdoc': tsdocPlugin,
+        },
+        rules: {
+            "tsdoc/syntax": "warn",
+            "@typescript-eslint/require-array-sort-compare": "error",
+            "no-unused-vars": "off",
+            "@typescript-eslint/no-misused-promises": "off", // http.createServer(app) is throwing this
+            "@typescript-eslint/no-unused-vars": [
+                "error",
+                {
+                    "argsIgnorePattern": "^_",
+                    "varsIgnorePattern": "^_",
+                    "caughtErrorsIgnorePattern": "^_"
+                }
+            ]
+        }
+    }
+);

package/package.json

@@ -0,0 +1,58 @@
+{
+    "name": "@epicgames-ps/lib-pixelstreamingsignalling-ue5.8",
+    "version": "0.1.0",
+    "description": "Basic signalling library for developers wishing to build applications that signal a Pixel Streaming application.",
+    "main": "dist/cjs/pixelstreamingsignalling.js",
+    "module": "dist/esm/pixelstreamingsignalling.js",
+    "types": "dist/types/pixelstreamingsignalling.d.ts",
+    "scripts": {
+        "clean": "rimraf ./dist",
+        "build:docs": "echo \"Make sure you're passing the right --gitRemote so the source links are correct!\" && typedoc --tsconfig tsconfig.cjs.json",
+        "build:cjs": "tsc --project tsconfig.cjs.json",
+        "build:esm": "tsc --project tsconfig.esm.json",
+        "build": "npm run build:cjs && npm run build:esm",
+        "rebuild": "npm run clean && npm run build",
+        "watch": "nodemon -V -d 3 --watch src --watch ../Common/dist -e \"ts,js,mjs,cjs,json\" --exec \"npm run build:cjs\"",
+        "lint": "eslint src",
+        "test": "echo \"Error: no test specified\" && exit 1"
+    },
+    "author": "Epic Games",
+    "license": "MIT",
+    "devDependencies": {
+        "@eslint/js": "^9.20.0",
+        "@types/cors": "^2.8.17",
+        "@types/express": "^5.0.0",
+        "@types/node": "^22.14.0",
+        "@types/ws": "^8.5.14",
+        "eslint": "^9.39.0",
+        "eslint-config-prettier": "^10.0.1",
+        "eslint-plugin-prettier": "^5.2.3",
+        "eslint-plugin-tsdoc": "^0.4.0",
+        "nodemon": "^3.1.9",
+        "rimraf": "^6.0.1",
+        "typedoc": "^0.28.0",
+        "typedoc-plugin-markdown": "^4.4.2",
+        "typescript": "^5.7.3",
+        "typescript-eslint": "8.57.2"
+    },
+    "dependencies": {
+        "body-parser": "^1.20.4",
+        "cors": "^2.8.5",
+        "express": "^4.22.1",
+        "express-rate-limit": "^8.5.1",
+        "helmet": "^8.0.0",
+        "hsts": "^2.2.0",
+        "jsonc": "^2.0.0",
+        "logform": "^2.7.0",
+        "winston": "^3.17.0",
+        "winston-daily-rotate-file": "^5.0.0",
+        "ws": "^8.18.0"
+    },
+    "peerDependencies": {
+        "@epicgames-ps/lib-pixelstreamingcommon-ue5.8": "^0.1.0"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/EpicGames/PixelStreamingInfrastructure"
+    }
+}

package/src/Logger.ts

@@ -0,0 +1,189 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+import { stringify, beautify } from './Utils';
+import { IProtoLogObj } from './LoggingUtils';
+import path from 'path';
+import winston from 'winston';
+import 'winston-daily-rotate-file';
+import { TransformableInfo } from 'logform';
+import { BaseMessage, ILogger, overrideLogger } from '@epicgames-ps/lib-pixelstreamingcommon-ue5.8';
+
+const { combine, timestamp, printf, colorize, splat } = winston.format;
+
+type WinstonLogger = ReturnType<typeof winston.createLogger>;
+
+/**
+ * The actual logger object. This is just a winston logger.
+ * You can use InitLogging to get a decent result, or you can
+ * completely create your own winston logger and assign it.
+ */
+export let Logger = createDefaultLogger();
+
+export interface IConfig {
+    // the directory to store log files
+    logDir?: string;
+
+    // if true, every message will be logged to the console in a condensed form
+    logMessagesToConsole?: string;
+
+    // the minimum log level for console messages
+    logLevelConsole?: string;
+
+    // the minimum log level for file messages
+    logLevelFile?: string;
+}
+
+/**
+ * A wrapper for the log calls in Common lib
+ */
+class CommonLogger implements ILogger {
+    logger: WinstonLogger;
+
+    constructor(winstonLogger: WinstonLogger) {
+        this.logger = winstonLogger;
+    }
+
+    InitLogging(_logLevel: number, _includeStack: boolean): void {}
+
+    Debug(message: string): void {
+        this.logger.debug(message);
+    }
+
+    Info(message: string): void {
+        this.logger.info(message);
+    }
+
+    Warning(message: string): void {
+        this.logger.warn(message);
+    }
+
+    Error(message: string): void {
+        this.logger.error(message);
+    }
+}
+
+/**
+ * Call this as early as possible to setup the logging module with your
+ * preferred settings.
+ * @param config - The settings to init the logger with. See IConfig interface
+ */
+export function InitLogging(config: IConfig): void {
+    const logDir = config.logDir || 'logs';
+    const logLevelConsole = config.logLevelConsole || 'info';
+    const logLevelFile = config.logLevelFile || 'info';
+    logMessagesToConsole = config.logMessagesToConsole || 'none';
+
+    Logger = winston.createLogger({
+        transports: [createConsoleTransport(logLevelConsole), createFileTransport(logDir, logLevelFile)]
+    });
+
+    const commonLogger = new CommonLogger(Logger);
+    overrideLogger(commonLogger);
+}
+
+let logMessagesToConsole = 'none';
+
+function createDefaultLogger() {
+    return winston.createLogger({
+        level: 'info',
+        format: winston.format.cli(),
+        transports: [new winston.transports.Console()]
+    });
+}
+
+function createConsoleTransport(logLevel: string) {
+    return new winston.transports.Console({
+        level: logLevel,
+        format: combine(
+            createProtoMessageFilter()(),
+            timestamp({ format: 'HH:mm:ss.SSS' }),
+            colorize(),
+            splat(),
+            createConsoleFormat()
+        )
+    });
+}
+
+function isLogObject(object: any): object is IProtoLogObj {
+    /* eslint-disable @typescript-eslint/no-unsafe-member-access */
+    return (
+        'event' in object &&
+        object.event == 'proto_message' &&
+        'direction' in object &&
+        'protoMessage' in object
+    );
+    /* eslint-enable @typescript-eslint/no-unsafe-member-access */
+}
+
+function createConsoleFormat() {
+    return printf((logObj: TransformableInfo) => {
+        const prefix = `[${String(logObj['timestamp'])}] ${logObj.level}: `;
+        if (typeof logObj.message === 'string') {
+            return prefix + logObj.message;
+        } else if (isLogObject(logObj.message)) {
+            const { direction, receiver, sender, target, protoMessage } = logObj.message;
+            switch (direction) {
+                case 'incoming':
+                    return prefix + `> ${receiver} :: ${formatMessageForConsole(protoMessage)}`;
+                case 'outgoing':
+                    return prefix + `< ${sender} :: ${formatMessageForConsole(protoMessage)}`;
+                case 'forward':
+                    return prefix + `${receiver} > ${target} :: ${formatMessageForConsole(protoMessage)}`;
+                default:
+                    return prefix + `Unknown proto direction: ${direction}`;
+            }
+        }
+        return '';
+    });
+}
+
+function formatMessageForConsole(message: BaseMessage) {
+    switch (logMessagesToConsole) {
+        case 'verbose':
+            return stringify(message);
+        case 'formatted':
+            return beautify(message);
+        default:
+            return `[${message.type}]`;
+    }
+}
+
+function createProtoMessageFilter() {
+    return winston.format((info: TransformableInfo, _opts: any) => {
+        if (typeof info.message !== 'string' && isLogObject(info.message) && logMessagesToConsole == 'none') {
+            return false;
+        }
+        return info;
+    });
+}
+
+function createFileTransport(logDirPath: string, logLevel: string) {
+    return new winston.transports.DailyRotateFile({
+        level: logLevel,
+        filename: path.join(logDirPath, 'server-%DATE%.log'),
+        datePattern: 'YYYY-MM-DD',
+        maxFiles: '14d',
+        format: combine(timestamp({ format: 'YYYY-MM-DD HH:mm:ss.SSS' }), splat(), createFileFormat())
+    });
+}
+
+function createFileFormat() {
+    return printf((logObj: TransformableInfo) => {
+        if (typeof logObj.message === 'string') {
+            const { timestamp, level, message } = logObj;
+            return JSON.stringify({
+                timestamp,
+                level,
+                event: 'message',
+                message
+            });
+        } else if (isLogObject(logObj.message)) {
+            const { timestamp, level, message } = logObj;
+            return JSON.stringify({
+                timestamp,
+                level,
+                ...message
+            });
+        }
+        return '';
+    });
+}

package/src/LoggingUtils.ts

@@ -0,0 +1,80 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+import { BaseMessage } from '@epicgames-ps/lib-pixelstreamingcommon-ue5.8';
+import { Logger } from './Logger';
+
+export interface IProtoLogObj {
+    event: string;
+    direction: string;
+    sender?: string;
+    receiver?: string;
+    target?: string;
+    protoMessage: BaseMessage;
+}
+
+/**
+ * Most methods in here rely on connections implementing this interface so we can identify
+ * who is sending or receiving etc.
+ */
+export interface IMessageLogger {
+    getReadableIdentifier(): string;
+}
+
+/**
+ * Call to log messages received on a connection that we will handle here at the server.
+ * Do not call this for messages being forwarded to another connection.
+ * @param recvr - IMessageLogger The connection the message was received on.
+ */
+export function logIncoming(recvr: IMessageLogger, message: BaseMessage): void {
+    const logObj: IProtoLogObj = {
+        event: 'proto_message',
+        direction: 'incoming',
+        receiver: recvr.getReadableIdentifier(),
+        protoMessage: message
+    };
+    Logger.info(logObj);
+}
+
+/**
+ * Call to log messages created here at the server and being sent to the connection.
+ * Do not call this for messages being forwarded to this connection.
+ * @param sender - IMessageLogger The connection the message is being sent to.
+ */
+export function logOutgoing(sender: IMessageLogger, message: BaseMessage): void {
+    Logger.info({
+        event: 'proto_message',
+        direction: 'outgoing',
+        sender: sender.getReadableIdentifier(),
+        protoMessage: message
+    });
+}
+
+/**
+ * Call this for messages being forwarded to this connection. That is messages received on
+ * one connection and being sent to another with only minor changes being made.
+ * @param recvr - The connection the message was received on.
+ * @param target - The connection the message is being sent to.
+ */
+export function logForward(recvr: IMessageLogger, target: IMessageLogger, message: BaseMessage): void {
+    Logger.info({
+        event: 'proto_message',
+        direction: 'forward',
+        receiver: recvr.getReadableIdentifier(),
+        target: target.getReadableIdentifier(),
+        protoMessage: message
+    });
+}
+
+/**
+ * We don't want to log every incoming and outgoing messages. This is because some messages are simply
+ * forwarded to other connections. This results in duplicated spam. So we only want to log incoming
+ * messages that we handle internally, and any messages that we forward we only log once for the recv
+ * and send events.
+ * This creation method allows a simple way to enforce this. Any events we handle directly will
+ * be preceded by the logging call.
+ */
+export function createHandlerListener(obj: IMessageLogger, handler: (message: any) => void) {
+    return (message: BaseMessage) => {
+        logIncoming(obj, message);
+        handler.bind(obj)(message);
+    };
+}