A Fibonacci heap is a data structure for priority queue / heap operations. It seems to have the best complexity for all operations:
Since it has the best performance, why not use it everywhere? What are the disadvantages of it?
$O(1)$ merely means that no matter how large your heap grows, the operation will always take roughly the same time to execute. It doesn't mean "the fastest".
Wikipedia article you linked has section named "Practical considerations":
Fibonacci heaps have a reputation for being slow in practice due to large memory consumption per node and high constant factors on all operations. Recent experimental results suggest that Fibonacci heaps are more efficient in practice than most of its later derivatives, including quake heaps, violation heaps, strict Fibonacci heaps, rank pairing heaps, but less efficient than either pairing heaps or array-based heaps.
It's a bit cheating to call insert and decrease-key O(1), because the implementation is incredibly lazy. The insert and decrease-key increase the entropy of the heap (makes it more messy). Instead of rebalancing immediately (which would make it O(log n)), it procrastinates until delete-min is called, which makes that operation more expensive. It's almost like the Fibonacci heap was invented for the sole purpose of looking good on a time complexity table like that!
So yes, consecutive calls to insert and decrease-key are technically O(1), but it results in mounting debt that you'll have to repay at some point. Since delete-min is the entire point of the priority que, you can't really avoid it. Therefore overall it's not necessarily going to have better performance than alternatives. In fact, it could even be outperformed by non-heap alternatives such as take-min operation on a binary tree.
The O(log n) listed for delete-min is amortized complexity, not worst case complexity. A disadvantage is that due to buildup of entropy/debt as described above, the actual cost of a given call could be as much as O(n). Another disadvantage of the Fibonacci heap is that it uses more memory per element than alternatives like binary heap.