Logit.io
Microsoft 365 audit logs: sign-ins, inbox rules and sharing
← Back to blog
11/20/2026 · 25 min read

Microsoft 365 audit logs: sign-ins, inbox rules and sharing

Logit.io Team
Logit.io Team
Technical Content Team

Last updated 11/20/2026

Log ManagementHow To GuidesOpensearch

The Microsoft 365 pack in the Logit.io Dashboard Library installs six OpenSearch Dashboards that read your tenant's unified audit log on filebeat-*: an overview, failed sign-ins, sharing activity, Exchange mailbox activity, DLP matches and a principal investigation view. They fill when the Filebeat o365 module pulls the Office 365 Management Activity API and ships the records through your stack's Logstash, because the panels filter on event.action, o365.audit.RecordType and fields such as event.provider, event.category and event.outcome that the module sets. Expect records 60 to 90 minutes after the activity, so treat the pack as an investigation and review tool rather than a live wire.

This guide is for teams who look after a Microsoft 365 tenant and already send, or want to send, its audit log to a Logit.io Logs stack. It's built around the questions people actually bring to the audit log: who keeps failing to sign in and from where, who created that inbox rule, which files went out on anonymous links and what DLP blocked. It covers the Entra ID app and module config, how to prove the records are arriving before you install, how to read each dashboard without being fooled by the noisy parts of the feed, the alert rules worth adding and what to do when a panel stays empty.

Contents

What the six dashboards read

Every panel in the pack starts from the same base query, in Lucene:

event.action:* AND o365.audit.RecordType:*

That keeps the pack to records the o365 module produced, even when other Beats share filebeat-*. Each dashboard then narrows it:

DashboardExtra filterUse it for
Logit.io Microsoft 365 Audit ActivityNone on the main panelsIs audit data arriving, which workloads are busy, what needs a look today
Logit.io Microsoft 365 failed sign-insevent.category:authentication AND event.outcome:failureWhich accounts fail and from which addresses
Logit.io Microsoft 365 sharing activityevent.action is one of eight sharing and link operationsGuest invitations, anonymous links and who created them
Logit.io Microsoft 365 Exchange mailbox activityevent.provider:ExchangeSend as, deletes, inbox rules and mailbox changes
Logit.io Microsoft 365 DLP matchesevent.action:DlpRuleMatchWhich people and workloads trip DLP rules
Logit.io Microsoft 365 principal investigationNone, you add the filterEverything one account or one action did, in time order

The overview's top row has six tiles: audit events, failed sign-ins, sign-in failure rate as a percentage, DLP rule matches, active users and Last event received. Under them sit audit events over time split by workload, top users by failed sign-ins, activity by workload, an Events to investigate table and an ingest errors table. Events to investigate is the one to read every morning. It lists any failed record plus six operations that usually deserve a second look:

event.outcome:failure OR event.action:(DlpRuleMatch OR New-InboxRule OR Set-InboxRule OR Set-Mailbox OR Add-MailboxPermission OR AnonymousLinkCreated)

The fields the panels group on are ECS fields that the o365 module writes from the raw audit schema: Operation becomes event.action, Workload becomes event.provider (AzureActiveDirectory, Exchange, SharePoint, OneDrive and so on), UserId becomes user.id and the client address becomes source.ip. The original record stays under o365.audit.* with its Microsoft field names, which is where you'll find LogonError, ObjectId, Parameters and TargetUserOrGroupName when a table row needs explaining.

From tenant to filebeat-* and where the delay comes from

Four hops sit between someone signing in and a row in the failed sign-ins table, and two of them add time you can't remove:

Microsoft 365 writes audit records for Entra ID sign-ins, Exchange, SharePoint and DLP. The Management Activity API publishes them in content blobs that one Filebeat o365 module instance pulls and maps to ECS fields. Your stack's Logstash receives them over Beats SSL and stores them in daily filebeat indices, where the six Microsoft 365 dashboards and your alert rules read them
  1. Microsoft 365 writes the record. The unified audit log has to be on for the tenant. It is by default on most tenants, but check it rather than assume.
  2. The Management Activity API publishes it. Records are grouped into content blobs per content type: Audit.AzureActiveDirectory, Audit.Exchange, Audit.SharePoint, Audit.General and DLP.All. Microsoft's guidance is that core services usually appear 60 to 90 minutes after the event, some take longer, and a brand-new subscription can take up to 12 hours to return its first blob. Records inside a blob aren't guaranteed to be in time order either.
  3. Filebeat pulls and maps it. The o365 module authenticates as an Entra ID app, polls each content type, and turns the raw JSON into ECS fields in Filebeat itself, before anything is sent. It keeps its position in the Filebeat registry, so a restart carries on where it stopped.
  4. Your stack's Logstash stores it. Filebeat sends to the Beats SSL port on your Logs stack, and Beats events are written to daily filebeat-* indices with the Beats mapping. ECS strings such as event.action and user.id are keyword fields there, which is why the panels group on event.action rather than event.action.keyword.

