RubyGems - itsi-server - Versions diffs - 0.1.1 → 0.1.18 - Mend

itsi-server 0.1.1 → 0.1.18

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (184) hide show

data/ext/itsi_server/src/default_responses/html/504.html ADDED Viewed

@@ -0,0 +1,69 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Gateway Timeout</title>
+    <style>
+      :root {
+        --bg-color: #f0f2f5;
+        --text-color: #333;
+        --accent-color: #0052cc;
+        --link-color: #0052cc;
+      }
+      body {
+        margin: 0;
+        font-family: "Helvetica Neue", Arial, sans-serif;
+        background: var(--bg-color);
+        color: var(--text-color);
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        min-height: 100vh;
+        padding: 2rem;
+      }
+      .error-container {
+        text-align: center;
+        max-width: 800px;
+        width: 100%;
+      }
+      h1 {
+        font-size: 5rem;
+        font-weight: 300;
+        margin-bottom: 0.5rem;
+      }
+      p {
+        font-size: 1.5rem;
+        line-height: 1.6;
+        margin-bottom: 2rem;
+      }
+      a {
+        font-size: 1rem;
+        text-decoration: none;
+        color: var(--link-color);
+        border-bottom: 1px solid transparent;
+        transition: border-color 0.2s ease-in-out;
+      }
+      a:hover {
+        border-color: var(--link-color);
+      }
+      @media (max-width: 480px) {
+        h1 {
+          font-size: 3.5rem;
+        }
+        p {
+          font-size: 1.2rem;
+        }
+      }
+    </style>
+  </head>
+  <body>
+    <div class="error-container">
+      <h1>504</h1>
+      <p>The service did not respond within the expected time frame.</p>
+      <p>Please try again later.</p>
+      <p><a href="/">Return Home</a></p>
+      <p><a href="javascript:history.back()">Go Back</a></p>
+    </div>
+  </body>
+</html>

data/ext/itsi_server/src/default_responses/html/index.html ADDED Viewed

