jspurefix 5.11.1 → 5.11.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jspurefix",
-  "version": "5.11.1",
+  "version": "5.11.2",
   "description": "pure node js fix engine",
   "keywords": [
     "typescript",

package/src/buffer/fixml/fixml-parser.ts

@@ -37,7 +37,7 @@ export class FiXmlParser extends MsgParser {
     this.definitions = this.config.definitions
     const description = config.description
     const me = description?.application?.name
-    this.logger = config.logFactory.logger(`${me}:FiXmlParser`)
+    this.logger = config.logFactory.logger(`${me}:FiXmlParser`, { component: 'FixmlParser', app: me })
     this.saxStream = require('sax').createStream(true, {})
     this.locations = new Tags(maxMessageLocations)
     this.logger.info('subscribe to stream')

package/src/config/empty-log-factory.ts

@@ -1,8 +1,8 @@
-import { EmptyLogger, IJsFixLogger } from './js-fix-logger'
+import { EmptyLogger, IJsFixLogger, JsFixLogFields } from './js-fix-logger'
 import { JsFixLoggerFactory } from './js-fix-logger-factory'
 
 export class EmptyLogFactory extends JsFixLoggerFactory {
-  public logger (type: string): IJsFixLogger {
+  public logger (type: string, _?: JsFixLogFields): IJsFixLogger {
     return new EmptyLogger(type)
   }
 

package/src/config/get-js-fx-logger.ts

@@ -1,3 +1,3 @@
-import { IJsFixLogger } from './js-fix-logger'
+import { IJsFixLogger, JsFixLogFields } from './js-fix-logger'
 
-export type GetJsFixLogger = (type: string) => IJsFixLogger
+export type GetJsFixLogger = (type: string, context?: JsFixLogFields) => IJsFixLogger

package/src/config/js-fix-logger-factory.ts

@@ -1,6 +1,12 @@
-import { IJsFixLogger } from './js-fix-logger'
+import { IJsFixLogger, JsFixLogFields } from './js-fix-logger'
 
 export abstract class JsFixLoggerFactory {
-  public abstract logger (type: string): IJsFixLogger
+  /**
+   * @param type the legacy display name, e.g. 'me:peer:FixSession'.  it is what the
+   * console format renders between brackets, so it is passed verbatim and unchanged
+   * @param context fields bound to every line this logger writes.  an implementation
+   * written before this argument existed keeps compiling and simply ignores it
+   */
+  public abstract logger (type: string, context?: JsFixLogFields): IJsFixLogger
   public abstract plain (fileName: string, maxSize?: number): IJsFixLogger
 }

package/src/config/js-fix-logger.ts

@@ -1,27 +1,42 @@
+/**
+ * structured fields carried alongside a log message.
+ *
+ * two kinds travel through the same shape.  *context* is bound once when a logger is made
+ * and repeats on every line it writes - the component, the application, the counterparty.
+ * *fields* are supplied per call and carry a value worth aggregating on - a msgType, a
+ * sequence number, a byte count.
+ *
+ * they are deliberately kept as a bag rather than spread into the log record, so a caller
+ * passing { message: ... } cannot clobber the real message, and so the choice of how to
+ * render them belongs to the formatter rather than the engine.  see
+ * docs/instrumentation.md.
+ */
+export type JsFixLogFields = Record<string, unknown>
+
 export interface IJsFixLogger {
-  info: (message: string) => void
-  warning: (message: string) => void
-  debug: (message: string) => void
-  error: (e: Error) => void
+  info: (message: string, fields?: JsFixLogFields) => void
+  warning: (message: string, fields?: JsFixLogFields) => void
+  debug: (message: string, fields?: JsFixLogFields) => void
+  error: (e: Error, fields?: JsFixLogFields) => void
 }
 
 export class EmptyLogger implements IJsFixLogger {
   constructor (public readonly type: string = '') {
   }
 
-  public info (_: string): void {
+  public info (_: string, __?: JsFixLogFields): void {
     // nothing
   }
 
-  public warning (_: string): void {
+  public warning (_: string, __?: JsFixLogFields): void {
     // nothing
   }
 
-  public debug (_: string): void {
+  public debug (_: string, __?: JsFixLogFields): void {
     // nothing
   }
 
-  public error (_: Error): void {
+  public error (_: Error, __?: JsFixLogFields): void {
     // nothing
   }
 }

package/src/config/js-fix-winston-log-factory.ts

@@ -1,4 +1,4 @@
-import { IJsFixLogger } from './js-fix-logger'
+import { IJsFixLogger, JsFixLogFields } from './js-fix-logger'
 import { WinstonLogger } from './winston-logger'
 import { JsFixLoggerFactory } from './js-fix-logger-factory'
 
@@ -10,8 +10,8 @@ export class JsFixWinstonLogFactory extends JsFixLoggerFactory {
     this.wl = new WinstonLogger(options)
   }
 
-  public logger (type: string): IJsFixLogger {
-    return this.wl.make(type)
+  public logger (type: string, context?: JsFixLogFields): IJsFixLogger {
+    return this.wl.make(type, context)
   }
 
   public plain (fileName: string, maxSize?: number): IJsFixLogger {

package/src/config/winston-logger.ts

@@ -1,9 +1,15 @@
-import { IJsFixLogger } from './js-fix-logger'
+import { IJsFixLogger, JsFixLogFields } from './js-fix-logger'
 import { Logger } from 'winston'
 const { createLogger, format, transports } = require('winston')
 const { combine, timestamp, printf } = format
 
 export class WinstonLogger {
+  /**
+   * the format this engine has emitted since it shipped.  it names exactly four fields, so
+   * the context and fields bags added later are invisible to it and the rendered line is
+   * unchanged - which is the whole reason they travel as separate keys.  covered by a
+   * golden output test; do not widen it.
+   */
   public static readonly appFormat = printf((info: any) => {
     return `${info.timestamp} [${info.type}] ${info.level}: ${info.message}`
   })
@@ -12,6 +18,38 @@ export class WinstonLogger {
     return `${info.message}`
   })
 
+  /**
+   * flattens the context and fields bags to ECS style names for Filebeat and friends.
+   *
+   * this MUST mutate info rather than return a fresh object - a new object loses
+   * Symbol.for('level') and winston then discards the record with no output and no error.
+   */
+  public static readonly ecsFormat = format((info: any) => {
+    const context = info.context ?? {}
+    const fields = info.fields ?? {}
+    const err = info.err
+    delete info.context
+    delete info.fields
+    delete info.err
+    // the legacy display name is redundant once component and app are real fields
+    delete info.type
+    info['@timestamp'] = info.timestamp
+    info['log.level'] = info.level
+    info['service.name'] = 'jspurefix'
+    delete info.timestamp
+    if (err) {
+      info['error.message'] = err.message
+      info['error.stack_trace'] = err.stack
+    }
+    for (const key of Object.keys(context)) {
+      info[`fix.${key}`] = context[key]
+    }
+    for (const key of Object.keys(fields)) {
+      info[`fix.${key}`] = fields[key]
+    }
+    return info
+  })
+
   private readonly appLogger: Logger
 
   constructor (public readonly options: any = WinstonLogger.consoleOptions()) {
@@ -31,6 +69,32 @@ export class WinstonLogger {
     }
   }
 
+  /**
+   * one JSON object per line, ECS style names, ready to be harvested.  opt in - the
+   * console default is deliberately left alone so an upgrade does not move anyone's logs.
+   */
+  public static ecsOptions (level: string = 'debug'): any {
+    return {
+      format: combine(
+        timestamp(),
+        WinstonLogger.ecsFormat(),
+        format.json()
+      ),
+      level,
+      transports: [
+        new transports.Console()
+      ]
+    }
+  }
+
+  public static ecsFileOptions (fileName: string, level: string = 'debug', maxSize: number = 50 * 1024 * 1024): any {
+    return WinstonLogger.fileOptions(fileName, level, maxSize, combine(
+      timestamp(),
+      WinstonLogger.ecsFormat(),
+      format.json()
+    ))
+  }
+
   public static fileOptions (fileName: string, level: string = 'debug', maxSize: number = 50 * 1024 * 1024, format: any = combine(
     timestamp(),
     WinstonLogger.appFormat
@@ -82,31 +146,42 @@ export class WinstonLogger {
     } as IJsFixLogger
   }
 
-  public make (type: string): IJsFixLogger {
+  public make (type: string, context?: JsFixLogFields): IJsFixLogger {
     const logger = this.appLogger
     return {
-      info: function (msg: string): void {
+      info: function (msg: string, fields?: JsFixLogFields): void {
         logger.info({
           type,
-          message: msg
+          message: msg,
+          context,
+          fields
         })
       },
-      debug: function (msg: string): void {
+      debug: function (msg: string, fields?: JsFixLogFields): void {
         logger.debug({
           type,
-          message: msg
+          message: msg,
+          context,
+          fields
         })
       },
-      warning: function (msg: string): void {
+      warning: function (msg: string, fields?: JsFixLogFields): void {
         logger.warn({
           type,
-          message: msg
+          message: msg,
+          context,
+          fields
         })
       },
-      error: function (e: Error): void {
+      error: function (e: Error, fields?: JsFixLogFields): void {
         logger.error({
           type,
-          message: `${e.message} : ${e.stack}`
+          // composed exactly as it always has been, so the console line does not move.
+          // the ecs format lifts error.message and error.stack_trace off err instead
+          message: `${e.message} : ${e.stack}`,
+          err: e,
+          context,
+          fields
         })
       }
     }

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`))