The module sets @timestamp from the record's CreationTime, the moment the activity happened, not when it reached your stack. That's the right choice for investigation. It also means the last hour of any time range is always thin and fills in later, which matters for alert rules further down.

Register the app and run one Filebeat per tenant

Filebeat doesn't need to run anywhere near Microsoft. Any small Linux host or VM that can reach login.microsoftonline.com and manage.office.com over HTTPS, and your stack's Beats SSL port, will do. Run exactly one instance per tenant. Two instances with the same app both pull every blob, and you'll see every event twice.

First confirm auditing is on. In Exchange Online PowerShell:

Connect-ExchangeOnline
Get-AdminAuditLogConfig | Format-List UnifiedAuditLogIngestionEnabled

True means records are being written. If it says False, turn auditing on in the Microsoft Purview portal and expect a delay before records exist at all.

Then register the app in the Microsoft Entra admin center:

  1. Under App registrations, choose New registration, give it a name such as logit-audit-reader and keep it single tenant. No redirect URI is needed.
  2. Note the Application (client) ID and the Directory (tenant) ID from the overview page.
  3. Under API permissions, choose Add a permission, then Office 365 Management APIs, then Application permissions, and add ActivityFeed.Read and ActivityFeed.ReadDlp. Choose Grant admin consent. Without consent, every request fails even though the permissions are listed.
  4. Under Certificates & secrets, create a client secret and copy its value straight away. Put its expiry date in a calendar. An expired secret is the most common reason this feed stops months after it was set up.

Open the Microsoft 365 integration guide while signed in to Logit.io and choose Install Integration for the stack you're sending to, which configures the stack for this source. Then install Filebeat 8.x on the host from Elastic's package repository, as the guide shows. Keep the secret in the Filebeat keystore rather than in YAML:

export O365_CLIENT_ID='<application-client-id>'
export O365_TENANT_ID='<directory-tenant-id>'
export O365_CLIENT_SECRET='<client-secret-value>'
sudo filebeat keystore list >/dev/null 2>&1 || sudo filebeat keystore create
printf '%s' "$O365_CLIENT_ID" | sudo filebeat keystore add O365_CLIENT_ID --force --stdin
printf '%s' "$O365_TENANT_ID" | sudo filebeat keystore add O365_TENANT_ID --force --stdin
printf '%s' "$O365_CLIENT_SECRET" | sudo filebeat keystore add O365_CLIENT_SECRET --force --stdin
unset O365_CLIENT_SECRET

Then the module file, /etc/filebeat/modules.d/o365.yml:

- module: o365
  audit:
    enabled: true
    var.application_id: ${O365_CLIENT_ID}
    var.tenants:
      - id: ${O365_TENANT_ID}
        name: yourcompany.onmicrosoft.com
    var.client_secret: ${O365_CLIENT_SECRET}
    # Leave content types at the default (all five) so every dashboard can fill.
    # var.content_type:
    #   - "Audit.AzureActiveDirectory"
    #   - "Audit.Exchange"
    #   - "Audit.SharePoint"
    #   - "Audit.General"
    #   - "DLP.All"

And /etc/filebeat/filebeat.yml, with the Logstash host and Beats SSL port from your stack's settings:

