@boshyxd/rosentry 0.1.0

package/out/index.d.ts

@@ -0,0 +1,32 @@
+import { CaptureOptions, ConfigOptions, ScopeInterface, Trace, TraceOptions, TraceStatus } from "./types";
+interface RoSentrySDK {
+    init(options: ConfigOptions): RoSentrySDK;
+    isInitialized(): boolean;
+    captureException(err: unknown, options?: CaptureOptions): string | undefined;
+    captureMessage(message: string, options?: CaptureOptions): string | undefined;
+    debug(message: string, data?: Map<string, unknown>): string | undefined;
+    info(message: string, data?: Map<string, unknown>): string | undefined;
+    warn(message: string, data?: Map<string, unknown>): string | undefined;
+    log(message: string, data?: Map<string, unknown>): string | undefined;
+    setUser(userId: number, playerName?: string, data?: Map<string, unknown>): void;
+    clearUser(): void;
+    addBreadcrumb(category: string, message: string, data?: Map<string, unknown>): void;
+    setTag(key: string, value: string): void;
+    setExtra(key: string, value: unknown): void;
+    wrap(fn: (...args: unknown[]) => unknown): (...args: unknown[]) => unknown;
+    withScope(callback: (scopeInterface: ScopeInterface) => void): void;
+    flush(): void;
+    enable(): void;
+    disable(): void;
+    getStatus(): {
+        initialized: boolean;
+        enabled: boolean;
+        queueSize: number;
+    };
+    startTrace(traceName: string, options?: TraceOptions): Trace | undefined;
+    getTrace(traceId: string): Trace | undefined;
+    endAllTraces(status?: TraceStatus): void;
+    getActiveTraceCount(): number;
+}
+declare const RoSentry: RoSentrySDK;
+export = RoSentry;

package/out/init.luau

