src/App/Entity/ActivityMonitoringEvent.php line 53

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Command\DatabaseCleanups;
  6. use App\Utility\GuidUtility;
  7. use DateTime;
  8. use Doctrine\ORM\Mapping as ORM;
  10. /**
  11. * Activity Monitoring Events: track what users do in order to decide if their behaviour is problematic and should be reported.
  12. *
  13. * While Business-, Application-, and Webrequest-Events are tracked for statistical use in the Data Warehouse, and Usage
  14. * Events used to change the platform behaviour according to a user's behaviour, Activity Monitoring Events are collected
  15. * to decide if a given user misuses or overuses the platform, which triggers an alarm.
  16. *
  17. * Usage and Activity Monitoring Events look very similar at first glance, but have some important differences and serve
  18. * very different purposes:
  19. *
  20. * - Usage Events are much leaner - instead of writing a new event entry for every relevant action the user takes, we
  21. * only store the info *that* he did something *at least* once, and merely update a counter if the action is repeated.
  22. * This is because most of the time, decisions that are based on Usage Events only need to know if a user not yet did
  23. * something, already did something, and sometimes, how often and when they did it the last time. In other words,
  24. * this is a very *qualitative* perspective
  25. *
  26. * - Activity Monitoring Events, on the other hand, provide a much more *quantitative* perspective. Because we need to
  27. * know if a user over-uses the platform, we need to know *how often* a user did something in a certain *time frame*.
  28. * For example, while writing many conversation messages is fine, writing a thousand conversation messages within the
  29. * last 24 hours would be considered over-use.
  30. *
  31. * In order to answer these "how often did user X do action Y in timeframe Z?" questions, we need to keep track of every
  32. * single occurrence of the action, while for Usage Events, it's sufficient to only increase a counter.
  33. *
  34. * Also, Activity Monitoring is more short-lived; we normally won't be interested in tracking user behaviour over more
  35. * than a couple of weeks, because alarming is based on misbehaviour during timeframes of hours or days. This is why
  36. * old Activity Monitoring Events can be wiped on a regular base via @see DatabaseCleanups, which mitigates the
  37. * disadvantage of their large data volume a bit.
  38. *
  39. * On the other hand, we generally keep Usage Events forever (or at least, until the related User is removed), because
  40. * we need the answers they provide all the time - which is no problem data volume wise, because Usage Events are very
  41. * lean.
  42. *
  43. * @ORM\Entity()
  44. *
  45. * @ORM\Table(
  46. * name="activity_monitoring_events",
  47. * indexes={
  48. *
  49. * @ORM\Index(name="timerange_search_idx", columns={"users_id", "event_type", "occurred_at"})
  50. * }
  51. * )
  52. */
  53. class ActivityMonitoringEvent
  54. {
  55. public const EVENT_TYPE_CONVERSATION_MESSAGE_SENT_BY_USER = 1;
  56. public const EVENT_TYPE_SEARCH_STARTED = 2;
  58. /**
  59. * @var string
  60. *
  61. * @ORM\GeneratedValue(strategy="CUSTOM")
  62. *
  63. * @ORM\CustomIdGenerator(class="App\Utility\DatabaseIdGenerator")
  64. *
  65. * @ORM\Column(name="id", type="guid")
  66. *
  67. * @ORM\Id
  68. */
  69. protected $id;
  71. public function getId()
  72. {
  73. return $this->id;
  74. }
  76. public function setId(string $id): void
  77. {
  78. GuidUtility::validOrThrow($id);
  79. $this->id = $id;
  80. }
  82. /**
  83. * @var User
  84. *
  85. * @ORM\ManyToOne(targetEntity="App\Entity\User", cascade={"persist"})
  86. *
  87. * @ORM\JoinColumn(name="users_id", referencedColumnName="id", nullable=false, onDelete="CASCADE")
  88. */
  89. protected $user;
  91. public function getUser(): User
  92. {
  93. return $this->user;
  94. }
  96. public function setUser(User $user): void
  97. {
  98. $this->user = $user;
  99. }
  101. /**
  102. * @var int
  103. *
  104. * @ORM\Column(name="event_type", type="smallint", nullable=false)
  105. */
  106. protected $eventType;
  108. public function getEventType(): int
  109. {
  110. return $this->eventType;
  111. }
  113. public function setEventType(int $eventType): void
  114. {
  115. $this->eventType = $eventType;
  116. }
  118. /**
  119. * @var DateTime
  120. *
  121. * @ORM\Column(name="occurred_at", type="datetime", nullable=false)
  122. */
  123. protected $occurredAt;
  125. public function getOccurredAt(): DateTime
  126. {
  127. return $this->occurredAt;
  128. }
  130. public function setOccurredAt(DateTime $occurredAt): void
  131. {
  132. $this->occurredAt = $occurredAt;
  133. }
  134. }