filebeat.config.modules:
  path: ${path.config}/modules.d/*.yml
output.logstash:
  hosts: ["<your-logstash-host>:<beats-ssl-port>"]
  loadbalance: true
  ssl.enabled: true

The name under var.tenants is your tenant's domain. It labels the events but doesn't authenticate anything, so a typo there won't break the feed. A wrong id will. Don't narrow var.content_type to save volume unless you're sure: drop DLP.All and the DLP dashboard stays empty, and drop Audit.AzureActiveDirectory and so does the failed sign-ins dashboard.

The module's var.api.max_retention defaults to 168h, the seven days the API keeps content. If the tenant already had an active subscription for the Activity API, from another tool for example, the first run can pull back up to a week of records in one go. That's useful for a baseline, but it lands as a burst of volume on day one, and the dashboards' 24-hour default range will only show the newest part of it.

Start it and test the output:

sudo filebeat test config
sudo filebeat test output
sudo systemctl enable filebeat && sudo systemctl restart filebeat
sudo journalctl -u filebeat --since "15 min ago" --no-pager | grep -i o365

filebeat test output should end with talk to server... OK. In the journal, an AADSTS7000215 error means the client secret is wrong or has expired, and AADSTS90002 (tenant not found) means the tenant ID isn't the Directory (tenant) ID GUID. A clean journal with no events yet is normal for the first hours on a new subscription.

Check the first records before you install

Give the feed something specific to find. Sign in to Microsoft 365 with a test account and get the password wrong twice, then sign in properly. Wait an hour or two. Then in Discover, choose filebeat-*, set the query language to Lucene, set the time picker to the last 4 hours and run:

event.module:o365 AND event.provider:AzureActiveDirectory AND user.id:"[email protected]"

You should see UserLoginFailed records with event.outcome failure and a UserLoggedIn with success, each with event.category authentication, a source.ip and o365.audit.RecordType 15. The failed ones carry o365.audit.LogonError InvalidUserNameOrPassword. Open one and check @timestamp matches when you typed the password, not when the record arrived.

Next, check the field types with the OpenSearch API on your stack. The endpoint and stack API key are on the Endpoints page in your stack settings, and the guide to connecting to your stack's OpenSearch API covers both authentication modes. In API key mode:

curl -s "https://<stack-id>-es.logit.io/filebeat-*/_field_caps?fields=event.action,event.provider,event.category,event.outcome,user.id,source.ip,o365.audit.RecordType,o365.audit.LogonError&apikey=<stack-api-key>&pretty"

You want every one of those as keyword, except source.ip as ip and o365.audit.RecordType as long (it's a number in the raw record), and aggregatable: true on event.action and event.provider, which the Library's detection depends on. If a field comes back as text on some indices and keyword on others, the events didn't arrive as Beats events for part of the range. That usually means something other than Filebeat wrote to filebeat-*. Index templates on Logs stacks are managed, so fix how the events are shipped rather than trying to change the mapping, and the older daily indices keep their first type until they age out.

Finally, count what the Library will see. Detection looks at the last 24 hours of filebeat-* for event.module: o365 or event.dataset: o365.audit, and it checks for the kinds of records the failed sign-ins, sharing, Exchange and DLP dashboards read:

curl -s -H 'Content-Type: application/json' \
  "https://<stack-id>-es.logit.io/filebeat-*/_search?apikey=<stack-api-key>" -d '{
  "size": 0,
  "query": { "bool": { "filter": [
    { "range": { "@timestamp": { "gte": "now-24h" } } },
    { "term":  { "event.module": "o365" } }
  ] } },
  "aggs": {
    "workloads": { "terms": { "field": "event.provider" } },
    "sign_ins":  { "filter": { "term": { "event.category": "authentication" } } },
    "dlp":       { "filter": { "term": { "event.action": "DlpRuleMatch" } } },
    "sharing":   { "filter": { "terms": { "event.action": [
      "SharingSet", "SharingInvitationCreated", "SharingInvitationAccepted", "SharingRevoked",
      "AnonymousLinkCreated", "AnonymousLinkUsed", "SecureLinkCreated", "AddedToSecureLink" ] } } }
  }
}'

An illustrative response from a small tenant looks like this (trimmed):

"aggregations": {
  "workloads": { "buckets": [
    { "key": "Exchange", "doc_count": 4120 },
    { "key": "SharePoint", "doc_count": 2380 },
    { "key": "AzureActiveDirectory", "doc_count": 1544 },
    { "key": "OneDrive", "doc_count": 611 } ] },
  "sign_ins": { "doc_count": 1544 },
  "dlp": { "doc_count": 0 },
  "sharing": { "doc_count": 37 }
}

A missing workload tells you which content type to look at. A zero for dlp is normal if you don't have DLP policies, and that dashboard will simply show its empty state.

Install the pack and read the overview

