general question
429 TopicsSharepoint lists mirroring issue
Hello, We currently face an issue with sharepoint lists mirroring in microsoft fabric and we have no clue what can happen because the error message is pretty useless : In fact, we are mirroring more than 20 lists but only half of them succeed. The others failed with the following error : Internal system error occurred. ArtifactId: daa35143-...-5aa6accfec68, SequenceNumber: 9 I have linked an eventhouse but the error message is still the same, no more information: Internal system error occurred. ArtifactId: daa35143-...-5aa6accfec68, SequenceNumber: 9 How can I have more information about the issue ? Thank you very much for your help, Regards14Views0likes0CommentsFabric Business Events: what delivery guarantees and replay pattern should we design for?
Hi all, I am testing the newer Business Events capability in Fabric Real-Time Intelligence and trying to understand what reliability assumptions should be made for a production design. The pattern I am looking at is roughly: Eventstream → Business Event → Activator → downstream action / User Data Function with Eventhouse enabled so the published business events are also retained for historical analysis. The current documentation explains the publisher/consumer model and shows how Eventstream can publish a governed business event that Activator then consumes. What I have not been able to find clearly documented is the delivery contract between the published business event and its consumers. A few things I am trying to clarify: If an Activator consumer or downstream action is temporarily unavailable, does Fabric retry delivery of the business event? Should consumers assume at-least-once delivery and therefore be designed to handle duplicate events, or is a different delivery model used? Is event ordering guaranteed in any scope, for example for events from the same Eventstream publisher? Since published business events can also be retained automatically in Eventhouse, is that retained history intended to support replay/reprocessing after a consumer outage, or is it primarily an analytical record and replay would need to be implemented separately? Are there documented retry or delivery-retention windows that should be considered when designing an operational workflow? I am mainly trying to understand what a resilient production pattern should look like when the business event triggers something with side effects, where processing the same event twice or silently missing an event would matter. Would you generally make the downstream consumer idempotent and treat Eventhouse as an audit/recovery store, or is there a more Fabric-native pattern for this? Interested to hear how others are approaching this with Business Events and Activator.84Views0likes3CommentsBest practice for handling schema evolution in Fabric Eventstream before data reaches Eventhouse?
I have an Eventstream receiving operational events where the schema may evolve over time. For example, the producer initially sends: DeviceId, Timestamp, Temperature, Status but later adds fields such as: Location, FirmwareVersion, ErrorCode I want the pipeline to continue ingesting events without breaking downstream KQL tables, update policies, materialized views, or Real-Time Dashboards. I am trying to understand where schema evolution should ideally be handled in a production Fabric RTI architecture. Would you: enforce the contract upstream using Schema Registry normalize changing fields inside Eventstream before Eventhouse ingestion land the raw payload first and handle schema evolution inside Eventhouse/KQL maintain separate versioned event schemas/tables How are people handling this in production when producers can add fields without notice? I am particularly interested in avoiding a design where every small upstream schema change forces updates across Eventstream, KQL tables, update policies, and downstream dashboards.Solved106Views0likes2CommentsInfrastructure and licensing costs for adopting Fabric Planning in production (business case)
Hi everyone, We're evaluating Fabric Planning for a client who wants to adopt it in production, and I need to put together a business case with the associated costs. I've already reviewed the role-based session model (Viewer/Stakeholder/Planner, ~37/168/847 CU-hours per 30-day session) and the F64+ capacity requirement for the XMLA endpoint, but I have a few specific questions on infrastructure and licensing that the documentation didn't fully answer: Per-user licensing: besides the capacity (F64+), is any individual license required (Power BI Pro or Premium Per User) for each Viewer/Stakeholder/Planner user, or does the session's CU consumption already cover full access? Production sizing: beyond the technical F64 minimum, what capacity size would you recommend as a practical floor for a real production scenario with several concurrent users, factoring in the ~30% additional infrastructure buffer (OneLake, XMLA API, etc.)? Billing status: is session/role-based billing already in effect (general availability), or is preview usage still free right now? Regional pricing differences: is there any regional price variation we should account for with a client outside the US (Latin America)? Any real-world sizing experience or business-case examples you can share would be much appreciated. Thanks in advance!56Views0likes1CommentBest practice for deciding between Eventstream transformations and Eventhouse update policies
Hi Fabric Community, I am exploring a Real-Time Intelligence architecture and would appreciate some guidance on where transformation logic should ideally be placed. The proposed flow is: Azure Event Hubs → Fabric Eventstream → Eventhouse → Real-Time Dashboard / Power BI Fabric Eventstream supports filtering, field management, aggregation and other processing before events are written to the destination. An Eventhouse can also ingest the raw events first and transform them into curated tables through KQL update policies. I am trying to understand the recommended boundary between these two layers. For example, assume the incoming event contains: Device or customer identifier Event timestamp Event type Location Numeric readings Additional JSON properties The required processing includes: Removing events that fail basic validation Renaming and standardizing fields Converting timestamps and data types Flattening selected JSON properties Enriching the event with reference data Creating five-minute aggregates Preserving the original event for auditing and future reprocessing My current thinking is: Use Eventstream for lightweight filtering, routing and simple schema normalization. Land the original event in a Bronze table whenever replay or auditing is required. Use Eventhouse update policies or KQL for enrichment, reusable business logic and curated Silver tables. Use materialized views for frequently queried aggregations rather than calculating them repeatedly in dashboards. However, I am unsure where Microsoft recommends drawing the line. A few questions: Are there transformation types that should generally remain in Eventstream rather than Eventhouse? Is it considered good practice to send both the raw stream and a transformed derived stream into separate Eventhouse tables? When using Eventstream’s Event processing before ingestion mode, what are the trade-offs compared with direct ingestion followed by an Eventhouse update policy? How do teams handle changes to transformation logic when historical events need to be reprocessed? For reference-data enrichment, would you normally perform the lookup in Eventstream or after ingestion with KQL? Are five-minute or hourly aggregations better implemented in Eventstream, through an update policy, or with an Eventhouse materialized view? Microsoft’s Eventstream destination guidance documents both direct ingestion and event processing before ingestion, while the KQL update-policy documentation provides another way to transform ingested data. I would be interested to hear how others divide responsibility between Eventstream and Eventhouse in production, particularly where auditability, reprocessing and maintainability are important. Thanks in advance!Solved109Views0likes2CommentsBest patterns for ingesting dynamic tax & compliance API data into Fabric Lakehouse?
Hi everyone, We are currently migrating our firm's analytical workloads to Microsoft Fabric. A huge part of our business involves tracking dynamic regional tax rates, company registration statuses, and financial compliance data for startups. Currently, our analysts manually pull this data from external regulatory sources and calculators, like this FBR Sales Tax Calculator, and we import it via Excel/CSV into Power BI. We want to fully automate this in Fabric. What is the recommended pattern for hitting external REST APIs on a scheduled basis (daily) to pull dynamic financial data? Should we use Data Factory pipelines with a Web activity to land the JSON directly into a Lakehouse, or is it better to use a Notebook (PySpark) to handle the API pagination and JSON flattening before writing to delta tables? Would appreciate any architecture advice for handling external financial APIs in Fabric! Thanks.118Views2likes1CommentHigh volume Dataverse dataflow times out avoid NESTED FROMs and/or JOINs best approach to resolve?
Background We have a Gen1 Dataverse dataflow that calculates aggregate totals per record (yearly, prior-year, lifetime, and household rollups) and writes them to two output entities, Merge Account and Merge Contact. Each output entity is built from a chain of ~11 Table.NestedJoin (JoinKind.FullOuter) joins over ~12 upstream aggregate queries. The problem The dataflow refreshes without issue on smaller environments but times out on high-volume ones with: Microsoft SQL: "The updated two minutes (2) timeout period elapsed prior to completion of the operation. Please avoid using SELECT *, or NESTED FROMs and/or JOINs to execute the query with default five minutes (5) timeout." ErrorCode = 10478; Number = 40000 (Some environments show error 40197 instead.) It stops on the Merge step. What we've implemented so far We've built a monitoring solution: a cloud flow that detects dataflow refresh failures and logs the details (dataflow name, ID, and error message) into a custom Refresh Audit table, surfaced in a model-driven app so the team has visibility into failures. We've analyzed the failure across multiple environments and confirmed it correlates with data volume — the same dataflow completes on smaller datasets and times out on larger ones, with the filtered row volume and per-record density appearing to be the main drivers. We've identified that the full-outer joins don't appear to fold, so a large nested query is sent to the Dataverse TDS endpoint and hits the query timeout — i.e. it's a timeout, not a data/row error. Approaches we're evaluating — would these be effective? Increasing the query/command timeout for a Gen1 Dataverse dataflow — is that configurable, and where? Using Table.Buffer on the join inputs to force local evaluation and avoid pushing the nested query to the TDS endpoint — would this reliably help, or just shift the bottleneck? Staging the upstream queries into computed/staged entities (or a separate staging dataflow) — is this the recommended pattern, and does it need enhanced compute / premium? For very large datasets (1M+ rows), pushing the aggregation source-side (FetchXML aggregate / SQL view) — is this the more reliable long-term approach? Is there a supported way to get per-step timing / query diagnostics for a dataflow refresh, to pinpoint the heaviest step and enrich our monitoring? Any guidance on which of these works best for high-volume Dataverse dataflows with heavy full-outer join chains would be much appreciated. Thanks!Solved352Views0likes5Comments