jspurefix 5.11.0 → 5.11.2

package/src/dictionary/fragment-safety.ts

@@ -0,0 +1,225 @@
+import {
+  ContainedComponentField,
+  ContainedField,
+  ContainedFieldType,
+  ContainedGroupField,
+  ContainedSimpleField,
+  IContainedSet
+} from './contained'
+import { FixDefinitions } from './definition'
+
+/**
+ * Static analysis of a dictionary, asking one question: if a component's tags arrived
+ * scattered through a message rather than adjacently, could this dictionary still say
+ * unambiguously which component each tag belongs to?
+ *
+ * The segment parser normally answers that from *position* - a tag between the first and
+ * last tag of a component belongs to it.  A counterparty that emits a component's tags
+ * non-adjacently breaks the inference, and the tags themselves become the only evidence
+ * left.  That works whenever the children of one set own disjoint tags, which FIX's tag
+ * numbering conventions (Underlying*, Leg*, NestedParties2/3) exist to guarantee, but a
+ * house dictionary is under no obligation to honour them.
+ *
+ * See docs/scattered-components.md.  Nothing in the engine consumes this yet - it is a
+ * diagnostic run against a dictionary to find out whether the assumption holds before any
+ * code is written that depends on it.
+ */
+
+export enum FragmentSafetyCode {
+  /**
+   * two children of one set both claim the same tag, so a scattered instance of either
+   * could not be attributed to one of them by tag alone
+   */
+  SiblingTagCollision = 'sibling-tag-collision',
+  /**
+   * a component owns no tag at its own level, so a scattered instance leaves no evidence
+   * it was ever present
+   */
+  UnclaimableComponent = 'unclaimable-component'
+}
+
+export interface IFragmentSafetyFinding {
+  readonly code: FragmentSafetyCode
+  /**
+   * dotted path to the set the finding is about, from the message it was first reached
+   * through e.g. 'NewOrderSingle.Instrument'
+   */
+  readonly path: string
+  /**
+   * name of the set whose children collide, or of the unclaimable component
+   */
+  readonly set: string
+  /**
+   * the contended tag, or 0 for an unclaimable component
+   */
+  readonly tag: number
+  /**
+   * names of the children of `set` that each claim `tag`
+   */
+  readonly owners: string[]
+}
+
+export function describeFinding (f: IFragmentSafetyFinding): string {
+  switch (f.code) {
+    case FragmentSafetyCode.SiblingTagCollision:
+      return `${f.path}: tag ${f.tag} is claimed by ${f.owners.join(' and ')}`
+    case FragmentSafetyCode.UnclaimableComponent:
+      return `${f.path}: owns no tag of its own`
+    default:
+      return f.path
+  }
+}
+
+export class FragmentSafety {
+  private readonly findings: IFragmentSafetyFinding[] = []
+  private readonly analysed = new Set<IContainedSet>()
+  private readonly owned = new Map<IContainedSet, number[]>()
+
+  /**
+   * tags a set can claim at its own level - its simple fields, the same from any
+   * component nested below it, and the NumInGroup tag of any group it contains.
+   *
+   * a group's *interior* is deliberately excluded.  a repeating group is the one
+   * self describing construct in tag value FIX, so its instances are always delimiter
+   * framed and contiguous, and its member tags are never evidence about the level above.
+   * this is the same distinction `flattenedTag` does not draw.
+   */
+  public ownTags (set: IContainedSet): number[] {
+    const memo = this.owned.get(set)
+    if (memo) return memo
+    // seed before recursing so a self referencing dictionary terminates
+    this.owned.set(set, [])
+    const tags: number[] = []
+    for (const field of set.fields) {
+      switch (field.type) {
+        case ContainedFieldType.Simple: {
+          tags.push((field as ContainedSimpleField).definition.tag)
+          break
+        }
+        case ContainedFieldType.Component: {
+          const cf = field as ContainedComponentField
+          for (const t of this.ownTags(cf.definition)) {
+            tags.push(t)
+          }
+          break
+        }
+        case ContainedFieldType.Group: {
+          const gf = field as ContainedGroupField
+          const nof = gf.definition.noOfField
+          if (nof) {
+            tags.push(nof.tag)
+          }
+          break
+        }
+        default:
+          break
+      }
+    }
+    this.owned.set(set, tags)
+    return tags
+  }
+
+  /**
+   * every message in the dictionary, and every component and group reachable from one,
+   * each analysed once however many messages reach it
+   */
+  public static analyse (definitions: FixDefinitions): IFragmentSafetyFinding[] {
+    const instance = new FragmentSafety()
+    // the message map is keyed by name, msgType and abbreviation, so walk distinct sets
+    const seen = new Set<IContainedSet>()
+    for (const message of definitions.message.values()) {
+      if (seen.has(message)) continue
+      seen.add(message)
+      instance.walk(message, message.name)
+    }
+    return instance.findings
+  }
+
+  /**
+   * a single set and everything below it, for a dictionary fragment under test
+   */
+  public static analyseSet (set: IContainedSet, path?: string): IFragmentSafetyFinding[] {
+    const instance = new FragmentSafety()
+    instance.walk(set, path ?? set.name)
+    return instance.findings
+  }
+
+  private walk (set: IContainedSet, path: string): void {
+    if (this.analysed.has(set)) return
+    this.analysed.add(set)
+    this.checkSiblings(set, path)
+    for (const field of set.fields) {
+      switch (field.type) {
+        case ContainedFieldType.Component: {
+          const cf = field as ContainedComponentField
+          this.checkClaimable(cf, `${path}.${cf.name}`)
+          this.walk(cf.definition, `${path}.${cf.name}`)
+          break
+        }
+        case ContainedFieldType.Group: {
+          // the instance body of a group is a level in its own right, and everything
+          // said about scattering above applies again inside it
+          const gf = field as ContainedGroupField
+          this.walk(gf.definition, `${path}.${gf.name}`)
+          break
+        }
+        default:
+          break
+      }
+    }
+  }
+
+  private checkClaimable (cf: ContainedComponentField, path: string): void {
+    if (this.ownTags(cf.definition).length > 0) return
+    this.findings.push({
+      code: FragmentSafetyCode.UnclaimableComponent,
+      path,
+      set: cf.name,
+      tag: 0,
+      owners: []
+    })
+  }
+
+  private checkSiblings (set: IContainedSet, path: string): void {
+    // tag -> the children of this set claiming it.  a tag reaching two children is what
+    // makes a scattered instance unattributable
+    const claims = new Map<number, string[]>()
+    for (const field of set.fields) {
+      for (const tag of this.claimsOf(field)) {
+        const owners = claims.get(tag)
+        if (owners) {
+          if (!owners.includes(field.name)) {
+            owners.push(field.name)
+          }
+        } else {
+          claims.set(tag, [field.name])
+        }
+      }
+    }
+    for (const [tag, owners] of claims) {
+      if (owners.length < 2) continue
+      this.findings.push({
+        code: FragmentSafetyCode.SiblingTagCollision,
+        path,
+        set: set.name,
+        tag,
+        owners
+      })
+    }
+  }
+
+  private claimsOf (field: ContainedField): number[] {
+    switch (field.type) {
+      case ContainedFieldType.Simple:
+        return [(field as ContainedSimpleField).definition.tag]
+      case ContainedFieldType.Component:
+        return this.ownTags((field as ContainedComponentField).definition)
+      case ContainedFieldType.Group: {
+        const nof = (field as ContainedGroupField).definition.noOfField
+        return nof ? [nof.tag] : []
+      }
+      default:
+        return []
+    }
+  }
+}

