Initial: yoga-opentelemetry

Author: i-am-the-slime

.github/workflows/ci.yml

@@ -0,0 +1,9 @@
+name: CI
+on: [push, pull_request]
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: rowtype-yoga/purescript-yoga-actions/.github/actions/setup@main
+      - run: spago build

.gitignore

@@ -0,0 +1,3 @@
+node_modules/
+.spago/
+output*/

package.json

@@ -0,0 +1,12 @@
+{
+  "name": "purescript-yoga-opentelemetry",
+  "version": "0.1.0",
+  "description": "PureScript FFI bindings for OpenTelemetry",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rowtype-yoga/purescript-yoga-backend-stack.git",
+    "directory": "packages/yoga-opentelemetry"
+  },
+  "keywords": ["purescript", "ffi", "bindings", "yoga"]
+}

spago.yaml

@@ -0,0 +1,24 @@
+workspace:
+  package_set:
+    registry: 51.1.0
+
+package:
+  name: yoga-opentelemetry
+  publish:
+    version: 0.1.0
+    license: MIT
+    location:
+      githubOwner: rowtype-yoga
+      githubRepo: purescript-yoga-opentelemetry
+  dependencies:
+    - js-promise: ">=1.0.0 <2.0.0"
+    - js-promise-aff: ">=1.0.0 <2.0.0"
+    - aff: ">=7.0.0 <8.0.0"
+    - effect: ">=4.0.0 <5.0.0"
+    - prelude: ">=6.0.0 <7.0.0"
+    - datetime: ">=6.0.0 <7.0.0"
+    - foreign-object: ">=4.0.0 <5.0.0"
+  test:
+    main: Test.Opentelemetry.Main
+    dependencies:
+      - spec: ">=7.0.0 <8.0.0"

src/Yoga/OpenTelemetry/Exporter/Console.js

@@ -0,0 +1,6 @@
+const { ConsoleSpanExporter } = require('@opentelemetry/sdk-trace-base');
+
+// Create console exporter
+export const createConsoleExporter = () => {
+  return new ConsoleSpanExporter();
+};

src/Yoga/OpenTelemetry/Exporter/Console.purs

@@ -0,0 +1,7 @@
+module Yoga.OpenTelemetry.Exporter.Console where
+
+import Effect (Effect)
+import Yoga.OpenTelemetry.OpenTelemetry (SpanExporter)
+
+-- Create console exporter (logs spans to console)
+foreign import createConsoleExporter :: Effect SpanExporter

src/Yoga/OpenTelemetry/Exporter/OTLP.js

@@ -0,0 +1,12 @@
+const { OTLPTraceExporter } = require('@opentelemetry/exporter-trace-otlp-http');
+
+// Create OTLP exporter
+export const createOTLPExporterImpl = (config) => {
+  const otlpConfig = {};
+  
+  if (config.url) {
+    otlpConfig.url = config.url;
+  }
+  
+  return new OTLPTraceExporter(otlpConfig);
+};

src/Yoga/OpenTelemetry/Exporter/OTLP.purs

@@ -0,0 +1,33 @@
+module Yoga.OpenTelemetry.Exporter.OTLP where
+
+import Prelude
+
+import Data.Newtype (class Newtype)
+import Effect (Effect)
+import Effect.Uncurried (EffectFn1, runEffectFn1)
+import Yoga.OpenTelemetry.OpenTelemetry (SpanExporter)
+import Prim.Row (class Union)
+
+-- OTLP-specific types
+newtype OTLPEndpoint = OTLPEndpoint String
+
+derive instance Newtype OTLPEndpoint _
+derive newtype instance Eq OTLPEndpoint
+derive newtype instance Show OTLPEndpoint
+
+-- OTLP exporter configuration
+type OTLPExporterConfigImpl =
+  ( url :: OTLPEndpoint
+  )
+
+-- Create OTLP exporter
+foreign import createOTLPExporterImpl :: forall opts. EffectFn1 { | opts } SpanExporter
+
+createOTLPExporter :: forall opts opts_. Union opts opts_ OTLPExporterConfigImpl => { | opts } -> Effect SpanExporter
+createOTLPExporter opts = runEffectFn1 createOTLPExporterImpl opts
+
+-- Convenience function with defaults for local Jaeger
+-- Jaeger's OTLP HTTP endpoint is at port 4318
+createOTLPExporterDefaults :: Effect SpanExporter
+createOTLPExporterDefaults = createOTLPExporter
+  { url: OTLPEndpoint "http://localhost:4318/v1/traces" }

src/Yoga/OpenTelemetry/Logs.js

