From 25c003a1af4408158f603836a38847787a6a4fb9 Mon Sep 17 00:00:00 2001
From: fabiovandewaeter <vandewaeter.fabio@gmail.com>
Date: Wed, 10 Jul 2024 15:21:51 +0200
Subject: [PATCH] add fromSton: to OTSpan class

---
 ...ifestOpenTelemetryInstrumentation.class.st |  10 +-
 .../OTAgentInstaller.class.st                 |  47 ++++---
 .../OTContext.class.st                        |  13 +-
 .../OTInstrumentation.class.st                |  39 +++---
 .../OTInstrumentationModule.class.st          |  21 ++-
 .../OTInstrumenter.class.st                   |  53 ++++----
 .../OTSpan.class.st                           | 126 +++++++++++-------
 src/OpenTelemetry-Instrumentation/package.st  |   2 +-
 8 files changed, 166 insertions(+), 145 deletions(-)

diff --git a/src/OpenTelemetry-Instrumentation/ManifestOpenTelemetryInstrumentation.class.st b/src/OpenTelemetry-Instrumentation/ManifestOpenTelemetryInstrumentation.class.st
index 0ee8642..51eb852 100644
--- a/src/OpenTelemetry-Instrumentation/ManifestOpenTelemetryInstrumentation.class.st
+++ b/src/OpenTelemetry-Instrumentation/ManifestOpenTelemetryInstrumentation.class.st
@@ -2,14 +2,12 @@
 Please describe the package using the class comment of the included manifest class. The manifest class also includes other additional metadata for the package. These meta data are used by other tools such as the SmalllintManifestChecker and the critics Browser
 "
 Class {
-	#name : 'ManifestOpenTelemetryInstrumentation',
-	#superclass : 'PackageManifest',
-	#category : 'OpenTelemetry-Instrumentation-Manifest',
-	#package : 'OpenTelemetry-Instrumentation',
-	#tag : 'Manifest'
+	#name : #ManifestOpenTelemetryInstrumentation,
+	#superclass : #PackageManifest,
+	#category : 'OpenTelemetry-Instrumentation-Manifest'
 }
 