@@ -0,0 +1,229 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local RunService = TS.import(script, TS.getModule(script, "@rbxts", "services")).RunService
+local Config = TS.import(script, script, "internal", "Config").Config
+local Transport = TS.import(script, script, "internal", "Transport").Transport
+local Scope = TS.import(script, script, "internal", "Scope").Scope
+local Queue = TS.import(script, script, "internal", "Queue").Queue
+local Capture = TS.import(script, script, "internal", "Capture").Capture
+local AutoCapture = TS.import(script, script, "internal", "AutoCapture").AutoCapture
+local TraceManager = TS.import(script, script, "internal", "Trace").TraceManager
+local IS_SERVER = RunService:IsServer()
+local config
+local transport
+local scope
+local queue
+local capture
+local autoCapture
+local traceManager
+local initialized = false
+local function debugLog(...)
+	local args = { ... }
+	if config and config:get("debug") then
+		print("[RoSentry]", unpack(args))
+	end
+end
+local function captureMessageImpl(message, options)
+	if not initialized then
+		warn("[RoSentry] SDK not initialized. Call RoSentry.init() first.")
+		return nil
+	end
+	return capture:captureMessage(message, options)
+end
+local RoSentry
+RoSentry = {
+	init = function(self, options)
+		if initialized then
+			warn("[RoSentry] Already initialized")
+			return RoSentry
+		end
+		config = Config.new()
+		config:init(options, IS_SERVER)
+		transport = Transport.new(config)
+		scope = Scope.new(config)
+		queue = Queue.new(config, transport)
+		capture = Capture.new(config, scope, queue)
+		autoCapture = AutoCapture.new(config, capture)
+		traceManager = TraceManager.new(config, scope, queue)
+		if IS_SERVER then
+			transport:setupServerRelay()
+		end
+		queue:startFlushLoop()
+		if config:get("autoCapture") then
+			autoCapture:setup()
+		end
+		initialized = true
+		debugLog("Initialized with environment:", config:get("environment"), if IS_SERVER then "(server)" else "(client)")
+		scope:addBreadcrumb("sdk", "RoSentry initialized", {
+			environment = config:get("environment"),
+			placeId = game.PlaceId,
+		})
+		return RoSentry
+	end,
+	isInitialized = function(self)
+		return initialized
+	end,
+	captureException = function(self, err, options)
+		if not initialized then
+			warn("[RoSentry] SDK not initialized. Call RoSentry.init() first.")
+			return nil
+		end
+		return capture:captureException(err, options)
+	end,
+	captureMessage = function(self, message, options)
+		return captureMessageImpl(message, options)
+	end,
+	debug = function(self, message, data)
+		return captureMessageImpl(message, {
+			level = "debug",
+			context = data,
+		})
+	end,
+	info = function(self, message, data)
+		return captureMessageImpl(message, {
+			level = "info",
+			context = data,
+		})
+	end,
+	warn = function(self, message, data)
+		return captureMessageImpl(message, {
+			level = "warn",
+			context = data,
+		})
+	end,
+	log = function(self, message, data)
+		return captureMessageImpl(message, {
+			level = "info",
+			context = data,
+		})
+	end,
+	setUser = function(self, userId, playerName, data)
+		if not initialized then
+			warn("[RoSentry] SDK not initialized. Call RoSentry.init() first.")
+			return nil
+		end
+		scope:setUser(userId, playerName, data)
+	end,
+	clearUser = function(self)
+		if not initialized then
+			return nil
+		end
+		scope:clearUser()
+	end,
+	addBreadcrumb = function(self, category, message, data)
+		if not initialized then
+			return nil
+		end
+		scope:addBreadcrumb(category, message, data)
+	end,
+	setTag = function(self, key, value)
+		if not initialized then
+			return nil
+		end
+		scope:setTag(key, value)
+	end,
+	setExtra = function(self, key, value)
+		if not initialized then
+			return nil
+		end
+		scope:setExtra(key, value)
+	end,
+	wrap = function(self, fn)
+		if not initialized then
+			warn("[RoSentry] SDK not initialized. Call RoSentry.init() first.")
+			return fn
+		end
+		return capture:wrap(fn)
+	end,
+	withScope = function(self, callback)
+		if not initialized then
+			warn("[RoSentry] SDK not initialized. Call RoSentry.init() first.")
+			return nil
+		end
+		local isolatedScope = scope:clone()
+		local scopeInterface = {
+			setUser = function(userId, playerName, data)
+				isolatedScope:setUser(userId, playerName, data)
+			end,
+			clearUser = function()
+				isolatedScope:clearUser()
+			end,
+			addBreadcrumb = function(category, message, data)
+				isolatedScope:addBreadcrumb(category, message, data)
+			end,
+			setTag = function(key, value)
+				isolatedScope:setTag(key, value)
+			end,
+			setExtra = function(key, value)
+				isolatedScope:setExtra(key, value)
+			end,
+		}
+		local originalScope = scope
+		scope = isolatedScope
+		capture:setScope(isolatedScope)
+		traceManager:setScope(isolatedScope)
+		local success, err = pcall(function()
+			return callback(scopeInterface)
+		end)
+		scope = originalScope
+		capture:setScope(originalScope)
+		traceManager:setScope(originalScope)
+		if not success then
+			capture:captureException(err)
+			error(err)
+		end
+	end,
+	flush = function(self)
+		if not initialized then
+			return nil
+		end
+		queue:flush()
+	end,
+	enable = function(self)
+		if not initialized then
+			return nil
+		end
+		config:enable()
+		debugLog("SDK enabled")
+	end,
+	disable = function(self)
+		if not initialized then
+			return nil
+		end
+		config:disable()
+		debugLog("SDK disabled")
+	end,
+	getStatus = function(self)
+		return {
+			initialized = initialized,
+			enabled = if initialized then config:isEnabled() else false,
+			queueSize = if initialized then queue:getSize() else 0,
+		}
+	end,
+	startTrace = function(self, traceName, options)
+		if not initialized then
+			warn("[RoSentry] SDK not initialized. Call RoSentry.init() first.")
+			return nil
+		end
+		return traceManager:startTrace(traceName, options)
+	end,
+	getTrace = function(self, traceId)
+		if not initialized then
+			return nil
+		end
+		return traceManager:getTrace(traceId)
+	end,
+	endAllTraces = function(self, status)
+		if not initialized then
+			return nil
+		end
+		traceManager:endAllTraces(status)
+	end,
+	getActiveTraceCount = function(self)
+		if not initialized then
+			return 0
+		end
+		return traceManager:getActiveCount()
+	end,
+}
+return RoSentry