@@ -0,0 +1,238 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>{{title}}</title>
+    <style>
+      :root {
+        --bg-color: #f0f2f5;
+        --text-color: #333;
+        --link-color: #0052cc;
+        --accent-color: #0052cc;
+      }
+      * {
+        box-sizing: border-box;
+      }
+      body {
+        margin: 0;
+        font-family: "Helvetica Neue", Arial, sans-serif;
+        background: var(--bg-color);
+        color: var(--text-color);
+        padding: 2rem;
+      }
+      h1 {
+        font-size: 2.5rem;
+        margin-bottom: 1rem;
+        text-align: center;
+      }
+      table {
+        width: 100%;
+        border-collapse: collapse;
+        margin-top: 1rem;
+      }
+      th,
+      td {
+        padding: 0.5rem;
+        text-align: left;
+      }
+      tr:nth-child(even) {
+        background-color: #e9ecef;
+      }
+      th {
+        border-bottom: 2px solid #ccc;
+        position: relative;
+        cursor: pointer;
+      }
+      /* Sorted header arrow */
+      th .sort-arrow {
+        font-size: 0.8rem;
+        display: none;
+      }
+      th.sorted .sort-arrow {
+        display: inline;
+      }
+      a {
+        color: var(--link-color);
+        text-decoration: none;
+      }
+      a:hover {
+        text-decoration: underline;
+      }
+      .size {
+        text-align: right;
+      }
+      .date {
+        white-space: nowrap;
+      }
+      footer {
+        margin-top: 2rem;
+        text-align: center;
+        font-size: 0.9rem;
+        color: #555;
+      }
+      th.name-header > span {
+        display: inline-block;
+        width: 100%;
+      }
+      th.name-header input {
+        margin-top: 0.3rem;
+        font-size: 0.8rem;
+        width: 100%;
+        max-width: 200px;
+        border: 1px solid #ccc;
+        background: none;
+        border-radius: 12px;
+        padding: 5px 15px;
+      }
+      /* Responsive adjustments */
+      @media (max-width: 480px) {
+        h1 {
+          font-size: 2.5rem;
+        }
+        th,
+        td {
+          padding: 0.4rem;
+        }
+        th {
+          vertical-align: top;
+        }
+        th.name-header input {
+          max-width: 150px;
+          font-size: 0.75rem;
+        }
+      }
+    </style>
+  </head>
+  <body>
+    <h1>Directory listing for {{directory}}</h1>
+    <table data-sort-asc="true" data-sorted-column="0">
+      <thead>
+        <tr>
+          <th data-type="text" data-column="0" class="name-header">
+            <span>Name <span class="sort-arrow">▲</span></span>
+            <input type="text" id="nameFilter" placeholder="Filter names" />
+          </th>
+          <th data-type="size" data-column="1">
+            Size <span class="sort-arrow"></span>
+          </th>
+          <th data-type="text" data-column="2">
+            Last Modified <span class="sort-arrow"></span>
+          </th>
+        </tr>
+      </thead>
+      <tbody>
+        {{rows}}
+      </tbody>
+    </table>
+    <footer>
+      <p>Served by Itsi Static Assets</p>
+    </footer>
+    <script>
+      document.addEventListener("DOMContentLoaded", function () {
+        const table = document.querySelector("table");
+        const headers = table.querySelectorAll("th");
+        const nameFilter = document.getElementById("nameFilter");
+        let currentSortedColumn = 0;
+        let ascending = true;
+        // Add sorting listeners
+        headers.forEach((header, index) => {
+          header.addEventListener("click", function (e) {
+            // Prevent clicks on the filter input from triggering a sort.
+            if (e.target.tagName.toLowerCase() === "input") return;
+            sortTable(index);
+            updateSortArrows(index, ascending);
+          });
+        });
+        // Filter rows as the user types.
+        nameFilter.addEventListener("input", function () {
+          filterTable(this.value);
+        });
+        function sortTable(columnIndex) {
+          const tbody = table.querySelector("tbody");
+          let rows = Array.from(tbody.querySelectorAll("tr"));
+          // If sorting on a new column, default to ascending.
+          if (currentSortedColumn !== columnIndex) {
+            ascending = true;
+            currentSortedColumn = columnIndex;
+          } else {
+            ascending = !ascending;
+          }
+          rows.sort((a, b) => {
+            let aText = a.cells[columnIndex].textContent.trim().toLowerCase();
+            let bText = b.cells[columnIndex].textContent.trim().toLowerCase();
+            // If sorting the file size column, convert sizes to bytes.
+            if (headers[columnIndex].getAttribute("data-type") === "size") {
+              aText = parseSize(aText);
+              bText = parseSize(bText);
+            }
+            if (aText < bText) return ascending ? -1 : 1;
+            if (aText > bText) return ascending ? 1 : -1;
+            return 0;
+          });
+          rows.forEach((row) => tbody.appendChild(row));
+          table.setAttribute("data-sort-asc", ascending.toString());
+          table.setAttribute("data-sorted-column", columnIndex.toString());
+        }
+        function updateSortArrows(sortedIndex, ascending) {
+          headers.forEach((header, index) => {
+            header.classList.remove("sorted");
+            const arrow = header.querySelector(".sort-arrow");
+            if (index === sortedIndex) {
+              header.classList.add("sorted");
+              arrow.textContent = ascending ? "▲" : "▼";
+            } else {
+              arrow.textContent = "";
+            }
+          });
+        }
+        function filterTable(filterValue) {
+          const tbody = table.querySelector("tbody");
+          const rows = Array.from(tbody.querySelectorAll("tr"));
+          const lowerFilter = filterValue.toLowerCase();
+          rows.forEach((row) => {
+            const nameCell = row.cells[0];
+            row.style.display = nameCell.textContent
+              .toLowerCase()
+              .includes(lowerFilter)
+              ? ""
+              : "none";
+          });
+        }
+        // Parse file size string (e.g., "12.3 KB") into a number (bytes)
+        function parseSize(sizeStr) {
+          sizeStr = sizeStr.trim();
+          if (sizeStr === "-" || sizeStr === "") return 0;
+          const parts = sizeStr.split(" ");
+          if (parts.length < 2) return parseFloat(parts[0]);
+          const value = parseFloat(parts[0]);
+          const unit = parts[1].toLowerCase();
+          switch (unit) {
+            case "b":
+              return value;
+            case "kb":
+              return value * 1024;
+            case "mb":
+              return value * 1024 * 1024;
+            case "gb":
+              return value * 1024 * 1024 * 1024;
+            default:
+              return value;
+          }
+        }
+      });
+    </script>
+  </body>
+</html>

