jspurefix 5.11.1 → 5.11.3

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/recovering-tcp-initiator.ts

@@ -39,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.')
     }

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

@@ -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.')
     }