-{ #category : 'code-critics' }
+{ #category : #'code-critics' }
 ManifestOpenTelemetryInstrumentation class >> ruleTempsReadBeforeWrittenRuleV1FalsePositive [
 
 	<ignoreForCoverage>
diff --git a/src/OpenTelemetry-Instrumentation/OTAgentInstaller.class.st b/src/OpenTelemetry-Instrumentation/OTAgentInstaller.class.st
index 89414c1..823200c 100644
--- a/src/OpenTelemetry-Instrumentation/OTAgentInstaller.class.st
+++ b/src/OpenTelemetry-Instrumentation/OTAgentInstaller.class.st
@@ -8,8 +8,8 @@ These methods allow them to specify contextual information, method parameters, r
 This ensures that the instrumentation is tailored to the specific needs of the application.
 "
 Class {
-	#name : 'OTAgentInstaller',
-	#superclass : 'Object',
+	#name : #OTAgentInstaller,
+	#superclass : #Object,
 	#instVars : [
 		'metalink',
 		'arguments'
@@ -17,11 +17,10 @@ Class {
 	#classInstVars : [
 		'permission'
 	],
-	#category : 'OpenTelemetry-Instrumentation',
-	#package : 'OpenTelemetry-Instrumentation'
+	#category : 'OpenTelemetry-Instrumentation'
 }
 
-{ #category : 'class initialization' }
+{ #category : #'class initialization' }
 OTAgentInstaller class >> askPermission [
 	"command line and GUI"
 
@@ -29,7 +28,7 @@ OTAgentInstaller class >> askPermission [
 	^ true
 ]
 
-{ #category : 'class initialization' }
+{ #category : #'class initialization' }
 OTAgentInstaller class >> denyPermission [
 
 	<script>
@@ -37,7 +36,7 @@ OTAgentInstaller class >> denyPermission [
 	self uninstall
 ]
 
-{ #category : 'class initialization' }
+{ #category : #'class initialization' }
 OTAgentInstaller class >> givePermission [
 
 	<script>
@@ -45,20 +44,20 @@ OTAgentInstaller class >> givePermission [
 	self install
 ]
 
-{ #category : 'class initialization' }
+{ #category : #'class initialization' }
 OTAgentInstaller class >> hasPermission [
 
 	^ permission ifNil: [ permission := self askPermission ]
 ]
 
-{ #category : 'class initialization' }
+{ #category : #'class initialization' }
 OTAgentInstaller class >> initialize [
 	"Install the instrumentations when OpenTelemetry is loaded."
 
 	self hasPermission ifTrue: [ self install ]
 ]
 
-{ #category : 'actions' }
+{ #category : #actions }
 OTAgentInstaller class >> install [
 	"Install all the active instrumentation modules present in this image."
 
@@ -67,7 +66,7 @@ OTAgentInstaller class >> install [
 		module enabled ifTrue: [ self installModule: module ] ]
 ]
 
-{ #category : 'actions' }
+{ #category : #actions }
 OTAgentInstaller class >> installInstrumentation: anInstrumentation [
 
 	| installer |
@@ -81,7 +80,7 @@ OTAgentInstaller class >> installInstrumentation: anInstrumentation [
 					installer instrument: method ] ]
 ]
 
-{ #category : 'actions' }
+{ #category : #actions }
 OTAgentInstaller class >> installModule: anInstrumentationModule [
 
 	anInstrumentationModule initialize instrumentations do: [
@@ -90,7 +89,7 @@ OTAgentInstaller class >> installModule: anInstrumentationModule [
 			self installInstrumentation: instrumentation ] ]
 ]
 
-{ #category : 'actions' }
+{ #category : #actions }
 OTAgentInstaller class >> reinstall [
 
 	<script>
@@ -98,7 +97,7 @@ OTAgentInstaller class >> reinstall [
 	self install
 ]
 
-{ #category : 'initialization' }
+{ #category : #initialization }
 OTAgentInstaller class >> resetEnvironment [
 
 	<script>
@@ -107,7 +106,7 @@ OTAgentInstaller class >> resetEnvironment [
 	OTSpanExporter reset
 ]
 
-{ #category : 'actions' }
+{ #category : #actions }
 OTAgentInstaller class >> uninstall [
 	"Uninstall all of the instrumentation present in this image."
 
@@ -117,7 +116,7 @@ OTAgentInstaller class >> uninstall [
 		self uninstallModule: module ]
 ]
 
-{ #category : 'actions' }
+{ #category : #actions }
 OTAgentInstaller class >> uninstallInstrumentation: anInstrumentation [
 
 	anInstrumentation reset.
@@ -126,21 +125,21 @@ OTAgentInstaller class >> uninstallInstrumentation: anInstrumentation [
 			metalink uninstall ] ]
 ]
 
-{ #category : 'actions' }
+{ #category : #actions }
 OTAgentInstaller class >> uninstallModule: anInstrumentationModule [
 
 	anInstrumentationModule instrumentations do: [ :instrumentation |
 		self uninstallInstrumentation: instrumentation ]
 ]
 
-{ #category : 'API - configuration' }
+{ #category : #'API - configuration' }
 OTAgentInstaller >> beOneShot [
 	"Only execute the instrumentation once."
 
 	metalink optionOneShot: true
 ]
 
-{ #category : 'private' }
+{ #category : #private }
 OTAgentInstaller >> configureWith: anInstrumentation [
 	"This is a private method, do not use this!
 	Configure the MetaLink to make it run the method instrumentation defined in an OTInstrumentation subclass."
@@ -152,7 +151,7 @@ OTAgentInstaller >> configureWith: anInstrumentation [
 	metalink metaObject: anInstrumentation
 ]
 
-{ #category : 'initialization' }
+{ #category : #initialization }
 OTAgentInstaller >> initialize [
 
 	metalink := MetaLink new.
@@ -165,7 +164,7 @@ OTAgentInstaller >> initialize [
 	arguments add: #operation -> nil
 ]
 
-{ #category : 'private' }
+{ #category : #private }
 OTAgentInstaller >> instrument: aMethod [
 	"This is a private method, do not use this!
 	Install the metalink on the instrumented method."
@@ -173,21 +172,21 @@ OTAgentInstaller >> instrument: aMethod [
 	aMethod ast link: metalink
 ]
 
-{ #category : 'API - configuration' }
+{ #category : #'API - configuration' }
 OTAgentInstaller >> withContext [
 	"The executing context, note that it is slow to reify."
 
 	arguments add: #context -> nil
 ]
 
-{ #category : 'API - configuration' }
+{ #category : #'API - configuration' }
 OTAgentInstaller >> withObject [
 	"Object executing the instrumented method."
 
 	arguments add: #object -> nil
 ]
 
-{ #category : 'API - configuration' }
+{ #category : #'API - configuration' }
 OTAgentInstaller >> withSender [
 	"Sender of the instrumented method."
 
diff --git a/src/OpenTelemetry-Instrumentation/OTContext.class.st b/src/OpenTelemetry-Instrumentation/OTContext.class.st
index eaed512..feb9b73 100644
--- a/src/OpenTelemetry-Instrumentation/OTContext.class.st
+++ b/src/OpenTelemetry-Instrumentation/OTContext.class.st
@@ -1,26 +1,25 @@
 Class {
-	#name : 'OTContext',
-	#superclass : 'Object',
+	#name : #OTContext,
+	#superclass : #Object,
 	#instVars : [
 		'currentSpan'
 	],
-	#category : 'OpenTelemetry-Instrumentation',
-	#package : 'OpenTelemetry-Instrumentation'
+	#category : 'OpenTelemetry-Instrumentation'
 }
 
-{ #category : 'accessing - context' }
+{ #category : #'accessing - context' }
 OTContext >> currentSpan [
 
 	^ currentSpan
 ]
 
-{ #category : 'accessing' }
+{ #category : #accessing }
 OTContext >> currentSpan: aSpan [
 
 	currentSpan := aSpan
 ]
 
-{ #category : 'initialization' }
+{ #category : #initialization }
 OTContext >> initialize [
 	"TODO gather data on executor"
 ]
diff --git a/src/OpenTelemetry-Instrumentation/OTInstrumentation.class.st b/src/OpenTelemetry-Instrumentation/OTInstrumentation.class.st
index bb46db8..1ac5f20 100644
--- a/src/OpenTelemetry-Instrumentation/OTInstrumentation.class.st
+++ b/src/OpenTelemetry-Instrumentation/OTInstrumentation.class.st
@@ -3,18 +3,17 @@ Interface representing a single type instrumentation.
 Part of an `OTelInstrumentationModule`.
 "
 Class {
-	#name : 'OTInstrumentation',
-	#superclass : 'Object',
+	#name : #OTInstrumentation,
+	#superclass : #Object,
 	#classInstVars : [
 		'enabled',
 		'instrumenter',
 		'sampler'
 	],
-	#category : 'OpenTelemetry-Instrumentation',
-	#package : 'OpenTelemetry-Instrumentation'
+	#category : 'OpenTelemetry-Instrumentation'
 }
 
-{ #category : 'matching' }
+{ #category : #matching }
 OTInstrumentation class >> classMatcher [
 	"Matches all classes by default.
 	Subclasses should redefine this method to focus the search on interesting classes."
@@ -22,13 +21,13 @@ OTInstrumentation class >> classMatcher [
 	^ OTMatcher any
 ]
 
-{ #category : 'configuring' }
+{ #category : #configuring }
 OTInstrumentation class >> configure: installer [
 	"Redefine this method to configure the arguments given to the instrumentation method.
 	Use the instance-side API of OTAgentInstaller."
 ]
 
-{ #category : 'configuring' }
+{ #category : #configuring }
 OTInstrumentation class >> defineInstrumenter [
 	"Redefine this method to define an OTInstrumenter to be used in the instrumentation methods.
 	It should be stored in the `instrumenter` class variable.
@@ -43,7 +42,7 @@ OTInstrumentation class >> defineInstrumenter [
 		contextProducer: [ ... ]"
 ]
 
-{ #category : 'configuring' }
+{ #category : #configuring }
 OTInstrumentation class >> defineSampler [
 	"Redefine this method to define an OTSampler to be used in the instrumentation methods.
 	It should be stored in the `sampler` class variable.
@@ -52,20 +51,20 @@ OTInstrumentation class >> defineSampler [
 	"sampler := OTSampler with..."
 ]
 
-{ #category : 'accessing' }
+{ #category : #accessing }
 OTInstrumentation class >> enabled [
 	"Instrumentations are enabled by default."
 
 	^ enabled ifNil: [ enabled := true ]
 ]
 
-{ #category : 'accessing' }
+{ #category : #accessing }
 OTInstrumentation class >> enabled: aBoolean [
 
 	enabled := aBoolean
 ]
 
-{ #category : 'actions' }
+{ #category : #actions }
 OTInstrumentation class >> install [
 	"Install a specific subclass of Instrumentation."
 
@@ -73,7 +72,7 @@ OTInstrumentation class >> install [
 	OTAgentInstaller installInstrumentation: self
 ]
 
-{ #category : 'private' }
+{ #category : #private }
 OTInstrumentation class >> matchingMethodsDo: aBlock [
 
 	| classMatcher methodMatcher |
@@ -86,27 +85,27 @@ OTInstrumentation class >> matchingMethodsDo: aBlock [
 				do: [ :method | aBlock value: method ] ] ]
 ]
 
-{ #category : 'matching' }
+{ #category : #matching }
 OTInstrumentation class >> methodMatcher [
 	"My subclasses must define a matcher for the methods to instrument."
 
 	self subclassResponsibility
 ]
 
-{ #category : 'instrumenting' }
+{ #category : #instrumenting }
 OTInstrumentation class >> onMethodEnter: event [
 	"This method is executed BEFORE the instrumented method.
 	The event contains the RFMethodOperation plus the data requested in #configure:."
 ]
 
-{ #category : 'instrumenting' }
+{ #category : #instrumenting }
 OTInstrumentation class >> onMethodExit: event withValue: returnValue [
 	"This method is executed AFTER the instrumented method.
 	The first argument contains the RFMethodOperation plus the data requested in #configure:.
 	The second contains the return value of the method."
 ]
 
-{ #category : 'matching' }
+{ #category : #matching }
 OTInstrumentation class >> packageMatcher [
 	"Matches all packages by default.
 	Subclasses should redefine this method to focus the search on interesting packages."
@@ -114,7 +113,7 @@ OTInstrumentation class >> packageMatcher [
 	^ OTMatcher any
 ]
 
-{ #category : 'actions' }
+{ #category : #actions }
 OTInstrumentation class >> reinstall [
 
 	<script>
@@ -122,13 +121,13 @@ OTInstrumentation class >> reinstall [
 	self install
 ]
 
-{ #category : 'class initialization' }
+{ #category : #'class initialization' }
 OTInstrumentation class >> reset [
 
 	instrumenter := sampler := nil
 ]
 
-{ #category : 'private' }
+{ #category : #private }
 OTInstrumentation class >> run: arguments [
 	"Hook called when executing an instrumented method.
 	If the trace should not be sampled, execute the method directly.
@@ -148,7 +147,7 @@ OTInstrumentation class >> run: arguments [
 		  ensure: [ self onMethodExit: arguments withValue: returnValue ]
 ]
 
-{ #category : 'actions' }
+{ #category : #actions }
 OTInstrumentation class >> uninstall [
 	"Uninstall a specific subclass of Instrumentation."
 
diff --git a/src/OpenTelemetry-Instrumentation/OTInstrumentationModule.class.st b/src/OpenTelemetry-Instrumentation/OTInstrumentationModule.class.st
index 3a32113..adf1d0c 100644
--- a/src/OpenTelemetry-Instrumentation/OTInstrumentationModule.class.st
+++ b/src/OpenTelemetry-Instrumentation/OTInstrumentationModule.class.st
@@ -3,29 +3,28 @@ I group several connected `OTInstrumentation`s together, sharing instrumentation
 Ideally all types in a single instrumented library should live in a single module.
 "
 Class {
-	#name : 'OTInstrumentationModule',
-	#superclass : 'Object',
+	#name : #OTInstrumentationModule,
+	#superclass : #Object,
 	#classInstVars : [
 		'enabled'
 	],
-	#category : 'OpenTelemetry-Instrumentation',
-	#package : 'OpenTelemetry-Instrumentation'
+	#category : 'OpenTelemetry-Instrumentation'
 }
 
-{ #category : 'accessing' }
+{ #category : #accessing }
 OTInstrumentationModule class >> enabled [
 	"Instrumentation modules are enabled by default."
 
 	^ enabled ifNil: [ enabled := true ]
 ]
 
-{ #category : 'accessing' }
+{ #category : #accessing }
 OTInstrumentationModule class >> enabled: aBoolean [
 
 	enabled := aBoolean
 ]
 
-{ #category : 'actions' }
+{ #category : #actions }
 OTInstrumentationModule class >> install [
 	"Install a specific subclass of InstrumentationModule."
 
@@ -33,7 +32,7 @@ OTInstrumentationModule class >> install [
 	OTAgentInstaller installModule: self
 ]
 
-{ #category : 'accessing' }
+{ #category : #accessing }
 OTInstrumentationModule class >> instrumentationName [
 	"My subclasses must return a string with the name of the instrumentation module.
 	Ideally, the name should be the same as the library being instrumented.
@@ -42,14 +41,14 @@ OTInstrumentationModule class >> instrumentationName [
 	self subclassResponsibility
 ]
 
-{ #category : 'accessing' }
+{ #category : #accessing }
 OTInstrumentationModule class >> instrumentations [
 	"My subclasses must return the list of Instrumentations contained in the module."
 
 	self subclassResponsibility
 ]
 
-{ #category : 'actions' }
+{ #category : #actions }
 OTInstrumentationModule class >> reinstall [
 
 	<script>
@@ -57,7 +56,7 @@ OTInstrumentationModule class >> reinstall [
 	self install
 ]
 
-{ #category : 'actions' }
+{ #category : #actions }
 OTInstrumentationModule class >> uninstall [
 	"Uninstall a specific subclass of InstrumentationModule."
 
diff --git a/src/OpenTelemetry-Instrumentation/OTInstrumenter.class.st b/src/OpenTelemetry-Instrumentation/OTInstrumenter.class.st
index 3b88037..f23010b 100644
--- a/src/OpenTelemetry-Instrumentation/OTInstrumenter.class.st
+++ b/src/OpenTelemetry-Instrumentation/OTInstrumenter.class.st
@@ -13,8 +13,8 @@ When instrumenting a library, there will generally be four steps:
 The `end` method is called when the instrumented operation finished. It is of extreme importance for this method to be always called after `start`. Calling `start` without later `end` will result in inaccurate or wrong telemetry and context leaks.
 "
 Class {
-	#name : 'OTInstrumenter',
-	#superclass : 'Object',
+	#name : #OTInstrumenter,
+	#superclass : #Object,
 	#instVars : [
 		'spanSuppressionStrategy',
 		'spanKindExtractor',
@@ -27,31 +27,30 @@ Class {
 		'defaultContextProducer',
 		'defaultSpanNameExtractor'
 	],
-	#category : 'OpenTelemetry-Instrumentation',
-	#package : 'OpenTelemetry-Instrumentation'
+	#category : 'OpenTelemetry-Instrumentation'
 }
 
-{ #category : 'instance creation' }
+{ #category : #'instance creation' }
 OTInstrumenter class >> default [
 	"A shared instrumenter with default configurations."
 
 	^ default ifNil: [ default := self new ]
 ]
 
-{ #category : 'defaults' }
+{ #category : #defaults }
 OTInstrumenter class >> defaultContextProducer [
 
 	^ defaultContextProducer ifNil: [
 		  defaultContextProducer := [ OTContext new ] ]
 ]
 
-{ #category : 'defaults' }
+{ #category : #defaults }
 OTInstrumenter class >> defaultSpanKindExtractor [
 
 	^ OTSpan alwaysInternal
 ]
 
-{ #category : 'defaults' }
+{ #category : #defaults }
 OTInstrumenter class >> defaultSpanNameExtractor [
 
 	^ defaultSpanNameExtractor ifNil: [
@@ -59,40 +58,40 @@ OTInstrumenter class >> defaultSpanNameExtractor [
 		                              request printStringLimitedTo: 50 ] ]
 ]
 
-{ #category : 'instance creation' }
+{ #category : #'instance creation' }
 OTInstrumenter class >> forInstrumentationNamed: aString [
 
 	^ self new instrumentationName: aString
 ]
 
-{ #category : 'accessing' }
+{ #category : #accessing }
 OTInstrumenter >> contextProducer [
 
 	^ contextProducer ifNil: [
 		  contextProducer := self class defaultContextProducer ]
 ]
 
-{ #category : 'accessing' }
+{ #category : #accessing }
 OTInstrumenter >> contextProducer: anObject [
 
 	contextProducer := anObject
 ]
 
-{ #category : 'instrumenting' }
+{ #category : #instrumenting }
 OTInstrumenter >> end [
 	"Mark the end of the current span."
 
 	^ self end: OTSpan current error: nil
 ]
 
-{ #category : 'instrumenting' }
+{ #category : #instrumenting }
 OTInstrumenter >> end: span [
 	"Mark the end of a span execution."
 
 	^ self end: span error: nil
 ]
 
-{ #category : 'instrumenting' }
+{ #category : #instrumenting }
 OTInstrumenter >> end: span error: error [
 	"Mark the end of a span execution."
 
@@ -101,7 +100,7 @@ OTInstrumenter >> end: span error: error [
 	^ OTSpanProcessor current process: span
 ]
 
-{ #category : 'instrumenting' }
+{ #category : #instrumenting }
 OTInstrumenter >> end: span request: request response: response error: error [
 	"Mark the end of a span execution."
 
@@ -110,25 +109,25 @@ OTInstrumenter >> end: span request: request response: response error: error [
 	^ OTSpanProcessor current process: span
 ]
 
-{ #category : 'accessing' }
+{ #category : #accessing }
 OTInstrumenter >> instrumentationName [
 
 	^ instrumentationName
 ]
 
-{ #category : 'accessing' }
+{ #category : #accessing }
 OTInstrumenter >> instrumentationName: aString [
 
 	instrumentationName := aString
 ]
 
-{ #category : 'instrumenting' }
+{ #category : #instrumenting }
 OTInstrumenter >> produceContext [
 
 	^ self contextProducer value
 ]
 
-{ #category : 'instrumenting' }
+{ #category : #instrumenting }
 OTInstrumenter >> shouldStartUnder: span request: request [
 
 	^ spanSuppressionStrategy ifNil: [ true ] ifNotNil: [
@@ -137,52 +136,52 @@ OTInstrumenter >> shouldStartUnder: span request: request [
 			  value: (spanKindExtractor value: request) ]
 ]
 
-{ #category : 'accessing' }
+{ #category : #accessing }
 OTInstrumenter >> spanKindExtractor [
 
 	^ spanKindExtractor ifNil: [
 		  spanKindExtractor := self class defaultSpanKindExtractor ]
 ]
 
-{ #category : 'accessing' }
+{ #category : #accessing }
 OTInstrumenter >> spanKindExtractor: aBlock [
 
 	spanKindExtractor := aBlock
 ]
 
-{ #category : 'accessing' }
+{ #category : #accessing }
 OTInstrumenter >> spanNameExtractor [
 
 	^ spanNameExtractor ifNil: [
 		  spanNameExtractor := self class defaultSpanNameExtractor ]
 ]
 
-{ #category : 'accessing' }
+{ #category : #accessing }
 OTInstrumenter >> spanNameExtractor: aBlock [
 
 	spanNameExtractor := aBlock
 ]
 
-{ #category : 'accessing' }
+{ #category : #accessing }
 OTInstrumenter >> spanSuppressionStrategy [
 
 	^ spanSuppressionStrategy
 ]
 
-{ #category : 'accessing' }
+{ #category : #accessing }
 OTInstrumenter >> spanSuppressionStrategy: aBlock [
 
 	spanSuppressionStrategy := aBlock
 ]
 
-{ #category : 'instrumenting' }
+{ #category : #instrumenting }
 OTInstrumenter >> startRequest: request [
 	"Start a new operation to be instrumented."
 
 	^ self startUnder: OTSpan current request: request
 ]
 
-{ #category : 'instrumenting' }
+{ #category : #instrumenting }
 OTInstrumenter >> startUnder: parentSpan request: request [
 	"Start a new operation to be instrumented.
 	The parentSpan is the parent context of the resulting instrumented operation."
diff --git a/src/OpenTelemetry-Instrumentation/OTSpan.class.st b/src/OpenTelemetry-Instrumentation/OTSpan.class.st
index 1f6d7ea..5afdda1 100644
--- a/src/OpenTelemetry-Instrumentation/OTSpan.class.st
+++ b/src/OpenTelemetry-Instrumentation/OTSpan.class.st
@@ -9,8 +9,8 @@ My instance-side API provides methods to set attributes, log events, set status,
 Additionally, my class-side API supports the creation of child spans to represent nested operations.
 "
 Class {
-	#name : 'OTSpan',
-	#superclass : 'Object',
+	#name : #OTSpan,
+	#superclass : #Object,
 	#instVars : [
 		'spanId',
 		'traceId',
@@ -35,48 +35,47 @@ Class {
 		'alwaysProducer',
 		'alwaysServer'
 	],
-	#category : 'OpenTelemetry-Instrumentation',
-	#package : 'OpenTelemetry-Instrumentation'
+	#category : #'OpenTelemetry-Instrumentation'
 }
 
-{ #category : 'extracting' }
+{ #category : #extracting }
 OTSpan class >> alwaysClient [
 
 	^ alwaysClient ifNil: [ alwaysClient := [ :request | #client ] ]
 ]
 
-{ #category : 'extracting' }
+{ #category : #extracting }
 OTSpan class >> alwaysConsumer [
 
 	^ alwaysConsumer ifNil: [ alwaysConsumer := [ :request | #consumer ] ]
 ]
 
-{ #category : 'extracting' }
+{ #category : #extracting }
 OTSpan class >> alwaysInternal [
 
 	^ alwaysInternal ifNil: [ alwaysInternal := [ :request | #internal ] ]
 ]
 
-{ #category : 'extracting' }
+{ #category : #extracting }
 OTSpan class >> alwaysProducer [
 
 	^ alwaysProducer ifNil: [ alwaysProducer := [ :request | #producer ] ]
 ]
 
-{ #category : 'extracting' }
+{ #category : #extracting }
 OTSpan class >> alwaysServer [
 
 	^ alwaysServer ifNil: [ alwaysServer := [ :request | #server ] ]
 ]
 
-{ #category : 'enumeration' }
+{ #category : #enumeration }
 OTSpan class >> client [
 	"Indicates that the span covers the client-side wrapper around an RPC or other remote request."
 
 	^ #client
 ]
 
-{ #category : 'enumeration' }
+{ #category : #enumeration }
 OTSpan class >> consumer [
 	"Indicates that the span describes consumer receiving a message from a broker.
 Unlike client and server, there is no direct critical path latency relationship between producer and consumer spans."
@@ -84,20 +83,49 @@ Unlike client and server, there is no direct critical path latency relationship
 	^ #consumer
 ]
 
-{ #category : 'accessing' }
+{ #category : #accessing }
 OTSpan class >> current [
 
 	^ Current
 ]
 
-{ #category : 'enumeration' }
+{ #category : #recording }
+OTSpan class >> fromSton: stonReader [
+	"enumeration"
+
+	| span representation |
+	span := self new.
+	representation := stonReader parseMapOrListRepresentation.
+	span instVarNamed: #spanId put: (representation at: #spanId).
+	span instVarNamed: #traceId put: (representation at: #traceId).
+	span name: (representation at: #name).
+	span context: (representation at: #context).
+	span kind: (representation at: #kind).
+	span startTime: (representation at: #startTime).
+	span endTime: (representation at: #endTime).
+	span status: (representation at: #status).
+	span instrumentationName: (representation at: #instrumentationName).
+	representation
+		at: #parentId
+		ifPresent: [ :parentId | "self allInstances detect: [ :s | s spanId = parentId ]"
+			 ].
+	representation
+		at: #attributes
+		ifPresent: [ :attributes | span attributes: attributes ].
+	representation
+		at: #events
+		ifPresent: [ :events | span events: events ].
+	^ span
+]
+
+{ #category : #enumeration }
 OTSpan class >> internal [
 	"Default value. Indicates that the span is used internally."
 
 	^ #internal
 ]
 
-{ #category : 'enumeration' }
+{ #category : #enumeration }
 OTSpan class >> producer [
 	"Indicates that the span describes producer sending a message to a broker.
 	Unlike client and server, there is no direct critical path latency relationship between producer and consumer spans."
@@ -105,19 +133,19 @@ OTSpan class >> producer [
 	^ #producer
 ]
 
-{ #category : 'recording' }
+{ #category : #recording }
 OTSpan class >> recordException: anException [
 
 	Current ifNotNil: [ Current recordException: anException ]
 ]
 
-{ #category : 'class initialization' }
+{ #category : #'class initialization' }
 OTSpan class >> reset [
 
 	Current := nil
 ]
 
-{ #category : 'instance creation' }
+{ #category : #'instance creation' }
 OTSpan class >> rootIn: aContext [
 
 	^ self new
@@ -125,14 +153,14 @@ OTSpan class >> rootIn: aContext [
 		  traceId: UUID new
 ]
 
-{ #category : 'enumeration' }
+{ #category : #enumeration }
 OTSpan class >> server [
 	"Indicates that the span covers server-side handling of an RPC or other remote request."
 
 	^ #server
 ]
 
-{ #category : 'instance creation' }
+{ #category : #'instance creation' }
 OTSpan class >> under: parentSpan [
 
 	^ self new
@@ -141,7 +169,7 @@ OTSpan class >> under: parentSpan [
 		  traceId: parentSpan traceId
 ]
 
-{ #category : 'accessing' }
+{ #category : #accessing }
 OTSpan >> attributeAt: key put: value [
 
 	(attributes ifNil: [ attributes := Dictionary new ])
@@ -149,116 +177,116 @@ OTSpan >> attributeAt: key put: value [
 		put: value
 ]
 
-{ #category : 'accessing' }
+{ #category : #accessing }
 OTSpan >> attributes [
 
 	^ attributes
 ]
 
-{ #category : 'accessing' }
+{ #category : #accessing }
 OTSpan >> attributes: aDictionary [
 
 	attributes := aDictionary
 ]
 
-{ #category : 'accessing' }
+{ #category : #accessing }
 OTSpan >> context [
 
 	^ context
 ]
 
-{ #category : 'accessing' }
+{ #category : #accessing }
 OTSpan >> context: aContext [
 
 	context := aContext
 ]
 
-{ #category : 'control' }
+{ #category : #control }
 OTSpan >> end [
 
 	self endTime: DateAndTime now.
 	Current := self parent
 ]
 
-{ #category : 'accessing' }
+{ #category : #accessing }
 OTSpan >> endTime [
 
 	^ endTime
 ]
 
-{ #category : 'accessing' }
+{ #category : #accessing }
 OTSpan >> endTime: aDateAndTime [
 
 	endTime := aDateAndTime
 ]
 
-{ #category : 'accessing' }
+{ #category : #accessing }
 OTSpan >> events [
 
 	^ events
 ]
 
-{ #category : 'accessing' }
+{ #category : #accessing }
 OTSpan >> events: aDictionary [
 
 	events := aDictionary
 ]
 
-{ #category : 'initialization' }
+{ #category : #initialization }
 OTSpan >> initialize [
 
 	spanId := UUID new
 ]
 
-{ #category : 'accessing' }
+{ #category : #accessing }
 OTSpan >> instrumentationName [
 
 	^ instrumentationName
 ]
 
-{ #category : 'accessing' }
+{ #category : #accessing }
 OTSpan >> instrumentationName: aString [
 
 	instrumentationName := aString
 ]
 
-{ #category : 'accessing' }
+{ #category : #accessing }
 OTSpan >> kind [
 
 	^ kind
 ]
 
-{ #category : 'accessing' }
+{ #category : #accessing }
 OTSpan >> kind: aSpanKind [
 
 	kind := aSpanKind
 ]
 
-{ #category : 'accessing' }
+{ #category : #accessing }
 OTSpan >> name [
 
 	^ name
 ]
 
-{ #category : 'accessing' }
+{ #category : #accessing }
 OTSpan >> name: aString [
 
 	name := aString
 ]
 
-{ #category : 'accessing' }
+{ #category : #accessing }
 OTSpan >> parent [
 
 	^ parent
 ]
 
-{ #category : 'accessing' }
+{ #category : #accessing }
 OTSpan >> parent: aSpan [
 
 	parent := aSpan
 ]
 
-{ #category : 'printing' }
+{ #category : #printing }
 OTSpan >> printOn: aStream [
 
 	aStream
@@ -269,51 +297,51 @@ OTSpan >> printOn: aStream [
 		nextPut: $]
 ]
 
-{ #category : 'recording' }
+{ #category : #recording }
 OTSpan >> recordException: anException [
 
 	self status: 'ERROR'.
 	self attributeAt: 'error' put: anException description
 ]
 
-{ #category : 'accessing' }
+{ #category : #accessing }
 OTSpan >> spanId [
 
 	^ spanId
 ]
 
-{ #category : 'control' }
+{ #category : #control }
 OTSpan >> start [
 
 	Current := self.
 	self startTime: DateAndTime now
 ]
 
-{ #category : 'accessing' }
+{ #category : #accessing }
 OTSpan >> startTime [
 
 	^ startTime
 ]
 
-{ #category : 'accessing' }
+{ #category : #accessing }
 OTSpan >> startTime: aDateAndTime [
 
 	startTime := aDateAndTime
 ]
 
-{ #category : 'accessing' }
+{ #category : #accessing }
 OTSpan >> status [
 
 	^ status
 ]
 
-{ #category : 'accessing' }
+{ #category : #accessing }
 OTSpan >> status: aString [
 
 	status := aString
 ]
 
-{ #category : 'ston persistence' }
+{ #category : #'ston persistence' }
 OTSpan >> stonOn: stonWriter [
 
 	stonWriter writeObject: self streamMap: [ :map |
@@ -333,13 +361,13 @@ OTSpan >> stonOn: stonWriter [
 		events isEmptyOrNil ifFalse: [ map at: #events put: events ] ]
 ]
 
-{ #category : 'accessing' }
+{ #category : #accessing }
 OTSpan >> traceId [
 
 	^ traceId
 ]
 
-{ #category : 'accessing' }
+{ #category : #accessing }
 OTSpan >> traceId: id [
 
 	traceId := id
diff --git a/src/OpenTelemetry-Instrumentation/package.st b/src/OpenTelemetry-Instrumentation/package.st
index 0757078..059e659 100644
--- a/src/OpenTelemetry-Instrumentation/package.st
+++ b/src/OpenTelemetry-Instrumentation/package.st
@@ -1 +1 @@
-Package { #name : 'OpenTelemetry-Instrumentation' }
+Package { #name : #'OpenTelemetry-Instrumentation' }