data/ext/itsi_server/src/default_responses/json/401.json ADDED Viewed

@@ -0,0 +1,6 @@
+{
+  "error": "Unauthorized",
+  "message": "You are not authorized to access this resource.",
+  "code": 401,
+  "status": "error"
+}

data/ext/itsi_server/src/default_responses/json/403.json ADDED Viewed

@@ -0,0 +1,6 @@
+{
+  "error": "Forbidden",
+  "message": "You are forbidden to access this resource.",
+  "code": 403,
+  "status": "error"
+}

data/ext/itsi_server/src/default_responses/json/404.json ADDED Viewed

@@ -0,0 +1,6 @@
+{
+  "error": "Not Found",
+  "message": "The requested resource could not be found.",
+  "code": 404,
+  "status": "error"
+}

data/ext/itsi_server/src/default_responses/json/413.json ADDED Viewed

@@ -0,0 +1,6 @@
+{
+  "error": "Payload Too Large",
+  "message": "The request entity is larger than the server is willing or able to process.",
+  "code": 413,
+  "status": "error"
+}

data/ext/itsi_server/src/default_responses/json/429.json ADDED Viewed

@@ -0,0 +1,6 @@
+{
+  "error": "Too Many Requests",
+  "message": "Too many requests within a limited time frame.",
+  "code": 429,
+  "status": "error"
+}

data/ext/itsi_server/src/default_responses/json/500.json ADDED Viewed

@@ -0,0 +1,6 @@
+{
+  "error": "Internal Server Error",
+  "message": "The server encountered an unexpected condition that prevented it from fulfilling the request.",
+  "code": 500,
+  "status": "error"
+}

data/ext/itsi_server/src/default_responses/json/502.json ADDED Viewed

@@ -0,0 +1,6 @@
+{
+  "error": "Bad Gateway",
+  "message": "The server was acting as a gateway or proxy and received an invalid response from the upstream server.",
+  "code": 502,
+  "status": "error"
+}

data/ext/itsi_server/src/default_responses/json/503.json ADDED Viewed

@@ -0,0 +1,6 @@
+{
+  "error": "Service Unavailable",
+  "message": "The server is currently unable to handle the request.",
+  "code": 503,
+  "status": "error"
+}

data/ext/itsi_server/src/default_responses/json/504.json ADDED Viewed

@@ -0,0 +1,6 @@
+{
+  "error": "Gateway Timeout",
+  "message": "The server did not respond in time.",
+  "code": 504,
+  "status": "error"
+}

data/ext/itsi_server/src/default_responses/mod.rs ADDED Viewed

@@ -0,0 +1,11 @@
+use std::sync::LazyLock;
+use crate::server::middleware_stack::ErrorResponse;
+pub static TIMEOUT_RESPONSE: LazyLock<ErrorResponse> =
+    LazyLock::new(ErrorResponse::gateway_timeout);
+pub static NOT_FOUND_RESPONSE: LazyLock<ErrorResponse> = LazyLock::new(ErrorResponse::not_found);
+pub static INTERNAL_SERVER_ERROR_RESPONSE: LazyLock<ErrorResponse> =
+    LazyLock::new(ErrorResponse::internal_server_error);

data/ext/itsi_server/src/env.rs ADDED Viewed