package/out/internal/AutoCapture.d.ts

@@ -0,0 +1,13 @@
+import { Config } from "./Config";
+import { Capture } from "./Capture";
+export declare class AutoCapture {
+    private _config;
+    private _capture;
+    private _connections;
+    private _enabled;
+    constructor(config: Config, capture: Capture);
+    private _debug;
+    setup(): void;
+    teardown(): void;
+    isEnabled(): boolean;
+}

package/out/internal/AutoCapture.luau

@@ -0,0 +1,74 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local _services = TS.import(script, TS.getModule(script, "@rbxts", "services"))
+local ScriptContext = _services.ScriptContext
+local LogService = _services.LogService
+local AutoCapture
+do
+	AutoCapture = setmetatable({}, {
+		__tostring = function()
+			return "AutoCapture"
+		end,
+	})
+	AutoCapture.__index = AutoCapture
+	function AutoCapture.new(...)
+		local self = setmetatable({}, AutoCapture)
+		return self:constructor(...) or self
+	end
+	function AutoCapture:constructor(config, capture)
+		self._config = config
+		self._capture = capture
+		self._connections = {}
+		self._enabled = false
+	end
+	function AutoCapture:_debug(...)
+		local args = { ... }
+		if self._config:get("debug") then
+			print("[RoSentry:AutoCapture]", unpack(args))
+		end
+	end
+	function AutoCapture:setup()
+		if self._enabled then
+			self:_debug("Auto-capture already enabled")
+			return nil
+		end
+		local errorConnection = ScriptContext.Error:Connect(function(message, stackTrace, scriptInstance)
+			if not self._config:isEnabled() then
+				return nil
+			end
+			self._capture:captureScriptError(message, stackTrace, scriptInstance)
+		end)
+		local _exp = self._connections
+		table.insert(_exp, errorConnection)
+		if self._config:get("captureWarnings") then
+			local warningConnection = LogService.MessageOut:Connect(function(message, messageType)
+				if not self._config:isEnabled() then
+					return nil
+				end
+				if messageType == Enum.MessageType.MessageWarning then
+					self._capture:captureMessage(message, {
+						level = "warn",
+					})
+				end
+			end)
+			local _exp_1 = self._connections
+			table.insert(_exp_1, warningConnection)
+		end
+		self._enabled = true
+		self:_debug("Auto-capture enabled")
+	end
+	function AutoCapture:teardown()
+		for _, connection in self._connections do
+			connection:Disconnect()
+		end
+		self._connections = {}
+		self._enabled = false
+		self:_debug("Auto-capture disabled")
+	end
+	function AutoCapture:isEnabled()
+		return self._enabled
+	end
+end
+return {
+	AutoCapture = AutoCapture,
+}

package/out/internal/Capture.d.ts

@@ -0,0 +1,17 @@
+import { CaptureOptions } from "../types";
+import { Config } from "./Config";
+import { Scope } from "./Scope";
+import { Queue } from "./Queue";
+export declare class Capture {
+    private _config;
+    private _scope;
+    private _queue;
+    constructor(config: Config, scope: Scope, queue: Queue);
+    private _debug;
+    private _buildErrorData;
+    captureException(err: unknown, options?: CaptureOptions): string | undefined;
+    captureMessage(message: string, options?: CaptureOptions): string | undefined;
+    captureScriptError(message: string, stackTrace: string, scriptInstance?: Instance): string | undefined;
+    wrap(fn: (...args: unknown[]) => unknown): (...args: unknown[]) => unknown;
+    setScope(scope: Scope): void;
+}

package/out/internal/Capture.luau

