@quenty/influxdbclient 1.1.0-canary.347.e0dad1c.0

package/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
+
+# 1.1.0-canary.347.e0dad1c.0 (2023-03-31)
+
+
+### Features
+
+* Add InfluxDBClient package with just writing ([e0dad1c](https://github.com/Quenty/NevermoreEngine/commit/e0dad1c6044f59b3a389ed388cebbfacf2b4a7ca))

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2014-2023 James Onnen (Quenty)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,23 @@
+## InfluxDBClient
+
+<div align="center">
+  <a href="http://quenty.github.io/NevermoreEngine/">
+    <img src="https://github.com/Quenty/NevermoreEngine/actions/workflows/docs.yml/badge.svg" alt="Documentation status" />
+  </a>
+  <a href="https://discord.gg/mhtGUS8">
+    <img src="https://img.shields.io/discord/385151591524597761?color=5865F2&label=discord&logo=discord&logoColor=white" alt="Discord" />
+  </a>
+  <a href="https://github.com/Quenty/NevermoreEngine/actions">
+    <img src="https://github.com/Quenty/NevermoreEngine/actions/workflows/build.yml/badge.svg" alt="Build and release status" />
+  </a>
+</div>
+
+Provides a Roblox Lua InfluxDB client
+
+<div align="center"><a href="https://quenty.github.io/NevermoreEngine/api/InfluxDBClientUtils">View docs →</a></div>
+
+## Installation
+
+```
+npm install @quenty/influxdbclient --save
+```

package/default.project.json

@@ -0,0 +1,6 @@
+{
+  "name": "influxdbclient",
+  "tree": {
+    "$path": "src"
+  }
+}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@quenty/influxdbclient",
+  "version": "1.1.0-canary.347.e0dad1c.0",
+  "description": "Provides a Roblox Lua InfluxDB client",
+  "keywords": [
+    "Roblox",
+    "Nevermore",
+    "Lua",
+    "influxdbclient"
+  ],
+  "bugs": {
+    "url": "https://github.com/Quenty/NevermoreEngine/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Quenty/NevermoreEngine.git",
+    "directory": "src/influxdbclient/"
+  },
+  "funding": {
+    "type": "patreon",
+    "url": "https://www.patreon.com/quenty"
+  },
+  "license": "MIT",
+  "contributors": [
+    "Quenty"
+  ],
+  "dependencies": {
+    "@quenty/baseobject": "6.2.0",
+    "@quenty/httppromise": "6.5.0-canary.347.e0dad1c.0",
+    "@quenty/jsonutils": "6.4.0-canary.347.e0dad1c.0",
+    "@quenty/loader": "6.2.0",
+    "@quenty/maid": "2.5.0",
+    "@quenty/math": "2.3.0-canary.347.e0dad1c.0",
+    "@quenty/promise": "6.4.0-canary.347.e0dad1c.0",
+    "@quenty/rx": "7.8.0-canary.347.e0dad1c.0",
+    "@quenty/servicebag": "6.6.0",
+    "@quenty/signal": "2.3.0",
+    "@quenty/string": "3.1.0",
+    "@quenty/table": "3.2.0",
+    "@quenty/valueobject": "7.9.0-canary.347.e0dad1c.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "e0dad1c6044f59b3a389ed388cebbfacf2b4a7ca"
+}

package/src/Server/Config/InfluxDBClientConfigUtils.lua

@@ -0,0 +1,22 @@
+--[=[
+	@class InfluxDBClientConfigUtils
+]=]
+
+local InfluxDBClientConfigUtils = {}
+
+function InfluxDBClientConfigUtils.isClientConfig(config)
+	return type(config) == "table"
+		and type(config.url) == "string"
+		and type(config.token) == "string"
+end
+
+function InfluxDBClientConfigUtils.createClientConfig(config)
+	assert(InfluxDBClientConfigUtils.isClientConfig(config), "Bad config")
+
+	return {
+		url = config.url;
+		token = config.token;
+	}
+end
+
+return InfluxDBClientConfigUtils

package/src/Server/Config/InfluxDBPointSettings.lua

@@ -0,0 +1,47 @@
+--[=[
+	@class InfluxDBPointSettings
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local InfluxDBPointSettings = {}
+InfluxDBPointSettings.ClassName = "InfluxDBPointSettings"
+InfluxDBPointSettings.__index = InfluxDBPointSettings
+
+function InfluxDBPointSettings.new()
+	local self = setmetatable({}, InfluxDBPointSettings)
+
+	self._defaultTags = {}
+	self._convertTime = nil
+
+	return self
+end
+
+function InfluxDBPointSettings:SetDefaultTags(tags)
+	assert(type(tags) == "table", "Bad tags")
+
+	for key, value in pairs(tags) do
+		assert(type(value) == "string", "Bad value")
+		assert(type(key) == "string", "Bad key")
+	end
+
+	self._defaultTags = tags
+end
+
+
+function InfluxDBPointSettings:GetDefaultTags()
+	return self._defaultTags
+end
+
+function InfluxDBPointSettings:SetConvertTime(convertTime)
+	assert(type(convertTime) == "function", "Bad convertTime")
+
+	self._convertTime = convertTime
+end
+
+function InfluxDBPointSettings:GetConvertTime()
+	return self._convertTime
+end
+
+
+return InfluxDBPointSettings

package/src/Server/Config/InfluxDBWriteOptionUtils.lua

@@ -0,0 +1,48 @@
+--[=[
+	@class InfluxDBWriteOptionUtils
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local Table = require("Table")
+
+local InfluxDBWriteOptionUtils = {}
+
+function InfluxDBWriteOptionUtils.getDefaultOptions()
+	return InfluxDBWriteOptionUtils.createWriteOptions({
+		batchSize = 1000;
+		maxBatchBytes = 50_000_000; -- default max batch size in the cloud
+		flushIntervalSeconds = 60;
+		-- maxRetries = 5;
+		-- maxRetryTimeSeconds = 180;
+		-- maxBufferLines = 32_000;
+		-- retryJitterSeconds = 0.2;
+		-- minRetryDelaySeconds = 5;
+		-- maxRetryDelaySeconds = 125;
+		-- exponentialBase = 2;
+		-- randomRetry = true;
+	})
+end
+
+function InfluxDBWriteOptionUtils.createWriteOptions(options)
+	assert(InfluxDBWriteOptionUtils.isWriteOptions(options), "Bad options")
+
+	return Table.readonly(options)
+end
+
+function InfluxDBWriteOptionUtils.isWriteOptions(options)
+	return type(options) == "table"
+		and type(options.batchSize) == "number"
+		and type(options.maxBatchBytes) == "number"
+		and type(options.flushIntervalSeconds) == "number"
+		-- and type(options.maxRetries) == "number"
+		-- and type(options.maxRetryTimeSeconds) == "number"
+		-- and type(options.maxBufferLines) == "number"
+		-- and type(options.retryJitterSeconds) == "number"
+		-- and type(options.minRetryDelaySeconds) == "number"
+		-- and type(options.maxRetryDelaySeconds) == "number"
+		-- and type(options.exponentialBase) == "number"
+		-- and type(options.randomRetry) == "boolean"
+end
+
+return InfluxDBWriteOptionUtils

package/src/Server/InfluxDBClient.lua

@@ -0,0 +1,96 @@
+--[=[
+	@class InfluxDBClient
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local BaseObject = require("BaseObject")
+local InfluxDBClientConfigUtils = require("InfluxDBClientConfigUtils")
+local InfluxDBWriteAPI = require("InfluxDBWriteAPI")
+local ValueObject = require("ValueObject")
+local Maid = require("Maid")
+local PromiseUtils = require("PromiseUtils")
+
+local InfluxDBClient = setmetatable({}, BaseObject)
+InfluxDBClient.ClassName = "InfluxDBClient"
+InfluxDBClient.__index = InfluxDBClient
+
+function InfluxDBClient.new(clientConfig)
+	local self = setmetatable(BaseObject.new(), InfluxDBClient)
+
+	self._clientConfig = ValueObject.new(nil)
+	self._maid:GiveTask(self._clientConfig)
+
+	if clientConfig then
+		self:SetClientConfig(clientConfig)
+	end
+
+	self._writeApis = {}
+
+	return self
+end
+
+function InfluxDBClient:SetClientConfig(clientConfig)
+	assert(InfluxDBClientConfigUtils.isClientConfig(clientConfig), "Bad clientConfig")
+
+	self._clientConfig.Value = InfluxDBClientConfigUtils.createClientConfig(clientConfig)
+end
+
+function InfluxDBClient:GetWriteAPI(org, bucket, precision)
+	assert(self._clientConfig, "No self._clientConfig")
+	assert(type(org) == "string", "Bad org")
+	assert(type(bucket) == "string", "Bad bucket")
+	assert(type(precision) == "string" or precision == nil, "Bad precision")
+
+	self._writeApis[org] = self._writeApis[org] or {}
+	if self._writeApis[org][bucket] then
+		return self._writeApis[org][bucket]
+	end
+
+	local maid = Maid.new()
+
+	local writeAPI = InfluxDBWriteAPI.new(org, bucket, precision)
+	maid:GiveTask(writeAPI)
+
+	maid:GiveTask(self._clientConfig:Observe():Subscribe(function(clientConfig)
+		writeAPI:SetClientConfig(clientConfig)
+	end))
+
+	maid:GiveTask(writeAPI.Destroying:Connect(function()
+		self._maid[maid] = nil
+	end))
+
+	self._maid[maid] = maid
+
+	-- TODO: On destroy flush
+	maid:GiveTask(function()
+		if self._writeApis[org] then
+			if self._writeApis[org][bucket] == writeAPI then
+				self._writeApis[org][bucket] = nil
+			end
+		end
+	end)
+
+	self._writeApis[org][bucket] = writeAPI
+
+	-- TODO: Proxy
+	return writeAPI
+end
+
+function InfluxDBClient:PromiseFlushAll()
+	if self._flushAllPromises and self._flushAllPromises:IsPending() then
+		return self._flushAllPromises
+	end
+
+	local promises = {}
+	for _, bucketList in pairs(self._writeApis) do
+		for _, writeAPI in pairs(bucketList) do
+			table.insert(promises, writeAPI:PromiseFlush())
+		end
+	end
+
+	self._flushAllPromises = PromiseUtils.all(promises)
+	return self._flushAllPromises
+end
+
+return InfluxDBClient

package/src/Server/InfluxDBClient.story.lua

@@ -0,0 +1,54 @@
+--[[
+	@class InfluxDBClient.story
+]]
+
+local require = require(game:GetService("ServerScriptService"):FindFirstChild("LoaderUtils", true).Parent).load(script)
+
+local Maid = require("Maid")
+local ServiceBag = require("ServiceBag")
+local InfluxDBClient = require("InfluxDBClient")
+local InfluxDBPoint = require("InfluxDBPoint")
+local InfluxDBClientConfigUtils = require("InfluxDBClientConfigUtils")
+
+return function(_target)
+	local maid = Maid.new()
+	local serviceBag = ServiceBag.new()
+	maid:GiveTask(serviceBag)
+
+	local config = InfluxDBClientConfigUtils.createClientConfig({
+		url = "https://ingest.robloxanalytics.com/";
+		token = "test-api-key";
+	})
+
+	local influxDBClient = InfluxDBClient.new(config)
+	maid:GiveTask(function()
+		influxDBClient:PromiseFlushAll():Finally(function()
+			influxDBClient:Destroy()
+		end)
+	end)
+
+	local writeAPI = influxDBClient:GetWriteAPI("studio-koi-koi", "initial-bucket")
+	writeAPI:SetPrintDebugWriteEnabled(true)
+
+	local point = InfluxDBPoint.new("test")
+	point:AddTag("game_name", "boxing")
+	point:AddTag("game_id", tostring(game.GameId))
+	point:AddTag("place_id", tostring(game.PlaceId))
+	point:AddStringField("username", "Quenty")
+	point:AddIntField("userid", 4397833)
+	point:AddFloatField("fps", 30 + math.random()*30)
+	point:AddBooleanField("is_alive", true)
+	point:AddBooleanField("is_silent", false)
+
+	writeAPI:QueuePoint(point)
+
+	maid:GiveTask(writeAPI.RequestFinished:Connect(function(response)
+		print("Got response", response)
+	end))
+
+	writeAPI:PromiseFlush()
+
+	return function()
+		maid:DoCleaning()
+	end
+end

package/src/Server/Utils/InfluxDBErrorUtils.lua

@@ -0,0 +1,30 @@
+--[=[
+	@class InfluxDBErrorUtils
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local JSONUtils = require("JSONUtils")
+
+local InfluxDBErrorUtils = {}
+
+function InfluxDBErrorUtils.tryParseErrorBody(body)
+	local ok, decoded, _err = JSONUtils.jsonDecode(body)
+	if not ok then
+		return nil
+	end
+
+	if InfluxDBErrorUtils.isInfluxDBError(decoded) then
+		return decoded
+	else
+		return nil
+	end
+end
+
+function InfluxDBErrorUtils.isInfluxDBError(data)
+	return type(data) == "table"
+		and type(data.code) == "string"
+		and type(data.message) == "string"
+end
+
+return InfluxDBErrorUtils

package/src/Server/Write/InfluxDBWriteAPI.lua

@@ -0,0 +1,191 @@
+--[=[
+	@class InfluxDBWriteAPI
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local BaseObject = require("BaseObject")
+local HttpPromise = require("HttpPromise")
+local InfluxDBClientConfigUtils = require("InfluxDBClientConfigUtils")
+local InfluxDBPoint = require("InfluxDBPoint")
+local InfluxDBPointSettings = require("InfluxDBPointSettings")
+local InfluxDBWriteBuffer = require("InfluxDBWriteBuffer")
+local InfluxDBWriteOptionUtils = require("InfluxDBWriteOptionUtils")
+local Promise = require("Promise")
+local Signal = require("Signal")
+local ValueObject = require("ValueObject")
+local InfluxDBErrorUtils = require("InfluxDBErrorUtils")
+
+local InfluxDBWriteAPI = setmetatable({}, BaseObject)
+InfluxDBWriteAPI.ClassName = "InfluxDBWriteAPI"
+InfluxDBWriteAPI.__index = InfluxDBWriteAPI
+
+function InfluxDBWriteAPI.new(org, bucket, precision)
+	local self = setmetatable(BaseObject.new(), InfluxDBWriteAPI)
+
+	assert(type(org) == "string", "Bad org")
+	assert(type(bucket) == "string", "Bad bucket")
+	assert(type(precision) == "string" or precision == nil, "Bad precision")
+
+	self._clientConfig = ValueObject.new(nil)
+	self._maid:GiveTask(self._clientConfig)
+
+	self._printDebugWriteEnabled = false
+	self._org = org
+	self._bucket = bucket
+	self._precision = precision or "ms" -- we can default to ns in the future
+
+	self._pointSettings = InfluxDBPointSettings.new()
+	self._writeOptions = InfluxDBWriteOptionUtils.getDefaultOptions()
+
+	self.RequestFinished = Signal.new()
+	self._maid:GiveTask(self.RequestFinished)
+
+	self.Destroying = Signal.new()
+	self._maid:GiveTask(function()
+		self.Destroying:Fire()
+		self.Destroying:Destroy()
+	end)
+
+	self._writeBuffer = InfluxDBWriteBuffer.new(self._writeOptions, function(toSend)
+		return self:_promiseSendBatch(toSend)
+	end)
+	self._maid:GiveTask(self._writeBuffer)
+
+	return self
+end
+
+function InfluxDBWriteAPI:SetPrintDebugWriteEnabled(printDebugEnabled)
+	assert(type(printDebugEnabled) == "boolean", "Bad printDebugEnabled")
+
+	self._printDebugWriteEnabled = printDebugEnabled
+end
+
+function InfluxDBWriteAPI:SetClientConfig(clientConfig)
+	assert(InfluxDBClientConfigUtils.isClientConfig(clientConfig), "Bad clientConfig")
+
+	self._clientConfig.Value = InfluxDBClientConfigUtils.createClientConfig(clientConfig)
+end
+
+function InfluxDBWriteAPI:SetDefaultTags(tags)
+	self._pointSettings:SetDefaultTags(tags)
+end
+
+function InfluxDBWriteAPI:SetConvertTime(convertTime)
+	self._pointSettings:SetConvertTime(convertTime)
+end
+
+function InfluxDBWriteAPI:QueuePoint(point)
+	assert(InfluxDBPoint.isInfluxDBPoint(point), "Bad point")
+
+	local line = point:ToLineProtocol(self._pointSettings)
+	if line then
+		self._writeBuffer:Add(line)
+	end
+
+	if self._printDebugWriteEnabled then
+		print(string.format("[InfluxDBWriteAPI.QueuePoint] - Queueing '%s'", line))
+	end
+end
+
+function InfluxDBWriteAPI:QueuePoints(points)
+	assert(type(points) == "table", "Bad points")
+
+	for _, point in pairs(points) do
+		assert(InfluxDBPoint.isInfluxDBPoint(point), "Bad point")
+
+		local line = point:ToLineProtocol(self._pointSettings)
+		if line then
+			self._writeBuffer:Add(line)
+		end
+
+		if self._printDebugWriteEnabled then
+			print(string.format("[InfluxDBWriteAPI.QueuePoints] - Queueing '%s'", line))
+		end
+	end
+end
+
+function InfluxDBWriteAPI:_promiseSendBatch(toSend)
+	assert(type(toSend) == "table", "Bad toSend")
+
+	local clientConfig = self._clientConfig.Value
+	if not clientConfig then
+		return Promise.rejected("No client configuration")
+	end
+
+	assert(type(clientConfig.token) == "string" and #clientConfig.token > 0, "Bad clientConfig.token")
+
+	local body = table.concat(toSend, "\n")
+	local request = {
+		Method = "POST";
+		Headers = {
+			["Content-Type"] = "application/json";
+			["Accept"] = "application/json";
+			["Authorization"] = "Token " .. clientConfig.token;
+		};
+		Url = self:_getWriteUrl();
+		Body = body;
+	}
+
+	if self._printDebugWriteEnabled then
+		print(string.format("[InfluxDBWriteAPI._promiseSendBatch] - Sending data %s", body))
+	end
+
+	return self._maid:GivePromise(HttpPromise.request(request))
+		:Then(function(result)
+			if result.Success then
+				self.RequestFinished:Fire(result)
+				return true
+			else
+				return Promise.rejected(result)
+			end
+		end)
+		:Catch(function(err)
+			self.RequestFinished:Fire(err)
+
+			if HttpPromise.isHttpResponse(err) then
+				local errorBody = InfluxDBErrorUtils.tryParseErrorBody(err.Body)
+
+				if errorBody then
+					local message = string.format("[InfluxDBWriteAPI:QueuePoint] - %d: %s - %s",
+						err.StatusCode,
+						errorBody.code,
+						errorBody.message)
+					warn(message)
+
+					return Promise.rejected(errorBody)
+				end
+
+				warn(string.format("[InfluxDBWriteAPI:QueuePoint] - %d: %s - %s",
+					err.StatusCode,
+					err.StatusMessage,
+					tostring(err.Body)))
+
+				return Promise.rejected(string.format("[InfluxDBWriteAPI:QueuePoint] - %d: %s", err.StatusCode, err.StatusMessage))
+			else
+				return Promise.rejected(err or "Request got cancelled")
+			end
+		end)
+end
+
+function InfluxDBWriteAPI:PromiseFlush()
+	return self._writeBuffer:PromiseFlush()
+end
+
+function InfluxDBWriteAPI:_getWriteUrl()
+	local config = self._clientConfig.Value
+	local url = config.url
+
+	assert(type(url) == "string", "Bad url")
+
+	-- escape trailing slashes
+	url = string.match(url, "(.-)[\\/]*$")
+
+	return string.format("%s/api/v2/write?org=%s&bucket=%s&precision=%s",
+		url,
+		self._org,
+		self._bucket,
+		self._precision)
+end
+
+return InfluxDBWriteAPI

package/src/Server/Write/InfluxDBWriteBuffer.lua

@@ -0,0 +1,94 @@
+--[=[
+	@class InfluxDBWriteBuffer
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local BaseObject = require("BaseObject")
+local Promise = require("Promise")
+local Signal = require("Signal")
+
+local InfluxDBWriteBuffer = setmetatable({}, BaseObject)
+InfluxDBWriteBuffer.ClassName = "InfluxDBWriteBuffer"
+InfluxDBWriteBuffer.__index = InfluxDBWriteBuffer
+
+function InfluxDBWriteBuffer.new(writeOptions, promiseHandleFlush)
+	local self = setmetatable(BaseObject.new(), InfluxDBWriteBuffer)
+
+	self._writeOptions = assert(writeOptions, "Bad writeOptions")
+	self._promiseHandleFlush = assert(promiseHandleFlush, "No promiseHandleFlush")
+
+	self._entries = {}
+	self._bytes = 0
+	self._length = 0
+
+	self._requestQueueNext = Signal.new()
+	self._maid:GiveTask(self._requestQueueNext)
+
+
+	return self
+end
+
+function InfluxDBWriteBuffer:Add(entry)
+	assert(type(entry) == "string", "Bad entry")
+
+
+	-- Already overflowing
+	if self._bytes + #entry + 1 >= self._writeOptions.maxBatchBytes then
+		self:_promiseFlushAll()
+	end
+
+	table.insert(self._entries, entry)
+
+	self._bytes = self._bytes + #entry + 1
+	self._length = self._length + 1
+
+	if self._length >= self._writeOptions.batchSize
+		or self._bytes >= self._writeOptions.maxBatchBytes then
+
+		self:_promiseFlushAll()
+	else
+		self:_queueNextSend()
+	end
+end
+
+function InfluxDBWriteBuffer:_queueNextSend()
+	if self._maid._queuedSendTask then
+		return
+	end
+
+	self._maid._queuedSendTask = task.delay(self._writeOptions.flushIntervalSeconds, function()
+		task.defer(function()
+			if self.Destroy then
+				self:_promiseFlushAll()
+			end
+		end)
+	end)
+end
+
+function InfluxDBWriteBuffer:_reset()
+	local entries = self._entries
+
+	self._bytes = 0
+	self._length = 0
+	self._entries = {}
+
+	return entries
+end
+
+function InfluxDBWriteBuffer:_promiseFlushAll()
+	self._maid._queuedSendTask = nil
+
+	local entries = self:_reset()
+	if #entries > 0 then
+		return self._promiseHandleFlush(entries)
+	else
+		return Promise.resolved()
+	end
+end
+
+function InfluxDBWriteBuffer:PromiseFlush()
+	return self:_promiseFlushAll()
+end
+
+return InfluxDBWriteBuffer

package/src/Shared/Utils/InfluxDBEscapeUtils.lua

@@ -0,0 +1,79 @@
+--[=[
+	@class InfluxDBEscapeUtils
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local InfluxDBEscapeUtils = {}
+
+local function gsubEscpae(str)
+	return str:gsub('%%', '%%%%')
+		:gsub('^%^', '%%^')
+		:gsub('%$$', '%%$')
+		:gsub('%(', '%%(')
+		:gsub('%)', '%%)')
+		:gsub('%.', '%%.')
+		:gsub('%[', '%%[')
+		:gsub('%]', '%%]')
+		:gsub('%*', '%%*')
+		:gsub('%+', '%%+')
+		:gsub('%-', '%%-')
+		:gsub('%?', '%%?')
+end
+
+function InfluxDBEscapeUtils.createEscaper(subTable)
+	assert(type(subTable) == "table", "Bad subTable")
+
+	local function replace(char)
+		return subTable[char]
+	end
+
+	local gsubStr = "(["
+	for char, _ in pairs(subTable) do
+		assert(#char == 1, "Bad char")
+
+		gsubStr = gsubStr .. gsubEscpae(char)
+	end
+	gsubStr = gsubStr .. "])"
+
+	return function(str)
+		return string.gsub(str, gsubStr, replace)
+	end
+end
+
+function InfluxDBEscapeUtils.createQuotedEscaper(subTable)
+	assert(type(subTable) == "table", "Bad subTable")
+
+	local escaper = InfluxDBEscapeUtils.createEscaper(subTable)
+
+	return function(str)
+		return string.format("\"%s\"", escaper(str))
+	end
+end
+
+
+InfluxDBEscapeUtils.measurement = InfluxDBEscapeUtils.createEscaper({
+	[","] = "\\,";
+	[" "] = "\\ ";
+	["\n"] = "\\n";
+	["\r"] = "\\r";
+	["\t"] = "\\t";
+	["\\"] = "\\\\"; -- not sure about this, is this part of spec?
+})
+
+InfluxDBEscapeUtils.quoted = InfluxDBEscapeUtils.createQuotedEscaper({
+	["\""] = "\\\"";
+	["\\"] = "\\\\";
+})
+
+InfluxDBEscapeUtils.tag = InfluxDBEscapeUtils.createEscaper({
+	[","] = "\\,";
+	[" "] = "\\ ";
+	["="] = "\\=";
+	["\n"] = "\\n";
+	["\r"] = "\\r";
+	["\t"] = "\\t";
+	["\\"] = "\\\\"; -- not sure about this, is this part of spec?
+})
+
+return InfluxDBEscapeUtils

package/src/Shared/Utils/InfluxDBEscapeUtils.spec.lua

@@ -0,0 +1,51 @@
+--[[
+	@class InfluxDBEscapeUtils.spec.lua
+]]
+
+local require = require(game:GetService("ServerScriptService"):FindFirstChild("LoaderUtils", true).Parent).load(script)
+
+local InfluxDBEscapeUtils = require("InfluxDBEscapeUtils")
+
+return function()
+	describe("InfluxDBEscapeUtils.measurement", function()
+		it("should pass through fine", function()
+			expect(InfluxDBEscapeUtils.measurement("hi")).to.equal("hi")
+		end)
+
+		it("should escape tabs", function()
+			expect(InfluxDBEscapeUtils.measurement("\thi")).to.equal("\\thi")
+		end)
+	end)
+
+	describe("InfluxDBEscapeUtils.quoted", function()
+		it("should pass through fine", function()
+			expect(InfluxDBEscapeUtils.quoted("hi")).to.equal("\"hi\"")
+		end)
+
+		it("should escape quotes", function()
+			expect(InfluxDBEscapeUtils.quoted("\"hi")).to.equal("\"\\\"hi\"")
+		end)
+	end)
+
+	describe("InfluxDBEscapeUtils.tag", function()
+		it("should pass through fine", function()
+			expect(InfluxDBEscapeUtils.tag("hi")).to.equal("hi")
+		end)
+
+		it("should escape tabs", function()
+			expect(InfluxDBEscapeUtils.tag("\thi")).to.equal("\\thi")
+		end)
+
+		it("should escape =", function()
+			expect(InfluxDBEscapeUtils.tag("=hi")).to.equal("\\=hi")
+		end)
+
+		it("should escape = and \\", function()
+			expect(InfluxDBEscapeUtils.tag("\\=hi")).to.equal("\\\\\\=hi")
+		end)
+
+		it("should escape \\n", function()
+			expect(InfluxDBEscapeUtils.tag("\nhi")).to.equal("\\nhi")
+		end)
+	end)
+end

package/src/Shared/Write/InfluxDBPoint.lua

@@ -0,0 +1,257 @@
+--[=[
+	@class InfluxDBPoint
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local Math = require("Math")
+local InfluxDBEscapeUtils = require("InfluxDBEscapeUtils")
+local Table = require("Table")
+local Set = require("Set")
+
+local InfluxDBPoint = {}
+InfluxDBPoint.ClassName = "InfluxDBPoint"
+InfluxDBPoint.__index = InfluxDBPoint
+
+function InfluxDBPoint.new(measurementName)
+	local self = setmetatable({}, InfluxDBPoint)
+
+	assert(type(measurementName) == "string" or measurementName == nil, "Bad measurementName")
+
+	self._measurementName = measurementName
+	self._timestamp = nil
+	self._tags = {}
+	self._fields = {}
+
+	return self
+end
+
+function InfluxDBPoint.fromTableData(data)
+	assert(type(data) == "table", "Bad data")
+
+	local copy = InfluxDBPoint.new(data.measurementName)
+	copy:SetTimestamp(data.timestamp)
+
+	if data.tags then
+		copy._tags = data.tags
+	end
+	if data.fields then
+		copy._fields = data.fields
+	end
+
+	return copy
+end
+
+function InfluxDBPoint.isInfluxDBPoint(point)
+	return type(point) == "table"
+		and getmetatable(point) == InfluxDBPoint
+end
+
+function InfluxDBPoint:SetMeasurement(name)
+	assert(type(name) == "string" or name == nil, "Bad name")
+
+	self._measurementName = name
+end
+
+function InfluxDBPoint:ToTableData()
+	return {
+		measurementName = self._measurementName;
+		timestamp = self._timestamp;
+		tags = table.clone(self._tags);
+		fields = table.clone(self._fields);
+	}
+end
+
+--[=[
+	If it's nil, the timestamp defaults to send time
+
+	@param timestamp DateTime | nil
+]=]
+function InfluxDBPoint:SetTimestamp(timestamp)
+	assert(typeof(timestamp) == "DateTime" or timestamp == nil, "Bad timestamp")
+
+	self._timestamp = timestamp
+end
+
+--[=[
+	Tags are indexed, whereas fields are not.
+
+	@param tagKey string
+	@param tagValue string
+]=]
+function InfluxDBPoint:AddTag(tagKey, tagValue)
+	assert(type(tagKey) == "string", "Bad tagKey")
+	assert(type(tagValue) == "string", "Bad tagValue")
+
+	self._tags[tagKey] = tagValue
+end
+
+--[=[
+	Adds an int field
+
+	@param fieldName string
+	@param value number
+]=]
+function InfluxDBPoint:AddIntField(fieldName, value)
+	assert(type(fieldName) == "string", "Bad fieldName")
+	assert(type(value) == "number", "Bad value")
+
+	if Math.isNaN(value)
+		or value <= -9223372036854776e3
+		or value >= 9223372036854776e3 then
+		error(string.format("invalid integer value for field '%s': %s", fieldName, value))
+	end
+
+	if not Math.isFinite(value) then
+		error(string.format("invalid integer value for field '%s': %s", fieldName, value))
+	end
+
+	self._fields[fieldName] = string.format("%di", value)
+end
+
+--[=[
+	Adds a uint field
+
+	@param fieldName string
+	@param value number
+]=]
+function InfluxDBPoint:AddUintField(fieldName, value)
+	assert(type(fieldName) == "string", "Bad fieldName")
+	assert(type(value) == "number", "Bad value")
+
+	if Math.isNaN(value)
+		or value < 0
+		or value >= 9007199254740991 then
+		error(string.format("invalid uint value for field '%s': %s", fieldName, value))
+	end
+
+	if not Math.isFinite(value) then
+		error(string.format("invalid uint value for field '%s': %s", fieldName, value))
+	end
+
+	-- TODO: Support larger uint sizes
+	self._fields[fieldName] = string.format("%du", value)
+end
+
+--[=[
+	Adds a float field
+
+	@param fieldName string
+	@param value number
+]=]
+function InfluxDBPoint:AddFloatField(fieldName, value)
+	assert(type(fieldName) == "string", "Bad fieldName")
+	assert(type(value) == "number", "Bad value")
+
+	if not Math.isFinite(value) then
+		error(string.format("invalid float value for field '%s': %s", fieldName, value))
+	end
+
+	self._fields[fieldName] = tostring(value)
+end
+
+--[=[
+	Adds a boolean field
+
+	@param fieldName string
+	@param value boolean
+]=]
+function InfluxDBPoint:AddBooleanField(fieldName, value)
+	assert(type(fieldName) == "string", "Bad fieldName")
+	assert(type(value) == "boolean", "Bad value")
+
+	self._fields[fieldName] = value and "T" or "F"
+end
+
+--[=[
+	Adds a string field
+
+	@param fieldName string
+	@param value string
+]=]
+function InfluxDBPoint:AddStringField(fieldName, value)
+	assert(type(fieldName) == "string", "Bad fieldName")
+	assert(type(value) == "string", "Bad value")
+
+	self._fields[fieldName] = InfluxDBEscapeUtils.quoted(value)
+end
+
+function InfluxDBPoint:ToLineProtocol(pointSettings)
+	if not self._measurementName then
+		return nil
+	end
+
+	local fieldKeys = Table.keys(self._fields)
+	table.sort(fieldKeys)
+
+	local fields = {}
+	for _, key in pairs(fieldKeys) do
+		local value = self._fields[key]
+		table.insert(fields, InfluxDBEscapeUtils.tag(key) .. "=" .. value)
+	end
+
+	-- No fields
+	if #fields == 0 then
+		warn("[InfluxDBPoint] - Cannot transform point without fields")
+		return nil
+	end
+
+	local tags = nil
+
+	local defaultTags = pointSettings:GetDefaultTags()
+	if next(defaultTags) or next(self._tags) then
+		local tagKeysSet = {}
+
+		for key, value in pairs(self._tags) do
+			tagKeysSet[key] = value
+		end
+		for key, value in pairs(defaultTags) do
+			tagKeysSet[key] = value
+		end
+		local tagKeys = Set.toList(tagKeysSet)
+		table.sort(tagKeys)
+
+		tags = {}
+		for _, key in pairs(tagKeys) do
+			local value = self._tags[key] or defaultTags[key]
+			table.insert(tags, InfluxDBEscapeUtils.tag(key) .. "=" .. InfluxDBEscapeUtils.tag(value))
+		end
+	end
+
+	local timestamp = self._timestamp
+	local convertTime = pointSettings:GetConvertTime()
+	if convertTime then
+		timestamp = convertTime(timestamp)
+	else
+		timestamp = self:_convertTimeToMillis(timestamp)
+	end
+
+	local tagsContent
+	if tags then
+		tagsContent = "," .. table.concat(tags, ",")
+	else
+		tagsContent = ""
+	end
+
+	return InfluxDBEscapeUtils.measurement(self._measurementName) .. tagsContent .. " " .. table.concat(fields, ",") .. " " .. timestamp
+end
+
+function InfluxDBPoint:_convertTimeToMillis(value)
+	if value == nil then
+	    return tostring(DateTime.now().UnixTimestampMillis)
+	elseif type(value) == "string" then
+		if #value > 0 then
+			return value
+		else
+			return nil
+		end
+	elseif typeof(value) == "DateTime" then
+		return tostring(value.UnixTimestampMillis)
+	elseif typeof(value) == "number" then
+		return string.format("%0d", value)
+	else
+		return tostring(value)
+	end
+end
+
+return InfluxDBPoint

package/src/node_modules.project.json

@@ -0,0 +1,7 @@
+{
+  "name": "node_modules",
+  "globIgnorePaths": [ "**/.package-lock.json" ],
+  "tree": {
+    "$path": { "optional": "../node_modules" }
+  }
+}

package/test/default.project.json

@@ -0,0 +1,14 @@
+{
+  "name": "InfluxDBClientTest",
+  "tree": {
+    "$className": "DataModel",
+    "ServerScriptService": {
+      "influxdbclient": {
+        "$path": ".."
+      },
+      "Script": {
+        "$path": "scripts/Server"
+      }
+    }
+  }
+}

package/test/scripts/Server/ServerMain.server.lua

@@ -0,0 +1,10 @@
+--[[
+	@class ServerMain
+]]
+
+local ServerScriptService = game:GetService("ServerScriptService")
+
+local loader = ServerScriptService:FindFirstChild("LoaderUtils", true).Parent
+local packages = require(loader).bootstrapGame(ServerScriptService.influxdbclient)
+
+require(packages.InfluxDBClient)