package/src/dictionary/index.ts

@@ -3,4 +3,5 @@ export * from './field-enum'
 export * from './contained/fields-dispatch'
 export * from './fix-parser'
 export * from './fix-versions'
+export * from './fragment-safety'
 export * from './set-reduce'

package/src/runtime/make-config.ts

@@ -25,7 +25,7 @@ export class RuntimeFactory {
         if (!type) reject(new Error('no application type in application object'))
         this.definitionFactory.getDefinitions(path,
           (t: string) => {
-            return this.logFactory.logger(`${type}.${t}`)
+            return this.logFactory.logger(`${type}.${t}`, { component: t, role: type })
           }).then((definitions: FixDefinitions) => {
           const config = new JsFixConfig(this.msgFactory, definitions, description, AsciiChars.Soh, this.logFactory)
           resolve(config)

package/src/runtime/session-launcher.ts

@@ -19,7 +19,7 @@ export abstract class SessionLauncher {
     acceptorConfig: string | ISessionDescription | null = null,
     private readonly loggerFactory: JsFixLoggerFactory = defaultLoggerFactory
   ) {
-    this.logger = this.loggerFactory.logger('launcher')
+    this.logger = this.loggerFactory.logger('launcher', { component: 'SessionLauncher' })
     this.initiatorConfig = initiatorConfig ? this.loadConfig(initiatorConfig) : null
     this.acceptorConfig = acceptorConfig ? this.loadConfig(acceptorConfig) : null
   }

package/src/sample/http/oms/http-client.ts

@@ -16,7 +16,7 @@ export class HttpClient extends FixmlSession {
     super(config)
     this.logReceivedMsgs = true
     this.fixLog = config.logFactory.plain(`jsfix.${config?.description?.application?.name}.txt`)
-    this.logger = config.logFactory.logger(`${this.me}`)
+    this.logger = config.logFactory.logger(`${this.me}`, { component: 'HttpClient', app: this.me })
   }
 
   protected onApplicationMsg (msgType: string, view: MsgView): void {

package/src/sample/http/oms/http-server.ts

@@ -16,7 +16,7 @@ export class HttpServer extends FixmlSession {
     super(config)
     this.logReceivedMsgs = true
     this.fixLog = config.logFactory.plain(`jsfix.${config?.description?.application?.name}.txt`)
-    this.logger = config.logFactory.logger(`${this.me}`)
+    this.logger = config.logFactory.logger(`${this.me}`, { component: 'HttpServer', app: this.me })
   }
 
   protected onApplicationMsg (msgType: string, view: MsgView): void {

package/src/sample/tcp/qf-md/md-client.ts

@@ -16,7 +16,7 @@ export class MDClient extends AsciiSession {
     super(config)
     this.logReceivedMsgs = true
     this.fixLog = config.logFactory.plain(`jsfix.${config?.description?.application?.name}.txt`)
-    this.logger = config.logFactory.logger(`${this.me}:MDClient`)
+    this.logger = config.logFactory.logger(`${this.me}:MDClient`, { component: 'MDClient', app: this.me })
   }
 
   protected onApplicationMsg (_: string, view: MsgView): void {

package/src/sample/tcp/qf-md/md-server.ts

@@ -16,7 +16,7 @@ export class MDServer extends AsciiSession {
   constructor (@inject('IJsFixConfig') public readonly config: IJsFixConfig) {
     super(config)
     this.logReceivedMsgs = true
-    this.logger = config.logFactory.logger(`${this.me}:MDServer`)
+    this.logger = config.logFactory.logger(`${this.me}:MDServer`, { component: 'MDServer', app: this.me })
     this.fixLog = config.logFactory.plain(`jsfix.${config?.description?.application?.name}.txt`)
   }
 

package/src/sample/tcp/recovering-skeleton/respawn-acceptor.ts

@@ -13,7 +13,8 @@ export class RespawnAcceptor extends FixEntity {
 
   constructor (@inject('IJsFixConfig') public readonly config: IJsFixConfig) {
     super(config)
-    this.logger = config.logFactory.logger('RespawnAcceptor')
+    this.logger = config.logFactory.logger('RespawnAcceptor',
+      { component: 'RespawnAcceptor', role: 'acceptor' })
   }
 
   // if acceptor errors e.g. via a forced connection drop, then respawn

package/src/sample/tcp/recovering-skeleton/skeleton-client.ts

@@ -13,7 +13,7 @@ export class SkeletonClient extends AsciiSession {
     super(config)
     this.logReceivedMsgs = true
     this.fixLog = config.logFactory.plain(`jsfix.${config?.description?.application?.name}.txt`)
-    this.logger = config.logFactory.logger(`${this.me}`)
+    this.logger = config.logFactory.logger(`${this.me}`, { component: 'SkeletonClient', app: this.me })
   }
 
   protected onApplicationMsg (msgType: string, view: MsgView): void {

package/src/sample/tcp/recovering-skeleton/skeleton-server.ts

@@ -13,7 +13,7 @@ export class SkeletonServer extends AsciiSession {
     super(config)
     this.logReceivedMsgs = true
     this.fixLog = config.logFactory.plain(`jsfix.${config?.description?.application?.name}.txt`)
-    this.logger = config.logFactory.logger(`${this.me}`)
+    this.logger = config.logFactory.logger(`${this.me}`, { component: 'SkeletonServer', app: this.me })
   }
 
   protected onApplicationMsg (msgType: string, _: MsgView): void {

package/src/sample/tcp/skeleton/skeleton-session.ts

@@ -17,7 +17,7 @@ export class SkeletonSession extends AsciiSession {
     super(config)
     this.logReceivedMsgs = true
     this.fixLog = config.logFactory.plain(`jsfix.${config?.description?.application?.name}.txt`)
-    this.logger = config.logFactory.logger(`${this.me}`)
+    this.logger = config.logFactory.logger(`${this.me}`, { component: 'SkeletonSession', app: this.me })
   }
 
   protected onApplicationMsg (msgType: string, view: MsgView): void {

package/src/sample/tcp/trade-capture/trade-capture-client.ts

@@ -18,7 +18,8 @@ export class TradeCaptureClient extends AsciiSession {
     this.logReceivedMsgs = true
     this.reports = new Map<string, ITradeCaptureReport>()
     this.fixLog = config.logFactory.plain(`jsfix.${config?.description?.application?.name}.txt`)
-    this.logger = config.logFactory.logger(`${this.me}:TradeCaptureClient`)
+    this.logger = config.logFactory.logger(`${this.me}:TradeCaptureClient`,
+      { component: 'TradeCaptureClient', app: this.me })
   }
 
   protected onApplicationMsg (msgType: string, view: MsgView): void {

package/src/sample/tcp/trade-capture/trade-capture-server.ts

@@ -18,7 +18,8 @@ export class TradeCaptureServer extends AsciiSession {
   constructor (public readonly config: IJsFixConfig) {
     super(config)
     this.logReceivedMsgs = true
-    this.logger = config.logFactory.logger(`${this.me}:TradeCaptureServer`)
+    this.logger = config.logFactory.logger(`${this.me}:TradeCaptureServer`,
+      { component: 'TradeCaptureServer', app: this.me })
     this.fixLog = config.logFactory.plain(`jsfix.${config?.description?.application?.name}.txt`)
   }
 

package/src/store/fix-msg-memory-store.ts

@@ -20,7 +20,8 @@ export class FixMsgMemoryStore implements IFixMsgStore {
   ]
 
   public constructor (public readonly id: string, public readonly config: IJsFixConfig) {
-    this.logger = config.logFactory.logger(`${this.id}:FixMsgMemoryStore`)
+    this.logger = config.logFactory.logger(`${this.id}:FixMsgMemoryStore`,
+      { component: 'FixMsgMemoryStore', store: this.id })
     this.setExcMsgType([])
   }
 

package/src/transport/ascii/ascii-msg-transmitter.ts

@@ -39,7 +39,8 @@ export class AsciiMsgTransmitter extends MsgTransmitter {
    */
   private reportUnknownFields (config: IJsFixConfig): void {
     const name = config.description.application?.name ?? 'na'
-    const logger = config.logFactory.logger(`${name}:encoder`)
+    const logger = config.logFactory.logger(`${name}:encoder`,
+      { component: 'AsciiMsgTransmitter', app: name })
     const reported = new Set<string>()
     this.encoder.onUnknownField = (fieldName: string, setName: string) => {
       const key = `${setName}.${fieldName}`

package/src/transport/ascii/ascii-session.ts

@@ -662,7 +662,8 @@ export abstract class AsciiSession extends FixSession {
 
     // every session on a wildcard listener shared one logger name until now, which
     // makes a multi-client server log impossible to follow
-    this.sessionLogger = this.config.logFactory.logger(`${this.me}:${peerCompId}:FixSession`)
+    this.sessionLogger = this.config.logFactory.logger(`${this.me}:${peerCompId}:FixSession`,
+      { component: 'FixSession', app: this.me, peer: peerCompId })
 
     this.sessionId = new SessionId(
       this.config.description.BeginString,

package/src/transport/http/http-acceptor-listener.ts

@@ -15,7 +15,8 @@ export class HttpAcceptorListener extends FixEntity {
 
   async start (): Promise<any> {
     return new Promise<any>(async (resolve, reject) => {
-      const logger = this.config.logFactory.logger('acceptor')
+      const logger = this.config.logFactory.logger('acceptor',
+        { component: 'HttpAcceptorListener', role: 'acceptor' })
       const sessionContainer = this.config.sessionContainer
       if (!sessionContainer.isRegistered(DITokens.FixSession)) {
         reject(new Error(`application must register a DI token '${DITokens.FixSession}' - see src/sample`))

package/src/transport/http/http-acceptor.ts

@@ -22,7 +22,8 @@ export class HttpAcceptor extends FixAcceptor {
 
   constructor (@inject(DITokens.IJsFixConfig) public readonly config: IJsFixConfig) {
     super(config?.description?.application ?? null)
-    this.logger = config.logFactory.logger(`${config?.description?.application?.name}:HttpAcceptor`)
+    this.logger = config.logFactory.logger(`${config?.description?.application?.name}:HttpAcceptor`,
+      { component: 'HttpAcceptor', app: config?.description?.application?.name, role: 'acceptor' })
     this.logger.info('creating http server')
     this.router = express.Router()
     this.router.use(bodyParser.json())

package/src/transport/http/http-initiator.ts

@@ -11,7 +11,8 @@ export class HttpInitiator extends FixEntity {
   logger: IJsFixLogger
   constructor (@inject(DITokens.IJsFixConfig) public readonly config: IJsFixConfig) {
     super(config)
-    this.logger = config.logFactory.logger('initiator')
+    this.logger = config.logFactory.logger('initiator',
+      { component: 'HttpInitiator', role: 'initiator' })
   }
 
   async start (): Promise<any> {

package/src/transport/http/http-json-sample-adapter.ts

@@ -13,7 +13,7 @@ export class HttpJsonSampleAdapter implements IHttpAdapter {
   private token: string | null = null
   private readonly routes: Map<string, IHtmlRoute> = new Map<string, IHtmlRoute>()
   constructor (@inject(DITokens.IJsFixConfig) public readonly config: IJsFixConfig) {
-    this.logger = config.logFactory.logger('http.adapter')
+    this.logger = config.logFactory.logger('http.adapter', { component: 'HttpJsonSampleAdapter' })
     const routes = this.routes
     const options = config?.description?.application?.http?.options
     if (!options) {

package/src/transport/session/fix-session.ts

@@ -61,7 +61,8 @@ export abstract class FixSession extends events.EventEmitter {
         heartBeat: config.description.HeartBtInt,
         lastPeerMsgSeqNum: config.description.LastReceivedSeqNum
       })
-    this.sessionLogger = config.logFactory.logger(`${this.me}:FixSession`)
+    this.sessionLogger = config.logFactory.logger(`${this.me}:FixSession`,
+      { component: 'FixSession', app: this.me, role: description?.application?.type })
     this.initiator = description?.application?.type === 'initiator'
     this.acceptor = !this.initiator
     this.checkMsgIntegrity = this.acceptor

package/src/transport/session/session-registry.ts

@@ -53,7 +53,7 @@ export class SessionRegistry implements ISessionRegistry {
   private readonly logger: IJsFixLogger | null
 
   constructor (logFactory?: JsFixLoggerFactory) {
-    this.logger = logFactory?.logger('SessionRegistry') ?? null
+    this.logger = logFactory?.logger('SessionRegistry', { component: 'SessionRegistry' }) ?? null
   }
 
   public get count (): number {

package/src/transport/tcp/connect-error.ts

@@ -0,0 +1,56 @@
+/**
+ * A readable reason for a failed connection.
+ *
+ * Node raises an AggregateError when the host resolved to more than one address and
+ * every attempt failed.  That is not an edge case: 'localhost' is both ::1 and
+ * 127.0.0.1 on any modern machine, so it is what an ordinary refused connection looks
+ * like.  Its own message is empty and the detail sits in errors[], so reporting
+ * e.message alone said nothing at all about the commonest failure there is - an
+ * application catching a rejected connect saw an Error with no message.
+ *
+ * Falls back to the code (ECONNREFUSED, ENOTFOUND, ETIMEDOUT) when there is no
+ * message anywhere, which is still enough to act on.
+ */
+export function describeConnectError (e: unknown): string {
+  if (e == null) return 'unknown error'
+  const described = detail(e)
+  return described.length > 0 ? described : String(e)
+}
+
+/**
+ * The reason, or '' when this error carries none.
+ *
+ * Kept separate from the public function so a nested error with nothing to say
+ * contributes nothing, rather than a stringified 'Error' that would then look like a
+ * reason and stop the aggregate falling back to its own code.
+ */
+function detail (e: unknown): string {
+  if (e == null) return ''
+
+  const err = e as { message?: string, code?: string, errors?: unknown[] }
+
+  if (Array.isArray(err.errors) && err.errors.length > 0) {
+    // every address usually fails the same way - say it once rather than repeating
+    // 'connect ECONNREFUSED' for each family
+    const unique = Array.from(new Set(err.errors.map(detail).filter(m => m.length > 0)))
+    if (unique.length > 0) return unique.join('; ')
+  }
+
+  if (err.message) return err.message
+  if (err.code) return err.code
+  return ''
+}
+
+/**
+ * Give an error a message when it has none, keeping the object itself.
+ *
+ * Deliberately not a wrapper: `code` and `errors` are what a caller switches on, and
+ * building a fresh Error to hold the text would throw both away.  Returns the same
+ * error so it can be used inline.
+ */
+export function withConnectReason (e: Error): Error {
+  if (!e.message) {
+    e.message = describeConnectError(e)
+  }
+  return e
+}

package/src/transport/tcp/recovering-tcp-initiator.ts

@@ -9,6 +9,7 @@ import { DITokens } from '../../runtime/di-tokens'
 import { ITcpTransportDescription } from './tcp-transport-description'
 import { IMsgApplication } from '../msg-application'
 import { FixEntity } from '../fix-entity'
+import { describeConnectError } from './connect-error'
 
 /*
    create one application session instance - and recover a lost transport.  Hence, the application
@@ -38,7 +39,8 @@ export class RecoveringTcpInitiator extends FixEntity {
     super(jsFixConfig)
     this.application = this.jsFixConfig.description.application ?? null
     const name = this.application?.name ?? 'na'
-    this.logger = jsFixConfig.logFactory.logger(`${name}:RecoveringTcpInitiator`)
+    this.logger = jsFixConfig.logFactory.logger(`${name}:RecoveringTcpInitiator`,
+      { component: 'RecoveringTcpInitiator', app: name, role: 'initiator' })
     if (!this.application) {
       throw new Error('no application in session description.')
     }
@@ -163,7 +165,7 @@ export class RecoveringTcpInitiator extends FixEntity {
       this.connect(this.connectTimeoutSecs).then(t => {
         this.logger.info(`new transport ${t.id}`)
       }).catch((e) => {
-        this.logger.info(`failed to re-connect ${e.message} - backoff for ${this.backoffFailConnectSecs}`)
+        this.logger.info(`failed to re-connect: ${describeConnectError(e)} - backoff for ${this.backoffFailConnectSecs}`)
         this.th = setTimeout(() => {
           this.logger.info('returning to recover()')
           setImmediate(() => {

package/src/transport/tcp/tcp-acceptor-listener.ts

@@ -27,7 +27,8 @@ export class TcpAcceptorListener extends FixEntity {
 
   async start (): Promise<any> {
     return await new Promise<any>(async (resolve, reject) => {
-      const logger = this.config.logFactory.logger('acceptor')
+      const logger = this.config.logFactory.logger('acceptor',
+        { component: 'TcpAcceptorListener', role: 'acceptor' })
       const sessionContainer = this.config.sessionContainer
       if (!sessionContainer.isRegistered(DITokens.FixSession)) {
         reject(new Error(`application must register a DI token '${DITokens.FixSession}' - see src/sample`))
@@ -93,7 +94,8 @@ export class TcpAcceptorListener extends FixEntity {
    */
   stop (): void {
     if (this.acceptor) {
-      const logger = this.config.logFactory.logger('acceptor')
+      const logger = this.config.logFactory.logger('acceptor',
+        { component: 'TcpAcceptorListener', role: 'acceptor' })
       logger.info('acceptor stopping')
       this.acceptor.close(() => {
         logger.info('acceptor closed.')

package/src/transport/tcp/tcp-acceptor.ts

@@ -18,7 +18,8 @@ export class TcpAcceptor extends FixAcceptor {
 
   constructor (@inject(DITokens.IJsFixConfig) public readonly config: IJsFixConfig) {
     super(config.description.application ?? null)
-    this.logger = config.logFactory.logger(`${config.description.application?.name}:TcpAcceptor`)
+    this.logger = config.logFactory.logger(`${config.description.application?.name}:TcpAcceptor`,
+      { component: 'TcpAcceptor', app: config.description.application?.name, role: 'acceptor' })
     const tlsOptions: TlsOptions | null = this.tlsOptions()
     if (tlsOptions) {
       this.tlsServer()

package/src/transport/tcp/tcp-initiator-connector.ts

@@ -21,7 +21,8 @@ export class TcpInitiatorConnector extends FixEntity {
   async start (reconnectTimeout: number = 0): Promise<any> {
 
     return await new Promise<any>(async (resolve, reject) => {
-      const logger = this.config.logFactory.logger('initiator')
+      const logger = this.config.logFactory.logger('initiator',
+      { component: 'TcpInitiatorConnector', role: 'initiator' })
       const sessionContainer = this.config.sessionContainer
       if (!sessionContainer.isRegistered(DITokens.FixSession)) {
         reject(new Error(`application must register a DI token '${DITokens.FixSession}' - see src/sample`))
@@ -64,7 +65,8 @@ export class TcpInitiatorConnector extends FixEntity {
   }
 
   async connect (initiatorSession: FixSession): Promise<any> {
-    const logger = this.config.logFactory.logger('initiator')
+    const logger = this.config.logFactory.logger('initiator',
+      { component: 'TcpInitiatorConnector', role: 'initiator' })
     const initiator: FixInitiator = this.config.sessionContainer.resolve<FixInitiator>(TcpInitiator)
     logger.info('connecting ...')
     const initiatorTransport: MsgTransport = await initiator.connect(this.connectTimeoutSecs)

package/src/transport/tcp/tcp-initiator.ts

@@ -4,12 +4,12 @@ import { MsgTransport } from '../factory'
 import { IJsFixConfig, IJsFixLogger } from '../../config'
 import { TcpDuplex, FixDuplex } from '../duplex'
 
-import * as util from 'util'
 import { connect as tlsConnect, ConnectionOptions, TLSSocket } from 'tls'
 import { createConnection } from 'net'
 import Timeout = NodeJS.Timeout
 import { TlsOptionsFactory } from './tls-options-factory'
 import { describeConnectionOptions, describeNegotiated, describePeerCertificate } from './tls-diagnostics'
+import { describeConnectError, withConnectReason } from './connect-error'
 import { inject, injectable } from 'tsyringe'
 import { DITokens } from '../../runtime/di-tokens'
 import { ITcpTransportDescription } from './tcp-transport-description'
@@ -33,7 +33,8 @@ export class TcpInitiator extends FixInitiator {
   constructor (@inject(DITokens.IJsFixConfig) public readonly jsFixConfig: IJsFixConfig) {
     super(jsFixConfig.description.application ?? null)
     const name = this.application?.name ?? 'initiator'
-    this.logger = jsFixConfig.logFactory.logger(`${name}:TcpInitiator`)
+    this.logger = jsFixConfig.logFactory.logger(`${name}:TcpInitiator`,
+      { component: 'TcpInitiator', app: name, role: 'initiator' })
     if (!this.application) {
       throw new Error('no application in session description.')
     }
@@ -74,7 +75,7 @@ export class TcpInitiator extends FixInitiator {
               // connect() whose timeout expires before the first retry interval fires - the
               // default case, timeout and reconnectSeconds are both 5 - reported a generic
               // "timeout whilst connecting" and threw away the reason.  see #94.
-              this.logger.info(`first connect attempt failed: ${first.message}`)
+              this.logger.info(`first connect attempt failed: ${describeConnectError(first)}`)
               this.repeatConnect(timeoutSeconds, first)
                 .then((t: MsgTransport) => { resolve(t) })
                 .catch((e: Error) => { reject(e) })
@@ -212,7 +213,7 @@ export class TcpInitiator extends FixInitiator {
             resolve(t)
           }).catch((e: Error) => {
             lastError = e
-            this.logger.info(`${name}: retries ${retries} ${e.message}`)
+            this.logger.info(`${name}: retries ${retries} ${describeConnectError(e)}`)
           })
       }, reconnectSeconds * 1000)
       // a plain timer, not a promisified one: promisify(setTimeout) hands back no
@@ -223,7 +224,10 @@ export class TcpInitiator extends FixInitiator {
       this.timeoutTh = setTimeout(() => {
         this.clearTimer()
         this.state = InitiatorState.Stopped
-        const e = lastError ?? new Error(`${name}: timeout of ${timeoutSeconds} whilst connecting`)
+        // this error is what the application catches from run() - so give it a message
+        // it can print.  An AggregateError arrives with none at all, which meant a
+        // caller handling a failed connect had nothing to report but an empty string.
+        const e = withConnectReason(lastError ?? new Error(`${name}: timeout of ${timeoutSeconds} whilst connecting`))
         this.logger.warning(`${name}: giving up after ${timeoutSeconds}s and ${retries} retries, last error: ${e.message}`)
         reject(e)
       }, timeoutSeconds * 1000)