@@ -0,0 +1,142 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local _util = TS.import(script, script.Parent, "util")
+local generateUUID = _util.generateUUID
+local getJobId = _util.getJobId
+local getPlaceId = _util.getPlaceId
+local getGameVersion = _util.getGameVersion
+local isServer = _util.isServer
+local sanitizeStackTrace = _util.sanitizeStackTrace
+local getTimestamp = _util.getTimestamp
+local Capture
+do
+	Capture = setmetatable({}, {
+		__tostring = function()
+			return "Capture"
+		end,
+	})
+	Capture.__index = Capture
+	function Capture.new(...)
+		local self = setmetatable({}, Capture)
+		return self:constructor(...) or self
+	end
+	function Capture:constructor(config, scope, queue)
+		self._config = config
+		self._scope = scope
+		self._queue = queue
+	end
+	function Capture:_debug(...)
+		local args = { ... }
+		if self._config:get("debug") then
+			print("[RoSentry:Capture]", unpack(args))
+		end
+	end
+	function Capture:_buildErrorData(message, level, stackTrace, options)
+		local opts = options or {}
+		local user = self._scope:getUser()
+		local breadcrumbs = self._scope:getBreadcrumbs()
+		local tags = self._scope:getTags()
+		local extras = self._scope:getExtras()
+		local allTags = {}
+		-- ▼ ReadonlyMap.forEach ▼
+		local _callback = function(value, key)
+			local _arg0 = `{key}:{value}`
+			table.insert(allTags, _arg0)
+		end
+		for _k, _v in tags do
+			_callback(_v, _k, tags)
+		end
+		-- ▲ ReadonlyMap.forEach ▲
+		if opts.tags then
+			for _, tag in opts.tags do
+				table.insert(allTags, tag)
+			end
+		end
+		local errorData = {
+			message = message,
+			level = opts.level or level,
+			stack_trace = sanitizeStackTrace(stackTrace),
+			user_id = if user then user.id else nil,
+			player_name = if user then user.name else nil,
+			job_id = getJobId(),
+			place_id = getPlaceId(),
+			game_version = getGameVersion(),
+			environment = self._config:get("environment"),
+			context = {
+				userData = if user then user.data else nil,
+				custom = opts.context or extras,
+				breadcrumbs = breadcrumbs,
+				isServer = isServer(),
+				script = nil,
+			},
+			tags = allTags,
+			timestamp = getTimestamp(),
+		}
+		return errorData
+	end
+	function Capture:captureException(err, options)
+		if not self._config:isEnabled() then
+			return nil
+		end
+		local opts = options or {}
+		local message = tostring(err)
+		local _condition = opts.stackTrace
+		if _condition == nil then
+			_condition = debug.traceback()
+		end
+		local stackTrace = _condition
+		local errorData = self:_buildErrorData(message, "error", stackTrace, opts)
+		local success = self._queue:push(errorData)
+		if success then
+			self:_debug("Captured exception:", message)
+			return generateUUID()
+		end
+		return nil
+	end
+	function Capture:captureMessage(message, options)
+		if not self._config:isEnabled() then
+			return nil
+		end
+		local opts = options or {}
+		local level = opts.level or "info"
+		local errorData = self:_buildErrorData(message, level, nil, opts)
+		local success = self._queue:push(errorData)
+		if success then
+			self:_debug("Captured message:", message)
+			return generateUUID()
+		end
+		return nil
+	end
+	function Capture:captureScriptError(message, stackTrace, scriptInstance)
+		if not self._config:isEnabled() then
+			return nil
+		end
+		local errorData = self:_buildErrorData(message, "error", stackTrace)
+		errorData.context.script = if scriptInstance then scriptInstance:GetFullName() else "Unknown"
+		local success = self._queue:push(errorData)
+		if success then
+			self:_debug("Captured script error:", message)
+			return generateUUID()
+		end
+		return nil
+	end
+	function Capture:wrap(fn)
+		return function(...)
+			local args = { ... }
+			local success, result = pcall(function()
+				return fn(unpack(args))
+			end)
+			if not success then
+				self:captureException(result)
+				error(result)
+			end
+			return result
+		end
+	end
+	function Capture:setScope(scope)
+		self._scope = scope
+	end
+end
+return {
+	Capture = Capture,
+}

package/out/internal/Config.d.ts

@@ -0,0 +1,12 @@
+import { Config as ConfigType, ConfigOptions } from "../types";
+export declare class Config {
+    private _config;
+    constructor();
+    init(options: ConfigOptions, isServer: boolean): void;
+    get<T extends keyof ConfigType>(key: T): ConfigType[T];
+    set<T extends keyof ConfigType>(key: T, value: ConfigType[T]): void;
+    getAll(): ConfigType;
+    isEnabled(): boolean;
+    enable(): void;
+    disable(): void;
+}

package/out/internal/Config.luau