Open your Logs stack's card in your Logit.io account and choose Dashboard Library. Search for Microsoft 365. Once records have arrived in the last 24 hours, the pack shows a Data detected badge, and dashboards with matching records arrive ticked. If you've only just started shipping, press Rescan stack after the first records appear. Choose Select all beside the pack, or keep only the dashboards you'll use, then Install dashboards, and open OpenSearch Dashboards a minute or two later. The Dashboard Library guide covers the permissions you need and what gets installed, and the post on how Dashboard Library detection works explains the badge and the ticks in more depth.

Every dashboard opens on the last 24 hours. There are no dropdown controls: narrow with the search bar, or click a slice or a bar to add a filter, which then applies to every panel on the page. Read Last event received first. It shows the newest @timestamp in range, and because of the API's delay a value 60 to 90 minutes old is healthy. Its description treats anything older than two hours as stale. On a weekday, more than three or four hours behind usually means Filebeat has stopped or the secret has expired.

The Sign-in failure rate tile divides failed authentication records by all authentication records with a success or failure outcome. A tenant with modern authentication and MFA will rarely sit at zero, for reasons the next section explains, so learn your normal number in the first week and look for changes rather than an absolute.

Failed sign-ins: separate interrupts from attacks

The failed sign-ins dashboard counts every authentication record with event.outcome:failure. In the audit feed, Entra ID sign-in failures arrive as UserLoginFailed with RecordType 15, and the reason is in o365.audit.LogonError. Not all of them are failures in the sense you care about. Two of the most common are steps in a normal sign-in:

LogonErrorEntra codeWhat happenedWorry?
KmsiInterrupt50140The "Stay signed in?" prompt interrupted the sign-inNo, part of the normal flow
UserStrongAuthClientAuthNRequiredInterrupt50074MFA was required and not completed in that requestUsually no, unless it repeats for one account from an unfamiliar address
InvalidUserNameOrPassword50126Wrong password or user nameIn bursts or across many accounts, yes
IdsLocked50053Account locked after repeated attempts, or sign-in blocked from a suspicious addressYes, look at the source addresses
UserDisabled50057The account is disabledYes if it's a leaver's account still being tried
InvalidPasswordExpiredPassword50055The password has expiredRarely, it's a helpdesk ticket

To see the failures that matter, add a query in the dashboard's search bar that removes the interrupts:

NOT o365.audit.LogonError:(KmsiInterrupt OR UserStrongAuthClientAuthNRequiredInterrupt)

Save it as a saved query so the whole team uses the same view. With the interrupts gone, two patterns stand out on the dashboard's Failed users and Source IP addresses pies:

  • One account, many addresses or many failures. A person who's forgotten a password fails from one or two addresses and then succeeds. A failing stream from many addresses against one account, with InvalidUserNameOrPassword and then IdsLocked, is someone guessing. Check the Successful sign-ins tile for the same account in the same range, because a guess that worked looks like a run of failures followed by a success from an address you haven't seen before.
  • One address, many accounts. Click a slice in the Source IP addresses pie to filter on it. If the Failed users pie then shows dozens of accounts with one or two failures each, that's password spraying. A spray deliberately stays under per-account lockout, so you won't see IdsLocked, and it won't show up in the top users bar either.

Then confirm the address in Discover with the full records:

event.module:o365 AND event.category:authentication AND source.ip:"203.0.113.30"

(Use the address from the pie.) The user.id values and o365.audit.LogonError across the hits tell you whether any guess succeeded. If one did, the next two sections are where you look.

Inbox rules and forwarding you didn't set up

After a mailbox is taken over, the first change is very often a rule that forwards mail out of the tenant or hides replies from the real owner. The Exchange mailbox activity dashboard shows send, delete and rule activity, and its Mailbox rule events tile counts New-InboxRule, Set-Mailbox and New-TransportRule. The overview's Events to investigate table also picks up Set-InboxRule and Add-MailboxPermission.

The parameters of each change are kept as fields, because the module turns Exchange's name and value list into an object under o365.audit.Parameters. That lets you search for forwarding directly:

event.provider:Exchange AND event.action:(New-InboxRule OR Set-InboxRule OR Set-Mailbox) AND (_exists_:o365.audit.Parameters.ForwardTo OR _exists_:o365.audit.Parameters.RedirectTo OR _exists_:o365.audit.Parameters.ForwardAsAttachmentTo OR _exists_:o365.audit.Parameters.ForwardingSmtpAddress OR _exists_:o365.audit.Parameters.ForwardingAddress OR _exists_:o365.audit.Parameters.DeliverToMailboxAndForward)