@@ -0,0 +1,43 @@
+use std::{
+    env::{var, VarError},
+    path::PathBuf,
+    sync::LazyLock,
+};
+type StringVar = LazyLock<String>;
+type MaybeStringVar = LazyLock<Result<String, VarError>>;
+type PathVar = LazyLock<PathBuf>;
+/// ACME Configuration for auto-generating production certificates
+/// *ITSI_ACME_CACHE_DIR* - Directory to store cached certificates
+/// so that these are not regenerated every time the server starts
+pub static ITSI_ACME_CACHE_DIR: StringVar = LazyLock::new(|| {
+    var("ITSI_ACME_CACHE_DIR").unwrap_or_else(|_| "./.rustls_acme_cache".to_string())
+});
+/// *ITSI_ACME_CONTACT_EMAIL* - Contact Email address to provide to ACME server during certificate renewal
+pub static ITSI_ACME_CONTACT_EMAIL: MaybeStringVar =
+    LazyLock::new(|| var("ITSI_ACME_CONTACT_EMAIL"));
+/// *ITSI_ACME_CA_PEM_PATH* - Optional CA Pem path, used for testing with non-trusted CAs for certifcate generation.
+pub static ITSI_ACME_CA_PEM_PATH: MaybeStringVar = LazyLock::new(|| var("ITSI_ACME_CA_PEM_PATH"));
+/// *ITSI_ACME_DIRECTORY_URL* - Directory URL to use for ACME certificate generation.
+pub static ITSI_ACME_DIRECTORY_URL: StringVar = LazyLock::new(|| {
+    var("ITSI_ACME_DIRECTORY_URL")
+        .unwrap_or_else(|_| "https://acme-v02.api.letsencrypt.org/directory".to_string())
+});
+/// *ITSI_ACME_LOCK_FILE_NAME* - Name of the lock file used to prevent concurrent certificate generation.
+pub static ITSI_ACME_LOCK_FILE_NAME: StringVar =
+    LazyLock::new(|| var("ITSI_ACME_LOCK_FILE_NAME").unwrap_or(".acme.lock".to_string()));
+pub static ITSI_LOCAL_CA_DIR: PathVar = LazyLock::new(|| {
+    var("ITSI_LOCAL_CA_DIR")
+        .map(PathBuf::from)
+        .unwrap_or_else(|_| {
+            dirs::home_dir()
+                .expect("Failed to find HOME directory when initializing ITSI_LOCAL_CA_DIR")
+                .join(".itsi")
+        })
+});

data/ext/itsi_server/src/lib.rs CHANGED Viewed

@@ -1,52 +1,144 @@
-use magnus::{error::Result, function, method, value::Lazy, Module, Object, RClass, RModule, Ruby};
-use request::itsi_request::ItsiRequest;
-use server::itsi_server::Server;
-use stream_writer::StreamWriter;
-pub mod request;
+#![deny(unused_crate_dependencies)]
+pub mod default_responses;
+pub mod env;
+pub mod prelude;
+pub mod ruby_types;
 pub mod server;