@@ -0,0 +1,116 @@
+-- Compiled with roblox-ts v3.0.0
+local DEFAULT_CONFIG = {
+	apiKey = "",
+	environment = "production",
+	endpoint = "https://rosentry.vercel.app/api/ingest",
+	enabled = true,
+	sampleRate = 1.0,
+	maxBreadcrumbs = 100,
+	maxQueueSize = 50,
+	flushInterval = 5,
+	debug = false,
+	autoCapture = true,
+	captureWarnings = false,
+	beforeSend = nil,
+}
+local Config
+do
+	Config = setmetatable({}, {
+		__tostring = function()
+			return "Config"
+		end,
+	})
+	Config.__index = Config
+	function Config.new(...)
+		local self = setmetatable({}, Config)
+		return self:constructor(...) or self
+	end
+	function Config:constructor()
+		local _object = table.clone(DEFAULT_CONFIG)
+		setmetatable(_object, nil)
+		self._config = _object
+	end
+	function Config:init(options, isServer)
+		if isServer then
+			local _arg0 = options.apiKey ~= nil and options.apiKey ~= ""
+			assert(_arg0, "[RoSentry] apiKey is required on server")
+		end
+		local _condition = options.apiKey
+		if _condition == nil then
+			_condition = ""
+		end
+		self._config.apiKey = _condition
+		local _condition_1 = options.environment
+		if _condition_1 == nil then
+			_condition_1 = self._config.environment
+		end
+		self._config.environment = _condition_1
+		local _condition_2 = options.endpoint
+		if _condition_2 == nil then
+			_condition_2 = self._config.endpoint
+		end
+		self._config.endpoint = _condition_2
+		local _condition_3 = options.enabled
+		if _condition_3 == nil then
+			_condition_3 = self._config.enabled
+		end
+		self._config.enabled = _condition_3
+		local _condition_4 = options.sampleRate
+		if _condition_4 == nil then
+			_condition_4 = self._config.sampleRate
+		end
+		self._config.sampleRate = _condition_4
+		local _condition_5 = options.maxBreadcrumbs
+		if _condition_5 == nil then
+			_condition_5 = self._config.maxBreadcrumbs
+		end
+		self._config.maxBreadcrumbs = _condition_5
+		local _condition_6 = options.maxQueueSize
+		if _condition_6 == nil then
+			_condition_6 = self._config.maxQueueSize
+		end
+		self._config.maxQueueSize = _condition_6
+		local _condition_7 = options.flushInterval
+		if _condition_7 == nil then
+			_condition_7 = self._config.flushInterval
+		end
+		self._config.flushInterval = _condition_7
+		local _condition_8 = options.debug
+		if _condition_8 == nil then
+			_condition_8 = self._config.debug
+		end
+		self._config.debug = _condition_8
+		local _condition_9 = options.autoCapture
+		if _condition_9 == nil then
+			_condition_9 = self._config.autoCapture
+		end
+		self._config.autoCapture = _condition_9
+		local _condition_10 = options.captureWarnings
+		if _condition_10 == nil then
+			_condition_10 = self._config.captureWarnings
+		end
+		self._config.captureWarnings = _condition_10
+		self._config.beforeSend = options.beforeSend
+	end
+	function Config:get(key)
+		return self._config[key]
+	end
+	function Config:set(key, value)
+		self._config[key] = value
+	end
+	function Config:getAll()
+		return self._config
+	end
+	function Config:isEnabled()
+		return self._config.enabled
+	end
+	function Config:enable()
+		self._config.enabled = true
+	end
+	function Config:disable()
+		self._config.enabled = false
+	end
+end
+return {
+	Config = Config,
+}

package/out/internal/Queue.d.ts

@@ -0,0 +1,19 @@
+import { ErrorData } from "../types";
+import { Config } from "./Config";
+import { Transport } from "./Transport";
+export declare class Queue {
+    private _config;
+    private _transport;
+    private _queue;
+    private _lastFlush;
+    private _flushLoopRunning;
+    constructor(config: Config, transport: Transport);
+    private _debug;
+    private _shouldSample;
+    push(errorData: ErrorData): boolean;
+    flush(): void;
+    startFlushLoop(): void;
+    stopFlushLoop(): void;
+    getSize(): number;
+    clear(): void;
+}