@boshyxd/rosentry 0.1.0

package/out/internal/Queue.luau

@@ -0,0 +1,120 @@
+-- Compiled with roblox-ts v3.0.0
+local Queue
+do
+	Queue = setmetatable({}, {
+		__tostring = function()
+			return "Queue"
+		end,
+	})
+	Queue.__index = Queue
+	function Queue.new(...)
+		local self = setmetatable({}, Queue)
+		return self:constructor(...) or self
+	end
+	function Queue:constructor(config, transport)
+		self._config = config
+		self._transport = transport
+		self._queue = {}
+		self._lastFlush = tick()
+		self._flushLoopRunning = false
+	end
+	function Queue:_debug(...)
+		local args = { ... }
+		if self._config:get("debug") then
+			print("[RoSentry:Queue]", unpack(args))
+		end
+	end
+	function Queue:_shouldSample()
+		local sampleRate = self._config:get("sampleRate")
+		return math.random() <= sampleRate
+	end
+	function Queue:push(errorData)
+		if not self._config:isEnabled() then
+			return false
+		end
+		if not self:_shouldSample() then
+			self:_debug("Event dropped due to sampling")
+			return false
+		end
+		local beforeSend = self._config:get("beforeSend")
+		if beforeSend then
+			local result = beforeSend(errorData)
+			if result == nil then
+				self:_debug("Event dropped by beforeSend hook")
+				return false
+			end
+			errorData = result
+		end
+		local __queue = self._queue
+		local _errorData = errorData
+		table.insert(__queue, _errorData)
+		self:_debug("Event queued, queue size:", #self._queue)
+		local maxQueueSize = self._config:get("maxQueueSize")
+		local flushInterval = self._config:get("flushInterval")
+		if #self._queue >= maxQueueSize or (tick() - self._lastFlush) >= flushInterval then
+			self:flush()
+		end
+		return true
+	end
+	function Queue:flush()
+		if #self._queue == 0 then
+			return nil
+		end
+		local maxQueueSize = self._config:get("maxQueueSize")
+		local errors = {}
+		local count = math.min(#self._queue, maxQueueSize)
+		do
+			local i = 0
+			local _shouldIncrement = false
+			while true do
+				if _shouldIncrement then
+					i += 1
+				else
+					_shouldIncrement = true
+				end
+				if not (i < count) then
+					break
+				end
+				local item = table.remove(self._queue, 1)
+				if item ~= nil then
+					table.insert(errors, item)
+				end
+			end
+		end
+		self:_debug("Flushing", #errors, "errors")
+		self._transport:sendAsync({
+			errors = errors,
+		})
+		self._lastFlush = tick()
+	end
+	function Queue:startFlushLoop()
+		if self._flushLoopRunning then
+			return nil
+		end
+		self._flushLoopRunning = true
+		task.spawn(function()
+			while self._flushLoopRunning do
+				local flushInterval = self._config:get("flushInterval")
+				task.wait(flushInterval)
+				if #self._queue > 0 then
+					self:flush()
+				end
+			end
+		end)
+		self:_debug("Flush loop started")
+	end
+	function Queue:stopFlushLoop()
+		self._flushLoopRunning = false
+		self:_debug("Flush loop stopped")
+	end
+	function Queue:getSize()
+		return #self._queue
+	end
+	function Queue:clear()
+		self._queue = {}
+		self:_debug("Queue cleared")
+	end
+end
+return {
+	Queue = Queue,
+}

package/out/internal/Scope.d.ts

@@ -0,0 +1,25 @@
+import { Breadcrumb, UserContext } from "../types";
+import { Config } from "./Config";
+export declare class Scope {
+    private _config;
+    private _user?;
+    private _breadcrumbs;
+    private _tags;
+    private _extras;
+    constructor(config: Config);
+    private _debug;
+    setUser(userId: number, playerName?: string, data?: Map<string, unknown>): void;
+    getUser(): UserContext | undefined;
+    clearUser(): void;
+    addBreadcrumb(category: string, message: string, data?: Map<string, unknown>): void;
+    getBreadcrumbs(): Breadcrumb[];
+    clearBreadcrumbs(): void;
+    setTag(key: string, value: string): void;
+    getTags(): Map<string, string>;
+    removeTag(key: string): void;
+    setExtra(key: string, value: unknown): void;
+    getExtras(): Map<string, unknown>;
+    removeExtra(key: string): void;
+    clear(): void;
+    clone(): Scope;
+}

package/out/internal/Scope.luau

@@ -0,0 +1,155 @@
+-- Compiled with roblox-ts v3.0.0
+local Scope
+do
+	Scope = setmetatable({}, {
+		__tostring = function()
+			return "Scope"
+		end,
+	})
+	Scope.__index = Scope
+	function Scope.new(...)
+		local self = setmetatable({}, Scope)
+		return self:constructor(...) or self
+	end
+	function Scope:constructor(config)
+		self._config = config
+		self._breadcrumbs = {}
+		self._tags = {}
+		self._extras = {}
+	end
+	function Scope:_debug(...)
+		local args = { ... }
+		if self._config:get("debug") then
+			print("[RoSentry:Scope]", unpack(args))
+		end
+	end
+	function Scope:setUser(userId, playerName, data)
+		self._user = {
+			id = userId,
+			name = playerName,
+			data = data or {},
+		}
+		self:addBreadcrumb("user", "User set", {
+			userId = userId,
+			playerName = playerName,
+		})
+		local _self = self
+		local _exp = userId
+		local _condition = playerName
+		if _condition == nil then
+			_condition = "(no name)"
+		end
+		_self:_debug("User set:", _exp, _condition)
+	end
+	function Scope:getUser()
+		return self._user
+	end
+	function Scope:clearUser()
+		self._user = nil
+		self:_debug("User cleared")
+	end
+	function Scope:addBreadcrumb(category, message, data)
+		local maxBreadcrumbs = self._config:get("maxBreadcrumbs")
+		local breadcrumb = {
+			category = category,
+			message = message,
+			data = data,
+			timestamp = os.time(),
+		}
+		local _exp = self._breadcrumbs
+		table.insert(_exp, breadcrumb)
+		while #self._breadcrumbs > maxBreadcrumbs do
+			table.remove(self._breadcrumbs, 1)
+		end
+		self:_debug("Breadcrumb added:", category, message)
+	end
+	function Scope:getBreadcrumbs()
+		return self._breadcrumbs
+	end
+	function Scope:clearBreadcrumbs()
+		self._breadcrumbs = {}
+		self:_debug("Breadcrumbs cleared")
+	end
+	function Scope:setTag(key, value)
+		local __tags = self._tags
+		local _key = key
+		local _value = value
+		__tags[_key] = _value
+		self:_debug("Tag set:", key, value)
+	end
+	function Scope:getTags()
+		return self._tags
+	end
+	function Scope:removeTag(key)
+		local __tags = self._tags
+		local _key = key
+		__tags[_key] = nil
+	end
+	function Scope:setExtra(key, value)
+		local __extras = self._extras
+		local _key = key
+		local _value = value
+		__extras[_key] = _value
+		self:_debug("Extra set:", key)
+	end
+	function Scope:getExtras()
+		return self._extras
+	end
+	function Scope:removeExtra(key)
+		local __extras = self._extras
+		local _key = key
+		__extras[_key] = nil
+	end
+	function Scope:clear()
+		self._user = nil
+		self._breadcrumbs = {}
+		self._tags = {}
+		self._extras = {}
+		self:_debug("Scope cleared")
+	end
+	function Scope:clone()
+		local cloned = Scope.new(self._config)
+		if self._user then
+			local _object = table.clone(self._user)
+			setmetatable(_object, nil)
+			cloned._user = _object
+		end
+		local _array = {}
+		local _length = #_array
+		local _array_1 = self._breadcrumbs
+		table.move(_array_1, 1, #_array_1, _length + 1, _array)
+		cloned._breadcrumbs = _array
+		local tagsCopy = {}
+		local _exp = self._tags
+		-- ▼ ReadonlyMap.forEach ▼
+		local _callback = function(v, k)
+			local _k = k
+			local _v = v
+			tagsCopy[_k] = _v
+			return tagsCopy
+		end
+		for _k, _v in _exp do
+			_callback(_v, _k, _exp)
+		end
+		-- ▲ ReadonlyMap.forEach ▲
+		cloned._tags = tagsCopy
+		local extrasCopy = {}
+		local _exp_1 = self._extras
+		-- ▼ ReadonlyMap.forEach ▼
+		local _callback_1 = function(v, k)
+			local _k = k
+			local _v = v
+			extrasCopy[_k] = _v
+			return extrasCopy
+		end
+		for _k, _v in _exp_1 do
+			_callback_1(_v, _k, _exp_1)
+		end
+		-- ▲ ReadonlyMap.forEach ▲
+		cloned._extras = extrasCopy
+		return cloned
+	end
+end
+return {
+	Scope = Scope,
+}

package/out/internal/Trace.d.ts

@@ -0,0 +1,21 @@
+import { Trace, TraceOptions, TraceStatus } from "../types";
+import { Config } from "./Config";
+import { Scope } from "./Scope";
+import { Queue } from "./Queue";
+export declare class TraceManager {
+    private _config;
+    private _scope;
+    private _queue;
+    private _activeTraces;
+    constructor(config: Config, scope: Scope, queue: Queue);
+    private _debug;
+    private _cleanupExpired;
+    getActiveCount(): number;
+    startTrace(traceName: string, options?: TraceOptions): Trace | undefined;
+    private _createTraceInterface;
+    private _logToTrace;
+    private _finishTrace;
+    getTrace(traceId: string): Trace | undefined;
+    endAllTraces(status?: TraceStatus): void;
+    setScope(scope: Scope): void;
+}

package/out/internal/Trace.luau

@@ -0,0 +1,299 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local HttpService = TS.import(script, TS.getModule(script, "@rbxts", "services")).HttpService
+local _util = TS.import(script, script.Parent, "util")
+local getJobId = _util.getJobId
+local getPlaceId = _util.getPlaceId
+local getGameVersion = _util.getGameVersion
+local isServer = _util.isServer
+local getTimestamp = _util.getTimestamp
+local DEFAULT_MAX_EVENTS = 100
+local DEFAULT_EXPIRES_IN = 3600
+local MAX_ACTIVE_TRACES = 50
+local function isoFromUnixSeconds(seconds)
+	return DateTime.fromUnixTimestamp(seconds):ToIsoDate()
+end
+local TraceManager
+do
+	TraceManager = setmetatable({}, {
+		__tostring = function()
+			return "TraceManager"
+		end,
+	})
+	TraceManager.__index = TraceManager
+	function TraceManager.new(...)
+		local self = setmetatable({}, TraceManager)
+		return self:constructor(...) or self
+	end
+	function TraceManager:constructor(config, scope, queue)
+		self._config = config
+		self._scope = scope
+		self._queue = queue
+		self._activeTraces = {}
+	end
+	function TraceManager:_debug(...)
+		local args = { ... }
+		if self._config:get("debug") then
+			print("[RoSentry:Trace]", unpack(args))
+		end
+	end
+	function TraceManager:_cleanupExpired()
+		local now = os.time()
+		local expired = {}
+		local _exp = self._activeTraces
+		-- ▼ ReadonlyMap.forEach ▼
+		local _callback = function(trace, id)
+			if now >= trace.expiresAt then
+				self:_debug("Trace expired:", trace.name, id)
+				local _id = id
+				table.insert(expired, _id)
+			end
+		end
+		for _k, _v in _exp do
+			_callback(_v, _k, _exp)
+		end
+		-- ▲ ReadonlyMap.forEach ▲
+		for _, id in expired do
+			self._activeTraces[id] = nil
+		end
+	end
+	function TraceManager:getActiveCount()
+		self:_cleanupExpired()
+		local count = 0
+		local _exp = self._activeTraces
+		-- ▼ ReadonlyMap.forEach ▼
+		local _callback = function()
+			count += 1
+		end
+		for _k, _v in _exp do
+			_callback(_v, _k, _exp)
+		end
+		-- ▲ ReadonlyMap.forEach ▲
+		return count
+	end
+	function TraceManager:startTrace(traceName, options)
+		if not self._config:isEnabled() then
+			return nil
+		end
+		self:_cleanupExpired()
+		if self:getActiveCount() >= MAX_ACTIVE_TRACES then
+			warn(`[RoSentry] Max active traces reached ({MAX_ACTIVE_TRACES}). Cannot start new trace.`)
+			return nil
+		end
+		local opts = options or {}
+		local now = os.time()
+		local _condition = opts.maxEvents
+		if _condition == nil then
+			_condition = DEFAULT_MAX_EVENTS
+		end
+		local maxEvents = _condition
+		local _condition_1 = opts.expiresIn
+		if _condition_1 == nil then
+			_condition_1 = DEFAULT_EXPIRES_IN
+		end
+		local expiresIn = _condition_1
+		maxEvents = math.min(maxEvents, 500)
+		expiresIn = math.min(expiresIn, 7200)
+		local traceId = HttpService:GenerateGUID(false)
+		local instance = {
+			id = traceId,
+			name = traceName,
+			status = "active",
+			eventCount = 0,
+			maxEvents = maxEvents,
+			startedAt = now,
+			expiresAt = now + expiresIn,
+			tags = opts.tags or {},
+			metadata = opts.metadata or {},
+		}
+		self._activeTraces[traceId] = instance
+		self:_debug("Started trace:", traceName, traceId, "maxEvents:", maxEvents, "expiresIn:", expiresIn)
+		return self:_createTraceInterface(instance)
+	end
+	function TraceManager:_createTraceInterface(instance)
+		local manager = self
+		local traceId = instance.id
+		local trace
+		trace = {
+			id = traceId,
+			name = instance.name,
+			log = function(message, data)
+				trace.info(message, data)
+			end,
+			debug = function(message, data)
+				manager:_logToTrace(traceId, "debug", message, data)
+			end,
+			info = function(message, data)
+				manager:_logToTrace(traceId, "info", message, data)
+			end,
+			warn = function(message, data)
+				manager:_logToTrace(traceId, "warn", message, data)
+			end,
+			error = function(message, data)
+				manager:_logToTrace(traceId, "error", message, data)
+			end,
+			isActive = function()
+				local inst = manager._activeTraces[traceId]
+				if not inst then
+					return false
+				end
+				if inst.status ~= "active" then
+					return false
+				end
+				if os.time() >= inst.expiresAt then
+					return false
+				end
+				return true
+			end,
+			finish = function(status)
+				manager:_finishTrace(traceId, status or "completed")
+			end,
+		}
+		return trace
+	end
+	function TraceManager:_logToTrace(traceId, level, message, data)
+		local __activeTraces = self._activeTraces
+		local _traceId = traceId
+		local instance = __activeTraces[_traceId]
+		if not instance then
+			self:_debug("Trace not found:", traceId)
+			return nil
+		end
+		if instance.status ~= "active" then
+			self:_debug("Trace not active:", traceId, instance.status)
+			return nil
+		end
+		if os.time() >= instance.expiresAt then
+			self:_debug("Trace expired:", traceId)
+			self:_finishTrace(traceId, "timeout")
+			return nil
+		end
+		if instance.eventCount >= instance.maxEvents then
+			self:_debug("Trace event limit reached:", traceId, instance.eventCount)
+			self:_finishTrace(traceId, "completed")
+			return nil
+		end
+		instance.eventCount += 1
+		local user = self._scope:getUser()
+		local errorData = {
+			message = message,
+			level = level,
+			stack_trace = nil,
+			user_id = if user then user.id else nil,
+			player_name = if user then user.name else nil,
+			trace_id = traceId,
+			job_id = getJobId(),
+			place_id = getPlaceId(),
+			game_version = getGameVersion(),
+			environment = self._config:get("environment"),
+			context = {
+				userData = if user then user.data else nil,
+				custom = data,
+				breadcrumbs = nil,
+				isServer = isServer(),
+				script = nil,
+				trace = {
+					id = traceId,
+					name = instance.name,
+					status = instance.status,
+					eventCount = instance.eventCount,
+					maxEvents = instance.maxEvents,
+					startedAt = isoFromUnixSeconds(instance.startedAt),
+					expiresAt = isoFromUnixSeconds(instance.expiresAt),
+					metadata = instance.metadata,
+				},
+			},
+			tags = instance.tags,
+			timestamp = getTimestamp(),
+		}
+		self._queue:push(errorData)
+		self:_debug("Logged to trace:", traceId, level, message, `({instance.eventCount}/{instance.maxEvents})`)
+	end
+	function TraceManager:_finishTrace(traceId, status)
+		local __activeTraces = self._activeTraces
+		local _traceId = traceId
+		local instance = __activeTraces[_traceId]
+		if not instance then
+			return nil
+		end
+		instance.status = status
+		self:_debug("Finished trace:", instance.name, traceId, "status:", status, "events:", instance.eventCount)
+		local user = self._scope:getUser()
+		local finishEvent = {
+			message = "trace:finish",
+			level = "debug",
+			stack_trace = nil,
+			user_id = if user then user.id else nil,
+			player_name = if user then user.name else nil,
+			trace_id = traceId,
+			job_id = getJobId(),
+			place_id = getPlaceId(),
+			game_version = getGameVersion(),
+			environment = self._config:get("environment"),
+			context = {
+				userData = if user then user.data else nil,
+				custom = {
+					__rosentry = {
+						kind = "trace_finish",
+						status = status,
+					},
+				},
+				breadcrumbs = nil,
+				isServer = isServer(),
+				script = nil,
+				trace = {
+					id = traceId,
+					name = instance.name,
+					status = status,
+					eventCount = instance.eventCount,
+					maxEvents = instance.maxEvents,
+					startedAt = isoFromUnixSeconds(instance.startedAt),
+					expiresAt = isoFromUnixSeconds(instance.expiresAt),
+					endedAt = getTimestamp(),
+					metadata = instance.metadata,
+				},
+			},
+			tags = instance.tags,
+			timestamp = getTimestamp(),
+		}
+		self._queue:push(finishEvent)
+		local __activeTraces_1 = self._activeTraces
+		local _traceId_1 = traceId
+		__activeTraces_1[_traceId_1] = nil
+	end
+	function TraceManager:getTrace(traceId)
+		local __activeTraces = self._activeTraces
+		local _traceId = traceId
+		local instance = __activeTraces[_traceId]
+		if not instance then
+			return nil
+		end
+		if instance.status ~= "active" or os.time() >= instance.expiresAt then
+			local __activeTraces_1 = self._activeTraces
+			local _traceId_1 = traceId
+			__activeTraces_1[_traceId_1] = nil
+			return nil
+		end
+		return self:_createTraceInterface(instance)
+	end
+	function TraceManager:endAllTraces(status)
+		local finalStatus = status or "completed"
+		local _exp = self._activeTraces
+		-- ▼ ReadonlyMap.forEach ▼
+		local _callback = function(instance, id)
+			self:_debug("Ending trace:", instance.name, id)
+			instance.status = finalStatus
+		end
+		for _k, _v in _exp do
+			_callback(_v, _k, _exp)
+		end
+		-- ▲ ReadonlyMap.forEach ▲
+		table.clear(self._activeTraces)
+	end
+	function TraceManager:setScope(scope)
+		self._scope = scope
+	end
+end
+return {
+	TraceManager = TraceManager,
+}

package/out/internal/Transport.d.ts

@@ -0,0 +1,13 @@
+import { Config } from "./Config";
+export declare class Transport {
+    private _config;
+    private _remoteEvent?;
+    constructor(config: Config);
+    private _debug;
+    private _getRemoteEvent;
+    setupServerRelay(): void;
+    private _sendHttp;
+    private _sendRemote;
+    send(payload: Record<string, unknown>): boolean;
+    sendAsync(payload: Record<string, unknown>): void;
+}