-pub mod stream_writer;
-pub static ITSI_MODULE: Lazy<RModule> = Lazy::new(|ruby| ruby.define_module("Itsi").unwrap());
-pub static ITSI_SERVER: Lazy<RClass> = Lazy::new(|ruby| {
-    ruby.get_inner(&ITSI_MODULE)
-        .define_class("Server", ruby.class_object())
-        .unwrap()
-});
-pub static ITSI_REQUEST: Lazy<RClass> = Lazy::new(|ruby| {
-    ruby.get_inner(&ITSI_MODULE)
-        .define_class("Request", ruby.class_object())
-        .unwrap()
-});
-pub static ITSI_STREAM_WRITER: Lazy<RClass> = Lazy::new(|ruby| {
-    ruby.get_inner(&ITSI_MODULE)
-        .define_class("StreamWriter", ruby.class_object())
-        .unwrap()
-});
+pub mod services;
+use magnus::{error::Result, function, method, Module, Object, Ruby};
+use prelude::*;
+use ruby_types::{
+    itsi_body_proxy::ItsiBodyProxy, itsi_grpc_call::ItsiGrpcCall,
+    itsi_grpc_response_stream::ItsiGrpcResponseStream, itsi_http_request::ItsiHttpRequest,
+    itsi_http_response::ItsiHttpResponse, itsi_server::ItsiServer, ITSI_BODY_PROXY, ITSI_GRPC_CALL,
+    ITSI_GRPC_RESPONSE_STREAM, ITSI_MODULE, ITSI_REQUEST, ITSI_RESPONSE, ITSI_SERVER,
+};
+use server::signal::reset_signal_handlers;
+use services::password_hasher;
 #[magnus::init]
 fn init(ruby: &Ruby) -> Result<()> {
     itsi_tracing::init();
+    rustls::crypto::aws_lc_rs::default_provider()
+        .install_default()
+        .ok();
+    let itsi = ruby.get_inner(&ITSI_MODULE);
+    itsi.define_singleton_method("log_debug", function!(log_debug, 1))?;
+    itsi.define_singleton_method("log_info", function!(log_info, 1))?;
+    itsi.define_singleton_method("log_warn", function!(log_warn, 1))?;
+    itsi.define_singleton_method("log_error", function!(log_error, 1))?;
+    itsi.define_singleton_method(
+        "create_password_hash",
+        function!(password_hasher::create_password_hash, 2),
+    )?;
     let server = ruby.get_inner(&ITSI_SERVER);
-    server.define_singleton_method("new", function!(Server::new, -1))?;
-    server.define_method("start", method!(Server::start, 0))?;
+    server.define_singleton_method("new", function!(ItsiServer::new, 3))?;
+    server.define_singleton_method("reset_signal_handlers", function!(reset_signal_handlers, 0))?;
+    server.define_method("start", method!(ItsiServer::start, 0))?;
+    server.define_method("stop", method!(ItsiServer::stop, 0))?;
     let request = ruby.get_inner(&ITSI_REQUEST);
-    request.define_method("path", method!(ItsiRequest::path, 0))?;
-    request.define_method("script_name", method!(ItsiRequest::script_name, 0))?;
-    request.define_method("query_string", method!(ItsiRequest::query_string, 0))?;
-    request.define_method("method", method!(ItsiRequest::method, 0))?;
-    request.define_method("version", method!(ItsiRequest::version, 0))?;
-    request.define_method("rack_protocol", method!(ItsiRequest::rack_protocol, 0))?;
-    request.define_method("host", method!(ItsiRequest::host, 0))?;
-    request.define_method("headers", method!(ItsiRequest::headers, 0))?;
-    request.define_method("remote_addr", method!(ItsiRequest::remote_addr, 0))?;
-    request.define_method("port", method!(ItsiRequest::port, 0))?;
-    request.define_method("body", method!(ItsiRequest::body, 0))?;
-    let stream_writer = ruby.get_inner(&ITSI_STREAM_WRITER);
-    stream_writer.define_method("write", method!(StreamWriter::write, 1))?;
+    request.define_method("path", method!(ItsiHttpRequest::path, 0))?;
+    request.define_method("script_name", method!(ItsiHttpRequest::script_name, 0))?;
+    request.define_method("query_string", method!(ItsiHttpRequest::query_string, 0))?;
+    request.define_method(
+        "content_type",
+        method!(ItsiHttpRequest::content_type_str, 0),
+    )?;
+    request.define_method(
+        "content_length",
+        method!(ItsiHttpRequest::content_length, 0),
+    )?;
+    request.define_method("request_method", method!(ItsiHttpRequest::method, 0))?;
+    request.define_method("version", method!(ItsiHttpRequest::version, 0))?;
+    request.define_method("rack_protocol", method!(ItsiHttpRequest::rack_protocol, 0))?;
+    request.define_method("host", method!(ItsiHttpRequest::host, 0))?;
+    request.define_method("headers", method!(ItsiHttpRequest::headers, 0))?;
+    request.define_method("header", method!(ItsiHttpRequest::header, 1))?;
+    request.define_method("[]", method!(ItsiHttpRequest::header, 1))?;
+    request.define_method("scheme", method!(ItsiHttpRequest::scheme, 0))?;
+    request.define_method("remote_addr", method!(ItsiHttpRequest::remote_addr, 0))?;
+    request.define_method("port", method!(ItsiHttpRequest::port, 0))?;
+    request.define_method("body", method!(ItsiHttpRequest::body, 0))?;
+    request.define_method("response", method!(ItsiHttpRequest::response, 0))?;
+    request.define_method("json?", method!(ItsiHttpRequest::is_json, 0))?;
+    request.define_method("html?", method!(ItsiHttpRequest::is_html, 0))?;
+    request.define_method("url_encoded?", method!(ItsiHttpRequest::is_url_encoded, 0))?;
+    request.define_method("multipart?", method!(ItsiHttpRequest::is_multipart, 0))?;
+    request.define_method("url_params", method!(ItsiHttpRequest::url_params, 0))?;
+    let body_proxy = ruby.get_inner(&ITSI_BODY_PROXY);
+    body_proxy.define_method("gets", method!(ItsiBodyProxy::gets, 0))?;
+    body_proxy.define_method("each", method!(ItsiBodyProxy::each, 0))?;
+    body_proxy.define_method("read", method!(ItsiBodyProxy::read, -1))?;
+    body_proxy.define_method("close", method!(ItsiBodyProxy::close, 0))?;
+    let response = ruby.get_inner(&ITSI_RESPONSE);
+    response.define_method("[]=", method!(ItsiHttpResponse::add_header, 2))?;
+    response.define_method("add_header", method!(ItsiHttpResponse::add_header, 2))?;
+    response.define_method("add_headers", method!(ItsiHttpResponse::add_headers, 1))?;
+    response.define_method("status=", method!(ItsiHttpResponse::set_status, 1))?;
+    response.define_method("send_frame", method!(ItsiHttpResponse::send_frame, 1))?;
+    response.define_method("<<", method!(ItsiHttpResponse::send_frame, 1))?;
+    response.define_method("write", method!(ItsiHttpResponse::send_frame, 1))?;
+    response.define_method("read", method!(ItsiHttpResponse::recv_frame, 0))?;
+    response.define_method(
+        "send_and_close",
+        method!(ItsiHttpResponse::send_and_close, 1),
+    )?;
+    response.define_method("close_write", method!(ItsiHttpResponse::close_write, 0))?;
+    response.define_method("close_read", method!(ItsiHttpResponse::close_read, 0))?;
+    response.define_method("close", method!(ItsiHttpResponse::close, 0))?;
+    response.define_method("hijack", method!(ItsiHttpResponse::hijack, 1))?;
+    response.define_method("accept", method!(ItsiHttpResponse::accept_str, 0))?;
+    response.define_method("json?", method!(ItsiHttpResponse::is_json, 0))?;
+    response.define_method("html?", method!(ItsiHttpResponse::is_html, 0))?;
+    let grpc_call = ruby.get_inner(&ITSI_GRPC_CALL);
+    grpc_call.define_method("service_name", method!(ItsiGrpcCall::service_name, 0))?;
+    grpc_call.define_method("method_name", method!(ItsiGrpcCall::method_name, 0))?;
+    grpc_call.define_method("stream", method!(ItsiGrpcCall::stream, 0))?;
+    grpc_call.define_method("json?", method!(ItsiGrpcCall::is_json, 0))?;
+    grpc_call.define_method("content_type", method!(ItsiGrpcCall::content_type_str, 0))?;
+    grpc_call.define_method("timeout", method!(ItsiGrpcCall::timeout, 0))?;
+    grpc_call.define_method("cancelled?", method!(ItsiGrpcCall::is_cancelled, 0))?;
+    grpc_call.define_method("add_headers", method!(ItsiGrpcCall::add_headers, 1))?;
+    grpc_call.define_method("compress_output", method!(ItsiGrpcCall::compress_output, 1))?;
+    grpc_call.define_method(
+        "decompress_input",
+        method!(ItsiGrpcCall::decompress_input, 1),
+    )?;
+    grpc_call.define_method(
+        "should_compress_output?",
+        method!(ItsiGrpcCall::should_compress_output, 1),
+    )?;
+    let grpc_response_stream = ruby.get_inner(&ITSI_GRPC_RESPONSE_STREAM);
+    grpc_response_stream
+        .define_method("reader_fileno", method!(ItsiGrpcResponseStream::reader, 0))?;
+    grpc_response_stream.define_method("write", method!(ItsiGrpcResponseStream::write, 1))?;
+    grpc_response_stream.define_method("flush", method!(ItsiGrpcResponseStream::flush, 0))?;
+    grpc_response_stream.define_method(
+        "send_trailers",
+        method!(ItsiGrpcResponseStream::send_trailers, 1),
+    )?;
+    grpc_response_stream.define_method("close", method!(ItsiGrpcResponseStream::close, 0))?;
     Ok(())
 }
+pub fn log_debug(msg: String) {
+    debug!(msg);
+}
+pub fn log_info(msg: String) {
+    info!(msg);
+}
+pub fn log_warn(msg: String) {
+    warn!(msg);
+}
+pub fn log_error(msg: String) {
+    error!(msg);
+}

data/ext/itsi_server/src/prelude.rs ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ pub use itsi_error::*;
2	+ pub use itsi_tracing::{debug, error, info, trace, warn};