@@ -0,0 +1,78 @@
+import { logs } from '@opentelemetry/api-logs';
+import { LoggerProvider, BatchLogRecordProcessor } from '@opentelemetry/sdk-logs';
+import { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-http';
+import { Resource } from '@opentelemetry/resources';
+import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from '@opentelemetry/semantic-conventions';
+import { PinoInstrumentation } from '@opentelemetry/instrumentation-pino';
+
+/**
+ * Create a LoggerProvider with OTLP exporter
+ * @param {Object} config - Configuration object
+ * @param {Object} config.resource - Resource attributes
+ * @param {string} config.resource.serviceName - Service name
+ * @param {string} config.resource.serviceVersion - Service version  
+ * @param {string} config.resource.serviceNamespace - Service namespace
+ * @param {Object} config.exporter - Exporter configuration
+ * @param {string} config.exporter.url - OTLP endpoint URL
+ * @returns {LoggerProvider} The logger provider instance
+ */
+export const createLoggerProviderImpl = (config) => {
+  const resource = new Resource({
+    [ATTR_SERVICE_NAME]: config.resource.serviceName,
+    [ATTR_SERVICE_VERSION]: config.resource.serviceVersion,
+    'service.namespace': config.resource.serviceNamespace,  // Use string literal for namespace
+  });
+
+  const logExporter = new OTLPLogExporter({
+    url: config.exporter.url,
+  });
+
+  const loggerProvider = new LoggerProvider({ 
+    resource,
+    logRecordProcessors: [new BatchLogRecordProcessor(logExporter)]
+  });
+
+  return loggerProvider;
+};
+
+/**
+ * Register the logger provider globally
+ * @param {LoggerProvider} provider - The logger provider to register
+ * @returns {void}
+ */
+export const registerLoggerProviderImpl = (provider) => {
+  logs.setGlobalLoggerProvider(provider);
+};
+
+/**
+ * Create and enable Pino instrumentation to send logs to OpenTelemetry
+ * This must be called BEFORE creating any Pino loggers
+ * @returns {PinoInstrumentation} The instrumentation instance
+ */
+export const createPinoInstrumentationImpl = () => {
+  const instrumentation = new PinoInstrumentation({
+    logHook: (span, record, level) => {
+      // Optionally correlate logs with active span
+      if (span) {
+        record['trace_id'] = span.spanContext().traceId;
+        record['span_id'] = span.spanContext().spanId;
+        record['trace_flags'] = span.spanContext().traceFlags;
+      }
+    },
+  });
+  
+  instrumentation.enable();
+  return instrumentation;
+};
+
+/**
+ * Hook up an existing Pino logger to OpenTelemetry
+ * Note: This is for already-created loggers. Ideally use instrumentation before logger creation.
+ * @param {Object} logger - Pino logger instance
+ * @returns {void}
+ */
+export const hookPinoToOtelImpl = (logger) => {
+  // The instrumentation should handle this automatically when enabled before logger creation
+  // This function exists for compatibility but the instrumentation approach is preferred
+  console.warn('hookPinoToOtelImpl called - prefer enabling instrumentation before logger creation');
+};

src/Yoga/OpenTelemetry/Logs.purs

@@ -0,0 +1,61 @@
+module Yoga.OpenTelemetry.Logs
+  ( LoggerProvider
+  , OTLPLogsEndpoint(..)
+  , createLoggerProvider
+  , registerLoggerProvider
+  , createPinoInstrumentation
+  , PinoInstrumentation
+  ) where
+
+import Prelude
+
+import Effect (Effect)
+import Effect.Uncurried (EffectFn1, EffectFn2, runEffectFn1, runEffectFn2)
+import Yoga.OpenTelemetry.OpenTelemetry (ServiceName(..), ServiceVersion(..), ServiceNamespace(..))
+
+-- Opaque types
+foreign import data LoggerProvider :: Type
+foreign import data PinoInstrumentation :: Type
+
+newtype OTLPLogsEndpoint = OTLPLogsEndpoint String
+
+derive newtype instance Eq OTLPLogsEndpoint
+derive newtype instance Show OTLPLogsEndpoint
+
+-- FFI imports
+foreign import createLoggerProviderImpl
+  :: EffectFn1
+       { resource ::
+           { serviceName :: String
+           , serviceVersion :: String
+           , serviceNamespace :: String
+           }
+       , exporter ::
+           { url :: String
+           }
+       }
+       LoggerProvider
+
+foreign import registerLoggerProviderImpl :: EffectFn1 LoggerProvider Unit
+
+foreign import createPinoInstrumentationImpl :: Effect PinoInstrumentation
+
+-- Public API
+createLoggerProvider
+  :: { serviceName :: ServiceName
+     , serviceVersion :: ServiceVersion
+     , serviceNamespace :: ServiceNamespace
+     , endpoint :: OTLPLogsEndpoint
+     }
+  -> Effect LoggerProvider
+createLoggerProvider { serviceName: ServiceName sn, serviceVersion: ServiceVersion sv, serviceNamespace: ServiceNamespace sns, endpoint: OTLPLogsEndpoint url } =
+  runEffectFn1 createLoggerProviderImpl
+    { resource: { serviceName: sn, serviceVersion: sv, serviceNamespace: sns }
+    , exporter: { url }
+    }
+
+registerLoggerProvider :: LoggerProvider -> Effect Unit
+registerLoggerProvider = runEffectFn1 registerLoggerProviderImpl
+
+createPinoInstrumentation :: Effect PinoInstrumentation
+createPinoInstrumentation = createPinoInstrumentationImpl