Rules that hide mail are just as telling. Look for New-InboxRule records that move to RSS Feeds, Archive or Deleted Items, or delete outright:

event.action:(New-InboxRule OR Set-InboxRule) AND (_exists_:o365.audit.Parameters.DeleteMessage OR _exists_:o365.audit.Parameters.MoveToFolder)

Read who made the change as well as whose mailbox it was. user.id is the account that ran the operation, and o365.audit.ObjectId or o365.audit.Parameters.Identity is the mailbox it changed. An administrator setting forwarding for a leaver's mailbox is routine. A user setting it on their own mailbox from an address that appeared in the failed sign-ins dashboard an hour earlier isn't.

Two gaps are worth knowing. Removing forwarding can also log Set-Mailbox with the forwarding parameter present but empty, so read the value before you raise an alarm. And rules created in the Outlook desktop client can be logged as UpdateInboxRules rather than New-InboxRule, which the pack's tiles don't count. Add it to your saved search:

event.provider:Exchange AND event.action:UpdateInboxRules

The sharing activity dashboard covers eight operations: SharingSet, SharingInvitationCreated, SharingInvitationAccepted, SharingRevoked, AnonymousLinkCreated, AnonymousLinkUsed, SecureLinkCreated and AddedToSecureLink. The Anonymous link events tile is the one to watch, because an anyone link works for whoever has it. In the Sharing events to investigate table, the file is in o365.audit.ObjectId (a full SharePoint or OneDrive URL) and the person who shared it is user.id. For guest invitations, o365.audit.TargetUserOrGroupName and o365.audit.TargetUserOrGroupType tell you who was invited and whether they're a guest.

A useful weekly check is anonymous links on sensitive sites. Adjust the path to your own site names:

event.action:AnonymousLinkCreated AND o365.audit.ObjectId:*\/sites\/finance\/*

AnonymousLinkUsed on the same ObjectId afterwards tells you the link was opened. It doesn't tell you by whom, because that's the point of an anyone link.

The DLP matches dashboard reads DlpRuleMatch records from the DLP.All content type, which is why the app needs ActivityFeed.ReadDlp. It splits matches by actor and by workload, so you can see whether matches come from SharePoint files or Exchange mail. When a policy blocks access, the record's event.outcome is failure, and those records also appear in the overview's Events to investigate table. Policy and rule names are under o365.audit.PolicyDetails. The DLP panels are marked optional in the pack: if your tenant doesn't license DLP or has no policies, they show an empty state rather than an error.

Follow one account across workloads

The principal investigation dashboard has no filter of its own. It's there for the moment someone asks "what else did this account do?" Open it, set the time range wide enough to cover the incident (a week is a good start), and add a filter on user.id. The Activity over time histogram shows when the account was busy, the Workloads and Actions pies show where, and the Principal investigation table lists every record in time order with action, source address, outcome and workload.

A typical takeover reads top to bottom as a story: failed sign-ins from a new address, a success from the same address, an inbox rule, a burst of Send or MailItemsAccessed records if your licence logs them, then file downloads or sharing in SharePoint. You can work the other way too: filter on source.ip instead of user.id to see every account an address touched.

Keep the window in mind. The Management Activity API only serves the last seven days, so the history you can investigate is whatever your stack has kept since Filebeat started, within your stack's retention. If you need audit records for longer than that, size the stack's retention for it before the incident rather than after.

Alert rules that allow for audit delay

Dashboards tell you what happened when you look. Logs stacks also include alerting with ElastAlert 2 rules, which you enable from Alerting & Notifications in your stack settings; the guide to creating alerting rules walks through it. Audit records need one change from the usual rule. ElastAlert queries a recent window of @timestamp, and these records arrive an hour or more after their @timestamp, so a default rule looks at a window that hasn't filled yet. Set query_delay so each run looks at a window that has, and keep buffer_time wide enough to catch stragglers.

First, repeated real failures against one account, with the frequency rule type:

name: Microsoft 365 repeated sign-in failures per account
type: frequency
index: "filebeat-*"
num_events: 15
timeframe:
  minutes: 30
query_key: user.id
query_delay:
  minutes: 120
buffer_time:
  minutes: 60
filter:
  - query:
      query_string:
        query: 'event.module:o365 AND event.category:authentication AND event.outcome:failure AND NOT o365.audit.LogonError:(KmsiInterrupt OR UserStrongAuthClientAuthNRequiredInterrupt)'
realert:
  hours: 2
alert:
  - "email"
email:
  - "[email protected]"

Second, any new forwarding, with the any rule type. These are rare enough that every one deserves a message. It also fires when someone clears forwarding, because that logs the same parameter with an empty value, so check the value before acting. Rules created in Outlook desktop log as UpdateInboxRules without these parameters, so keep the UpdateInboxRules saved search as well:

name: Microsoft 365 mail forwarding set
type: any
index: "filebeat-*"
query_delay:
  minutes: 120
buffer_time:
  minutes: 60
filter:
  - query:
      query_string:
        query: 'event.provider:Exchange AND event.action:(New-InboxRule OR Set-InboxRule OR Set-Mailbox) AND (_exists_:o365.audit.Parameters.ForwardTo OR _exists_:o365.audit.Parameters.RedirectTo OR _exists_:o365.audit.Parameters.ForwardAsAttachmentTo OR _exists_:o365.audit.Parameters.ForwardingSmtpAddress OR _exists_:o365.audit.Parameters.ForwardingAddress)'
include:
  - "user.id"
  - "source.ip"
  - "event.action"
  - "o365.audit.ObjectId"
  - "o365.audit.Parameters"
realert:
  minutes: 0
alert:
  - "email"
email:
  - "[email protected]"

Third, the feed itself stopping, with the flatline rule type. An expired client secret fails quietly from Microsoft's side, so this is the rule that saves you from finding a two-week gap during an incident:

name: Microsoft 365 audit feed stopped
type: flatline
index: "filebeat-*"
threshold: 1
timeframe:
  hours: 6
filter:
  - query:
      query_string:
        query: 'event.module:o365'
realert:
  hours: 6
alert:
  - "email"
email:
  - "[email protected]"

Six hours is deliberately long. Blob delivery is lumpy, and a small tenant can be quiet for a few hours overnight. Run each rule with Test only before enabling it to see how often it would have fired over recent data, and tune num_events to your tenant: fifteen in half an hour is a starting point for a few hundred users, not a rule of nature. If you'd rather hear about a first sign-in from a country or address an account has never used, the new term rule type can watch the combination of user.id and source.ip, but expect noise from people travelling and from mobile networks.

When a panel stays empty or the counts look wrong

Nothing at all after a day. Check the Filebeat journal first. Authentication errors (AADSTS codes) mean the app ID, tenant ID or secret is wrong, or admin consent wasn't granted. If the journal shows the module polling without errors and still nothing arrives, check auditing is on with Get-AdminAuditLogConfig and remember the first blobs on a new subscription can take up to 12 hours.

The pack has no Data detected badge, but Discover shows events. Detection only reads filebeat-* and the last 24 hours. If your events are in another index family, because a Logstash pipeline or a different shipper renamed them, the pack won't detect them and its panels won't read them either. Send the module's output to your stack's Logstash as a Beats event so it lands in filebeat-*. If the events are there but older than 24 hours, sign in with a test account, wait for the record, then press Rescan stack.

The overview fills but failed sign-ins is empty. Either Audit.AzureActiveDirectory was left out of var.content_type, or the records are arriving without event.category. Run event.module:o365 AND event.provider:AzureActiveDirectory in Discover and open a UserLoginFailed record. If it has no event.category, something between Filebeat and the stack rewrote it, and the fix is to send the raw module output.

Workload names mixed with numbers. If a bar chart that you built yourself shows buckets like 15 or 14, it's grouping on o365.audit.RecordType, which is a numeric code per record type. Group on event.provider for workloads, as the pack does.

No country or city on the records. Country and city are optional enrichments under source.geo.*, and no panel in the pack relies on them. If they're missing, the source IP pies and tables still work. Don't build searches or alert rules on country until you've confirmed the field is populated on your events.

Every event appears twice. Two Filebeat instances are pulling the same tenant with the same app. Stop one. The duplicates already stored stay until their indices age out, so compare by o365.audit.Id, which is the same on both copies, if you need exact counts for that period.

Ingest errors. The overview's Ingest errors table lists events tagged pipeline_error. Failures on the o365 path show up differently: your stack's pipeline sets error.message, and Filebeat's script processor tags _js_exception. Search event.module:o365 AND (_exists_:error.message OR tags:_js_exception) in Discover. A handful from one unusual record type is a parsing edge case and doesn't affect the other panels. A steady stream across all actions means something is reprocessing the events.

What the audit feed won't tell you

  • It's not real time. 60 to 90 minutes is typical and longer happens. For identity attacks in progress, Entra ID's own protections (lockout, Conditional Access, risk policies) act first. This feed is for seeing what happened, proving it to someone else and catching what those controls let through.
  • It's not the full Entra ID sign-in log. The unified audit log has interactive sign-in records, but Entra ID's own sign-in logs carry more, including non-interactive and service principal sign-ins and Conditional Access details. Those are exported through Azure Monitor diagnostic settings, a separate setup that this pack doesn't read.
  • What's logged depends on licence and settings. Some Exchange mailbox actions, such as MailItemsAccessed, depend on your licence and mailbox auditing configuration. Check what your tenant records before you rely on an action being there.
  • The records are sensitive. They name people, files, recipients and addresses. Check who can see filebeat-* on your stack, and keep retention to what you need for investigations and compliance.
  • Volume varies a lot by tenant. SharePoint and OneDrive file activity can dwarf everything else in a busy tenant. Look at the overview's activity by workload after the first full day so the daily volume doesn't surprise you.

Start Free Trial

Unlock complete visibility with hosted ELK, Grafana, and Prometheus-backed Observability

Start Free Trial

FAQ

Why are the last two hours on the dashboards always low?

Because @timestamp is when the activity happened, and Microsoft publishes most records 60 to 90 minutes later. The recent end of every chart fills in as blobs arrive. Judge trends on ranges that end at least two hours ago, and use the Last event received tile to tell a normal delay from a stopped feed.

Why is our sign-in failure rate never zero?

Normal sign-ins produce UserLoginFailed records for the "Stay signed in?" prompt (KmsiInterrupt) and for MFA challenges (UserStrongAuthClientAuthNRequiredInterrupt). The pack counts every failed authentication event, so those are in the rate. Add NOT o365.audit.LogonError:(KmsiInterrupt OR UserStrongAuthClientAuthNRequiredInterrupt) to the search bar to see real failures.

Our DLP dashboard is empty. Is something broken?

Probably not. It needs DLP policies that match something, the DLP.All content type in the module config and the ActivityFeed.ReadDlp permission on the app. If all three are in place and nothing has matched, the panels show their empty state, which is the right answer.

Can one Filebeat collect from several tenants?

Yes. var.tenants takes a list of tenant IDs and names, and the app must be registered as multi-tenant and consented in each tenant. Each event carries its tenant, so filter on o365.audit.OrganizationId in the dashboards when you need one tenant at a time. Keep it to one Filebeat for the whole list, or you'll pull everything twice.

Why are the events in filebeat-* rather than logstash-*?

Events from Beats sent through your stack's Logstash are written to daily filebeat-* indices, which use the Beats mapping with ECS strings as keywords. Data sent to Logstash without a Beat goes to logstash-*, where strings are text with .keyword sub-fields. The pack and its detection only read filebeat-*.

Can I try this on the free trial?

Yes. The free trial includes every feature, including the Dashboard Library, alerting and Hosted OpenSearch MCP. Register the app, point one Filebeat at your tenant and install the pack once the first records arrive.

Next steps

Check auditing is on, register the Entra ID app with both Activity API permissions and admin consent, put the secret in the Filebeat keystore and start one Filebeat with the o365 module. Fail a test sign-in, find it in Discover with its LogonError, then install the Microsoft 365 pack and add the forwarding and feed-stopped alerts. Save the interrupt-free failed sign-ins query so everyone reads the same numbers. If you also look after Linux servers, the guide to Linux auth log dashboards covers SSH sign-ins and password spraying on the host side. If you're running your own OpenSearch cluster for security logs, a Logit.io Logs stack gives you managed Logstash, OpenSearch and OpenSearch Dashboards with the Dashboard Library built in. For a dedicated cluster, see Hosted OpenSearch and OpenSearch pricing. To ask questions of the same audit records from any MCP-compatible AI assistant, such as which accounts an address tried this week, see Hosted OpenSearch MCP.

Get the latest Elastic Stack & logging resources when you subscribe

Want to see this in action?
Start a free trial and connect logs to your alert workflows.